- start of external Imager API access:
[imager.git] / pnm.c
1 #include "imager.h"
2 #include "log.h"
3 #include "iolayer.h"
4 #include "imageri.h"
5
6 #include <stdlib.h>
7 #include <errno.h>
8
9
10 /*
11 =head1 NAME
12
13 pnm.c - implements reading and writing ppm/pnm/pbm files, uses io layer.
14
15 =head1 SYNOPSIS
16
17    io_glue *ig = io_new_fd( fd );
18    i_img *im   = i_readpnm_wiol(ig, -1); // no limit on how much is read
19    // or 
20    io_glue *ig = io_new_fd( fd );
21    return_code = i_writepnm_wiol(im, ig); 
22
23 =head1 DESCRIPTION
24
25 pnm.c implements the basic functions to read and write portable 
26 anymap files.  It uses the iolayer and needs either a seekable source
27 or an entire memory mapped buffer.
28
29 =head1 FUNCTION REFERENCE
30
31 Some of these functions are internal.
32
33 =over
34
35 =cut
36 */
37
38
39 #define BSIZ 1024
40 #define misspace(x) (x==' ' || x=='\n' || x=='\r' || x=='\t' || x=='\f' || x=='\v')
41 #define misnumber(x) (x <= '9' && x>='0')
42
43 static char *typenames[]={"ascii pbm", "ascii pgm", "ascii ppm", "binary pbm", "binary pgm", "binary ppm"};
44
45 /*
46  * Type to encapsulate the local buffer
47  * management skipping over in a file 
48  */
49
50 typedef struct {
51   io_glue *ig;
52   int len;
53   int cp;
54   char buf[BSIZ];
55 } mbuf;
56
57
58 static
59 void init_buf(mbuf *mb, io_glue *ig) {
60   mb->len = 0;
61   mb->cp  = 0;
62   mb->ig  = ig;
63 }
64
65
66
67 /*
68 =item gnext(mbuf *mb)
69
70 Fetches a character and advances in stream by one character.  
71 Returns a pointer to the byte or NULL on failure (internal).
72
73    mb - buffer object
74
75 =cut
76 */
77
78 static
79 char *
80 gnext(mbuf *mb) {
81   io_glue *ig = mb->ig;
82   if (mb->cp == mb->len) {
83     mb->cp = 0;
84     mb->len = ig->readcb(ig, mb->buf, BSIZ);
85     if (mb->len == -1) {
86       i_push_error(errno, "file read error");
87       mm_log((1, "i_readpnm: read error\n"));
88       return NULL;
89     }
90     if (mb->len == 0) {
91       i_push_error(errno, "unexpected end of file");
92       mm_log((1, "i_readpnm: end of file\n"));
93       return NULL;
94     }
95   }
96   return &mb->buf[mb->cp++];
97 }
98
99
100 /*
101 =item gpeek(mbuf *mb)
102
103 Fetches a character but does NOT advance.  Returns a pointer to
104 the byte or NULL on failure (internal).
105
106    mb - buffer object
107
108 =cut
109 */
110
111 static
112 char *
113 gpeek(mbuf *mb) {
114   io_glue *ig = mb->ig;
115   if (mb->cp == mb->len) {
116     mb->cp = 0;
117     mb->len = ig->readcb(ig, mb->buf, BSIZ);
118     if (mb->len == -1) {
119       i_push_error(errno, "read error");
120       mm_log((1, "i_readpnm: read error\n"));
121       return NULL;
122     }
123     if (mb->len == 0) {
124       i_push_error(0, "unexpected end of file");
125       mm_log((1, "i_readpnm: end of file\n"));
126       return NULL;
127     }
128   }
129   return &mb->buf[mb->cp];
130 }
131
132
133
134
135 /*
136 =item skip_spaces(mb)
137
138 Advances in stream until it is positioned at a
139 non white space character. (internal)
140
141    mb - buffer object
142
143 =cut
144 */
145
146 static
147 int
148 skip_spaces(mbuf *mb) {
149   char *cp;
150   while( (cp = gpeek(mb)) && misspace(*cp) ) if ( !gnext(mb) ) break;
151   if (!cp) return 0;
152   return 1;
153 }
154
155
156 /*
157 =item skip_comment(mb)
158
159 Advances in stream over whitespace and a comment if one is found. (internal)
160
161    mb - buffer object
162
163 =cut
164 */
165
166 static
167 int
168 skip_comment(mbuf *mb) {
169   char *cp;
170
171   if (!skip_spaces(mb)) return 0;
172
173   if (!(cp = gpeek(mb))) return 0;
174   if (*cp == '#') {
175     while( (cp = gpeek(mb)) && (*cp != '\n' && *cp != '\r') ) {
176       if ( !gnext(mb) ) break;
177     }
178   }
179   if (!cp) return 0;
180   
181   return 1;
182 }
183
184
185 /*
186 =item gnum(mb, i)
187
188 Fetches the next number from stream and stores in i, returns true
189 on success else false.
190
191    mb - buffer object
192    i  - integer to store result in
193
194 =cut
195 */
196
197 static
198 int
199 gnum(mbuf *mb, int *i) {
200   char *cp;
201   *i = 0;
202
203   if (!skip_spaces(mb)) return 0; 
204
205   while( (cp = gpeek(mb)) && misnumber(*cp) ) {
206     *i = *i*10+(*cp-'0');
207     cp = gnext(mb);
208   }
209   return 1;
210 }
211
212
213 /*
214 =item i_readpnm_wiol(ig, length)
215
216 Retrieve an image and stores in the iolayer object. Returns NULL on fatal error.
217
218    ig     - io_glue object
219    length - maximum length to read from data source, before closing it -1 
220             signifies no limit.
221
222 =cut
223 */
224
225
226 i_img *
227 i_readpnm_wiol(io_glue *ig, int length) {
228   i_img* im;
229   int type;
230   int x, y, ch;
231   int width, height, maxval, channels, pcount;
232   int rounder;
233   char *cp;
234   unsigned char *uc;
235   mbuf buf;
236   i_color val;
237
238   i_clear_error();
239
240   mm_log((1,"i_readpnm(ig %p, length %d)\n", ig, length));
241
242   io_glue_commit_types(ig);
243   init_buf(&buf, ig);
244
245   cp = gnext(&buf);
246
247   if (!cp || *cp != 'P') {
248     i_push_error(0, "bad header magic, not a PNM file");
249     mm_log((1, "i_readpnm: Could not read header of file\n"));
250     return NULL;
251   }
252
253   if ( !(cp = gnext(&buf)) ) {
254     mm_log((1, "i_readpnm: Could not read header of file\n"));
255     return NULL;
256   }
257   
258   type = *cp-'0';
259
260   if (type < 1 || type > 6) {
261     i_push_error(0, "unknown PNM file type, not a PNM file");
262     mm_log((1, "i_readpnm: Not a pnm file\n"));
263     return NULL;
264   }
265
266   if ( !(cp = gnext(&buf)) ) {
267     mm_log((1, "i_readpnm: Could not read header of file\n"));
268     return NULL;
269   }
270   
271   if ( !misspace(*cp) ) {
272     i_push_error(0, "unexpected character, not a PNM file");
273     mm_log((1, "i_readpnm: Not a pnm file\n"));
274     return NULL;
275   }
276   
277   mm_log((1, "i_readpnm: image is a %s\n", typenames[type-1] ));
278
279   
280   /* Read sizes and such */
281
282   if (!skip_comment(&buf)) {
283     i_push_error(0, "while skipping to width");
284     mm_log((1, "i_readpnm: error reading before width\n"));
285     return NULL;
286   }
287   
288   if (!gnum(&buf, &width)) {
289     i_push_error(0, "could not read image width");
290     mm_log((1, "i_readpnm: error reading width\n"));
291     return NULL;
292   }
293
294   if (!skip_comment(&buf)) {
295     i_push_error(0, "while skipping to height");
296     mm_log((1, "i_readpnm: error reading before height\n"));
297     return NULL;
298   }
299
300   if (!gnum(&buf, &height)) {
301     i_push_error(0, "could not read image height");
302     mm_log((1, "i_readpnm: error reading height\n"));
303     return NULL;
304   }
305   
306   if (!(type == 1 || type == 4)) {
307     if (!skip_comment(&buf)) {
308       i_push_error(0, "while skipping to maxval");
309       mm_log((1, "i_readpnm: error reading before maxval\n"));
310       return NULL;
311     }
312
313     if (!gnum(&buf, &maxval)) {
314       i_push_error(0, "could not read maxval");
315       mm_log((1, "i_readpnm: error reading maxval\n"));
316       return NULL;
317     }
318
319     if (maxval == 0) {
320       i_push_error(0, "maxval is zero - invalid pnm file");
321       mm_log((1, "i_readpnm: maxval is zero, invalid pnm file\n"));
322       return NULL;
323     }
324     else if (maxval > 65535) {
325       i_push_errorf(0, "maxval of %d is over 65535 - invalid pnm file", 
326                     maxval);
327       mm_log((1, "i_readpnm: maxval of %d is over 65535 - invalid pnm file\n"));
328       return NULL;
329     }
330     else if (type >= 4 && maxval > 255) {
331       i_push_errorf(0, "maxval of %d is over 255 - not currently supported by Imager for binary pnm", maxval);
332       mm_log((1, "i_readpnm: maxval of %d is over 255 - not currently supported by Imager for binary pnm\n", maxval));
333       return NULL;
334     }
335   } else maxval=1;
336   rounder = maxval / 2;
337
338   if (!(cp = gnext(&buf)) || !misspace(*cp)) {
339     i_push_error(0, "garbage in header, invalid PNM file");
340     mm_log((1, "i_readpnm: garbage in header\n"));
341     return NULL;
342   }
343
344   channels = (type == 3 || type == 6) ? 3:1;
345   pcount = width*height*channels;
346
347   if (!i_int_check_image_file_limits(width, height, channels, sizeof(i_sample_t))) {
348     mm_log((1, "i_readpnm: image size exceeds limits\n"));
349     return NULL;
350   }
351
352   mm_log((1, "i_readpnm: (%d x %d), channels = %d, maxval = %d\n", width, height, channels, maxval));
353   
354   im = i_img_empty_ch(NULL, width, height, channels);
355
356   i_tags_add(&im->tags, "i_format", 0, "pnm", -1, 0);
357
358   switch (type) {
359   case 1: /* Ascii types */
360   case 2:
361   case 3:
362     for(y=0;y<height;y++) for(x=0; x<width; x++) {
363       for(ch=0; ch<channels; ch++) {
364         int t;
365         if (gnum(&buf, &t)) val.channel[ch] = (t * 255 + rounder) / maxval;
366         else {
367           mm_log((1,"i_readpnm: gnum() returned false in data\n"));
368           return im;
369         }
370       }
371       i_ppix(im, x, y, &val);
372     }
373     break;
374     
375   case 4: /* binary pbm */
376     for(y=0;y<height;y++) for(x=0; x<width; x+=8) {
377       if ( (uc = (unsigned char*)gnext(&buf)) ) {
378         int xt;
379         int pc = width-x < 8 ? width-x : 8;
380         /*      mm_log((1,"i_readpnm: y=%d x=%d pc=%d\n", y, x, pc)); */
381         for(xt = 0; xt<pc; xt++) {
382           val.channel[0] = (*uc & (128>>xt)) ? 0 : 255; 
383           i_ppix(im, x+xt, y, &val);
384         }
385       } else {
386         mm_log((1,"i_readpnm: gnext() returned false in data\n"));
387         return im;
388       }
389     }
390     break;
391
392   case 5: /* binary pgm */
393   case 6: /* binary ppm */
394     for(y=0;y<height;y++) for(x=0; x<width; x++) {
395       for(ch=0; ch<channels; ch++) {
396         if ( (uc = (unsigned char*)gnext(&buf)) ) 
397           val.channel[ch] = (*uc * 255 + rounder) / maxval;
398         else {
399           mm_log((1,"i_readpnm: gnext() returned false in data\n"));
400           return im;
401         }
402       }
403       i_ppix(im, x, y, &val);
404     }
405     break;
406   default:
407     mm_log((1, "type %s [P%d] unsupported\n", typenames[type-1], type));
408     return NULL;
409   }
410   return im;
411 }
412
413
414 undef_int
415 i_writeppm_wiol(i_img *im, io_glue *ig) {
416   char header[255];
417   int rc;
418
419   mm_log((1,"i_writeppm(im %p, ig %p)\n", im, ig));
420   i_clear_error();
421
422   /* Add code to get the filename info from the iolayer */
423   /* Also add code to check for mmapped code */
424
425   io_glue_commit_types(ig);
426
427   if (im->channels == 3) {
428     sprintf(header,"P6\n#CREATOR: Imager\n%d %d\n255\n",im->xsize,im->ysize);
429     if (ig->writecb(ig,header,strlen(header))<0) {
430       i_push_error(errno, "could not write ppm header");
431       mm_log((1,"i_writeppm: unable to write ppm header.\n"));
432       return(0);
433     }
434
435     if (!im->virtual && im->bits == i_8_bits && im->type == i_direct_type) {
436       rc = ig->writecb(ig,im->idata,im->bytes);
437     }
438     else {
439       unsigned char *data = mymalloc(3 * im->xsize);
440       if (data != NULL) {
441         int y = 0;
442         static int rgb_chan[3] = { 0, 1, 2 };
443
444         rc = 0;
445         while (y < im->ysize && rc >= 0) {
446           i_gsamp(im, 0, im->xsize, y, data, rgb_chan, 3);
447           rc = ig->writecb(ig, data, im->xsize * 3);
448           ++y;
449         }
450         myfree(data);
451       }
452       else {
453         i_push_error(0, "Out of memory");
454         return 0;
455       }
456     }
457     if (rc<0) {
458       i_push_error(errno, "could not write ppm data");
459       mm_log((1,"i_writeppm: unable to write ppm data.\n"));
460       return(0);
461     }
462   }
463   else if (im->channels == 1) {
464     sprintf(header, "P5\n#CREATOR: Imager\n%d %d\n255\n",
465             im->xsize, im->ysize);
466     if (ig->writecb(ig,header, strlen(header)) < 0) {
467       i_push_error(errno, "could not write pgm header");
468       mm_log((1,"i_writeppm: unable to write pgm header.\n"));
469       return(0);
470     }
471
472     if (!im->virtual && im->bits == i_8_bits && im->type == i_direct_type) {
473       rc=ig->writecb(ig,im->idata,im->bytes);
474     }
475     else {
476       unsigned char *data = mymalloc(im->xsize);
477       if (data != NULL) {
478         int y = 0;
479         int chan = 0;
480
481         rc = 0;
482         while (y < im->ysize && rc >= 0) {
483           i_gsamp(im, 0, im->xsize, y, data, &chan, 1);
484           rc = ig->writecb(ig, data, im->xsize);
485           ++y;
486         }
487         myfree(data);
488       }
489       else {
490         i_push_error(0, "Out of memory");
491         return 0;
492       }
493     }
494     if (rc<0) {
495       i_push_error(errno, "could not write pgm data");
496       mm_log((1,"i_writeppm: unable to write pgm data.\n"));
497       return(0);
498     }
499   }
500   else {
501     i_push_error(0, "can only save 1 or 3 channel images to pnm");
502     mm_log((1,"i_writeppm: ppm/pgm is 1 or 3 channel only (current image is %d)\n",im->channels));
503     return(0);
504   }
505   ig->closecb(ig);
506
507   return(1);
508 }
509
510 /*
511 =back
512
513 =head1 AUTHOR
514
515 Arnar M. Hrafnkelsson <addi@umich.edu>
516
517 =head1 SEE ALSO
518
519 Imager(3)
520
521 =cut
522 */