13 pnm.c - implements reading and writing ppm/pnm/pbm files, uses io layer.
17 io_glue *ig = io_new_fd( fd );
18 i_img *im = i_readpnm_wiol(ig, 0); // no limit on how much is read
20 io_glue *ig = io_new_fd( fd );
21 return_code = i_writepnm_wiol(im, ig);
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.
29 =head1 FUNCTION REFERENCE
31 Some of these functions are internal.
40 #define misspace(x) (x==' ' || x=='\n' || x=='\r' || x=='\t' || x=='\f' || x=='\v')
41 #define misnumber(x) (x <= '9' && x>='0')
43 static char *typenames[]={"ascii pbm", "ascii pgm", "ascii ppm", "binary pbm", "binary pgm", "binary ppm"};
46 * Type to encapsulate the local buffer
47 * management skipping over in a file
59 void init_buf(mbuf *mb, io_glue *ig) {
70 Fetches a character and advances in stream by one character.
71 Returns a pointer to the byte or NULL on failure (internal).
78 #define gnext(mb) (((mb)->cp == (mb)->len) ? gnextf(mb) : (mb)->buf + (mb)->cp++)
84 if (mb->cp == mb->len) {
86 mb->len = ig->readcb(ig, mb->buf, BSIZ);
88 i_push_error(errno, "file read error");
89 mm_log((1, "i_readpnm: read error\n"));
93 mm_log((1, "i_readpnm: end of file\n"));
97 return &mb->buf[mb->cp++];
102 =item gpeek(mbuf *mb)
104 Fetches a character but does NOT advance. Returns a pointer to
105 the byte or NULL on failure (internal).
112 #define gpeek(mb) ((mb)->cp == (mb)->len ? gpeekf(mb) : (mb)->buf + (mb)->cp)
117 io_glue *ig = mb->ig;
118 if (mb->cp == mb->len) {
120 mb->len = ig->readcb(ig, mb->buf, BSIZ);
122 i_push_error(errno, "read error");
123 mm_log((1, "i_readpnm: read error\n"));
127 mm_log((1, "i_readpnm: end of file\n"));
131 return &mb->buf[mb->cp];
135 gread(mbuf *mb, unsigned char *buf, size_t read_size) {
137 if (mb->cp != mb->len) {
138 int avail_size = mb->len - mb->cp;
139 int use_size = read_size > avail_size ? avail_size : read_size;
140 memcpy(buf, mb->buf+mb->cp, use_size);
142 total_read += use_size;
143 read_size -= use_size;
147 io_glue *ig = mb->ig;
148 int read_res = i_io_read(ig, buf, read_size);
150 total_read += read_res;
158 =item skip_spaces(mb)
160 Advances in stream until it is positioned at a
161 non white space character. (internal)
170 skip_spaces(mbuf *mb) {
172 while( (cp = gpeek(mb)) && misspace(*cp) ) if ( !gnext(mb) ) break;
179 =item skip_comment(mb)
181 Advances in stream over whitespace and a comment if one is found. (internal)
190 skip_comment(mbuf *mb) {
193 if (!skip_spaces(mb)) return 0;
195 if (!(cp = gpeek(mb))) return 0;
197 while( (cp = gpeek(mb)) && (*cp != '\n' && *cp != '\r') ) {
198 if ( !gnext(mb) ) break;
210 Fetches the next number from stream and stores in i, returns true
211 on success else false.
214 i - integer to store result in
221 gnum(mbuf *mb, int *i) {
225 if (!skip_spaces(mb)) return 0;
227 if (!(cp = gpeek(mb)))
231 while( (cp = gpeek(mb)) && misnumber(*cp) ) {
232 *i = *i*10+(*cp-'0');
240 read_pgm_ppm_bin8(mbuf *mb, i_img *im, int width, int height,
241 int channels, int maxval, int allow_partial) {
242 i_color *line, *linep;
244 unsigned char *read_buf, *readp;
246 int rounder = maxval / 2;
248 line = mymalloc(width * sizeof(i_color));
249 read_size = channels * width;
250 read_buf = mymalloc(read_size);
251 for(y=0;y<height;y++) {
254 if (gread(mb, read_buf, read_size) != read_size) {
258 i_tags_setn(&im->tags, "i_incomplete", 1);
259 i_tags_setn(&im->tags, "i_lines_read", y);
263 i_push_error(0, "short read - file truncated?");
269 for(x=0; x<width; x++) {
270 for(ch=0; ch<channels; ch++) {
271 linep->channel[ch] = *readp++;
277 for(x=0; x<width; x++) {
278 for(ch=0; ch<channels; ch++) {
279 /* we just clamp samples to the correct range */
280 unsigned sample = *readp++;
283 linep->channel[ch] = (sample * 255 + rounder) / maxval;
288 i_plin(im, 0, width, y, line);
298 read_pgm_ppm_bin16(mbuf *mb, i_img *im, int width, int height,
299 int channels, int maxval, int allow_partial) {
300 i_fcolor *line, *linep;
302 unsigned char *read_buf, *readp;
304 double maxvalf = maxval;
306 line = mymalloc(width * sizeof(i_fcolor));
307 read_size = channels * width * 2;
308 read_buf = mymalloc(read_size);
309 for(y=0;y<height;y++) {
312 if (gread(mb, read_buf, read_size) != read_size) {
316 i_tags_setn(&im->tags, "i_incomplete", 1);
317 i_tags_setn(&im->tags, "i_lines_read", y);
321 i_push_error(0, "short read - file truncated?");
326 for(x=0; x<width; x++) {
327 for(ch=0; ch<channels; ch++) {
328 unsigned sample = (readp[0] << 8) + readp[1];
332 linep->channel[ch] = sample / maxvalf;
336 i_plinf(im, 0, width, y, line);
346 read_pbm_bin(mbuf *mb, i_img *im, int width, int height, int allow_partial) {
347 i_palidx *line, *linep;
349 unsigned char *read_buf, *readp;
353 line = mymalloc(width * sizeof(i_palidx));
354 read_size = (width + 7) / 8;
355 read_buf = mymalloc(read_size);
356 for(y = 0; y < height; y++) {
357 if (gread(mb, read_buf, read_size) != read_size) {
361 i_tags_setn(&im->tags, "i_incomplete", 1);
362 i_tags_setn(&im->tags, "i_lines_read", y);
366 i_push_error(0, "short read - file truncated?");
374 for(x = 0; x < width; ++x) {
375 *linep++ = *readp & mask ? 1 : 0;
382 i_ppal(im, 0, width, y, line);
390 /* unlike pgm/ppm pbm:
391 - doesn't require spaces between samples (bits)
392 - 1 (maxval) is black instead of white
396 read_pbm_ascii(mbuf *mb, i_img *im, int width, int height, int allow_partial) {
397 i_palidx *line, *linep;
400 line = mymalloc(width * sizeof(i_palidx));
401 for(y = 0; y < height; y++) {
403 for(x = 0; x < width; ++x) {
406 if (!(cp = gnext(mb)) || (*cp != '0' && *cp != '1')) {
409 i_tags_setn(&im->tags, "i_incomplete", 1);
410 i_tags_setn(&im->tags, "i_lines_read", y);
415 i_push_error(0, "invalid data for ascii pnm");
417 i_push_error(0, "short read - file truncated?");
422 *linep++ = *cp == '0' ? 0 : 1;
424 i_ppal(im, 0, width, y, line);
433 read_pgm_ppm_ascii(mbuf *mb, i_img *im, int width, int height, int channels,
434 int maxval, int allow_partial) {
435 i_color *line, *linep;
437 int rounder = maxval / 2;
439 line = mymalloc(width * sizeof(i_color));
440 for(y=0;y<height;y++) {
442 for(x=0; x<width; x++) {
443 for(ch=0; ch<channels; ch++) {
446 if (!gnum(mb, &sample)) {
449 i_tags_setn(&im->tags, "i_incomplete", 1);
450 i_tags_setn(&im->tags, "i_lines_read", 1);
455 i_push_error(0, "invalid data for ascii pnm");
457 i_push_error(0, "short read - file truncated?");
464 linep->channel[ch] = (sample * 255 + rounder) / maxval;
468 i_plin(im, 0, width, y, line);
477 read_pgm_ppm_ascii_16(mbuf *mb, i_img *im, int width, int height,
478 int channels, int maxval, int allow_partial) {
479 i_fcolor *line, *linep;
481 double maxvalf = maxval;
483 line = mymalloc(width * sizeof(i_fcolor));
484 for(y=0;y<height;y++) {
486 for(x=0; x<width; x++) {
487 for(ch=0; ch<channels; ch++) {
490 if (!gnum(mb, &sample)) {
496 i_push_error(0, "invalid data for ascii pnm");
498 i_push_error(0, "short read - file truncated?");
505 linep->channel[ch] = sample / maxvalf;
509 i_plinf(im, 0, width, y, line);
517 =item i_readpnm_wiol(ig, allow_partial)
519 Retrieve an image and stores in the iolayer object. Returns NULL on fatal error.
522 allow_partial - allows a partial file to be read successfully
529 i_readpnm_wiol(io_glue *ig, int allow_partial) {
532 int width, height, maxval, channels, pcount;
538 mm_log((1,"i_readpnm(ig %p, allow_partial %d)\n", ig, allow_partial));
540 io_glue_commit_types(ig);
545 if (!cp || *cp != 'P') {
546 i_push_error(0, "bad header magic, not a PNM file");
547 mm_log((1, "i_readpnm: Could not read header of file\n"));
551 if ( !(cp = gnext(&buf)) ) {
552 mm_log((1, "i_readpnm: Could not read header of file\n"));
558 if (type < 1 || type > 6) {
559 i_push_error(0, "unknown PNM file type, not a PNM file");
560 mm_log((1, "i_readpnm: Not a pnm file\n"));
564 if ( !(cp = gnext(&buf)) ) {
565 mm_log((1, "i_readpnm: Could not read header of file\n"));
569 if ( !misspace(*cp) ) {
570 i_push_error(0, "unexpected character, not a PNM file");
571 mm_log((1, "i_readpnm: Not a pnm file\n"));
575 mm_log((1, "i_readpnm: image is a %s\n", typenames[type-1] ));
578 /* Read sizes and such */
580 if (!skip_comment(&buf)) {
581 i_push_error(0, "while skipping to width");
582 mm_log((1, "i_readpnm: error reading before width\n"));
586 if (!gnum(&buf, &width)) {
587 i_push_error(0, "could not read image width");
588 mm_log((1, "i_readpnm: error reading width\n"));
592 if (!skip_comment(&buf)) {
593 i_push_error(0, "while skipping to height");
594 mm_log((1, "i_readpnm: error reading before height\n"));
598 if (!gnum(&buf, &height)) {
599 i_push_error(0, "could not read image height");
600 mm_log((1, "i_readpnm: error reading height\n"));
604 if (!(type == 1 || type == 4)) {
605 if (!skip_comment(&buf)) {
606 i_push_error(0, "while skipping to maxval");
607 mm_log((1, "i_readpnm: error reading before maxval\n"));
611 if (!gnum(&buf, &maxval)) {
612 i_push_error(0, "could not read maxval");
613 mm_log((1, "i_readpnm: error reading maxval\n"));
618 i_push_error(0, "maxval is zero - invalid pnm file");
619 mm_log((1, "i_readpnm: maxval is zero, invalid pnm file\n"));
622 else if (maxval > 65535) {
623 i_push_errorf(0, "maxval of %d is over 65535 - invalid pnm file",
625 mm_log((1, "i_readpnm: maxval of %d is over 65535 - invalid pnm file\n"));
629 rounder = maxval / 2;
631 if (!(cp = gnext(&buf)) || !misspace(*cp)) {
632 i_push_error(0, "garbage in header, invalid PNM file");
633 mm_log((1, "i_readpnm: garbage in header\n"));
637 channels = (type == 3 || type == 6) ? 3:1;
638 pcount = width*height*channels;
640 if (!i_int_check_image_file_limits(width, height, channels, sizeof(i_sample_t))) {
641 mm_log((1, "i_readpnm: image size exceeds limits\n"));
645 mm_log((1, "i_readpnm: (%d x %d), channels = %d, maxval = %d\n", width, height, channels, maxval));
647 if (type == 1 || type == 4) {
649 pbm_pal[0].channel[0] = 255;
650 pbm_pal[1].channel[0] = 0;
652 im = i_img_pal_new(width, height, 1, 256);
653 i_addcolors(im, pbm_pal, 2);
657 im = i_img_16_new(width, height, channels);
659 im = i_img_8_new(width, height, channels);
663 case 1: /* Ascii types */
664 im = read_pbm_ascii(&buf, im, width, height, allow_partial);
670 im = read_pgm_ppm_ascii_16(&buf, im, width, height, channels, maxval, allow_partial);
672 im = read_pgm_ppm_ascii(&buf, im, width, height, channels, maxval, allow_partial);
675 case 4: /* binary pbm */
676 im = read_pbm_bin(&buf, im, width, height, allow_partial);
679 case 5: /* binary pgm */
680 case 6: /* binary ppm */
682 im = read_pgm_ppm_bin16(&buf, im, width, height, channels, maxval, allow_partial);
684 im = read_pgm_ppm_bin8(&buf, im, width, height, channels, maxval, allow_partial);
688 mm_log((1, "type %s [P%d] unsupported\n", typenames[type-1], type));
695 i_tags_add(&im->tags, "i_format", 0, "pnm", -1, 0);
696 i_tags_setn(&im->tags, "pnm_maxval", maxval);
697 i_tags_setn(&im->tags, "pnm_type", type);
704 write_pbm(i_img *im, io_glue *ig, int zero_is_white) {
708 unsigned char *write_buf;
709 unsigned char *writep;
713 sprintf(header, "P4\012# CREATOR: Imager\012%d %d\012",
714 im->xsize, im->ysize);
715 if (i_io_write(ig, header, strlen(header)) < 0) {
716 i_push_error(0, "could not write pbm header");
719 write_size = (im->xsize + 7) / 8;
720 line = mymalloc(sizeof(i_palidx) * im->xsize);
721 write_buf = mymalloc(write_size);
722 for (y = 0; y < im->ysize; ++y) {
723 i_gpal(im, 0, im->xsize, y, line);
726 memset(write_buf, 0, write_size);
727 for (x = 0; x < im->xsize; ++x) {
728 if (zero_is_white ? line[x] : !line[x])
736 if (i_io_write(ig, write_buf, write_size) != write_size) {
737 i_push_error(0, "write failure");
751 write_ppm_data_8(i_img *im, io_glue *ig) {
752 int write_size = im->xsize * im->channels;
753 unsigned char *data = mymalloc(write_size);
757 while (y < im->ysize && rc >= 0) {
758 i_gsamp(im, 0, im->xsize, y, data, NULL, im->channels);
759 if (i_io_write(ig, data, write_size) != write_size) {
760 i_push_error(errno, "could not write ppm data");
773 write_ppm_data_16(i_img *im, io_glue *ig) {
774 int sample_count = im->channels * im->xsize;
775 int write_size = sample_count * 2;
776 int line_size = sample_count * sizeof(i_fsample_t);
777 i_fsample_t *line_buf = mymalloc(line_size);
778 i_fsample_t *samplep;
779 unsigned char *write_buf = mymalloc(write_size);
780 unsigned char *writep;
785 while (y < im->ysize) {
786 i_gsampf(im, 0, im->xsize, y, line_buf, NULL, im->channels);
789 for (sample_num = 0; sample_num < sample_count; ++sample_num) {
790 unsigned sample16 = SampleFTo16(*samplep++);
791 *writep++ = sample16 >> 8;
792 *writep++ = sample16 & 0xFF;
794 if (i_io_write(ig, write_buf, write_size) != write_size) {
795 i_push_error(errno, "could not write ppm data");
808 i_writeppm_wiol(i_img *im, io_glue *ig) {
813 mm_log((1,"i_writeppm(im %p, ig %p)\n", im, ig));
816 /* Add code to get the filename info from the iolayer */
817 /* Also add code to check for mmapped code */
819 io_glue_commit_types(ig);
821 if (i_img_is_monochrome(im, &zero_is_white)) {
822 return write_pbm(im, ig, zero_is_white);
828 if (!i_tags_get_int(&im->tags, "pnm_write_wide_data", 0, &wide_data))
831 if (im->channels == 3) {
834 else if (im->channels == 1) {
838 i_push_error(0, "can only save 1 or 3 channel images to pnm");
839 mm_log((1,"i_writeppm: ppm/pgm is 1 or 3 channel only (current image is %d)\n",im->channels));
842 if (im->bits <= 8 || !wide_data)
847 sprintf(header,"P%d\n#CREATOR: Imager\n%d %d\n%d\n",
848 type, im->xsize, im->ysize, maxval);
850 if (ig->writecb(ig,header,strlen(header)) != strlen(header)) {
851 i_push_error(errno, "could not write ppm header");
852 mm_log((1,"i_writeppm: unable to write ppm header.\n"));
856 if (!im->virtual && im->bits == i_8_bits && im->type == i_direct_type) {
857 if (ig->writecb(ig,im->idata,im->bytes) != im->bytes) {
858 i_push_error(errno, "could not write ppm data");
862 else if (maxval == 255) {
863 if (!write_ppm_data_8(im, ig))
867 if (!write_ppm_data_16(im, ig))
881 Arnar M. Hrafnkelsson <addi@umich.edu>, Tony Cook<tony@imager.perl.org>