← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/ghostscript/oneiric

« back to all changes in this revision

Viewing changes to base/gdevsgi.c

  • Committer: Bazaar Package Importer
  • Author(s): Till Kamppeter
  • Date: 2011-07-15 16:49:55 UTC
  • mfrom: (1.1.23 upstream)
  • Revision ID: james.westby@ubuntu.com-20110715164955-uga6qibao6kez05c
Tags: 9.04~dfsg~20110715-0ubuntu1
* New upstream release
   - GIT snapshot from Jult, 12 2011.
* debian/patches/020110406~a54df2d.patch,
  debian/patches/020110408~0791cc8.patch,
  debian/patches/020110408~507cbee.patch,
  debian/patches/020110411~4509a49.patch,
  debian/patches/020110412~78bb9a6.patch,
  debian/patches/020110418~a05ab8a.patch,
  debian/patches/020110420~20b6c78.patch,
  debian/patches/020110420~4ddefa2.patch: Removed upstream patches.
* debian/rules: Generate ABI version number (variable "abi") correctly,
  cutting off repackaging and pre-release parts.
* debian/rules: Added ./lcms2/ directory to DEB_UPSTREAM_REPACKAGE_EXCLUDES.
* debian/copyright: Added lcms2/* to the list of excluded files.
* debian/symbols.common: Updated for new upstream source. Applied patch
  which dpkg-gensymbols generated for debian/libgs9.symbols to this file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
base/gdevsgi.c
4
4
 * public domain.
5
5
 */
6
6
 
7
 
/* $Id: gdevsgi.c 11176 2010-05-04 18:47:12Z robin $*/
 
7
/* $Id$*/
8
8
/* SGI raster file driver */
9
9
#include "gdevprn.h"
10
10
#include "gdevsgi.h"
14
14
 
15
15
#define sgi_prn_device(procs, dev_name, num_comp, depth, max_gray, max_color, print_page)\
16
16
{prn_device_body(gx_device_printer, procs, dev_name, \
17
 
                 DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS, X_DPI, Y_DPI, \
18
 
                 0, 0, 0, 0, \
19
 
                 num_comp, depth, max_gray, max_color, max_gray+1, max_color+1, \
20
 
                 print_page)}
 
17
                 DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS, X_DPI, Y_DPI, \
 
18
                 0, 0, 0, 0, \
 
19
                 num_comp, depth, max_gray, max_color, max_gray+1, max_color+1, \
 
20
                 print_page)}
21
21
 
22
22
static dev_proc_map_rgb_color(sgi_map_rgb_color);
23
23
static dev_proc_map_color_rgb(sgi_map_color_rgb);
26
26
 
27
27
static gx_device_procs sgi_procs =
28
28
  prn_color_procs(gdev_prn_open, gdev_prn_output_page, gdev_prn_close,
29
 
                  sgi_map_rgb_color, sgi_map_color_rgb);
 
29
                  sgi_map_rgb_color, sgi_map_color_rgb);
30
30
 
31
31
const gx_device_printer far_data gs_sgirgb_device =
32
32
  sgi_prn_device(sgi_procs, "sgirgb", 3, 24, 255, 255, sgi_print_page);
39
39
       red = cv[0]; green = cv[1]; blue = cv[2];
40
40
 
41
41
       return ((red*max_value / gx_max_color_value) << (bitspercolor * 2)) +
42
 
              ((green*max_value / gx_max_color_value) << bitspercolor) +
43
 
              (blue*max_value / gx_max_color_value);
 
42
              ((green*max_value / gx_max_color_value) << bitspercolor) +
 
43
              (blue*max_value / gx_max_color_value);
44
44
}
45
45
 
46
46
static int
47
47
sgi_map_color_rgb(gx_device *dev, gx_color_index color, ushort prgb[3])
48
48
{       ushort bitspercolor = dev->color_info.depth / 3;
49
 
        ushort colormask = (1 << bitspercolor) - 1;
 
49
        ushort colormask = (1 << bitspercolor) - 1;
50
50
 
51
 
        prgb[0] = (ushort)(((color >> (bitspercolor * 2)) & colormask) *
52
 
                (ulong)gx_max_color_value / colormask);
53
 
        prgb[1] = (ushort)(((color >> bitspercolor) & colormask) *
54
 
                (ulong)gx_max_color_value / colormask);
55
 
        prgb[2] = (ushort)((color & colormask) *
56
 
                (ulong)gx_max_color_value / colormask);
57
 
        return 0;
 
51
        prgb[0] = (ushort)(((color >> (bitspercolor * 2)) & colormask) *
 
52
                (ulong)gx_max_color_value / colormask);
 
53
        prgb[1] = (ushort)(((color >> bitspercolor) & colormask) *
 
54
                (ulong)gx_max_color_value / colormask);
 
55
        prgb[2] = (ushort)((color & colormask) *
 
56
                (ulong)gx_max_color_value / colormask);
 
57
        return 0;
58
58
}
59
59
 
