pnm.c

   1 #include "image.h"
   2 #include "io.h"
   3 #include "log.h"
   4 #include "iolayer.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 gnext(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_spaces(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   /*  char *pp; */
 241
 242   mm_log((1,"i_readpnm(ig %p, length %d)\n", ig, length));
 243
 244   /*
 245   pp = mymalloc(20);
 246
 247   pp[-1]= 'c';
 248   pp[-2]= 'c';
 249
 250   bndcheck_all();
 251
 252   myfree(pp);
 253
 254   mm_log((1, "Hack is exiting\n"));
 255
 256 */
 257
 258   io_glue_commit_types(ig);
 259   init_buf(&buf, ig);
 260
 261   cp = gnext(&buf);
 262
 263   if (!cp || *cp != 'P') {
 264     i_push_error(0, "bad header magic, not a PNM file");
 265     mm_log((1, "i_readpnm: Could not read header of file\n"));
 266     return NULL;
 267   }
 268
 269   if ( !(cp = gnext(&buf)) ) {
 270     mm_log((1, "i_readpnm: Could not read header of file\n"));
 271     return NULL;
 272   }
 273
 274   type = *cp-'0';
 275
 276   if (type < 1 || type > 6) {
 277     i_push_error(0, "unknown PNM file type, not a PNM file");
 278     mm_log((1, "i_readpnm: Not a pnm file\n"));
 279     return NULL;
 280   }
 281
 282   if ( !(cp = gnext(&buf)) ) {
 283     mm_log((1, "i_readpnm: Could not read header of file\n"));
 284     return NULL;
 285   }
 286
 287   if ( !misspace(*cp) ) {
 288     i_push_error(0, "unexpected character, not a PNM file");
 289     mm_log((1, "i_readpnm: Not a pnm file\n"));
 290     return NULL;
 291   }
 292
 293   mm_log((1, "i_readpnm: image is a %s\n", typenames[type-1] ));
 294
 295
 296   /* Read sizes and such */
 297
 298   if (!skip_comment(&buf)) {
 299     i_push_error(0, "while skipping to width");
 300     mm_log((1, "i_readpnm: error reading before width\n"));
 301     return NULL;
 302   }
 303
 304   if (!gnum(&buf, &width)) {
 305     i_push_error(0, "could not read image width");
 306     mm_log((1, "i_readpnm: error reading width\n"));
 307     return NULL;
 308   }
 309
 310   if (!skip_comment(&buf)) {
 311     i_push_error(0, "while skipping to height");
 312     mm_log((1, "i_readpnm: error reading before height\n"));
 313     return NULL;
 314   }
 315
 316   if (!gnum(&buf, &height)) {
 317     i_push_error(0, "could not read image height");
 318     mm_log((1, "i_readpnm: error reading height\n"));
 319     return NULL;
 320   }
 321
 322   if (!(type == 1 || type == 4)) {
 323     if (!skip_comment(&buf)) {
 324       i_push_error(0, "while skipping to maxval");
 325       mm_log((1, "i_readpnm: error reading before maxval\n"));
 326       return NULL;
 327     }
 328
 329     if (!gnum(&buf, &maxval)) {
 330       i_push_error(0, "could not read maxval");
 331       mm_log((1, "i_readpnm: error reading maxval\n"));
 332       return NULL;
 333     }
 334
 335     if (maxval == 0) {
 336       i_push_error(0, "maxval is zero - invalid pnm file");
 337       mm_log((1, "i_readpnm: maxval is zero, invalid pnm file\n"));
 338       return NULL;
 339     }
 340     else if (maxval > 65535) {
 341       i_push_errorf(0, "maxval of %d is over 65535 - invalid pnm file",
 342                     maxval);
 343       mm_log((1, "i_readpnm: maxval of %d is over 65535 - invalid pnm file\n"));
 344       return NULL;
 345     }
 346     else if (type >= 4 && maxval > 255) {
 347       i_push_errorf(0, "maxval of %d is over 255 - not currently supported by Imager for binary pnm", maxval);
 348       mm_log((1, "i_readpnm: maxval of %d is over 255 - not currently supported by Imager for binary pnm\n", maxval));
 349       return NULL;
 350     }
 351   } else maxval=1;
 352   rounder = maxval / 2;
 353
 354   if (!(cp = gnext(&buf)) || !misspace(*cp)) {
 355     i_push_error(0, "garbage in header, invalid PNM file");
 356     mm_log((1, "i_readpnm: garbage in header\n"));
 357     return NULL;
 358   }
 359
 360   channels = (type == 3 || type == 6) ? 3:1;
 361   pcount = width*height*channels;
 362
 363   mm_log((1, "i_readpnm: (%d x %d), channels = %d, maxval = %d\n", width, height, channels, maxval));
 364
 365   im = i_img_empty_ch(NULL, width, height, channels);
 366
 367   switch (type) {
 368   case 1: /* Ascii types */
 369   case 2:
 370   case 3:
 371     for(y=0;y<height;y++) for(x=0; x<width; x++) {
 372       for(ch=0; ch<channels; ch++) {
 373         int t;
 374         if (gnum(&buf, &t)) val.channel[ch] = (t * 255 + rounder) / maxval;
 375         else {
 376           mm_log((1,"i_readpnm: gnum() returned false in data\n"));
 377           return im;
 378         }
 379       }
 380       i_ppix(im, x, y, &val);
 381     }
 382     break;
 383
 384   case 4: /* binary pbm */
 385     for(y=0;y<height;y++) for(x=0; x<width; x+=8) {
 386       if ( (uc = (unsigned char*)gnext(&buf)) ) {
 387         int xt;
 388         int pc = width-x < 8 ? width-x : 8;
 389         /*      mm_log((1,"i_readpnm: y=%d x=%d pc=%d\n", y, x, pc)); */
 390         for(xt = 0; xt<pc; xt++) {
 391           val.channel[0] = (*uc & (128>>xt)) ? 0 : 255;
 392           i_ppix(im, x+xt, y, &val);
 393         }
 394       } else {
 395         mm_log((1,"i_readpnm: gnext() returned false in data\n"));
 396         return im;
 397       }
 398     }
 399     break;
 400
 401   case 5: /* binary pgm */
 402   case 6: /* binary ppm */
 403     for(y=0;y<height;y++) for(x=0; x<width; x++) {
 404       for(ch=0; ch<channels; ch++) {
 405         if ( (uc = (unsigned char*)gnext(&buf)) )
 406           val.channel[ch] = (*uc * 255 + rounder) / maxval;
 407         else {
 408           mm_log((1,"i_readpnm: gnext() returned false in data\n"));
 409           return im;
 410         }
 411       }
 412       i_ppix(im, x, y, &val);
 413     }
 414     break;
 415   default:
 416     mm_log((1, "type %s [P%d] unsupported\n", typenames[type-1], type));
 417     return NULL;
 418   }
 419   return im;
 420 }
 421
 422
 423 undef_int
 424 i_writeppm_wiol(i_img *im, io_glue *ig) {
 425   char header[255];
 426   int rc;
 427   writep write_func;
 428
 429   mm_log((1,"i_writeppm(im %p, ig %p)\n", im, ig));
 430   i_clear_error();
 431
 432   /* Add code to get the filename info from the iolayer */
 433   /* Also add code to check for mmapped code */
 434
 435   io_glue_commit_types(ig);
 436
 437   if (im->channels == 3) {
 438     sprintf(header,"P6\n#CREATOR: Imager\n%d %d\n255\n",im->xsize,im->ysize);
 439     if (ig->writecb(ig,header,strlen(header))<0) {
 440       i_push_error(errno, "could not write ppm header");
 441       mm_log((1,"i_writeppm: unable to write ppm header.\n"));
 442       return(0);
 443     }
 444
 445     if (!im->virtual && im->bits == i_8_bits && im->type == i_direct_type) {
 446       rc = ig->writecb(ig,im->idata,im->bytes);
 447     }
 448     else {
 449       unsigned char *data = mymalloc(3 * im->xsize);
 450       if (data != NULL) {
 451         int y = 0;
 452         int x, ch;
 453         unsigned char *p;
 454         static int rgb_chan[3] = { 0, 1, 2 };
 455
 456         rc = 0;
 457         while (y < im->ysize && rc >= 0) {
 458           i_gsamp(im, 0, im->xsize, y, data, rgb_chan, 3);
 459           rc = ig->writecb(ig, data, im->xsize * 3);
 460           ++y;
 461         }
 462         myfree(data);
 463       }
 464       else {
 465         i_push_error(0, "Out of memory");
 466         return 0;
 467       }
 468     }
 469     if (rc<0) {
 470       i_push_error(errno, "could not write ppm data");
 471       mm_log((1,"i_writeppm: unable to write ppm data.\n"));
 472       return(0);
 473     }
 474   }
 475   else if (im->channels == 1) {
 476     sprintf(header, "P5\n#CREATOR: Imager\n%d %d\n255\n",
 477             im->xsize, im->ysize);
 478     if (ig->writecb(ig,header, strlen(header)) < 0) {
 479       i_push_error(errno, "could not write pgm header");
 480       mm_log((1,"i_writeppm: unable to write pgm header.\n"));
 481       return(0);
 482     }
 483
 484     if (!im->virtual && im->bits == i_8_bits && im->type == i_direct_type) {
 485       rc=ig->writecb(ig,im->idata,im->bytes);
 486     }
 487     else {
 488       unsigned char *data = mymalloc(im->xsize);
 489       if (data != NULL) {
 490         int y = 0;
 491         int x, ch;
 492         int chan = 0;
 493         unsigned char *p;
 494
 495         rc = 0;
 496         while (y < im->ysize && rc >= 0) {
 497           i_gsamp(im, 0, im->xsize, y, data, &chan, 1);
 498           rc = ig->writecb(ig, data, im->xsize);
 499           ++y;
 500         }
 501         myfree(data);
 502       }
 503       else {
 504         i_push_error(0, "Out of memory");
 505         return 0;
 506       }
 507     }
 508     if (rc<0) {
 509       i_push_error(errno, "could not write pgm data");
 510       mm_log((1,"i_writeppm: unable to write pgm data.\n"));
 511       return(0);
 512     }
 513   }
 514   else {
 515     i_push_error(0, "can only save 1 or 3 channel images to pnm");
 516     mm_log((1,"i_writeppm: ppm/pgm is 1 or 3 channel only (current image is %d)\n",im->channels));
 517     return(0);
 518   }
 519   ig->closecb(ig);
 520
 521   return(1);
 522 }
 523
 524 /*
 525 =back
 526
 527 =head1 AUTHOR
 528
 529 Arnar M. Hrafnkelsson <addi@umich.edu>
 530
 531 =head1 SEE ALSO
 532
 533 Imager(3)
 534
 535 =cut
 536 */