home *** CD-ROM | disk | FTP | other *** search
/ C!T ROM 5 / ctrom5b.zip / ctrom5b / DOS / GRAFISCH / JPGSRC5A / RDTARGA.C < prev    next >
C/C++ Source or Header  |  1994-09-22  |  15KB  |  500 lines
  1. /*
  2.  * rdtarga.c
  3.  *
  4.  * Copyright (C) 1991-1994, Thomas G. Lane.
  5.  * This file is part of the Independent JPEG Group's software.
  6.  * For conditions of distribution and use, see the accompanying README file.
  7.  *
  8.  * This file contains routines to read input images in Targa format.
  9.  *
  10.  * These routines may need modification for non-Unix environments or
  11.  * specialized applications.  As they stand, they assume input from
  12.  * an ordinary stdio stream.  They further assume that reading begins
  13.  * at the start of the file; start_input may need work if the
  14.  * user interface has already read some data (e.g., to determine that
  15.  * the file is indeed Targa format).
  16.  *
  17.  * Based on code contributed by Lee Daniel Crocker.
  18.  */
  19.  
  20. #include "cdjpeg.h"        /* Common decls for cjpeg/djpeg applications */
  21.  
  22. #ifdef TARGA_SUPPORTED
  23.  
  24.  
  25. /* Macros to deal with unsigned chars as efficiently as compiler allows */
  26.  
  27. #ifdef HAVE_UNSIGNED_CHAR
  28. typedef unsigned char U_CHAR;
  29. #define UCH(x)    ((int) (x))
  30. #else /* !HAVE_UNSIGNED_CHAR */
  31. #ifdef CHAR_IS_UNSIGNED
  32. typedef char U_CHAR;
  33. #define UCH(x)    ((int) (x))
  34. #else
  35. typedef char U_CHAR;
  36. #define UCH(x)    ((int) (x) & 0xFF)
  37. #endif
  38. #endif /* HAVE_UNSIGNED_CHAR */
  39.  
  40.  
  41. #define    ReadOK(file,buffer,len)    (JFREAD(file,buffer,len) == ((size_t) (len)))
  42.  
  43.  
  44. /* Private version of data source object */
  45.  
  46. typedef struct _tga_source_struct * tga_source_ptr;
  47.  
  48. typedef struct _tga_source_struct {
  49.   struct cjpeg_source_struct pub; /* public fields */
  50.  
  51.   j_compress_ptr cinfo;        /* back link saves passing separate parm */
  52.  
  53.   JSAMPARRAY colormap;        /* Targa colormap (converted to my format) */
  54.  
  55.   jvirt_sarray_ptr whole_image;    /* Needed if funny input row order */
  56.   JDIMENSION current_row;    /* Current logical row number to read */
  57.  
  58.   /* Pointer to routine to extract next Targa pixel from input file */
  59.   JMETHOD(void, read_pixel, (tga_source_ptr sinfo));
  60.  
  61.   /* Result of read_pixel is delivered here: */
  62.   U_CHAR tga_pixel[4];
  63.  
  64.   int pixel_size;        /* Bytes per Targa pixel (1 to 4) */
  65.  
  66.   /* State info for reading RLE-coded pixels; both counts must be init to 0 */
  67.   int block_count;        /* # of pixels remaining in RLE block */
  68.   int dup_pixel_count;        /* # of times to duplicate previous pixel */
  69.  
  70.   /* This saves the correct pixel-row-expansion method for preload_image */
  71.   JMETHOD(JDIMENSION, get_pixel_rows, (j_compress_ptr cinfo,
  72.                        cjpeg_source_ptr sinfo));
  73. } tga_source_struct;
  74.  
  75.  
  76. /* For expanding 5-bit pixel values to 8-bit with best rounding */
  77.  
  78. static const UINT8 c5to8bits[32] = {
  79.     0,   8,  16,  24,  32,  41,  49,  57,
  80.    65,  74,  82,  90,  98, 106, 115, 123,
  81.   131, 139, 148, 156, 164, 172, 180, 189,
  82.   197, 205, 213, 222, 230, 238, 246, 255
  83. };
  84.  
  85.  
  86.  
  87. LOCAL int
  88. read_byte (tga_source_ptr sinfo)
  89. /* Read next byte from Targa file */
  90. {
  91.   register FILE *infile = sinfo->pub.input_file;
  92.   register int c;
  93.  
  94.   if ((c = getc(infile)) == EOF)
  95.     ERREXIT(sinfo->cinfo, JERR_INPUT_EOF);
  96.   return c;
  97. }
  98.  
  99.  
  100. LOCAL void
  101. read_colormap (tga_source_ptr sinfo, int cmaplen, int mapentrysize)
  102. /* Read the colormap from a Targa file */
  103. {
  104.   int i;
  105.  
  106.   /* Presently only handles 24-bit BGR format */
  107.   if (mapentrysize != 24)
  108.     ERREXIT(sinfo->cinfo, JERR_TGA_BADCMAP);
  109.  
  110.   for (i = 0; i < cmaplen; i++) {
  111.     sinfo->colormap[2][i] = (JSAMPLE) read_byte(sinfo);
  112.     sinfo->colormap[1][i] = (JSAMPLE) read_byte(sinfo);
  113.     sinfo->colormap[0][i] = (JSAMPLE) read_byte(sinfo);
  114.   }
  115. }
  116.  
  117.  
  118. /*
  119.  * read_pixel methods: get a single pixel from Targa file into tga_pixel[]
  120.  */
  121.  
  122. LOCAL void
  123. read_non_rle_pixel (tga_source_ptr sinfo)
  124. /* Read one Targa pixel from the input file; no RLE expansion */
  125. {
  126.   register FILE *infile = sinfo->pub.input_file;
  127.   register int i;
  128.  
  129.   for (i = 0; i < sinfo->pixel_size; i++) {
  130.     sinfo->tga_pixel[i] = (U_CHAR) getc(infile);
  131.   }
  132. }
  133.  
  134.  
  135. LOCAL void
  136. read_rle_pixel (tga_source_ptr sinfo)
  137. /* Read one Targa pixel from the input file, expanding RLE data as needed */
  138. {
  139.   register FILE *infile = sinfo->pub.input_file;
  140.   register int i;
  141.  
  142.   /* Duplicate previously read pixel? */
  143.   if (sinfo->dup_pixel_count > 0) {
  144.     sinfo->dup_pixel_count--;
  145.     return;
  146.   }
  147.  
  148.   /* Time to read RLE block header? */
  149.   if (--sinfo->block_count < 0) { /* decrement pixels remaining in block */
  150.     i = read_byte(sinfo);
  151.     if (i & 0x80) {        /* Start of duplicate-pixel block? */
  152.       sinfo->dup_pixel_count = i & 0x7F; /* number of dups after this one */
  153.       sinfo->block_count = 0;    /* then read new block header */
  154.     } else {
  155.       sinfo->block_count = i & 0x7F; /* number of pixels after this one */
  156.     }
  157.   }
  158.  
  159.   /* Read next pixel */
  160.   for (i = 0; i < sinfo->pixel_size; i++) {
  161.     sinfo->tga_pixel[i] = (U_CHAR) getc(infile);
  162.   }
  163. }
  164.  
  165.  
  166. /*
  167.  * Read one row of pixels.
  168.  *
  169.  * We provide several different versions depending on input file format.
  170.  */
  171.  
  172.  
  173. METHODDEF JDIMENSION
  174. get_8bit_gray_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
  175. /* This version is for reading 8-bit grayscale pixels */
  176. {
  177.   tga_source_ptr source = (tga_source_ptr) sinfo;
  178.   register JSAMPROW ptr;
  179.   register JDIMENSION col;
  180.   
  181.   ptr = source->pub.buffer[0];
  182.   for (col = cinfo->image_width; col > 0; col--) {
  183.     (*source->read_pixel) (source); /* Load next pixel into tga_pixel */
  184.     *ptr++ = (JSAMPLE) UCH(source->tga_pixel[0]);
  185.   }
  186.   return 1;
  187. }
  188.  
  189. METHODDEF JDIMENSION
  190. get_8bit_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
  191. /* This version is for reading 8-bit colormap indexes */
  192. {
  193.   tga_source_ptr source = (tga_source_ptr) sinfo;
  194.   register int t;
  195.   register JSAMPROW ptr;
  196.   register JDIMENSION col;
  197.   register JSAMPARRAY colormap = source->colormap;
  198.  
  199.   ptr = source->pub.buffer[0];
  200.   for (col = cinfo->image_width; col > 0; col--) {
  201.     (*source->read_pixel) (source); /* Load next pixel into tga_pixel */
  202.     t = UCH(source->tga_pixel[0]);
  203.     *ptr++ = colormap[0][t];
  204.     *ptr++ = colormap[1][t];
  205.     *ptr++ = colormap[2][t];
  206.   }
  207.   return 1;
  208. }
  209.  
  210. METHODDEF JDIMENSION
  211. get_16bit_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
  212. /* This version is for reading 16-bit pixels */
  213. {
  214.   tga_source_ptr source = (tga_source_ptr) sinfo;
  215.   register int t;
  216.   register JSAMPROW ptr;
  217.   register JDIMENSION col;
  218.   
  219.   ptr = source->pub.buffer[0];
  220.   for (col = cinfo->image_width; col > 0; col--) {
  221.     (*source->read_pixel) (source); /* Load next pixel into tga_pixel */
  222.     t = UCH(source->tga_pixel[0]);
  223.     t += UCH(source->tga_pixel[1]) << 8;
  224.     /* We expand 5 bit data to 8 bit sample width.
  225.      * The format of the 16-bit (LSB first) input word is
  226.      *     xRRRRRGGGGGBBBBB
  227.      */
  228.     ptr[2] = (JSAMPLE) c5to8bits[t & 0x1F];
  229.     t >>= 5;
  230.     ptr[1] = (JSAMPLE) c5to8bits[t & 0x1F];
  231.     t >>= 5;
  232.     ptr[0] = (JSAMPLE) c5to8bits[t & 0x1F];
  233.     ptr += 3;
  234.   }
  235.   return 1;
  236. }
  237.  
  238. METHODDEF JDIMENSION
  239. get_24bit_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
  240. /* This version is for reading 24-bit pixels */
  241. {
  242.   tga_source_ptr source = (tga_source_ptr) sinfo;
  243.   register JSAMPROW ptr;
  244.   register JDIMENSION col;
  245.   
  246.   ptr = source->pub.buffer[0];
  247.   for (col = cinfo->image_width; col > 0; col--) {
  248.     (*source->read_pixel) (source); /* Load next pixel into tga_pixel */
  249.     *ptr++ = (JSAMPLE) UCH(source->tga_pixel[2]); /* change BGR to RGB order */
  250.     *ptr++ = (JSAMPLE) UCH(source->tga_pixel[1]);
  251.     *ptr++ = (JSAMPLE) UCH(source->tga_pixel[0]);
  252.   }
  253.   return 1;
  254. }
  255.  
  256. /*
  257.  * Targa also defines a 32-bit pixel format with order B,G,R,A.
  258.  * We presently ignore the attribute byte, so the code for reading
  259.  * these pixels is identical to the 24-bit routine above.
  260.  * This works because the actual pixel length is only known to read_pixel.
  261.  */
  262.  
  263. #define get_32bit_row  get_24bit_row
  264.  
  265.  
  266. /*
  267.  * This method is for re-reading the input data in standard top-down
  268.  * row order.  The entire image has already been read into whole_image
  269.  * with proper conversion of pixel format, but it's in a funny row order.
  270.  */
  271.  
  272. METHODDEF JDIMENSION
  273. get_memory_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
  274. {
  275.   tga_source_ptr source = (tga_source_ptr) sinfo;
  276.   JDIMENSION source_row;
  277.  
  278.   /* Compute row of source that maps to current_row of normal order */
  279.   /* For now, assume image is bottom-up and not interlaced. */
  280.   /* NEEDS WORK to support interlaced images! */
  281.   source_row = cinfo->image_height - source->current_row - 1;
  282.  
  283.   /* Fetch that row from virtual array */
  284.   source->pub.buffer = (*cinfo->mem->access_virt_sarray)
  285.     ((j_common_ptr) cinfo, source->whole_image, source_row, FALSE);
  286.  
  287.   source->current_row++;
  288.   return 1;
  289. }
  290.  
  291.  
  292. /*
  293.  * This method loads the image into whole_image during the first call on
  294.  * get_pixel_rows.  The get_pixel_rows pointer is then adjusted to call
  295.  * get_memory_row on subsequent calls.
  296.  */
  297.  
  298. METHODDEF JDIMENSION
  299. preload_image (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
  300. {
  301.   tga_source_ptr source = (tga_source_ptr) sinfo;
  302.   JDIMENSION row;
  303.   cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress;
  304.  
  305.   /* Read the data into a virtual array in input-file row order. */
  306.   for (row = 0; row < cinfo->image_height; row++) {
  307.     if (progress != NULL) {
  308.       progress->pub.pass_counter = (long) row;
  309.       progress->pub.pass_limit = (long) cinfo->image_height;
  310.       (*progress->pub.progress_monitor) ((j_common_ptr) cinfo);
  311.     }
  312.     source->pub.buffer = (*cinfo->mem->access_virt_sarray)
  313.       ((j_common_ptr) cinfo, source->whole_image, row, TRUE);
  314.     (*source->get_pixel_rows) (cinfo, sinfo);
  315.   }
  316.   if (progress != NULL)
  317.     progress->completed_extra_passes++;
  318.  
  319.   /* Set up to read from the virtual array in unscrambled order */
  320.   source->pub.get_pixel_rows = get_memory_row;
  321.   source->current_row = 0;
  322.   /* And read the first row */
  323.   return get_memory_row(cinfo, sinfo);
  324. }
  325.  
  326.  
  327. /*
  328.  * Read the file header; return image size and component count.
  329.  */
  330.  
  331. METHODDEF void
  332. start_input_tga (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
  333. {
  334.   tga_source_ptr source = (tga_source_ptr) sinfo;
  335.   U_CHAR targaheader[18];
  336.   int idlen, cmaptype, subtype, flags, interlace_type, components;
  337.   unsigned int width, height, maplen;
  338.   boolean is_bottom_up;
  339.  
  340. #define GET_2B(offset)    ((unsigned int) UCH(targaheader[offset]) + \
  341.              (((unsigned int) UCH(targaheader[offset+1])) << 8))
  342.  
  343.   if (! ReadOK(source->pub.input_file, targaheader, 18))
  344.     ERREXIT(cinfo, JERR_INPUT_EOF);
  345.  
  346.   /* Pretend "15-bit" pixels are 16-bit --- we ignore attribute bit anyway */
  347.   if (targaheader[16] == 15)
  348.     targaheader[16] = 16;
  349.  
  350.   idlen = UCH(targaheader[0]);
  351.   cmaptype = UCH(targaheader[1]);
  352.   subtype = UCH(targaheader[2]);
  353.   maplen = GET_2B(5);
  354.   width = GET_2B(12);
  355.   height = GET_2B(14);
  356.   source->pixel_size = UCH(targaheader[16]) >> 3;
  357.   flags = UCH(targaheader[17]);    /* Image Descriptor byte */
  358.  
  359.   is_bottom_up = ((flags & 0x20) == 0);    /* bit 5 set => top-down */
  360.   interlace_type = flags >> 6;    /* bits 6/7 are interlace code */
  361.  
  362.   if (cmaptype > 1 ||        /* cmaptype must be 0 or 1 */
  363.       source->pixel_size < 1 || source->pixel_size > 4 ||
  364.       (UCH(targaheader[16]) & 7) != 0 || /* bits/pixel must be multiple of 8 */
  365.       interlace_type != 0)    /* currently don't allow interlaced image */
  366.     ERREXIT(cinfo, JERR_TGA_BADPARMS);
  367.   
  368.   if (subtype > 8) {
  369.     /* It's an RLE-coded file */
  370.     source->read_pixel = read_rle_pixel;
  371.     source->block_count = source->dup_pixel_count = 0;
  372.     subtype -= 8;
  373.   } else {
  374.     /* Non-RLE file */
  375.     source->read_pixel = read_non_rle_pixel;
  376.   }
  377.  
  378.   /* Now should have subtype 1, 2, or 3 */
  379.   components = 3;        /* until proven different */
  380.   cinfo->in_color_space = JCS_RGB;
  381.  
  382.   switch (subtype) {
  383.   case 1:            /* Colormapped image */
  384.     if (source->pixel_size == 1 && cmaptype == 1)
  385.       source->get_pixel_rows = get_8bit_row;
  386.     else
  387.       ERREXIT(cinfo, JERR_TGA_BADPARMS);
  388.     TRACEMS2(cinfo, 1, JTRC_TGA_MAPPED, width, height);
  389.     break;
  390.   case 2:            /* RGB image */
  391.     switch (source->pixel_size) {
  392.     case 2:
  393.       source->get_pixel_rows = get_16bit_row;
  394.       break;
  395.     case 3:
  396.       source->get_pixel_rows = get_24bit_row;
  397.       break;
  398.     case 4:
  399.       source->get_pixel_rows = get_32bit_row;
  400.       break;
  401.     default:
  402.       ERREXIT(cinfo, JERR_TGA_BADPARMS);
  403.       break;
  404.     }
  405.     TRACEMS2(cinfo, 1, JTRC_TGA, width, height);
  406.     break;
  407.   case 3:            /* Grayscale image */
  408.     components = 1;
  409.     cinfo->in_color_space = JCS_GRAYSCALE;
  410.     if (source->pixel_size == 1)
  411.       source->get_pixel_rows = get_8bit_gray_row;
  412.     else
  413.       ERREXIT(cinfo, JERR_TGA_BADPARMS);
  414.     TRACEMS2(cinfo, 1, JTRC_TGA_GRAY, width, height);
  415.     break;
  416.   default:
  417.     ERREXIT(cinfo, JERR_TGA_BADPARMS);
  418.     break;
  419.   }
  420.  
  421.   if (is_bottom_up) {
  422.     /* Create a virtual array to buffer the upside-down image. */
  423.     source->whole_image = (*cinfo->mem->request_virt_sarray)
  424.       ((j_common_ptr) cinfo, JPOOL_IMAGE,
  425.        (JDIMENSION) width * components, (JDIMENSION) height, (JDIMENSION) 1);
  426.     if (cinfo->progress != NULL) {
  427.       cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress;
  428.       progress->total_extra_passes++; /* count file input as separate pass */
  429.     }
  430.     /* source->pub.buffer will point to the virtual array. */
  431.     source->pub.buffer_height = 1; /* in case anyone looks at it */
  432.     source->pub.get_pixel_rows = preload_image;
  433.   } else {
  434.     /* Don't need a virtual array, but do need a one-row input buffer. */
  435.     source->whole_image = NULL;
  436.     source->pub.buffer = (*cinfo->mem->alloc_sarray)
  437.       ((j_common_ptr) cinfo, JPOOL_IMAGE,
  438.        (JDIMENSION) width * components, (JDIMENSION) 1);
  439.     source->pub.buffer_height = 1;
  440.     source->pub.get_pixel_rows = source->get_pixel_rows;
  441.   }
  442.   
  443.   while (idlen--)        /* Throw away ID field */
  444.     (void) read_byte(source);
  445.  
  446.   if (maplen > 0) {
  447.     if (maplen > 256 || GET_2B(3) != 0)
  448.       ERREXIT(cinfo, JERR_TGA_BADCMAP);
  449.     /* Allocate space to store the colormap */
  450.     source->colormap = (*cinfo->mem->alloc_sarray)
  451.       ((j_common_ptr) cinfo, JPOOL_IMAGE, (JDIMENSION) maplen, (JDIMENSION) 3);
  452.     /* and read it from the file */
  453.     read_colormap(source, (int) maplen, UCH(targaheader[7]));
  454.   } else {
  455.     if (cmaptype)        /* but you promised a cmap! */
  456.       ERREXIT(cinfo, JERR_TGA_BADPARMS);
  457.     source->colormap = NULL;
  458.   }
  459.  
  460.   cinfo->input_components = components;
  461.   cinfo->data_precision = 8;
  462.   cinfo->image_width = width;
  463.   cinfo->image_height = height;
  464. }
  465.  
  466.  
  467. /*
  468.  * Finish up at the end of the file.
  469.  */
  470.  
  471. METHODDEF void
  472. finish_input_tga (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
  473. {
  474.   /* no work */
  475. }
  476.  
  477.  
  478. /*
  479.  * The module selection routine for Targa format input.
  480.  */
  481.  
  482. GLOBAL cjpeg_source_ptr
  483. jinit_read_targa (j_compress_ptr cinfo)
  484. {
  485.   tga_source_ptr source;
  486.  
  487.   /* Create module interface object */
  488.   source = (tga_source_ptr)
  489.       (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
  490.                   SIZEOF(tga_source_struct));
  491.   source->cinfo = cinfo;    /* make back link for subroutines */
  492.   /* Fill in method ptrs, except get_pixel_rows which start_input sets */
  493.   source->pub.start_input = start_input_tga;
  494.   source->pub.finish_input = finish_input_tga;
  495.  
  496.   return (cjpeg_source_ptr) source;
  497. }
  498.  
  499. #endif /* TARGA_SUPPORTED */
  500.