60
60
typedef struct sgi_cursor_s {
68
68
/* write a short int to disk as big-endean */
69
69
static int putshort(unsigned int val, FILE *outf)
70
70
{
71
 
        unsigned char buf[2];
 
71
        unsigned char buf[2];
72
72
 
73
 
        buf[0] = (val>>8);
74
 
        buf[1] = val;
75
 
        return fwrite(buf,2,1,outf);
 
73
        buf[0] = (val>>8);
 
74
        buf[1] = val;
 
75
        return fwrite(buf,2,1,outf);
76
76
}
77
77
 
78
78
/* write an int to disk as big-endean */
79
79
static int putint(unsigned int val, FILE *outf)
80
80
{
81
 
        unsigned char buf[4];
 
81
        unsigned char buf[4];
82
82
 
83
 
        buf[0] = (val>>24);
84
 
        buf[1] = (val>>16);
85
 
        buf[2] = (val>>8);
86
 
        buf[3] = val;
87
 
        return fwrite(buf,4,1,outf);
 
83
        buf[0] = (val>>24);
 
84
        buf[1] = (val>>16);
 
85
        buf[2] = (val>>8);
 
86
        buf[3] = val;
 
87
        return fwrite(buf,4,1,outf);
88
88
}
89
89
 
90
90
/* write the header field by field in big-endian */
91
91
static void putheader(IMAGE *header, FILE *outf)
92
92
{
93
 
        int i;
94
 
        char filler= '\0';
95
 
 
96
 
        putshort(header->imagic, outf);
97
 
        fputc(1, outf); /* RLE */
98
 
        fputc(1, outf); /* bpp */
99
 
        putshort(header->dim, outf);
100
 
        putshort(header->xsize, outf);
101
 
        putshort(header->ysize, outf);
102
 
        putshort(header->zsize, outf);
103
 
 
104
 
        putint(header->min_color, outf);
105
 
        putint(header->max_color, outf);
106
 
        putint(header->wastebytes, outf);
107
 
 
108
 
        fwrite(header->name,80,1,outf);
109
 
 
110
 
        putint(header->colormap, outf);
 
93
        int i;
 
94
        char filler= '\0';
 
95
 
 
96
        putshort(header->imagic, outf);
 
97
        fputc(1, outf); /* RLE */
 
98
        fputc(1, outf); /* bpp */
 
99
        putshort(header->dim, outf);
 
100
        putshort(header->xsize, outf);
 
101
        putshort(header->ysize, outf);
 
102
        putshort(header->zsize, outf);
 
103
 
 
104
        putint(header->min_color, outf);
 
105
        putint(header->max_color, outf);
 
106
        putint(header->wastebytes, outf);
 
107
 
 
108
        fwrite(header->name,80,1,outf);
 
109
 
 
110
        putint(header->colormap, outf);
111
111
 
112
112
   /* put the filler for the rest */
113
113
    for (i=0; i<404; i++)
125
125
          emprintf(bdev->memory,
126
126
                   "sgi rgb format only supports one page per file.\n"
127
127
                   "Please use the '%%d' OutputFile option to create one file for each page.\n");
128
 
          return_error(gs_error_rangecheck);
 
128
          return_error(gs_error_rangecheck);
129
129
     }
130
130
     line_size = gdev_mem_bytes_per_scan_line((gx_device_printer*)bdev);
131
131
     data = (byte*)gs_malloc(bdev->memory, line_size, 1, "sgi_begin_page");
134
134
     if ((data == (byte*)0)||(header == (IMAGE*)0)) {
135
135
        gs_free(bdev->memory, data, line_size, 1, "sgi_begin_page");
136
136
        gs_free(bdev->memory, header, sizeof(IMAGE),1,"sgi_begin_page");
137
 
        return_error(gs_error_VMerror);
 
137
        return_error(gs_error_VMerror);
138
138
     }
139
139
     memset(header,0, sizeof(IMAGE));
140
140
     header->imagic = IMAGIC;
162
162
{    if (pcur->lnum < 0)
163
163
       return 1;
164
164
     gdev_prn_copy_scan_lines((gx_device_printer*)pcur->dev,
165
 
                              pcur->lnum--, pcur->data, pcur->line_size);
 
165
                              pcur->lnum--, pcur->data, pcur->line_size);
166
166
     return 0;
167
167
}
168
168
 
