- start of external Imager API access:
[imager.git] / rgb.c
1 #include "imager.h"
2 #include "log.h"
3 #include "iolayer.h"
4
5 #include <stdlib.h>
6 #include <errno.h>
7
8
9 /*
10 =head1 NAME
11
12 rgb.c - implements reading and writing sgi image files, uses io layer.
13
14 =head1 SYNOPSIS
15
16    io_glue *ig = io_new_fd( fd );
17    i_img *im   = i_readrgb_wiol(ig, -1); // no limit on how much is read
18    // or 
19    io_glue *ig = io_new_fd( fd );
20    return_code = i_writergb_wiol(im, ig); 
21
22 =head1 DESCRIPTION
23
24 rgb.c implements the basic functions to read and write portable targa
25 files.  It uses the iolayer and needs either a seekable source or an
26 entire memory mapped buffer.
27
28 =head1 FUNCTION REFERENCE
29
30 Some of these functions are internal.
31
32 =over
33
34 =cut
35 */
36
37 typedef struct {
38   unsigned short imagic;
39   unsigned char storagetype;
40   unsigned char BPC;
41   unsigned short dimensions;
42   unsigned short xsize, ysize, zsize;
43   unsigned int min, max;
44   char name[80];
45   unsigned int colormap;
46 } rgb_header;
47
48 typedef struct {
49   int start, length;
50 } stlen_pair;
51
52 typedef enum { NoInit, Raw, Rle } rle_state;
53
54
55
56 typedef struct {
57   int compressed;
58   int bytepp;
59   io_glue *ig;
60 } rgb_dest;
61
62
63
64
65
66
67 /*
68 =item rgb_header_unpack(header, headbuf)
69
70 Unpacks the header structure into from buffer and stores
71 in the header structure.
72
73     header - header structure
74     headbuf - buffer to unpack from
75
76 =cut
77 */
78
79
80 static
81 void
82 rgb_header_unpack(rgb_header *header, unsigned char *headbuf) {
83   header->imagic      = (headbuf[0]<<8) + headbuf[1];
84   header->storagetype = headbuf[2];
85   header->BPC         = headbuf[3];
86   header->dimensions  = (headbuf[4]<<8) + headbuf[5];
87   header->xsize       = (headbuf[6]<<8) + headbuf[7];
88   header->ysize       = (headbuf[8]<<8) + headbuf[9];
89   header->zsize       = (headbuf[10]<<8) + headbuf[11];
90   header->min         = (headbuf[12]<<24) + (headbuf[13]<<16)+(headbuf[14]<<8)+headbuf[15];
91   header->max         = (headbuf[16]<<24) + (headbuf[17]<<16)+(headbuf[18]<<8)+headbuf[19];
92   memcpy(header->name,headbuf+20,80);
93   header->colormap    = (headbuf[100]<<24) + (headbuf[101]<<16)+(headbuf[102]<<8)+headbuf[103];
94 }
95
96
97 /*
98 =item rgb_header_pack(header, headbuf)
99
100 Packs header structure into buffer for writing.
101
102     header - header structure
103     headbuf - buffer to pack into
104
105 =cut
106 */
107
108 static
109 void
110 rgb_header_pack(rgb_header *header, unsigned char headbuf[512]) {
111   
112   header->imagic      = (headbuf[0]<<8) + headbuf[1];
113   header->storagetype = headbuf[2];
114   header->BPC         = headbuf[3];
115   header->dimensions  = (headbuf[4]<<8) + headbuf[5];
116   header->xsize       = (headbuf[6]<<8) + headbuf[7];
117   header->ysize       = (headbuf[8]<<8) + headbuf[9];
118   header->zsize       = (headbuf[10]<<8) + headbuf[11];
119   header->min         = (headbuf[12]<<24) + (headbuf[13]<<16)+(headbuf[14]<<8)+headbuf[15];
120   header->max         = (headbuf[16]<<24) + (headbuf[17]<<16)+(headbuf[18]<<8)+headbuf[19];
121   memcpy(header->name,headbuf+20,80);
122   header->colormap    = (headbuf[100]<<24) + (headbuf[101]<<16)+(headbuf[102]<<8)+headbuf[103];
123
124 }
125
126
127
128
129
130 /*
131 =item rgb_dest_write(s, buf, pixels)
132
133 Writes pixels from buf to destination s.  Takes care of compressing if the
134 destination is compressed.
135
136     s - data destination
137     buf - source buffer
138     pixels - number of pixels to put write to destination
139
140 =cut
141 */
142
143 static
144 int
145 rgb_dest_write(rgb_dest *s, unsigned char *buf, size_t pixels) {
146
147 }
148
149
150
151
152
153
154
155
156 /*
157 =item i_readrgb_wiol(ig, length)
158
159 Read in an image from the iolayer data source and return the image structure to it.
160 Returns NULL on error.
161
162    ig     - io_glue object
163    length - maximum length to read from data source, before closing it -1 
164             signifies no limit.
165
166 =cut
167 */
168
169 i_img *
170 i_readrgb_wiol(io_glue *ig, int length) {
171   i_img *img;
172   int y, c,i;
173   int width, height, channels;
174   unsigned long maxlen;
175
176   int savemask;
177   
178   rgb_header header;
179   unsigned char headbuf[512];
180   unsigned char *databuf;
181   unsigned long *starttab, *lengthtab;
182   i_color *linebuf = NULL;
183   i_mempool mp;
184
185   mm_log((1,"i_readrgb(ig %p, length %d)\n", ig, length));
186   i_clear_error();
187   i_mempool_init(&mp);
188   
189   io_glue_commit_types(ig);
190
191   if (ig->readcb(ig, headbuf, 512) != 512) {
192     i_push_error(errno, "could not read SGI rgb header");
193     return NULL;
194   }
195
196   rgb_header_unpack(&header, headbuf);
197   
198   
199   mm_log((1,"imagic:         %d\n", header.imagic));
200   mm_log((1,"storagetype:    %d\n", header.storagetype));
201   mm_log((1,"BPC:            %d\n", header.BPC));
202   mm_log((1,"dimensions:     %d\n", header.dimensions));
203   mm_log((1,"xsize:          %d\n", header.xsize));
204   mm_log((1,"ysize:          %d\n", header.ysize));
205   mm_log((1,"zsize:          %d\n", header.zsize));
206   mm_log((1,"min:            %d\n", header.min));
207   mm_log((1,"max:            %d\n", header.max));
208   mm_log((1,"name [skipped]\n"));
209   mm_log((1,"colormap:       %d\n", header.colormap));
210
211   if (header.colormap != 0) {
212     i_push_error(0, "SGI rgb image has a non zero colormap entry - obsolete format");
213     return NULL;
214   }
215
216   if (header.storagetype != 0 && header.storagetype != 1) {
217     i_push_error(0, "SGI rgb image has has invalid storage field");
218     return NULL;
219   }
220
221   width    = header.xsize;
222   height   = header.ysize;
223   channels = header.zsize;
224
225   img = i_img_empty_ch(NULL, width, height, channels);
226   if (!img)
227     return NULL;
228   
229   i_tags_add(&img->tags, "rgb_namestr", 0, header.name, 80, 0);
230   i_tags_add(&img->tags, "i_format", 0, "rgb", -1, 0);
231
232   switch (header.storagetype) {
233   case 0: /* uncompressed */
234     
235     linebuf   = i_mempool_alloc(&mp, width*sizeof(i_color));
236     databuf   = i_mempool_alloc(&mp, width);
237
238     savemask = i_img_getmask(img);
239
240     for(c=0; c<channels; c++) {
241       i_img_setmask(img, 1<<c);
242       for(y=0; y<height; y++) {
243         int x;
244         
245         if (ig->readcb(ig, databuf, width) != width) {
246           i_push_error(0, "SGI rgb: cannot read");
247           goto ErrorReturn;
248         }
249
250         for(x=0; x<width; x++)
251           linebuf[x].channel[c] = databuf[x];
252         
253         i_plin(img, 0, width, height-1-y, linebuf);
254       }
255     }
256     i_img_setmask(img, savemask);
257     break;
258   case 1: /* RLE compressed */
259     
260     databuf   = i_mempool_alloc(&mp, height*channels*4);
261     starttab  = i_mempool_alloc(&mp, height*channels*sizeof(unsigned long));
262     lengthtab = i_mempool_alloc(&mp, height*channels*sizeof(unsigned long));
263     linebuf   = i_mempool_alloc(&mp, width*sizeof(i_color));
264     
265     /* Read offset table */
266     if (ig->readcb(ig, databuf, height*channels*4) != height*channels*4) goto ErrorReturn;
267     for(i=0; i<height*channels; i++) starttab[i] = 
268                                        (databuf[i*4]<<24) | 
269                                        (databuf[i*4+1]<<16) | 
270                                        (databuf[i*4+2]<<8) |
271                                        (databuf[i*4+3]);
272
273
274     /* Read length table */
275     if (ig->readcb(ig, databuf, height*channels*4) != height*channels*4) goto ErrorReturn;
276     for(i=0; i<height*channels; i++) lengthtab[i] = 
277                                        (databuf[i*4]<<24)+
278                                        (databuf[i*4+1]<<16)+
279                                        (databuf[i*4+2]<<8)+
280                                        (databuf[i*4+3]);
281
282     mm_log((3, "Offset/length table:\n"));
283     for(i=0; i<height*channels; i++)
284       mm_log((3, "%d: %d/%d\n", i, starttab[i], lengthtab[i]));
285
286
287     /* Find max spanlength if someone is making very badly formed RLE data */
288     maxlen = 0;
289     for(y=0; y<height; y++) maxlen = (maxlen>lengthtab[y])?maxlen:lengthtab[y];
290
291     mm_log((1, "maxlen for an rle buffer: %d\n", maxlen));
292
293     databuf = i_mempool_alloc(&mp, maxlen);
294
295     for(y=0; y<height; y++) {
296       for(c=0; c<channels; c++) {
297         unsigned long iidx = 0, oidx = 0, span = 0;
298         unsigned char cval;
299         int rle = 0;
300         int ci = height*c+y;
301         int datalen = lengthtab[ci];
302
303         if (ig->seekcb(ig, starttab[ci], SEEK_SET) != starttab[ci]) {
304           i_push_error(0, "SGI rgb: cannot seek");
305           goto ErrorReturn;
306         }
307         if (ig->readcb(ig, databuf, datalen) != datalen) {
308           i_push_error(0, "SGI rgb: cannot read");
309           goto ErrorReturn;
310         }
311
312         /*
313           mm_log((1, "Buffer length %d\n", datalen));
314           for(i=0; i<datalen; i++) 
315           mm_log((1, "0x%x\n", databuf[i]));
316         */
317
318         while( iidx <= datalen && oidx < width ) {
319           if (!span) {
320             span = databuf[iidx] & 0x7f;
321             rle  = !(databuf[iidx++] & 0x80);
322             /*      mm_log((1,"new span %d, rle %d\n", span, rle)); */
323             if (rle) {
324               if (iidx==datalen) {
325                 i_push_error(0, "SGI rgb: bad rle data");
326                 goto ErrorReturn;
327               }
328               cval = databuf[iidx++];
329               /* mm_log((1, "rle value %d\n", cval)); */
330             }
331           }
332           linebuf[oidx++].channel[c] = rle ? cval : databuf[iidx++];
333           span--;
334           /*
335             mm_log((1,"iidx=%d/%d, oidx=%d/%d, linebuf[%d].channel[%d] %d\n", iidx-1, datalen, oidx-1, width, oidx-1, c, linebuf[oidx-1].channel[c]));
336           */
337         }
338       }
339       i_plin(img, 0, width, height-1-y, linebuf);
340     }
341     
342     break;
343   }
344
345   i_tags_add(&img->tags, "i_format", 0, "rgb", -1, 0);
346
347   i_mempool_destroy(&mp);
348   return img;
349
350  ErrorReturn:
351   i_mempool_destroy(&mp);
352   if (img) i_img_destroy(img);
353   return NULL;
354 }
355
356
357
358 /*
359 =item i_writergb_wiol(img, ig)
360
361 Writes an image in targa format.  Returns 0 on error.
362
363    img    - image to store
364    ig     - io_glue object
365
366 =cut
367 */
368
369 undef_int
370 i_writergb_wiol(i_img *img, io_glue *ig, int wierdpack, int compress, char *idstring, size_t idlen) {
371   i_clear_error();
372   i_push_error(0, "writing SGI RGB files is not implemented");
373
374   return 0;
375 }
376