workbench/libs/jpeg/rdppm.c

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