180
180
       int rownumber;
181
181
 
182
182
       if (pdev->PageCount >= 1 && !pdev->file_is_new)
183
 
          return_error(gs_error_rangecheck);  /* support single page only, can't happen */
 
183
          return_error(gs_error_rangecheck);  /* support single page only, can't happen */
184
184
 
185
185
#define aref2(a,b) (a)*bdev->height+(b)
186
 
           rowsizes=(int*)gs_malloc(pdev->memory, sizeof(int),3*bdev->height,"sgi_print_page");
 
186
           rowsizes=(int*)gs_malloc(pdev->memory, sizeof(int),3*bdev->height,"sgi_print_page");
187
187
       edata =  (byte*)gs_malloc(pdev->memory, cur.line_size, 1, "sgi_begin_page");
188
188
 
189
189
       if((code<0)||(rowsizes==(int*)NULL)||(edata==(byte*)NULL)) {
194
194
       lastval = 512+4*6*bdev->height; /* skip offset table */
195
195
       fseek(pstream,lastval,0);
196
196
       for (separation=0; separation < 3; separation++)
197
 
         {
198
 
           cur.lnum = cur.dev->height-1;
199
 
           rownumber = 0;
200
 
           bpe = cur.bpp/3;
201
 
           mask = (1<<bpe) - 1;
202
 
           while ( !(code=sgi_next_row(&cur)))
203
 
             { byte *bp;
204
 
               uint x;
205
 
               int shift;
206
 
               byte *curcol=cur.data;
207
 
               byte *startcol=edata;
208
 
               int count;
209
 
               byte todo, cc;
210
 
               byte *iptr, *sptr, *optr, *ibufend;
211
 
               for (bp = cur.data, x=0, shift = 8 - cur.bpp;
212
 
                    x < bdev->width;
213
 
                    )
214
 
                 { uint pixel = 0;
215
 
                   uint r, g, b;
216
 
                   switch (cur.bpp >> 3)
217
 
                     {
218
 
                     case 3: pixel = (uint)*bp << 16; bp++;
219
 
                     case 2: pixel += (uint)*bp << 8; bp++;
220
 
                     case 1: pixel += *bp; bp++; break;
221
 
                     case 0: pixel = *bp >> shift;
222
 
                       if ((shift-=cur.bpp) < 0)
223
 
                         bp++, shift += 8; break;
224
 
                     }
225
 
                   ++x;
226
 
                   b = pixel & mask; pixel >>= bpe;
227
 
                   g = pixel & mask; pixel >>= bpe;
228
 
                   r = pixel & mask;
229
 
                   switch(separation)
230
 
                     {
231
 
                     case 0: *curcol++=r; break;
232
 
                     case 1: *curcol++=g; break;
233
 
                     case 2: *curcol++=b; break;
234
 
                     }
235
 
                 }
236
 
               iptr=cur.data;
237
 
               optr=startcol;
238
 
               ibufend=curcol-1;
239
 
               while(iptr<ibufend) {
240
 
                 sptr = iptr;                                           
241
 
                 iptr += 2;
242
 
                 while((iptr<ibufend)&&((iptr[-2]!=iptr[-1])||(iptr[-1]!=iptr[0])))
243
 
                   iptr++;
244
 
                 iptr -= 2;
245
 
                 count = iptr-sptr;
246
 
                 while(count) {
247
 
                   todo = count>126 ? 126:count;
248
 
                   count -= todo;
249
 
                   *optr++ = 0x80|todo;
250
 
                   while(todo--)
251
 
                     *optr++ = *sptr++;
252
 
                 }
253
 
                 sptr = iptr;
254
 
                 cc = *iptr++;
255
 
                 while( (iptr<ibufend) && (*iptr == cc) )
256
 
                   iptr++;
257
 
                 count = iptr-sptr;
258
 
                 while(count) {
259
 
                   todo = count>126 ? 126:count;
260
 
                   count -= todo;
261
 
                   *optr++ = todo;
262
 
                   *optr++ = cc;
263
 
                 }
264
 
               }
 
197
         {
 
198
           cur.lnum = cur.dev->height-1;
 
199
           rownumber = 0;
 
200
           bpe = cur.bpp/3;
 
201
           mask = (1<<bpe) - 1;
 
202
           while ( !(code=sgi_next_row(&cur)))
 
203
             { byte *bp;
 
204
               uint x;
 
205
               int shift;
 
206
               byte *curcol=cur.data;
 
207
               byte *startcol=edata;
 
208
               int count;
 
209
               byte todo, cc;
 
210
               byte *iptr, *sptr, *optr, *ibufend;
 
211
               for (bp = cur.data, x=0, shift = 8 - cur.bpp;
 
212
                    x < bdev->width;
 
213
                    )
 
214
                 { uint pixel = 0;
 
215
                   uint r, g, b;
 
216
                   switch (cur.bpp >> 3)
 
217
                     {
 
218
                     case 3: pixel = (uint)*bp << 16; bp++;
 
219
                     case 2: pixel += (uint)*bp << 8; bp++;
 
220
                     case 1: pixel += *bp; bp++; break;
 
221
                     case 0: pixel = *bp >> shift;
 
222
                       if ((shift-=cur.bpp) < 0)
 
223
                         bp++, shift += 8; break;
 
224
                     }
 
225
                   ++x;
 
226
                   b = pixel & mask; pixel >>= bpe;
 
227
                   g = pixel & mask; pixel >>= bpe;
 
228
                   r = pixel & mask;
 
229
                   switch(separation)
 
230
                     {
 
231
                     case 0: *curcol++=r; break;
 
232
                     case 1: *curcol++=g; break;
 
233
                     case 2: *curcol++=b; break;
 
234
                     }
 
235
                 }
 
236
               iptr=cur.data;
 
237
               optr=startcol;
 
238
               ibufend=curcol-1;
 
239
               while(iptr<ibufend) {
 
240
                 sptr = iptr;
 
241
                 iptr += 2;
 
242
                 while((iptr<ibufend)&&((iptr[-2]!=iptr[-1])||(iptr[-1]!=iptr[0])))
 
243
                   iptr++;
 
244
                 iptr -= 2;
 
245
                 count = iptr-sptr;
 
246
                 while(count) {
 
247
                   todo = count>126 ? 126:count;
 
248
                   count -= todo;
 
249
                   *optr++ = 0x80|todo;
 
250
                   while(todo--)
 
251
                     *optr++ = *sptr++;
 
252
                 }
 
253
                 sptr = iptr;
 
254
                 cc = *iptr++;
 
255
                 while( (iptr<ibufend) && (*iptr == cc) )
 
256
                   iptr++;
 
257
                 count = iptr-sptr;
 
258
                 while(count) {
 
259
                   todo = count>126 ? 126:count;
 
260
                   count -= todo;
 
261
                   *optr++ = todo;
 
262
                   *optr++ = cc;
 
263
                 }
 
264
               }
265
265
               *optr++ = 0;
266
 
               rowsizes[aref2(separation,rownumber++)] = optr-startcol;
267
 
               if (fwrite(startcol,1,optr-startcol,pstream) != optr-startcol) {
 
266
               rowsizes[aref2(separation,rownumber++)] = optr-startcol;
 
267
               if (fwrite(startcol,1,optr-startcol,pstream) != optr-startcol) {
268
268
                   code = gs_note_error(gs_error_ioerror);
269
269
                   goto free_mem;
270
270
               }
271
 
             }
272
 
         }
 
271
             }
 
272
         }
273
273
       fseek(pstream,512L,0);
274
274
       for(separation=0; separation<3; separation++)
275
 
         for(rownumber=0; rownumber<bdev->height; rownumber++)
276
 
           {putint(lastval,pstream);
277
 
            lastval+=rowsizes[aref2(separation,rownumber)];}
 
275
         for(rownumber=0; rownumber<bdev->height; rownumber++)
 
276
           {putint(lastval,pstream);
 
277
            lastval+=rowsizes[aref2(separation,rownumber)];}
278
278
       for(separation=0; separation<3; separation++)
279
 
         for(rownumber=0; rownumber<bdev->height; rownumber++)
280
 
           {lastval=rowsizes[aref2(separation,rownumber)];
281
 
            putint(lastval,pstream);}
 
279
         for(rownumber=0; rownumber<bdev->height; rownumber++)
 
280
           {lastval=rowsizes[aref2(separation,rownumber)];
 
281
            putint(lastval,pstream);}
282
282
     free_mem:
283
283
       gs_free(pdev->memory, (char*)cur.data, cur.line_size, 1,
284
 
                 "sgi_print_page(done)");
 
284
                 "sgi_print_page(done)");
285
285
       gs_free(pdev->memory, (char*)edata, cur.line_size, 1, "sgi_print_page(done)");
286
286
       gs_free(pdev->memory, (char*)rowsizes,4,3*bdev->height,"sgi_print_page(done)");
287
287
       return (code < 0 ? code : 0);