rdppm.c

   1 /*
   2  * rdppm.c
   3  *
   4  * This file was part of the Independent JPEG Group's software:
   5  * Copyright (C) 1991-1997, Thomas G. Lane.
   6  * Modified 2009 by Bill Allombert, Guido Vollbeding.
   7  * It was modified by The libjpeg-turbo Project to include only code and
   8  * information relevant to libjpeg-turbo.
   9  * For conditions of distribution and use, see the accompanying README file.
  10  *
  11  * This file contains routines to read input images in PPM/PGM format.
  12  * The extended 2-byte-per-sample raw PPM/PGM formats are supported.
  13  * The PBMPLUS library is NOT required to compile this software
  14  * (but it is highly useful as a set of PPM image manipulation programs).
  15  *
  16  * These routines may need modification for non-Unix environments or
  17  * specialized applications.  As they stand, they assume input from
  18  * an ordinary stdio stream.  They further assume that reading begins
  19  * at the start of the file; start_input may need work if the
  20  * user interface has already read some data (e.g., to determine that
  21  * the file is indeed PPM format).
  22  */
  23
  24 #include "cdjpeg.h"             /* Common decls for cjpeg/djpeg applications */
  25
  26 #ifdef PPM_SUPPORTED
  27
  28
  29 /* Portions of this code are based on the PBMPLUS library, which is:
  30 **
  31 ** Copyright (C) 1988 by Jef Poskanzer.
  32 **
  33 ** Permission to use, copy, modify, and distribute this software and its
  34 ** documentation for any purpose and without fee is hereby granted, provided
  35 ** that the above copyright notice appear in all copies and that both that
  36 ** copyright notice and this permission notice appear in supporting
  37 ** documentation.  This software is provided "as is" without express or
  38 ** implied warranty.
  39 */
  40
  41
  42 /* Macros to deal with unsigned chars as efficiently as compiler allows */
  43
  44 #ifdef HAVE_UNSIGNED_CHAR
  45 typedef unsigned char U_CHAR;
  46 #define UCH(x)  ((int) (x))
  47 #else /* !HAVE_UNSIGNED_CHAR */
  48 #ifdef __CHAR_UNSIGNED__
  49 typedef char U_CHAR;
  50 #define UCH(x)  ((int) (x))
  51 #else
  52 typedef char U_CHAR;
  53 #define UCH(x)  ((int) (x) & 0xFF)
  54 #endif
  55 #endif /* HAVE_UNSIGNED_CHAR */
  56
  57
  58 #define ReadOK(file,buffer,len) (JFREAD(file,buffer,len) == ((size_t) (len)))
  59
  60
  61 /* Private version of data source object */
  62
  63 typedef struct {
  64   struct cjpeg_source_struct pub; /* public fields */
  65
  66   /* Usually these two pointers point to the same place: */
  67   U_CHAR *iobuffer;             /* fread's I/O buffer */
  68   JSAMPROW pixrow;              /* compressor input buffer */
  69   size_t buffer_width;          /* width of I/O buffer */
  70   JSAMPLE *rescale;             /* => maxval-remapping array, or NULL */
  71   int maxval;
  72 } ppm_source_struct;
  73
  74 typedef ppm_source_struct * ppm_source_ptr;
  75
  76
  77 LOCAL(int)
  78 pbm_getc (FILE * infile)
  79 /* Read next char, skipping over any comments */
  80 /* A comment/newline sequence is returned as a newline */
  81 {
  82   register int ch;
  83
  84   ch = getc(infile);
  85   if (ch == '#') {
  86     do {
  87       ch = getc(infile);
  88     } while (ch != '\n' && ch != EOF);
  89   }
  90   return ch;
  91 }
  92
  93
  94 LOCAL(unsigned int)
  95 read_pbm_integer (j_compress_ptr cinfo, FILE * infile, int maxval)
  96 /* Read an unsigned decimal integer from the PPM file */
  97 /* Swallows one trailing character after the integer */
  98 /* Note that on a 16-bit-int machine, only values up to 64k can be read. */
  99 /* This should not be a problem in practice. */
 100 {
 101   register int ch;
 102   register unsigned int val;
 103
 104   /* Skip any leading whitespace */
 105   do {
 106     ch = pbm_getc(infile);
 107     if (ch == EOF)
 108       ERREXIT(cinfo, JERR_INPUT_EOF);
 109   } while (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r');
 110
 111   if (ch < '0' || ch > '9')
 112     ERREXIT(cinfo, JERR_PPM_NONNUMERIC);
 113
 114   val = ch - '0';
 115   while ((ch = pbm_getc(infile)) >= '0' && ch <= '9') {
 116     val *= 10;
 117     val += ch - '0';
 118   }
 119
 120   if (val > maxval)
 121     ERREXIT(cinfo, JERR_PPM_TOOLARGE);
 122
 123   return val;
 124 }
 125
 126
 127 /*
 128  * Read one row of pixels.
 129  *
 130  * We provide several different versions depending on input file format.
 131  * In all cases, input is scaled to the size of JSAMPLE.
 132  *
 133  * A really fast path is provided for reading byte/sample raw files with
 134  * maxval = MAXJSAMPLE, which is the normal case for 8-bit data.
 135  */
 136
 137
 138 METHODDEF(JDIMENSION)
 139 get_text_gray_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
 140 /* This version is for reading text-format PGM files with any maxval */
 141 {
 142   ppm_source_ptr source = (ppm_source_ptr) sinfo;
 143   FILE * infile = source->pub.input_file;
 144   register JSAMPROW ptr;
 145   register JSAMPLE *rescale = source->rescale;
 146   JDIMENSION col;
 147   int maxval = source->maxval;
 148
 149   ptr = source->pub.buffer[0];
 150   for (col = cinfo->image_width; col > 0; col--) {
 151     *ptr++ = rescale[read_pbm_integer(cinfo, infile, maxval)];
 152   }
 153   return 1;
 154 }
 155
 156
 157 METHODDEF(JDIMENSION)
 158 get_text_rgb_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
 159 /* This version is for reading text-format PPM files with any maxval */
 160 {
 161   ppm_source_ptr source = (ppm_source_ptr) sinfo;
 162   FILE * infile = source->pub.input_file;
 163   register JSAMPROW ptr;
 164   register JSAMPLE *rescale = source->rescale;
 165   JDIMENSION col;
 166   int maxval = source->maxval;
 167
 168   ptr = source->pub.buffer[0];
 169   for (col = cinfo->image_width; col > 0; col--) {
 170     *ptr++ = rescale[read_pbm_integer(cinfo, infile, maxval)];
 171     *ptr++ = rescale[read_pbm_integer(cinfo, infile, maxval)];
 172     *ptr++ = rescale[read_pbm_integer(cinfo, infile, maxval)];
 173   }
 174   return 1;
 175 }
 176
 177
 178 METHODDEF(JDIMENSION)
 179 get_scaled_gray_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
 180 /* This version is for reading raw-byte-format PGM files with any maxval */
 181 {
 182   ppm_source_ptr source = (ppm_source_ptr) sinfo;
 183   register JSAMPROW ptr;
 184   register U_CHAR * bufferptr;
 185   register JSAMPLE *rescale = source->rescale;
 186   JDIMENSION col;
 187
 188   if (! ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width))
 189     ERREXIT(cinfo, JERR_INPUT_EOF);
 190   ptr = source->pub.buffer[0];
 191   bufferptr = source->iobuffer;
 192   for (col = cinfo->image_width; col > 0; col--) {
 193     *ptr++ = rescale[UCH(*bufferptr++)];
 194   }
 195   return 1;
 196 }
 197
 198
 199 METHODDEF(JDIMENSION)
 200 get_scaled_rgb_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
 201 /* This version is for reading raw-byte-format PPM files with any maxval */
 202 {
 203   ppm_source_ptr source = (ppm_source_ptr) sinfo;
 204   register JSAMPROW ptr;
 205   register U_CHAR * bufferptr;
 206   register JSAMPLE *rescale = source->rescale;
 207   JDIMENSION col;
 208
 209   if (! ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width))
 210     ERREXIT(cinfo, JERR_INPUT_EOF);
 211   ptr = source->pub.buffer[0];
 212   bufferptr = source->iobuffer;
 213   for (col = cinfo->image_width; col > 0; col--) {
 214     *ptr++ = rescale[UCH(*bufferptr++)];
 215     *ptr++ = rescale[UCH(*bufferptr++)];
 216     *ptr++ = rescale[UCH(*bufferptr++)];
 217   }
 218   return 1;
 219 }
 220
 221
 222 METHODDEF(JDIMENSION)
 223 get_raw_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
 224 /* This version is for reading raw-byte-format files with maxval = MAXJSAMPLE.
 225  * In this case we just read right into the JSAMPLE buffer!
 226  * Note that same code works for PPM and PGM files.
 227  */
 228 {
 229   ppm_source_ptr source = (ppm_source_ptr) sinfo;
 230
 231   if (! ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width))
 232     ERREXIT(cinfo, JERR_INPUT_EOF);
 233   return 1;
 234 }
 235
 236
 237 METHODDEF(JDIMENSION)
 238 get_word_gray_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
 239 /* This version is for reading raw-word-format PGM files with any maxval */
 240 {
 241   ppm_source_ptr source = (ppm_source_ptr) sinfo;
 242   register JSAMPROW ptr;
 243   register U_CHAR * bufferptr;
 244   register JSAMPLE *rescale = source->rescale;
 245   JDIMENSION col;
 246
 247   if (! ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width))
 248     ERREXIT(cinfo, JERR_INPUT_EOF);
 249   ptr = source->pub.buffer[0];
 250   bufferptr = source->iobuffer;
 251   for (col = cinfo->image_width; col > 0; col--) {
 252     register int temp;
 253     temp  = UCH(*bufferptr++) << 8;
 254     temp |= UCH(*bufferptr++);
 255     *ptr++ = rescale[temp];
 256   }
 257   return 1;
 258 }
 259
 260
 261 METHODDEF(JDIMENSION)
 262 get_word_rgb_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
 263 /* This version is for reading raw-word-format PPM files with any maxval */
 264 {
 265   ppm_source_ptr source = (ppm_source_ptr) sinfo;
 266   register JSAMPROW ptr;
 267   register U_CHAR * bufferptr;
 268   register JSAMPLE *rescale = source->rescale;
 269   JDIMENSION col;
 270
 271   if (! ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width))
 272     ERREXIT(cinfo, JERR_INPUT_EOF);
 273   ptr = source->pub.buffer[0];
 274   bufferptr = source->iobuffer;
 275   for (col = cinfo->image_width; col > 0; col--) {
 276     register int temp;
 277     temp  = UCH(*bufferptr++) << 8;
 278     temp |= UCH(*bufferptr++);
 279     *ptr++ = rescale[temp];
 280     temp  = UCH(*bufferptr++) << 8;
 281     temp |= UCH(*bufferptr++);
 282     *ptr++ = rescale[temp];
 283     temp  = UCH(*bufferptr++) << 8;
 284     temp |= UCH(*bufferptr++);
 285     *ptr++ = rescale[temp];
 286   }
 287   return 1;
 288 }
 289
 290
 291 /*
 292  * Read the file header; return image size and component count.
 293  */
 294
 295 METHODDEF(void)
 296 start_input_ppm (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
 297 {
 298   ppm_source_ptr source = (ppm_source_ptr) sinfo;
 299   int c;
 300   unsigned int w, h, maxval;
 301   boolean need_iobuffer, use_raw_buffer, need_rescale;
 302
 303   if (getc(source->pub.input_file) != 'P')
 304     ERREXIT(cinfo, JERR_PPM_NOT);
 305
 306   c = getc(source->pub.input_file); /* subformat discriminator character */
 307
 308   /* detect unsupported variants (ie, PBM) before trying to read header */
 309   switch (c) {
 310   case '2':                     /* it's a text-format PGM file */
 311   case '3':                     /* it's a text-format PPM file */
 312   case '5':                     /* it's a raw-format PGM file */
 313   case '6':                     /* it's a raw-format PPM file */
 314     break;
 315   default:
 316     ERREXIT(cinfo, JERR_PPM_NOT);
 317     break;
 318   }
 319
 320   /* fetch the remaining header info */
 321   w = read_pbm_integer(cinfo, source->pub.input_file, 65535);
 322   h = read_pbm_integer(cinfo, source->pub.input_file, 65535);
 323   maxval = read_pbm_integer(cinfo, source->pub.input_file, 65535);
 324
 325   if (w <= 0 || h <= 0 || maxval <= 0) /* error check */
 326     ERREXIT(cinfo, JERR_PPM_NOT);
 327
 328   cinfo->data_precision = BITS_IN_JSAMPLE; /* we always rescale data to this */
 329   cinfo->image_width = (JDIMENSION) w;
 330   cinfo->image_height = (JDIMENSION) h;
 331   source->maxval = maxval;
 332
 333   /* initialize flags to most common settings */
 334   need_iobuffer = TRUE;         /* do we need an I/O buffer? */
 335   use_raw_buffer = FALSE;       /* do we map input buffer onto I/O buffer? */
 336   need_rescale = TRUE;          /* do we need a rescale array? */
 337
 338   switch (c) {
 339   case '2':                     /* it's a text-format PGM file */
 340     cinfo->input_components = 1;
 341     cinfo->in_color_space = JCS_GRAYSCALE;
 342     TRACEMS2(cinfo, 1, JTRC_PGM_TEXT, w, h);
 343     source->pub.get_pixel_rows = get_text_gray_row;
 344     need_iobuffer = FALSE;
 345     break;
 346
 347   case '3':                     /* it's a text-format PPM file */
 348     cinfo->input_components = 3;
 349     cinfo->in_color_space = JCS_RGB;
 350     TRACEMS2(cinfo, 1, JTRC_PPM_TEXT, w, h);
 351     source->pub.get_pixel_rows = get_text_rgb_row;
 352     need_iobuffer = FALSE;
 353     break;
 354
 355   case '5':                     /* it's a raw-format PGM file */
 356     cinfo->input_components = 1;
 357     cinfo->in_color_space = JCS_GRAYSCALE;
 358     TRACEMS2(cinfo, 1, JTRC_PGM, w, h);
 359     if (maxval > 255) {
 360       source->pub.get_pixel_rows = get_word_gray_row;
 361     } else if (maxval == MAXJSAMPLE && sizeof(JSAMPLE) == sizeof(U_CHAR)) {
 362       source->pub.get_pixel_rows = get_raw_row;
 363       use_raw_buffer = TRUE;
 364       need_rescale = FALSE;
 365     } else {
 366       source->pub.get_pixel_rows = get_scaled_gray_row;
 367     }
 368     break;
 369
 370   case '6':                     /* it's a raw-format PPM file */
 371     cinfo->input_components = 3;
 372     cinfo->in_color_space = JCS_RGB;
 373     TRACEMS2(cinfo, 1, JTRC_PPM, w, h);
 374     if (maxval > 255) {
 375       source->pub.get_pixel_rows = get_word_rgb_row;
 376     } else if (maxval == MAXJSAMPLE && sizeof(JSAMPLE) == sizeof(U_CHAR)) {
 377       source->pub.get_pixel_rows = get_raw_row;
 378       use_raw_buffer = TRUE;
 379       need_rescale = FALSE;
 380     } else {
 381       source->pub.get_pixel_rows = get_scaled_rgb_row;
 382     }
 383     break;
 384   }
 385
 386   /* Allocate space for I/O buffer: 1 or 3 bytes or words/pixel. */
 387   if (need_iobuffer) {
 388     source->buffer_width = (size_t) w * cinfo->input_components *
 389       ((maxval<=255) ? sizeof(U_CHAR) : (2*sizeof(U_CHAR)));
 390     source->iobuffer = (U_CHAR *)
 391       (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
 392                                   source->buffer_width);
 393   }
 394
 395   /* Create compressor input buffer. */
 396   if (use_raw_buffer) {
 397     /* For unscaled raw-input case, we can just map it onto the I/O buffer. */
 398     /* Synthesize a JSAMPARRAY pointer structure */
 399     source->pixrow = (JSAMPROW) source->iobuffer;
 400     source->pub.buffer = & source->pixrow;
 401     source->pub.buffer_height = 1;
 402   } else {
 403     /* Need to translate anyway, so make a separate sample buffer. */
 404     source->pub.buffer = (*cinfo->mem->alloc_sarray)
 405       ((j_common_ptr) cinfo, JPOOL_IMAGE,
 406        (JDIMENSION) w * cinfo->input_components, (JDIMENSION) 1);
 407     source->pub.buffer_height = 1;
 408   }
 409
 410   /* Compute the rescaling array if required. */
 411   if (need_rescale) {
 412     INT32 val, half_maxval;
 413
 414     /* On 16-bit-int machines we have to be careful of maxval = 65535 */
 415     source->rescale = (JSAMPLE *)
 416       (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
 417                                   (size_t) (((long) maxval + 1L) * sizeof(JSAMPLE)));
 418     half_maxval = maxval / 2;
 419 #if _USE_PRODUCT_TV
 420     if(maxval > 0) {
 421       for (val = 0; val <= (INT32) maxval; val++) {
 422         /* The multiplication here must be done in 32 bits to avoid overflow */
 423         source->rescale[val] = (JSAMPLE) ((val*MAXJSAMPLE + half_maxval)/maxval);
 424       }
 425     }
 426 #else
 427     for (val = 0; val <= (INT32) maxval; val++) {
 428       /* The multiplication here must be done in 32 bits to avoid overflow */
 429       source->rescale[val] = (JSAMPLE) ((val*MAXJSAMPLE + half_maxval)/maxval);
 430     }
 431 #endif
 432   }
 433 }
 434
 435
 436 /*
 437  * Finish up at the end of the file.
 438  */
 439
 440 METHODDEF(void)
 441 finish_input_ppm (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
 442 {
 443   /* no work */
 444 }
 445
 446
 447 /*
 448  * The module selection routine for PPM format input.
 449  */
 450
 451 GLOBAL(cjpeg_source_ptr)
 452 jinit_read_ppm (j_compress_ptr cinfo)
 453 {
 454   ppm_source_ptr source;
 455
 456   /* Create module interface object */
 457   source = (ppm_source_ptr)
 458       (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
 459                                   sizeof(ppm_source_struct));
 460   /* Fill in method ptrs, except get_pixel_rows which start_input sets */
 461   source->pub.start_input = start_input_ppm;
 462   source->pub.finish_input = finish_input_ppm;
 463
 464   return (cjpeg_source_ptr) source;
 465 }
 466
 467 #endif /* PPM_SUPPORTED */