home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk1.iso / altsrc / articles / 10954 < prev    next >
Internet Message Format  |  1994-07-23  |  32KB
  1. Path: wupost!uhog.mit.edu!MathWorks.Com!europa.eng.gtefsd.com!emory!swrinde!sgiblab!a2i!flash.us.com!britt!dclunie
  2. From: dclunie@flash.us.com (David Clunie)
  3. Newsgroups: alt.graphics.pixutils,alt.sources,alt.image.medical
  4. Subject: PATCH: IJG jpegv4 12 bit mode & pgm/ppm files
  5. Date: 23 Jul 1994 17:37:52 GMT
  6. Organization: Her Master's Voice
  7. Lines: 1008
  8. Distribution: world
  9. Message-ID: <30rkhg$bq@flash.ksapax>
  10. Reply-To: dclunie@flash.us.com
  11. NNTP-Posting-Host: britt.ksapax
  12. Xref: wupost alt.graphics.pixutils:8225 alt.sources:10954 alt.image.medical:1287
  13.  
  14. Patch to use 12 bit mode and handle pgm/ppm files. Will use proposed new
  15. extended raw 16 bit pgm/ppm files if desired.
  16.  
  17. Works fine with v4 and v4a of the Independent JPEG Groups code.
  18.  
  19. Use "cd jpegv4; patch -p1 <thismessage".
  20.  
  21.  
  22. diff -r -c jpegv4a/README.pbm12bits jpegv4a.12/README.pbm12bits
  23. *** jpegv4a/README.pbm12bits    Sat Jul 23 20:10:13 1994
  24. --- jpegv4a.12/README.pbm12bits    Sat Jul 23 20:02:39 1994
  25. ***************
  26. *** 0 ****
  27. --- 1,91 ----
  28. + Sat Jul 23 19:02:07 GMT+0300 1994
  29. + 
  30. + Doing 8 bits, 12 bits, 16 bits and the PGM/PPM format.
  31. + 
  32. + The standard distribution has limited support for the PGM/PPM format:
  33. + 
  34. +     - it will read raw (8 bit) or text files (any maxval) and scale
  35. +       the data to the current data precision (usually 8).
  36. + 
  37. +     - it will write raw 8 bit files only (though passed through the
  38. +       colormaps if quantized) and if the precision is greater than
  39. +       8 bits only the low 8 bits would be used, if it weren't for the
  40. +       fact that there is a pre-processor generated compile error
  41. +       when BITS_IN_JSAMPLE is not 8.
  42. + 
  43. + In otherwords, though one can compile the library with 12 bits of precision
  44. + and use the standard "jrdppm.c" to read 12 bit data, there is no way to
  45. + write it out again.
  46. + 
  47. + This patch addresses these issues, and in addition supports the use of an
  48. + extension to the PGM/PPM format that allows >8 <16 bit values to be read
  49. + or written in raw form (little endian two byte word) based on the value
  50. + of maxval in the header ... if it is <=255 use a byte, if it is >255 but
  51. + <= 65535, use a word. Though nonstandard, there is another simple patch
  52. + floating around to patch the pbmplus and netpbm toolkits to handle such
  53. + files. These raw binary files save enormous amounts of space compared
  54. + with their text equivalents and make PGM/PPM a potentially useful file
  55. + format for handling such images.
  56. + 
  57. + The patched version has the following characteristics:
  58. + 
  59. +     - it can read any text, normal 8 bit and extended 16 bit PGM/PPM
  60. +       regardless of compile time options, and scales the data to the
  61. +       data precision.
  62. + 
  63. +     - if compiled with EIGHT_BIT_SAMPLES, it will write normal 8 bit
  64. +       raw PGM/PPM files, unless PPM_WRITETEXT is defined, in which
  65. +       case it will always write text files (pretty useless option).
  66. + 
  67. +     - if compiled with TWELVE_BIT_SAMPLES, it will write text format
  68. +       PGM/PPM files, unless PPM_WRITERAWWORDS is defined, in which
  69. +       case it will write 16 bit raw extended PGM/PPM files - this is
  70. +       the setting I use.
  71. + 
  72. + Note that the jwrppm.c and jrdppm.c routines are actually a little more
  73. + complicated and prepared for the day when 8 or 12 bits can be selected
  74. + at runtime rather than compile time, and they will behave properly
  75. + bases on the data_precision set in the cinfo structure. For now they just
  76. + behave the easy way.
  77. + 
  78. + Note that because the input is automatically scaled, you can actually
  79. + feed 8 bit files into a 12 bit "cjpeg|djpeg" and get 12 bits out, or
  80. + feed 12 bit data into an 8 bit "cjpeg|djpeg" and get 8 bits out !
  81. + 
  82. + On old versions of the source, one had to set the "-o" flag to cjpeg when 
  83. + using 12 bit precision, as there are no default Huffman tables for 12 bit 
  84. + mode, but you didn't know until you get a "Corrupted data in JPEG file" 
  85. + message from djpeg! This is now set automatically in more recent versions 
  86. + when a precision other than 8 is set.
  87. + 
  88. + Also if you do define TWELVE_BIT_SAMPLES, remember to undefine 
  89. + TARGA_SUPPORTED  and RLE_SUPPORTED as neither of these can handle 12 bits
  90. + and bitch if they have to. Intrestingly the gif routines have a little
  91. + shift in there to take care of data precisions > 8 ! In fact ...
  92. + 
  93. +     cjpeg12 < test.grey.12.raw.pgm | djpeg12 -gif >test.gif
  94. + 
  95. + works just fine, amazingly enough.
  96. + 
  97. + Once you have versions for 12 bits compiled, and if you have defined 
  98. + PPM_WRITERAWWORDS at compile time, and have updated your pbmplus library 
  99. + but not your X viewer to handle the "extended 16 bit raw" format, one 
  100. + can do things like this ...
  101. + 
  102. +     cjpeg12 < test.grey.12.raw.pgm | djpeg12 | pnmnoraw | xv -
  103. + 
  104. + and actually see an image ! (Although you will have to mess with the 
  105. + color editor of xv to window the image if your data is all squashed 
  106. + down the bottom of the dynamic range like MRI data usually is).
  107. + 
  108. + You don't HAVE to use the extended format ... if you want your images 
  109. + to be compatible and transportable (at least until the known universe 
  110. + fully adopts this wonderful new format) you can always leave out 
  111. + PPM_WRITERAWWORDS, still use the 12 bit mode and produce huge, but 
  112. + functional text files ... well it works, and is better than nothing.
  113. + 
  114. + Finally thanks to whoever wrote the JPEG stuff to handle 12 bits in the 
  115. + first place even though hardly anyone wants it ... those of us who do 
  116. + are very grateful !
  117. + 
  118. + David A. Clunie (dclunie@flash.us.com)
  119. diff -r -c jpegv4a/jconfig.h jpegv4a.12/jconfig.h
  120. *** jpegv4a/jconfig.h    Fri Apr 23 04:32:38 1993
  121. --- jpegv4a.12/jconfig.h    Sat Jul 23 18:50:11 1994
  122. ***************
  123. *** 200,206 ****
  124.   #define GIF_SUPPORTED        /* GIF image file format */
  125.   /* #define RLE_SUPPORTED */    /* RLE image file format (by default, no) */
  126.   #define PPM_SUPPORTED        /* PPM/PGM image file format */
  127. ! #define TARGA_SUPPORTED        /* Targa image file format */
  128.   #undef  TIFF_SUPPORTED        /* TIFF image file format (not yet impl.) */
  129.   
  130.   /* more capability options later, no doubt */
  131. --- 200,207 ----
  132.   #define GIF_SUPPORTED        /* GIF image file format */
  133.   /* #define RLE_SUPPORTED */    /* RLE image file format (by default, no) */
  134.   #define PPM_SUPPORTED        /* PPM/PGM image file format */
  135. ! #define PPM_WRITERAWWORDS       /* If 12 bits, write extended raw word format */
  136. ! #undef  TARGA_SUPPORTED        /* Targa image file format */
  137.   #undef  TIFF_SUPPORTED        /* TIFF image file format (not yet impl.) */
  138.   
  139.   /* more capability options later, no doubt */
  140. ***************
  141. *** 221,228 ****
  142.    * you'll have to supply different default Huffman tables.
  143.    */
  144.   
  145. ! #define EIGHT_BIT_SAMPLES
  146. ! #undef  TWELVE_BIT_SAMPLES
  147.   #undef  SIXTEEN_BIT_SAMPLES
  148.   
  149.   
  150. --- 222,229 ----
  151.    * you'll have to supply different default Huffman tables.
  152.    */
  153.   
  154. ! #undef EIGHT_BIT_SAMPLES
  155. ! #define  TWELVE_BIT_SAMPLES
  156.   #undef  SIXTEEN_BIT_SAMPLES
  157.   
  158.   
  159. diff -r -c jpegv4a/jrdppm.c jpegv4a.12/jrdppm.c
  160. *** jpegv4a/jrdppm.c    Fri Apr 23 04:32:36 1993
  161. --- jpegv4a.12/jrdppm.c    Sat Jul 23 19:15:21 1994
  162. ***************
  163. *** 119,124 ****
  164. --- 119,138 ----
  165.   }
  166.   
  167.   
  168. + LOCAL unsigned int
  169. + read_raw_integer (compress_info_ptr cinfo)
  170. + /* Read a little-endian binary 16 bit value from the PPM file */
  171. + {
  172. +   register unsigned int ch1;
  173. +   register unsigned int ch2;
  174. +   register unsigned int val;
  175. +   
  176. +   ch1 = getc(cinfo->input_file);
  177. +   ch2 = getc(cinfo->input_file);
  178. +   val = (ch2<<8)|ch1;
  179. +   return val;
  180. + }
  181. + 
  182.   /*
  183.    * Read one row of pixels.
  184.    *
  185. ***************
  186. *** 334,339 ****
  187. --- 348,417 ----
  188.   #endif /* USE_GETC_INPUT */
  189.   
  190.   
  191. + METHODDEF void
  192. + get_scaled_word_gray_row (compress_info_ptr cinfo, JSAMPARRAY pixel_row)
  193. + /* This version is for reading raw-format word PGM files with scaling */
  194. + {
  195. +   register JSAMPROW ptr0;
  196. +   register long col;
  197. +   
  198. +   ptr0 = pixel_row[0];
  199. +   for (col = cinfo->image_width; col > 0; col--) {
  200. +     *ptr0++ = rescale[read_raw_integer(cinfo)];
  201. +   }
  202. + }
  203. + 
  204. + 
  205. + METHODDEF void
  206. + get_scaled_word_rgb_row (compress_info_ptr cinfo, JSAMPARRAY pixel_row)
  207. + /* This version is for reading raw-format word PPM files with scaling */
  208. + {
  209. +   register JSAMPROW ptr0, ptr1, ptr2;
  210. +   register long col;
  211. +   
  212. +   ptr0 = pixel_row[0];
  213. +   ptr1 = pixel_row[1];
  214. +   ptr2 = pixel_row[2];
  215. +   for (col = cinfo->image_width; col > 0; col--) {
  216. +     *ptr0++ = rescale[read_raw_integer(cinfo)];
  217. +     *ptr1++ = rescale[read_raw_integer(cinfo)];
  218. +     *ptr2++ = rescale[read_raw_integer(cinfo)];
  219. +   }
  220. + }
  221. + 
  222. + 
  223. + METHODDEF void
  224. + get_raw_word_gray_row (compress_info_ptr cinfo, JSAMPARRAY pixel_row)
  225. + /* This version is for reading raw-format word PGM files without scaling */
  226. + {
  227. +   register JSAMPROW ptr0;
  228. +   register long col;
  229. +   
  230. +   ptr0 = pixel_row[0];
  231. +   for (col = cinfo->image_width; col > 0; col--) {
  232. +     *ptr0++ = (JSAMPLE) read_raw_integer(cinfo);
  233. +   }
  234. + }
  235. + 
  236. + 
  237. + METHODDEF void
  238. + get_raw_word_rgb_row (compress_info_ptr cinfo, JSAMPARRAY pixel_row)
  239. + /* This version is for reading raw-format word PPM files without scaling */
  240. + {
  241. +   register JSAMPROW ptr0, ptr1, ptr2;
  242. +   register long col;
  243. +   
  244. +   ptr0 = pixel_row[0];
  245. +   ptr1 = pixel_row[1];
  246. +   ptr2 = pixel_row[2];
  247. +   for (col = cinfo->image_width; col > 0; col--) {
  248. +     *ptr0++ = (JSAMPLE) read_raw_integer(cinfo);
  249. +     *ptr1++ = (JSAMPLE) read_raw_integer(cinfo);
  250. +     *ptr2++ = (JSAMPLE) read_raw_integer(cinfo);
  251. +   }
  252. + }
  253. + 
  254. + 
  255.   /*
  256.    * Read the file header; return image size and component count.
  257.    */
  258. ***************
  259. *** 343,351 ****
  260.   {
  261.     int c;
  262.     unsigned int w, h, maxval;
  263.   
  264.     if (getc(cinfo->input_file) != 'P')
  265. !     ERREXIT(cinfo->emethods, "Not a PPM file");
  266.   
  267.     c = getc(cinfo->input_file);    /* save format discriminator for a sec */
  268.   
  269. --- 421,430 ----
  270.   {
  271.     int c;
  272.     unsigned int w, h, maxval;
  273. +   int scaling;
  274.   
  275.     if (getc(cinfo->input_file) != 'P')
  276. !     ERREXIT(cinfo->emethods, "Not a PGM or PPM file");
  277.   
  278.     c = getc(cinfo->input_file);    /* save format discriminator for a sec */
  279.   
  280. ***************
  281. *** 354,361 ****
  282.     maxval = read_pbm_integer(cinfo);
  283.   
  284.     if (w <= 0 || h <= 0 || maxval <= 0) /* error check */
  285. !     ERREXIT(cinfo->emethods, "Not a PPM file");
  286.   
  287.     switch (c) {
  288.     case '2':            /* it's a text-format PGM file */
  289.       cinfo->methods->get_input_row = get_text_gray_row;
  290. --- 433,459 ----
  291.     maxval = read_pbm_integer(cinfo);
  292.   
  293.     if (w <= 0 || h <= 0 || maxval <= 0) /* error check */
  294. !     ERREXIT(cinfo->emethods, "Not a PGM or PPM file");
  295.   
  296. + #ifdef MULTIPLEPRECISIONSCANCOEXIST    /* Nice fantasy */
  297. +   if (maxval > MAXJSAMPLE) {
  298. +     scaling=1;
  299. +     cinfo->data_precision = BITS_IN_JSAMPLE;
  300. +   } else if (maxval <= 255) {
  301. +     scaling=0;
  302. +     cinfo->data_precision = 8;
  303. +   } else if (maxval <= 4095) {
  304. +     scaling=0;
  305. +     cinfo->data_precision = 12;
  306. +   } else {
  307. +     cinfo->data_precision = BITS_IN_JSAMPLE;    /* optimistic or what ? */
  308. +   }
  309. + #else  /*MULTIPLEPRECISIONSCANCOEXIST*/
  310. +   cinfo->data_precision = BITS_IN_JSAMPLE;
  311. +   if (maxval != MAXJSAMPLE) scaling=1;
  312. +   else scaling=0;
  313. + #endif /*MULTIPLEPRECISIONSCANCOEXIST*/
  314. + 
  315.     switch (c) {
  316.     case '2':            /* it's a text-format PGM file */
  317.       cinfo->methods->get_input_row = get_text_gray_row;
  318. ***************
  319. *** 372,414 ****
  320.       break;
  321.   
  322.     case '5':            /* it's a raw-format PGM file */
  323. !     if (maxval == MAXJSAMPLE)
  324. !       cinfo->methods->get_input_row = get_raw_gray_row;
  325. !     else
  326. !       cinfo->methods->get_input_row = get_scaled_gray_row;
  327. !     cinfo->input_components = 1;
  328. !     cinfo->in_color_space = CS_GRAYSCALE;
  329.   #ifndef USE_GETC_INPUT
  330. !     /* allocate space for row buffer: 1 byte/pixel */
  331. !     row_buffer = (U_CHAR *) (*cinfo->emethods->alloc_small)
  332.               ((size_t) (SIZEOF(U_CHAR) * (long) w));
  333.   #endif
  334.       TRACEMS2(cinfo->emethods, 1, "%ux%u PGM image", w, h);
  335.       break;
  336.   
  337.     case '6':            /* it's a raw-format PPM file */
  338. !     if (maxval == MAXJSAMPLE)
  339. !       cinfo->methods->get_input_row = get_raw_rgb_row;
  340. !     else
  341. !       cinfo->methods->get_input_row = get_scaled_rgb_row;
  342. !     cinfo->input_components = 3;
  343. !     cinfo->in_color_space = CS_RGB;
  344.   #ifndef USE_GETC_INPUT
  345. !     /* allocate space for row buffer: 3 bytes/pixel */
  346. !     row_buffer = (U_CHAR *) (*cinfo->emethods->alloc_small)
  347.               ((size_t) (3 * SIZEOF(U_CHAR) * (long) w));
  348.   #endif
  349.       TRACEMS2(cinfo->emethods, 1, "%ux%u PPM image", w, h);
  350.       break;
  351.   
  352.     default:
  353. !     ERREXIT(cinfo->emethods, "Not a PPM file");
  354.       break;
  355.     }
  356.   
  357.     /* Compute the rescaling array if necessary */
  358.     /* This saves per-pixel calculation */
  359. !   if (maxval == MAXJSAMPLE)
  360.       rescale = NULL;        /* no rescaling required */
  361.     else {
  362.       INT32 val, half_maxval;
  363. --- 470,528 ----
  364.       break;
  365.   
  366.     case '5':            /* it's a raw-format PGM file */
  367. !     if (maxval <= 255)
  368. !     {
  369.   #ifndef USE_GETC_INPUT
  370. !         /* allocate space for row buffer: 1 byte/pixel */
  371. !         row_buffer = (U_CHAR *) (*cinfo->emethods->alloc_small)
  372.               ((size_t) (SIZEOF(U_CHAR) * (long) w));
  373.   #endif
  374. +         if (!scaling)
  375. +             cinfo->methods->get_input_row = get_raw_gray_row;
  376. +         else
  377. +             cinfo->methods->get_input_row = get_scaled_gray_row;
  378. +     } else {
  379. +         if (!scaling)
  380. +             cinfo->methods->get_input_row = get_raw_word_gray_row;
  381. +         else
  382. +             cinfo->methods->get_input_row = get_scaled_word_gray_row;
  383. +     }
  384. +     cinfo->input_components = 1;
  385. +     cinfo->in_color_space = CS_GRAYSCALE;
  386.       TRACEMS2(cinfo->emethods, 1, "%ux%u PGM image", w, h);
  387.       break;
  388.   
  389.     case '6':            /* it's a raw-format PPM file */
  390. !     if (maxval <= 255)
  391. !     {
  392.   #ifndef USE_GETC_INPUT
  393. !         /* allocate space for row buffer: 3 bytes/pixel */
  394. !         row_buffer = (U_CHAR *) (*cinfo->emethods->alloc_small)
  395.               ((size_t) (3 * SIZEOF(U_CHAR) * (long) w));
  396.   #endif
  397. +         if (!scaling)
  398. +             cinfo->methods->get_input_row = get_raw_rgb_row;
  399. +         else
  400. +             cinfo->methods->get_input_row = get_scaled_rgb_row;
  401. +     } else {
  402. +         if (!scaling)
  403. +             cinfo->methods->get_input_row = get_raw_word_rgb_row;
  404. +         else
  405. +             cinfo->methods->get_input_row = get_scaled_word_rgb_row;
  406. +     }
  407. +     cinfo->input_components = 3;
  408. +     cinfo->in_color_space = CS_RGB;
  409.       TRACEMS2(cinfo->emethods, 1, "%ux%u PPM image", w, h);
  410.       break;
  411.   
  412.     default:
  413. !     ERREXIT(cinfo->emethods, "Not a PGM or PPM file");
  414.       break;
  415.     }
  416.   
  417.     /* Compute the rescaling array if necessary */
  418.     /* This saves per-pixel calculation */
  419. !   if (!scaling)
  420.       rescale = NULL;        /* no rescaling required */
  421.     else {
  422.       INT32 val, half_maxval;
  423. ***************
  424. *** 425,431 ****
  425.   
  426.     cinfo->image_width = w;
  427.     cinfo->image_height = h;
  428. -   cinfo->data_precision = BITS_IN_JSAMPLE;
  429.   }
  430.   
  431.   
  432. --- 539,544 ----
  433. diff -r -c jpegv4a/jwrppm.c jpegv4a.12/jwrppm.c
  434. *** jpegv4a/jwrppm.c    Fri Apr 23 04:32:37 1993
  435. --- jpegv4a.12/jwrppm.c    Sat Jul 23 20:12:08 1994
  436. ***************
  437. *** 19,36 ****
  438.   
  439.   #ifdef PPM_SUPPORTED
  440.   
  441. - 
  442.   /*
  443. -  * Haven't yet got around to making this work with text-format output,
  444. -  * hence cannot handle pixels wider than 8 bits.
  445. -  */
  446. - 
  447. - #ifndef EIGHT_BIT_SAMPLES
  448. -   Sorry, this code only copes with 8-bit JSAMPLEs. /* deliberate syntax err */
  449. - #endif
  450. - 
  451. - 
  452. - /*
  453.    * On most systems, writing individual bytes with putc() is drastically less
  454.    * efficient than buffering a row at a time for fwrite().  But we must
  455.    * allocate the row buffer in near data space on PCs, because we are assuming
  456. --- 19,25 ----
  457. ***************
  458. *** 53,79 ****
  459.   METHODDEF void
  460.   output_init (decompress_info_ptr cinfo)
  461.   {
  462. !   if (cinfo->out_color_space == CS_GRAYSCALE) {
  463.       /* emit header for raw PGM format */
  464.       fprintf(cinfo->output_file, "P5\n%ld %ld\n%d\n",
  465. !         cinfo->image_width, cinfo->image_height, 255);
  466. ! #ifndef USE_PUTC_OUTPUT
  467. !     /* allocate space for row buffer: 1 byte/pixel */
  468. !     row_buffer = (char *) (*cinfo->emethods->alloc_small)
  469. !             ((size_t) (SIZEOF(char) * cinfo->image_width));
  470. ! #endif
  471. !   } else if (cinfo->out_color_space == CS_RGB) {
  472.       /* emit header for raw PPM format */
  473.       fprintf(cinfo->output_file, "P6\n%ld %ld\n%d\n",
  474. !         cinfo->image_width, cinfo->image_height, 255);
  475.   #ifndef USE_PUTC_OUTPUT
  476. !     /* allocate space for row buffer: 3 bytes/pixel */
  477. !     row_buffer = (char *) (*cinfo->emethods->alloc_small)
  478.               ((size_t) (3 * SIZEOF(char) * cinfo->image_width));
  479. ! #endif
  480. !   } else {
  481. !     ERREXIT(cinfo->emethods, "PPM output must be grayscale or RGB");
  482. !   }
  483.   }
  484.   
  485.   
  486. --- 42,118 ----
  487.   METHODDEF void
  488.   output_init (decompress_info_ptr cinfo)
  489.   {
  490. !   unsigned maxval;
  491. ! 
  492. !   /* don't need to check MAXJSAMPLE etc. because couldn't get this far */
  493. !   /* with any other value of cinfo->data_precision than 8 if only 8 bits */
  494. ! 
  495. !   if (cinfo->data_precision == 8) {
  496. !     maxval=255;
  497. !   } else if (cinfo->data_precision == 12) {
  498. !     maxval=4095;
  499. !   } else {
  500. !     ERREXIT(cinfo->emethods, "PPM output - only 8 or 12 bits supported");
  501. !   }
  502. ! 
  503. ! #ifdef PPM_WRITETEXT
  504. !   if (cinfo->out_color_space == CS_GRAYSCALE)
  505. !     /* emit header for text PGM format */
  506. !     fprintf(cinfo->output_file, "P2\n%ld %ld\n%d\n",
  507. !         cinfo->image_width, cinfo->image_height, maxval);
  508. !   else if (cinfo->out_color_space == CS_RGB)
  509. !     /* emit header for text PPM format */
  510. !     fprintf(cinfo->output_file, "P3\n%ld %ld\n%d\n",
  511. !         cinfo->image_width, cinfo->image_height, maxval);
  512. ! #else  /*PPM_WRITETEXT*/
  513. !   if (cinfo->out_color_space == CS_GRAYSCALE)
  514. ! #ifdef PPM_WRITERAWWORDS
  515.       /* emit header for raw PGM format */
  516.       fprintf(cinfo->output_file, "P5\n%ld %ld\n%d\n",
  517. !         cinfo->image_width, cinfo->image_height, maxval);
  518. ! #else  /*PPM_WRITERAWWORDS*/
  519. !     if (cinfo->data_precision == 8)
  520. !       /* emit header for raw PGM format */
  521. !       fprintf(cinfo->output_file, "P5\n%ld %ld\n%d\n",
  522. !           cinfo->image_width, cinfo->image_height, maxval);
  523. !     else
  524. !       /* emit header for text PGM format */
  525. !       fprintf(cinfo->output_file, "P2\n%ld %ld\n%d\n",
  526. !           cinfo->image_width, cinfo->image_height, maxval);
  527. ! #endif /*PPM_WRITERAWWORDS*/
  528. !   else if (cinfo->out_color_space == CS_RGB)
  529. ! #ifdef PPM_WRITERAWWORDS
  530.       /* emit header for raw PPM format */
  531.       fprintf(cinfo->output_file, "P6\n%ld %ld\n%d\n",
  532. !         cinfo->image_width, cinfo->image_height, maxval);
  533. ! #else  /*PPM_WRITERAWWORDS*/
  534. !     if (cinfo->data_precision == 8)
  535. !       /* emit header for raw PPM format */
  536. !       fprintf(cinfo->output_file, "P6\n%ld %ld\n%d\n",
  537. !           cinfo->image_width, cinfo->image_height, maxval);
  538. !     else
  539. !       /* emit header for text PPM format */
  540. !       fprintf(cinfo->output_file, "P3\n%ld %ld\n%d\n",
  541. !           cinfo->image_width, cinfo->image_height, maxval);
  542. ! #endif /*PPM_WRITERAWWORDS*/
  543. ! #endif /*PPM_WRITETEXT*/
  544. !   else
  545. !     ERREXIT(cinfo->emethods, "PPM output must be grayscale or RGB");
  546. ! 
  547. ! #ifndef PPM_WRITETEXT
  548.   #ifndef USE_PUTC_OUTPUT
  549. !     if (cinfo->data_precision == 8) {
  550. !       if (cinfo->out_color_space == CS_GRAYSCALE)
  551. !         /* allocate space for row buffer: 1 byte/pixel */
  552. !         row_buffer = (char *) (*cinfo->emethods->alloc_small)
  553. !             ((size_t) (SIZEOF(char) * cinfo->image_width));
  554. !       else
  555. !         /* allocate space for row buffer: 3 bytes/pixel */
  556. !         row_buffer = (char *) (*cinfo->emethods->alloc_small)
  557.               ((size_t) (3 * SIZEOF(char) * cinfo->image_width));
  558. !     }
  559. ! #endif /*USE_PUTC_OUTPUT*/
  560. ! #endif /*PPM_WRITETEXT*/
  561.   }
  562.   
  563.   
  564. ***************
  565. *** 81,90 ****
  566.    * Write some pixel data.
  567.    */
  568.   
  569.   #ifdef USE_PUTC_OUTPUT
  570.   
  571.   METHODDEF void
  572. ! put_pixel_rows (decompress_info_ptr cinfo, int num_rows,
  573.           JSAMPIMAGE pixel_data)
  574.   {
  575.     register FILE * outfile = cinfo->output_file;
  576. --- 120,227 ----
  577.    * Write some pixel data.
  578.    */
  579.   
  580. + METHODDEF void
  581. + put_rgb_text_rows (decompress_info_ptr cinfo, int num_rows,
  582. +         JSAMPIMAGE pixel_data)
  583. + {
  584. +   register FILE * outfile = cinfo->output_file;
  585. +   register JSAMPROW ptr0, ptr1, ptr2;
  586. +   register long col;
  587. +   long width = cinfo->image_width;
  588. +   int row;
  589. +   
  590. +   for (row = 0; row < num_rows; row++) {
  591. +     ptr0 = pixel_data[0][row];
  592. +     ptr1 = pixel_data[1][row];
  593. +     ptr2 = pixel_data[2][row];
  594. +     for (col = width; col > 0; col--) {
  595. +       fprintf(outfile,"%u\n",(unsigned)GETJSAMPLE(*ptr0));
  596. +       ptr0++;
  597. +       fprintf(outfile,"%u\n",(unsigned)GETJSAMPLE(*ptr1));
  598. +       ptr1++;
  599. +       fprintf(outfile,"%u\n",(unsigned)GETJSAMPLE(*ptr2));
  600. +       ptr2++;
  601. +     }
  602. +   }
  603. + }
  604. + 
  605. + METHODDEF void
  606. + put_gray_text_rows (decompress_info_ptr cinfo, int num_rows,
  607. +            JSAMPIMAGE pixel_data)
  608. + {
  609. +   register FILE * outfile = cinfo->output_file;
  610. +   register JSAMPROW ptr0;
  611. +   register long col;
  612. +   long width = cinfo->image_width;
  613. +   int row;
  614. +   
  615. +   for (row = 0; row < num_rows; row++) {
  616. +     ptr0 = pixel_data[0][row];
  617. +     for (col = width; col > 0; col--) {
  618. +       fprintf(outfile,"%u\n",(unsigned)GETJSAMPLE(*ptr0));
  619. +       ptr0++;
  620. +     }
  621. +   }
  622. + }
  623. + 
  624. + METHODDEF void
  625. + put_rgb_raw_word_rows (decompress_info_ptr cinfo, int num_rows,
  626. +         JSAMPIMAGE pixel_data)
  627. + {
  628. +   register FILE * outfile = cinfo->output_file;
  629. +   register JSAMPROW ptr0, ptr1, ptr2;
  630. +   register long col;
  631. +   long width = cinfo->image_width;
  632. +   int row;
  633. +   
  634. +   for (row = 0; row < num_rows; row++) {
  635. +     ptr0 = pixel_data[0][row];
  636. +     ptr1 = pixel_data[1][row];
  637. +     ptr2 = pixel_data[2][row];
  638. +     for (col = width; col > 0; col--) {
  639. +       JSAMPLE value;
  640. +       value=GETJSAMPLE(*ptr0);
  641. +       putc(value&0xff, outfile);
  642. +       putc((value>>8)&0xff, outfile);
  643. +       ptr0++;
  644. +       value=GETJSAMPLE(*ptr1);
  645. +       putc(value&0xff, outfile);
  646. +       putc((value>>8)&0xff, outfile);
  647. +       ptr1++;
  648. +       value=GETJSAMPLE(*ptr2);
  649. +       putc(value&0xff, outfile);
  650. +       putc((value>>8)&0xff, outfile);
  651. +       ptr2++;
  652. +     }
  653. +   }
  654. + }
  655. + 
  656. + METHODDEF void
  657. + put_gray_raw_word_rows (decompress_info_ptr cinfo, int num_rows,
  658. +            JSAMPIMAGE pixel_data)
  659. + {
  660. +   register FILE * outfile = cinfo->output_file;
  661. +   register JSAMPROW ptr0;
  662. +   register long col;
  663. +   long width = cinfo->image_width;
  664. +   int row;
  665. + 
  666. +   for (row = 0; row < num_rows; row++) {
  667. +     ptr0 = pixel_data[0][row];
  668. +     for (col = width; col > 0; col--) {
  669. +       JSAMPLE value;
  670. +       value=GETJSAMPLE(*ptr0);
  671. +       putc(value&0xff, outfile);
  672. +       putc((value>>8)&0xff, outfile);
  673. +       ptr0++;
  674. +     }
  675. +   }
  676. + }
  677. + 
  678.   #ifdef USE_PUTC_OUTPUT
  679.   
  680.   METHODDEF void
  681. ! put_rgb_raw_byte_rows (decompress_info_ptr cinfo, int num_rows,
  682.           JSAMPIMAGE pixel_data)
  683.   {
  684.     register FILE * outfile = cinfo->output_file;
  685. ***************
  686. *** 109,115 ****
  687.   }
  688.   
  689.   METHODDEF void
  690. ! put_gray_rows (decompress_info_ptr cinfo, int num_rows,
  691.              JSAMPIMAGE pixel_data)
  692.   {
  693.     register FILE * outfile = cinfo->output_file;
  694. --- 246,252 ----
  695.   }
  696.   
  697.   METHODDEF void
  698. ! put_gray_raw_byte_rows (decompress_info_ptr cinfo, int num_rows,
  699.              JSAMPIMAGE pixel_data)
  700.   {
  701.     register FILE * outfile = cinfo->output_file;
  702. ***************
  703. *** 130,136 ****
  704.   #else /* use row buffering */
  705.   
  706.   METHODDEF void
  707. ! put_pixel_rows (decompress_info_ptr cinfo, int num_rows,
  708.           JSAMPIMAGE pixel_data)
  709.   {
  710.     FILE * outfile = cinfo->output_file;
  711. --- 267,273 ----
  712.   #else /* use row buffering */
  713.   
  714.   METHODDEF void
  715. ! put_rgb_raw_byte_rows (decompress_info_ptr cinfo, int num_rows,
  716.           JSAMPIMAGE pixel_data)
  717.   {
  718.     FILE * outfile = cinfo->output_file;
  719. ***************
  720. *** 155,161 ****
  721.   }
  722.   
  723.   METHODDEF void
  724. ! put_gray_rows (decompress_info_ptr cinfo, int num_rows,
  725.              JSAMPIMAGE pixel_data)
  726.   {
  727.     FILE * outfile = cinfo->output_file;
  728. --- 292,298 ----
  729.   }
  730.   
  731.   METHODDEF void
  732. ! put_gray_raw_byte_rows (decompress_info_ptr cinfo, int num_rows,
  733.              JSAMPIMAGE pixel_data)
  734.   {
  735.     FILE * outfile = cinfo->output_file;
  736. ***************
  737. *** 182,191 ****
  738.    * Write some pixel data when color quantization is in effect.
  739.    */
  740.   
  741.   #ifdef USE_PUTC_OUTPUT
  742.   
  743.   METHODDEF void
  744. ! put_demapped_rgb (decompress_info_ptr cinfo, int num_rows,
  745.             JSAMPIMAGE pixel_data)
  746.   {
  747.     register FILE * outfile = cinfo->output_file;
  748. --- 319,430 ----
  749.    * Write some pixel data when color quantization is in effect.
  750.    */
  751.   
  752. + METHODDEF void
  753. + put_demapped_rgb_text_rows (decompress_info_ptr cinfo, int num_rows,
  754. +           JSAMPIMAGE pixel_data)
  755. + {
  756. +   register FILE * outfile = cinfo->output_file;
  757. +   register JSAMPROW ptr;
  758. +   register JSAMPROW color_map0 = cinfo->colormap[0];
  759. +   register JSAMPROW color_map1 = cinfo->colormap[1];
  760. +   register JSAMPROW color_map2 = cinfo->colormap[2];
  761. +   register int pixval;
  762. +   register long col;
  763. +   long width = cinfo->image_width;
  764. +   int row;
  765. +   
  766. +   for (row = 0; row < num_rows; row++) {
  767. +     ptr = pixel_data[0][row];
  768. +     for (col = width; col > 0; col--) {
  769. +       pixval = GETJSAMPLE(*ptr++);
  770. +       fprintf(outfile,"%u\n",(unsigned)GETJSAMPLE(color_map0[pixval]));
  771. +       fprintf(outfile,"%u\n",(unsigned)GETJSAMPLE(color_map1[pixval]));
  772. +       fprintf(outfile,"%u\n",(unsigned)GETJSAMPLE(color_map2[pixval]));
  773. +     }
  774. +   }
  775. + }
  776. + 
  777. + METHODDEF void
  778. + put_demapped_gray_text_rows (decompress_info_ptr cinfo, int num_rows,
  779. +            JSAMPIMAGE pixel_data)
  780. + {
  781. +   register FILE * outfile = cinfo->output_file;
  782. +   register JSAMPROW ptr;
  783. +   register JSAMPROW color_map0 = cinfo->colormap[0];
  784. +   register int pixval;
  785. +   register long col;
  786. +   long width = cinfo->image_width;
  787. +   int row;
  788. +   
  789. +   for (row = 0; row < num_rows; row++) {
  790. +     ptr = pixel_data[0][row];
  791. +     for (col = width; col > 0; col--) {
  792. +       pixval = GETJSAMPLE(*ptr++);
  793. +       fprintf(outfile,"%u\n",(unsigned)GETJSAMPLE(color_map0[pixval]));
  794. +     }
  795. +   }
  796. + }
  797. + 
  798. + METHODDEF void
  799. + put_demapped_rgb_raw_word_rows (decompress_info_ptr cinfo, int num_rows,
  800. +           JSAMPIMAGE pixel_data)
  801. + {
  802. +   register FILE * outfile = cinfo->output_file;
  803. +   register JSAMPROW ptr;
  804. +   register JSAMPROW color_map0 = cinfo->colormap[0];
  805. +   register JSAMPROW color_map1 = cinfo->colormap[1];
  806. +   register JSAMPROW color_map2 = cinfo->colormap[2];
  807. +   register int pixval;
  808. +   register long col;
  809. +   long width = cinfo->image_width;
  810. +   int row;
  811. +   
  812. +   for (row = 0; row < num_rows; row++) {
  813. +     ptr = pixel_data[0][row];
  814. +     for (col = width; col > 0; col--) {
  815. +       JSAMPLE value;
  816. +       pixval = GETJSAMPLE(*ptr++);
  817. +       value=GETJSAMPLE(color_map0[pixval]);
  818. +       putc(value&0xff, outfile);
  819. +       putc((value>>8)&0xff, outfile);
  820. +       value=GETJSAMPLE(color_map1[pixval]);
  821. +       putc(value&0xff, outfile);
  822. +       putc((value>>8)&0xff, outfile);
  823. +       value=GETJSAMPLE(color_map2[pixval]);
  824. +       putc(value&0xff, outfile);
  825. +       putc((value>>8)&0xff, outfile);
  826. +     }
  827. +   }
  828. + }
  829. + 
  830. + METHODDEF void
  831. + put_demapped_gray_raw_word_rows (decompress_info_ptr cinfo, int num_rows,
  832. +            JSAMPIMAGE pixel_data)
  833. + {
  834. +   register FILE * outfile = cinfo->output_file;
  835. +   register JSAMPROW ptr;
  836. +   register JSAMPROW color_map0 = cinfo->colormap[0];
  837. +   register int pixval;
  838. +   register long col;
  839. +   long width = cinfo->image_width;
  840. +   int row;
  841. +   
  842. +   for (row = 0; row < num_rows; row++) {
  843. +     ptr = pixel_data[0][row];
  844. +     for (col = width; col > 0; col--) {
  845. +       JSAMPLE value;
  846. +       pixval = GETJSAMPLE(*ptr++);
  847. +       value=GETJSAMPLE(color_map0[pixval]);
  848. +       putc(value&0xff, outfile);
  849. +       putc((value>>8)&0xff, outfile);
  850. +     }
  851. +   }
  852. + }
  853. + 
  854.   #ifdef USE_PUTC_OUTPUT
  855.   
  856.   METHODDEF void
  857. ! put_demapped_rgb_raw_byte_rows (decompress_info_ptr cinfo, int num_rows,
  858.             JSAMPIMAGE pixel_data)
  859.   {
  860.     register FILE * outfile = cinfo->output_file;
  861. ***************
  862. *** 210,216 ****
  863.   }
  864.   
  865.   METHODDEF void
  866. ! put_demapped_gray (decompress_info_ptr cinfo, int num_rows,
  867.              JSAMPIMAGE pixel_data)
  868.   {
  869.     register FILE * outfile = cinfo->output_file;
  870. --- 449,455 ----
  871.   }
  872.   
  873.   METHODDEF void
  874. ! put_demapped_gray_raw_byte_rows (decompress_info_ptr cinfo, int num_rows,
  875.              JSAMPIMAGE pixel_data)
  876.   {
  877.     register FILE * outfile = cinfo->output_file;
  878. ***************
  879. *** 233,239 ****
  880.   #else /* use row buffering */
  881.   
  882.   METHODDEF void
  883. ! put_demapped_rgb (decompress_info_ptr cinfo, int num_rows,
  884.             JSAMPIMAGE pixel_data)
  885.   {
  886.     FILE * outfile = cinfo->output_file;
  887. --- 472,478 ----
  888.   #else /* use row buffering */
  889.   
  890.   METHODDEF void
  891. ! put_demapped_rgb_raw_byte_rows (decompress_info_ptr cinfo, int num_rows,
  892.             JSAMPIMAGE pixel_data)
  893.   {
  894.     FILE * outfile = cinfo->output_file;
  895. ***************
  896. *** 261,267 ****
  897.   }
  898.   
  899.   METHODDEF void
  900. ! put_demapped_gray (decompress_info_ptr cinfo, int num_rows,
  901.              JSAMPIMAGE pixel_data)
  902.   {
  903.     FILE * outfile = cinfo->output_file;
  904. --- 500,506 ----
  905.   }
  906.   
  907.   METHODDEF void
  908. ! put_demapped_gray_raw_byte_rows (decompress_info_ptr cinfo, int num_rows,
  909.              JSAMPIMAGE pixel_data)
  910.   {
  911.     FILE * outfile = cinfo->output_file;
  912. ***************
  913. *** 295,304 ****
  914.   METHODDEF void
  915.   put_color_map (decompress_info_ptr cinfo, int num_colors, JSAMPARRAY colormap)
  916.   {
  917. !   if (cinfo->out_color_space == CS_RGB)
  918. !     cinfo->methods->put_pixel_rows = put_demapped_rgb;
  919. !   else
  920. !     cinfo->methods->put_pixel_rows = put_demapped_gray;
  921.   }
  922.   
  923.   
  924. --- 534,568 ----
  925.   METHODDEF void
  926.   put_color_map (decompress_info_ptr cinfo, int num_colors, JSAMPARRAY colormap)
  927.   {
  928. !   if (cinfo->out_color_space == CS_RGB) {
  929. ! #ifdef PPM_WRITETEXT
  930. !     cinfo->methods->put_pixel_rows = put_demapped_rgb_text_rows;
  931. ! #else  /*PPM_WRITETEXT*/
  932. !     if (cinfo->data_precision == 8) {
  933. !       cinfo->methods->put_pixel_rows = put_demapped_rgb_raw_byte_rows;
  934. !     } else {
  935. ! #ifdef PPM_WRITERAWWORDS
  936. !       cinfo->methods->put_pixel_rows = put_demapped_rgb_raw_word_rows;
  937. ! #else  /*PPM_WRITERAWWORDS*/
  938. !       cinfo->methods->put_pixel_rows = put_demapped_rgb_text_rows;
  939. ! #endif /*PPM_WRITERAWWORDS*/
  940. !     }
  941. ! #endif /*PPM_WRITETEXT*/
  942. !   } else {
  943. ! #ifdef PPM_WRITETEXT
  944. !     cinfo->methods->put_pixel_rows = put_demapped_gray_text_rows;
  945. ! #else  /*PPM_WRITETEXT*/
  946. !     if (cinfo->data_precision == 8) {
  947. !       cinfo->methods->put_pixel_rows = put_demapped_gray_raw_byte_rows;
  948. !     } else {
  949. ! #ifdef PPM_WRITERAWWORDS
  950. !       cinfo->methods->put_pixel_rows = put_demapped_gray_raw_word_rows;
  951. ! #else  /*PPM_WRITERAWWORDS*/
  952. !       cinfo->methods->put_pixel_rows = put_demapped_gray_text_rows;
  953. ! #endif /*PPM_WRITERAWWORDS*/
  954. !     }
  955. ! #endif /*PPM_WRITETEXT*/
  956. !   }
  957.   }
  958.   
  959.   
  960. ***************
  961. *** 327,337 ****
  962.   {
  963.     cinfo->methods->output_init = output_init;
  964.     cinfo->methods->put_color_map = put_color_map;
  965. !   if (cinfo->out_color_space == CS_RGB)
  966. !     cinfo->methods->put_pixel_rows = put_pixel_rows;
  967. !   else
  968. !     cinfo->methods->put_pixel_rows = put_gray_rows;
  969.     cinfo->methods->output_term = output_term;
  970.   }
  971.   
  972.   #endif /* PPM_SUPPORTED */
  973. --- 591,631 ----
  974.   {
  975.     cinfo->methods->output_init = output_init;
  976.     cinfo->methods->put_color_map = put_color_map;
  977. ! 
  978. !   if (cinfo->out_color_space == CS_RGB) {
  979. ! #ifdef PPM_WRITETEXT
  980. !     cinfo->methods->put_pixel_rows = put_rgb_text_rows;
  981. ! #else  /*PPM_WRITETEXT*/
  982. !     if (cinfo->data_precision == 8) {
  983. !       cinfo->methods->put_pixel_rows = put_rgb_raw_byte_rows;
  984. !     } else {
  985. ! #ifdef PPM_WRITERAWWORDS
  986. !       cinfo->methods->put_pixel_rows = put_rgb_raw_word_rows;
  987. ! #else  /*PPM_WRITERAWWORDS*/
  988. !       cinfo->methods->put_pixel_rows = put_rgb_text_rows;
  989. ! #endif /*PPM_WRITERAWWORDS*/
  990. !     }
  991. ! #endif /*PPM_WRITETEXT*/
  992. !   } else {
  993. ! #ifdef PPM_WRITETEXT
  994. !     cinfo->methods->put_pixel_rows = put_gray_text_rows;
  995. ! #else  /*PPM_WRITETEXT*/
  996. !     if (cinfo->data_precision == 8) {
  997. !       cinfo->methods->put_pixel_rows = put_gray_raw_byte_rows;
  998. !     } else {
  999. ! #ifdef PPM_WRITERAWWORDS
  1000. !       cinfo->methods->put_pixel_rows = put_gray_raw_word_rows;
  1001. ! #else  /*PPM_WRITERAWWORDS*/
  1002. !       cinfo->methods->put_pixel_rows = put_gray_text_rows;
  1003. ! #endif /*PPM_WRITERAWWORDS*/
  1004. !     }
  1005. ! #endif /*PPM_WRITETEXT*/
  1006. !   }
  1007. ! 
  1008.     cinfo->methods->output_term = output_term;
  1009.   }
  1010.   
  1011.   #endif /* PPM_SUPPORTED */
  1012. + 
  1013. + 
  1014. + 
  1015.  
  1016. ---
  1017. David A. Clunie (dclunie@flash.us.com)
  1018. In sunny Riyadh, Saudi Arabia.
  1019.  
  1020. "I must see your DICOM 3 conformance statement before I buy."
  1021.  
  1022.