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, 0); // 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 #define gnext(mb) (((mb)->cp == (mb)->len) ? gnextf(mb) : (mb)->buf + (mb)->cp++)
  79
  80 static
  81 char *
  82 gnextf(mbuf *mb) {
  83   io_glue *ig = mb->ig;
  84   if (mb->cp == mb->len) {
  85     mb->cp = 0;
  86     mb->len = ig->readcb(ig, mb->buf, BSIZ);
  87     if (mb->len == -1) {
  88       i_push_error(errno, "file read error");
  89       mm_log((1, "i_readpnm: read error\n"));
  90       return NULL;
  91     }
  92     if (mb->len == 0) {
  93       mm_log((1, "i_readpnm: end of file\n"));
  94       return NULL;
  95     }
  96   }
  97   return &mb->buf[mb->cp++];
  98 }
  99
 100
 101 /*
 102 =item gpeek(mbuf *mb)
 103
 104 Fetches a character but does NOT advance.  Returns a pointer to
 105 the byte or NULL on failure (internal).
 106
 107    mb - buffer object
 108
 109 =cut
 110 */
 111
 112 #define gpeek(mb) ((mb)->cp == (mb)->len ? gpeekf(mb) : (mb)->buf + (mb)->cp)
 113
 114 static
 115 char *
 116 gpeekf(mbuf *mb) {
 117   io_glue *ig = mb->ig;
 118   if (mb->cp == mb->len) {
 119     mb->cp = 0;
 120     mb->len = ig->readcb(ig, mb->buf, BSIZ);
 121     if (mb->len == -1) {
 122       i_push_error(errno, "read error");
 123       mm_log((1, "i_readpnm: read error\n"));
 124       return NULL;
 125     }
 126     if (mb->len == 0) {
 127       mm_log((1, "i_readpnm: end of file\n"));
 128       return NULL;
 129     }
 130   }
 131   return &mb->buf[mb->cp];
 132 }
 133
 134 int
 135 gread(mbuf *mb, unsigned char *buf, size_t read_size) {
 136   int total_read = 0;
 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);
 141     mb->cp += use_size;
 142     total_read += use_size;
 143     read_size -= use_size;
 144     buf += use_size;
 145   }
 146   if (read_size) {
 147     io_glue *ig = mb->ig;
 148     int read_res = i_io_read(ig, buf, read_size);
 149     if (read_res >= 0) {
 150       total_read += read_res;
 151     }
 152   }
 153   return total_read;
 154 }
 155
 156
 157 /*
 158 =item skip_spaces(mb)
 159
 160 Advances in stream until it is positioned at a
 161 non white space character. (internal)
 162
 163    mb - buffer object
 164
 165 =cut
 166 */
 167
 168 static
 169 int
 170 skip_spaces(mbuf *mb) {
 171   char *cp;
 172   while( (cp = gpeek(mb)) && misspace(*cp) ) if ( !gnext(mb) ) break;
 173   if (!cp) return 0;
 174   return 1;
 175 }
 176
 177
 178 /*
 179 =item skip_comment(mb)
 180
 181 Advances in stream over whitespace and a comment if one is found. (internal)
 182
 183    mb - buffer object
 184
 185 =cut
 186 */
 187
 188 static
 189 int
 190 skip_comment(mbuf *mb) {
 191   char *cp;
 192
 193   if (!skip_spaces(mb)) return 0;
 194
 195   if (!(cp = gpeek(mb))) return 0;
 196   if (*cp == '#') {
 197     while( (cp = gpeek(mb)) && (*cp != '\n' && *cp != '\r') ) {
 198       if ( !gnext(mb) ) break;
 199     }
 200   }
 201   if (!cp) return 0;
 202
 203   return 1;
 204 }
 205
 206
 207 /*
 208 =item gnum(mb, i)
 209
 210 Fetches the next number from stream and stores in i, returns true
 211 on success else false.
 212
 213    mb - buffer object
 214    i  - integer to store result in
 215
 216 =cut
 217 */
 218
 219 static
 220 int
 221 gnum(mbuf *mb, int *i) {
 222   char *cp;
 223   *i = 0;
 224
 225   if (!skip_spaces(mb)) return 0;
 226
 227   if (!(cp = gpeek(mb)))
 228     return 0;
 229   if (!misnumber(*cp))
 230     return 0;
 231   while( (cp = gpeek(mb)) && misnumber(*cp) ) {
 232     *i = *i*10+(*cp-'0');
 233     cp = gnext(mb);
 234   }
 235   return 1;
 236 }
 237
 238 static
 239 i_img *
 240 read_pgm_ppm_bin8(mbuf *mb, i_img *im, int width, int height,
 241                   int channels, int maxval, int allow_incomplete) {
 242   i_color *line, *linep;
 243   int read_size;
 244   unsigned char *read_buf, *readp;
 245   int x, y, ch;
 246   int rounder = maxval / 2;
 247
 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++) {
 252     linep = line;
 253     readp = read_buf;
 254     if (gread(mb, read_buf, read_size) != read_size) {
 255       myfree(line);
 256       myfree(read_buf);
 257       if (allow_incomplete) {
 258         i_tags_setn(&im->tags, "i_incomplete", 1);
 259         i_tags_setn(&im->tags, "i_lines_read", y);
 260         return im;
 261       }
 262       else {
 263         i_push_error(0, "short read - file truncated?");
 264         i_img_destroy(im);
 265         return NULL;
 266       }
 267     }
 268     if (maxval == 255) {
 269       for(x=0; x<width; x++) {
 270         for(ch=0; ch<channels; ch++) {
 271           linep->channel[ch] = *readp++;
 272         }
 273         ++linep;
 274       }
 275     }
 276     else {
 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++;
 281           if (sample > maxval)
 282             sample = maxval;
 283           linep->channel[ch] = (sample * 255 + rounder) / maxval;
 284         }
 285         ++linep;
 286       }
 287     }
 288     i_plin(im, 0, width, y, line);
 289   }
 290   myfree(read_buf);
 291   myfree(line);
 292
 293   return im;
 294 }
 295
 296 static
 297 i_img *
 298 read_pgm_ppm_bin16(mbuf *mb, i_img *im, int width, int height,
 299                   int channels, int maxval, int allow_incomplete) {
 300   i_fcolor *line, *linep;
 301   int read_size;
 302   unsigned char *read_buf, *readp;
 303   int x, y, ch;
 304   double maxvalf = maxval;
 305
 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++) {
 310     linep = line;
 311     readp = read_buf;
 312     if (gread(mb, read_buf, read_size) != read_size) {
 313       myfree(line);
 314       myfree(read_buf);
 315       if (allow_incomplete) {
 316         i_tags_setn(&im->tags, "i_incomplete", 1);
 317         i_tags_setn(&im->tags, "i_lines_read", y);
 318         return im;
 319       }
 320       else {
 321         i_push_error(0, "short read - file truncated?");
 322         i_img_destroy(im);
 323         return NULL;
 324       }
 325     }
 326     for(x=0; x<width; x++) {
 327       for(ch=0; ch<channels; ch++) {
 328         unsigned sample = (readp[0] << 8) + readp[1];
 329         if (sample > maxval)
 330           sample = maxval;
 331         readp += 2;
 332         linep->channel[ch] = sample / maxvalf;
 333       }
 334       ++linep;
 335     }
 336     i_plinf(im, 0, width, y, line);
 337   }
 338   myfree(read_buf);
 339   myfree(line);
 340
 341   return im;
 342 }
 343
 344 static
 345 i_img *
 346 read_pbm_bin(mbuf *mb, i_img *im, int width, int height, int allow_incomplete) {
 347   i_palidx *line, *linep;
 348   int read_size;
 349   unsigned char *read_buf, *readp;
 350   int x, y;
 351   unsigned mask;
 352
 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) {
 358       myfree(line);
 359       myfree(read_buf);
 360       if (allow_incomplete) {
 361         i_tags_setn(&im->tags, "i_incomplete", 1);
 362         i_tags_setn(&im->tags, "i_lines_read", y);
 363         return im;
 364       }
 365       else {
 366         i_push_error(0, "short read - file truncated?");
 367         i_img_destroy(im);
 368         return NULL;
 369       }
 370     }
 371     linep = line;
 372     readp = read_buf;
 373     mask = 0x80;
 374     for(x = 0; x < width; ++x) {
 375       *linep++ = *readp & mask ? 1 : 0;
 376       mask >>= 1;
 377       if (mask == 0) {
 378         ++readp;
 379         mask = 0x80;
 380       }
 381     }
 382     i_ppal(im, 0, width, y, line);
 383   }
 384   myfree(read_buf);
 385   myfree(line);
 386
 387   return im;
 388 }
 389
 390 /* unlike pgm/ppm pbm:
 391   - doesn't require spaces between samples (bits)
 392   - 1 (maxval) is black instead of white
 393 */
 394 static
 395 i_img *
 396 read_pbm_ascii(mbuf *mb, i_img *im, int width, int height, int allow_incomplete) {
 397   i_palidx *line, *linep;
 398   int x, y;
 399
 400   line = mymalloc(width * sizeof(i_palidx));
 401   for(y = 0; y < height; y++) {
 402     linep = line;
 403     for(x = 0; x < width; ++x) {
 404       char *cp;
 405       skip_spaces(mb);
 406       if (!(cp = gnext(mb)) || (*cp != '0' && *cp != '1')) {
 407         myfree(line);
 408         if (allow_incomplete) {
 409           i_tags_setn(&im->tags, "i_incomplete", 1);
 410           i_tags_setn(&im->tags, "i_lines_read", y);
 411           return im;
 412         }
 413         else {
 414           if (cp)
 415             i_push_error(0, "invalid data for ascii pnm");
 416           else
 417             i_push_error(0, "short read - file truncated?");
 418           i_img_destroy(im);
 419           return NULL;
 420         }
 421       }
 422       *linep++ = *cp == '0' ? 0 : 1;
 423     }
 424     i_ppal(im, 0, width, y, line);
 425   }
 426   myfree(line);
 427
 428   return im;
 429 }
 430
 431 static
 432 i_img *
 433 read_pgm_ppm_ascii(mbuf *mb, i_img *im, int width, int height, int channels,
 434                    int maxval, int allow_incomplete) {
 435   i_color *line, *linep;
 436   int x, y, ch;
 437   int rounder = maxval / 2;
 438
 439   line = mymalloc(width * sizeof(i_color));
 440   for(y=0;y<height;y++) {
 441     linep = line;
 442     for(x=0; x<width; x++) {
 443       for(ch=0; ch<channels; ch++) {
 444         int sample;
 445
 446         if (!gnum(mb, &sample)) {
 447           myfree(line);
 448           if (allow_incomplete) {
 449             i_tags_setn(&im->tags, "i_incomplete", 1);
 450             i_tags_setn(&im->tags, "i_lines_read", 1);
 451             return im;
 452           }
 453           else {
 454             if (gpeek(mb))
 455               i_push_error(0, "invalid data for ascii pnm");
 456             else
 457               i_push_error(0, "short read - file truncated?");
 458             i_img_destroy(im);
 459             return NULL;
 460           }
 461         }
 462         if (sample > maxval)
 463           sample = maxval;
 464         linep->channel[ch] = (sample * 255 + rounder) / maxval;
 465       }
 466       ++linep;
 467     }
 468     i_plin(im, 0, width, y, line);
 469   }
 470   myfree(line);
 471
 472   return im;
 473 }
 474
 475 static
 476 i_img *
 477 read_pgm_ppm_ascii_16(mbuf *mb, i_img *im, int width, int height,
 478                       int channels, int maxval, int allow_incomplete) {
 479   i_fcolor *line, *linep;
 480   int x, y, ch;
 481   double maxvalf = maxval;
 482
 483   line = mymalloc(width * sizeof(i_fcolor));
 484   for(y=0;y<height;y++) {
 485     linep = line;
 486     for(x=0; x<width; x++) {
 487       for(ch=0; ch<channels; ch++) {
 488         int sample;
 489
 490         if (!gnum(mb, &sample)) {
 491           myfree(line);
 492           if (allow_incomplete) {
 493             i_tags_setn(&im->tags, "i_incomplete", 1);
 494             i_tags_setn(&im->tags, "i_lines_read", y);
 495             return im;
 496           }
 497           else {
 498             if (gpeek(mb))
 499               i_push_error(0, "invalid data for ascii pnm");
 500             else
 501               i_push_error(0, "short read - file truncated?");
 502             i_img_destroy(im);
 503             return NULL;
 504           }
 505         }
 506         if (sample > maxval)
 507           sample = maxval;
 508         linep->channel[ch] = sample / maxvalf;
 509       }
 510       ++linep;
 511     }
 512     i_plinf(im, 0, width, y, line);
 513   }
 514   myfree(line);
 515
 516   return im;
 517 }
 518
 519 /*
 520 =item i_readpnm_wiol(ig, allow_incomplete)
 521
 522 Retrieve an image and stores in the iolayer object. Returns NULL on fatal error.
 523
 524    ig     - io_glue object
 525    allow_incomplete - allows a partial file to be read successfully
 526
 527 =cut
 528 */
 529
 530
 531 i_img *
 532 i_readpnm_wiol(io_glue *ig, int allow_incomplete) {
 533   i_img* im;
 534   int type;
 535   int width, height, maxval, channels, pcount;
 536   int rounder;
 537   char *cp;
 538   mbuf buf;
 539
 540   i_clear_error();
 541   mm_log((1,"i_readpnm(ig %p, allow_incomplete %d)\n", ig, allow_incomplete));
 542
 543   io_glue_commit_types(ig);
 544   init_buf(&buf, ig);
 545
 546   cp = gnext(&buf);
 547
 548   if (!cp || *cp != 'P') {
 549     i_push_error(0, "bad header magic, not a PNM file");
 550     mm_log((1, "i_readpnm: Could not read header of file\n"));
 551     return NULL;
 552   }
 553
 554   if ( !(cp = gnext(&buf)) ) {
 555     mm_log((1, "i_readpnm: Could not read header of file\n"));
 556     return NULL;
 557   }
 558
 559   type = *cp-'0';
 560
 561   if (type < 1 || type > 6) {
 562     i_push_error(0, "unknown PNM file type, not a PNM file");
 563     mm_log((1, "i_readpnm: Not a pnm file\n"));
 564     return NULL;
 565   }
 566
 567   if ( !(cp = gnext(&buf)) ) {
 568     mm_log((1, "i_readpnm: Could not read header of file\n"));
 569     return NULL;
 570   }
 571
 572   if ( !misspace(*cp) ) {
 573     i_push_error(0, "unexpected character, not a PNM file");
 574     mm_log((1, "i_readpnm: Not a pnm file\n"));
 575     return NULL;
 576   }
 577
 578   mm_log((1, "i_readpnm: image is a %s\n", typenames[type-1] ));
 579
 580
 581   /* Read sizes and such */
 582
 583   if (!skip_comment(&buf)) {
 584     i_push_error(0, "while skipping to width");
 585     mm_log((1, "i_readpnm: error reading before width\n"));
 586     return NULL;
 587   }
 588
 589   if (!gnum(&buf, &width)) {
 590     i_push_error(0, "could not read image width");
 591     mm_log((1, "i_readpnm: error reading width\n"));
 592     return NULL;
 593   }
 594
 595   if (!skip_comment(&buf)) {
 596     i_push_error(0, "while skipping to height");
 597     mm_log((1, "i_readpnm: error reading before height\n"));
 598     return NULL;
 599   }
 600
 601   if (!gnum(&buf, &height)) {
 602     i_push_error(0, "could not read image height");
 603     mm_log((1, "i_readpnm: error reading height\n"));
 604     return NULL;
 605   }
 606
 607   if (!(type == 1 || type == 4)) {
 608     if (!skip_comment(&buf)) {
 609       i_push_error(0, "while skipping to maxval");
 610       mm_log((1, "i_readpnm: error reading before maxval\n"));
 611       return NULL;
 612     }
 613
 614     if (!gnum(&buf, &maxval)) {
 615       i_push_error(0, "could not read maxval");
 616       mm_log((1, "i_readpnm: error reading maxval\n"));
 617       return NULL;
 618     }
 619
 620     if (maxval == 0) {
 621       i_push_error(0, "maxval is zero - invalid pnm file");
 622       mm_log((1, "i_readpnm: maxval is zero, invalid pnm file\n"));
 623       return NULL;
 624     }
 625     else if (maxval > 65535) {
 626       i_push_errorf(0, "maxval of %d is over 65535 - invalid pnm file",
 627                     maxval);
 628       mm_log((1, "i_readpnm: maxval of %d is over 65535 - invalid pnm file\n"));
 629       return NULL;
 630     }
 631   } else maxval=1;
 632   rounder = maxval / 2;
 633
 634   if (!(cp = gnext(&buf)) || !misspace(*cp)) {
 635     i_push_error(0, "garbage in header, invalid PNM file");
 636     mm_log((1, "i_readpnm: garbage in header\n"));
 637     return NULL;
 638   }
 639
 640   channels = (type == 3 || type == 6) ? 3:1;
 641   pcount = width*height*channels;
 642
 643   if (!i_int_check_image_file_limits(width, height, channels, sizeof(i_sample_t))) {
 644     mm_log((1, "i_readpnm: image size exceeds limits\n"));
 645     return NULL;
 646   }
 647
 648   mm_log((1, "i_readpnm: (%d x %d), channels = %d, maxval = %d\n", width, height, channels, maxval));
 649
 650   if (type == 1 || type == 4) {
 651     i_color pbm_pal[2];
 652     pbm_pal[0].channel[0] = 255;
 653     pbm_pal[1].channel[0] = 0;
 654
 655     im = i_img_pal_new(width, height, 1, 256);
 656     i_addcolors(im, pbm_pal, 2);
 657   }
 658   else {
 659     if (maxval > 255)
 660       im = i_img_16_new(width, height, channels);
 661     else
 662       im = i_img_8_new(width, height, channels);
 663   }
 664
 665   switch (type) {
 666   case 1: /* Ascii types */
 667     im = read_pbm_ascii(&buf, im, width, height, allow_incomplete);
 668     break;
 669
 670   case 2:
 671   case 3:
 672     if (maxval > 255)
 673       im = read_pgm_ppm_ascii_16(&buf, im, width, height, channels, maxval, allow_incomplete);
 674     else
 675       im = read_pgm_ppm_ascii(&buf, im, width, height, channels, maxval, allow_incomplete);
 676     break;
 677
 678   case 4: /* binary pbm */
 679     im = read_pbm_bin(&buf, im, width, height, allow_incomplete);
 680     break;
 681
 682   case 5: /* binary pgm */
 683   case 6: /* binary ppm */
 684     if (maxval > 255)
 685       im = read_pgm_ppm_bin16(&buf, im, width, height, channels, maxval, allow_incomplete);
 686     else
 687       im = read_pgm_ppm_bin8(&buf, im, width, height, channels, maxval, allow_incomplete);
 688     break;
 689
 690   default:
 691     mm_log((1, "type %s [P%d] unsupported\n", typenames[type-1], type));
 692     return NULL;
 693   }
 694
 695   if (!im)
 696     return NULL;
 697
 698   i_tags_add(&im->tags, "i_format", 0, "pnm", -1, 0);
 699   i_tags_setn(&im->tags, "pnm_maxval", maxval);
 700   i_tags_setn(&im->tags, "pnm_type", type);
 701
 702   return im;
 703 }
 704
 705 static
 706 int
 707 write_pbm(i_img *im, io_glue *ig, int zero_is_white) {
 708   int x, y;
 709   i_palidx *line;
 710   int write_size;
 711   unsigned char *write_buf;
 712   unsigned char *writep;
 713   char header[255];
 714   unsigned mask;
 715
 716   sprintf(header, "P4\012# CREATOR: Imager\012%d %d\012",
 717           im->xsize, im->ysize);
 718   if (i_io_write(ig, header, strlen(header)) < 0) {
 719     i_push_error(0, "could not write pbm header");
 720     return 0;
 721   }
 722   write_size = (im->xsize + 7) / 8;
 723   line = mymalloc(sizeof(i_palidx) * im->xsize);
 724   write_buf = mymalloc(write_size);
 725   for (y = 0; y < im->ysize; ++y) {
 726     i_gpal(im, 0, im->xsize, y, line);
 727     mask = 0x80;
 728     writep = write_buf;
 729     memset(write_buf, 0, write_size);
 730     for (x = 0; x < im->xsize; ++x) {
 731       if (zero_is_white ? line[x] : !line[x])
 732         *writep |= mask;
 733       mask >>= 1;
 734       if (!mask) {
 735         ++writep;
 736         mask = 0x80;
 737       }
 738     }
 739     if (i_io_write(ig, write_buf, write_size) != write_size) {
 740       i_push_error(0, "write failure");
 741       myfree(write_buf);
 742       myfree(line);
 743       return 0;
 744     }
 745   }
 746   myfree(write_buf);
 747   myfree(line);
 748
 749   return 1;
 750 }
 751
 752 static
 753 int
 754 write_ppm_data_8(i_img *im, io_glue *ig) {
 755   int write_size = im->xsize * im->channels;
 756   unsigned char *data = mymalloc(write_size);
 757   int y = 0;
 758   int rc = 1;
 759
 760   while (y < im->ysize && rc >= 0) {
 761     i_gsamp(im, 0, im->xsize, y, data, NULL, im->channels);
 762     if (i_io_write(ig, data, write_size) != write_size) {
 763       i_push_error(errno, "could not write ppm data");
 764       rc = 0;
 765       break;
 766     }
 767     ++y;
 768   }
 769   myfree(data);
 770
 771   return rc;
 772 }
 773
 774 static
 775 int
 776 write_ppm_data_16(i_img *im, io_glue *ig) {
 777   int sample_count = im->channels * im->xsize;
 778   int write_size = sample_count * 2;
 779   int line_size = sample_count * sizeof(i_fsample_t);
 780   i_fsample_t *line_buf = mymalloc(line_size);
 781   i_fsample_t *samplep;
 782   unsigned char *write_buf = mymalloc(write_size);
 783   unsigned char *writep;
 784   int sample_num;
 785   int y = 0;
 786   int rc = 1;
 787
 788   while (y < im->ysize) {
 789     i_gsampf(im, 0, im->xsize, y, line_buf, NULL, im->channels);
 790     samplep = line_buf;
 791     writep = write_buf;
 792     for (sample_num = 0; sample_num < sample_count; ++sample_num) {
 793       unsigned sample16 = SampleFTo16(*samplep++);
 794       *writep++ = sample16 >> 8;
 795       *writep++ = sample16 & 0xFF;
 796     }
 797     if (i_io_write(ig, write_buf, write_size) != write_size) {
 798       i_push_error(errno, "could not write ppm data");
 799       rc = 0;
 800       break;
 801     }
 802     ++y;
 803   }
 804   myfree(line_buf);
 805   myfree(write_buf);
 806
 807   return rc;
 808 }
 809
 810 undef_int
 811 i_writeppm_wiol(i_img *im, io_glue *ig) {
 812   char header[255];
 813   int zero_is_white;
 814   int wide_data;
 815
 816   mm_log((1,"i_writeppm(im %p, ig %p)\n", im, ig));
 817   i_clear_error();
 818
 819   /* Add code to get the filename info from the iolayer */
 820   /* Also add code to check for mmapped code */
 821
 822   io_glue_commit_types(ig);
 823
 824   if (i_img_is_monochrome(im, &zero_is_white)) {
 825     return write_pbm(im, ig, zero_is_white);
 826   }
 827   else {
 828     int type;
 829     int maxval;
 830
 831     if (!i_tags_get_int(&im->tags, "pnm_write_wide_data", 0, &wide_data))
 832       wide_data = 0;
 833
 834     if (im->channels == 3) {
 835       type = 6;
 836     }
 837     else if (im->channels == 1) {
 838       type = 5;
 839     }
 840     else {
 841       i_push_error(0, "can only save 1 or 3 channel images to pnm");
 842       mm_log((1,"i_writeppm: ppm/pgm is 1 or 3 channel only (current image is %d)\n",im->channels));
 843       return(0);
 844     }
 845     if (im->bits <= 8 || !wide_data)
 846       maxval = 255;
 847     else
 848       maxval = 65535;
 849
 850     sprintf(header,"P%d\n#CREATOR: Imager\n%d %d\n%d\n",
 851             type, im->xsize, im->ysize, maxval);
 852
 853     if (ig->writecb(ig,header,strlen(header)) != strlen(header)) {
 854       i_push_error(errno, "could not write ppm header");
 855       mm_log((1,"i_writeppm: unable to write ppm header.\n"));
 856       return(0);
 857     }
 858
 859     if (!im->virtual && im->bits == i_8_bits && im->type == i_direct_type) {
 860       if (ig->writecb(ig,im->idata,im->bytes) != im->bytes) {
 861         i_push_error(errno, "could not write ppm data");
 862         return 0;
 863       }
 864     }
 865     else if (maxval == 255) {
 866       if (!write_ppm_data_8(im, ig))
 867         return 0;
 868     }
 869     else {
 870       if (!write_ppm_data_16(im, ig))
 871         return 0;
 872     }
 873   }
 874   ig->closecb(ig);
 875
 876   return(1);
 877 }
 878
 879 /*
 880 =back
 881
 882 =head1 AUTHOR
 883
 884 Arnar M. Hrafnkelsson <addi@umich.edu>, Tony Cook<tony@imager.perl.org>
 885
 886 =head1 SEE ALSO
 887
 888 Imager(3)
 889
 890 =cut
 891 */