/* 
 * rdrle.c 
 * 
 * Copyright (C) 1991-1996, Thomas G. Lane. 
 * This file is part of the Independent JPEG Group's software. 
 * For conditions of distribution and use, see the accompanying README file. 
 * 
 * This file contains routines to read input images in Utah RLE format. 
 * The Utah Raster Toolkit library is required (version 3.1 or later). 
 * 
 * These routines may need modification for non-Unix environments or 
 * specialized applications.  As they stand, they assume input from 
 * an ordinary stdio stream.  They further assume that reading begins 
 * at the start of the file; start_input may need work if the 
 * user interface has already read some data (e.g., to determine that 
 * the file is indeed RLE format). 
 * 
 * Based on code contributed by Mike Lijewski, 
 * with updates from Robert Hutchinson. 
 */ 
 
#include "cdjpeg.h"		/* Common decls for cjpeg/djpeg applications */ 
 
#ifdef RLE_SUPPORTED 
 
/* rle.h is provided by the Utah Raster Toolkit. */ 
 
#include <rle.h> 
 
/* 
 * We assume that JSAMPLE has the same representation as rle_pixel, 
 * to wit, "unsigned char".  Hence we can't cope with 12- or 16-bit samples. 
 */ 
 
#if BITS_IN_JSAMPLE != 8 
  Sorry, this code only copes with 8-bit JSAMPLEs. /* deliberate syntax err */ 
#endif 
 
/* 
 * We support the following types of RLE files: 
 *    
 *   GRAYSCALE   - 8 bits, no colormap 
 *   MAPPEDGRAY  - 8 bits, 1 channel colomap 
 *   PSEUDOCOLOR - 8 bits, 3 channel colormap 
 *   TRUECOLOR   - 24 bits, 3 channel colormap 
 *   DIRECTCOLOR - 24 bits, no colormap 
 * 
 * For now, we ignore any alpha channel in the image. 
 */ 
 
typedef enum 
  { GRAYSCALE, MAPPEDGRAY, PSEUDOCOLOR, TRUECOLOR, DIRECTCOLOR } rle_kind; 
 
 
/* 
 * Since RLE stores scanlines bottom-to-top, we have to invert the image 
 * to conform to JPEG's top-to-bottom order.  To do this, we read the 
 * incoming image into a virtual array on the first get_pixel_rows call, 
 * then fetch the required row from the virtual array on subsequent calls. 
 */ 
 
typedef struct _rle_source_struct * rle_source_ptr; 
 
typedef struct _rle_source_struct { 
  struct cjpeg_source_struct pub; /* public fields */ 
 
  rle_kind visual;              /* actual type of input file */ 
  jvirt_sarray_ptr image;       /* virtual array to hold the image */ 
  JDIMENSION row;		/* current row # in the virtual array */ 
  rle_hdr header;               /* Input file information */ 
  rle_pixel** rle_row;          /* holds a row returned by rle_getrow() */ 
 
} rle_source_struct; 
 
 
/* 
 * Read the file header; return image size and component count. 
 */ 
 
METHODDEF(void) 
start_input_rle (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) 
{ 
  rle_source_ptr source = (rle_source_ptr) sinfo; 
  JDIMENSION width, height; 
#ifdef PROGRESS_REPORT 
  cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress; 
#endif 
 
  /* Use RLE library routine to get the header info */ 
  source->header = *rle_hdr_init(NULL); 
  source->header.rle_file = source->pub.input_file; 
  switch (rle_get_setup(&(source->header))) { 
  case RLE_SUCCESS: 
    /* A-OK */ 
    break; 
  case RLE_NOT_RLE: 
    ERREXIT(cinfo, JERR_RLE_NOT); 
    break; 
  case RLE_NO_SPACE: 
    ERREXIT(cinfo, JERR_RLE_MEM); 
    break; 
  case RLE_EMPTY: 
    ERREXIT(cinfo, JERR_RLE_EMPTY); 
    break; 
  case RLE_EOF: 
    ERREXIT(cinfo, JERR_RLE_EOF); 
    break; 
  default: 
    ERREXIT(cinfo, JERR_RLE_BADERROR); 
    break; 
  } 
 
  /* Figure out what we have, set private vars and return values accordingly */ 
   
  width  = source->header.xmax - source->header.xmin + 1; 
  height = source->header.ymax - source->header.ymin + 1; 
  source->header.xmin = 0;		/* realign horizontally */ 
  source->header.xmax = width-1; 
 
  cinfo->image_width      = width; 
  cinfo->image_height     = height; 
  cinfo->data_precision   = 8;  /* we can only handle 8 bit data */ 
 
  if (source->header.ncolors == 1 && source->header.ncmap == 0) { 
    source->visual     = GRAYSCALE; 
    TRACEMS2(cinfo, 1, JTRC_RLE_GRAY, width, height); 
  } else if (source->header.ncolors == 1 && source->header.ncmap == 1) { 
    source->visual     = MAPPEDGRAY; 
    TRACEMS3(cinfo, 1, JTRC_RLE_MAPGRAY, width, height, 
             1 << source->header.cmaplen); 
  } else if (source->header.ncolors == 1 && source->header.ncmap == 3) { 
    source->visual     = PSEUDOCOLOR; 
    TRACEMS3(cinfo, 1, JTRC_RLE_MAPPED, width, height, 
	     1 << source->header.cmaplen); 
  } else if (source->header.ncolors == 3 && source->header.ncmap == 3) { 
    source->visual     = TRUECOLOR; 
    TRACEMS3(cinfo, 1, JTRC_RLE_FULLMAP, width, height, 
	     1 << source->header.cmaplen); 
  } else if (source->header.ncolors == 3 && source->header.ncmap == 0) { 
    source->visual     = DIRECTCOLOR; 
    TRACEMS2(cinfo, 1, JTRC_RLE, width, height); 
  } else 
    ERREXIT(cinfo, JERR_RLE_UNSUPPORTED); 
   
  if (source->visual == GRAYSCALE || source->visual == MAPPEDGRAY) { 
    cinfo->in_color_space   = JCS_GRAYSCALE; 
    cinfo->input_components = 1; 
  } else { 
    cinfo->in_color_space   = JCS_RGB; 
    cinfo->input_components = 3; 
  } 
 
  /* 
   * A place to hold each scanline while it's converted. 
   * (GRAYSCALE scanlines don't need converting) 
   */ 
  if (source->visual != GRAYSCALE) { 
    source->rle_row = (rle_pixel**) (*cinfo->mem->alloc_sarray) 
      ((j_common_ptr) cinfo, JPOOL_IMAGE, 
       (JDIMENSION) width, (JDIMENSION) cinfo->input_components); 
  } 
 
  /* request a virtual array to hold the image */ 
  source->image = (*cinfo->mem->request_virt_sarray) 
    ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE, 
     (JDIMENSION) (width * source->header.ncolors), 
     (JDIMENSION) height, (JDIMENSION) 1); 
 
#ifdef PROGRESS_REPORT 
  if (progress != NULL) { 
    /* count file input as separate pass */ 
    progress->total_extra_passes++; 
  } 
#endif 
 
  source->pub.buffer_height = 1; 
} 
 
 
/* 
 * Read one row of pixels. 
 * Called only after load_image has read the image into the virtual array. 
 * Used for GRAYSCALE, MAPPEDGRAY, TRUECOLOR, and DIRECTCOLOR images. 
 */ 
 
METHODDEF(JDIMENSION) 
get_rle_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) 
{ 
  rle_source_ptr source = (rle_source_ptr) sinfo; 
 
  source->row--; 
  source->pub.buffer = (*cinfo->mem->access_virt_sarray) 
    ((j_common_ptr) cinfo, source->image, source->row, (JDIMENSION) 1, FALSE); 
 
  return 1; 
} 
 
/* 
 * Read one row of pixels. 
 * Called only after load_image has read the image into the virtual array. 
 * Used for PSEUDOCOLOR images. 
 */ 
 
METHODDEF(JDIMENSION) 
get_pseudocolor_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) 
{ 
  rle_source_ptr source = (rle_source_ptr) sinfo; 
  JSAMPROW src_row, dest_row; 
  JDIMENSION col; 
  rle_map *colormap; 
  int val; 
 
  colormap = source->header.cmap; 
  dest_row = source->pub.buffer[0]; 
  source->row--; 
  src_row = * (*cinfo->mem->access_virt_sarray) 
    ((j_common_ptr) cinfo, source->image, source->row, (JDIMENSION) 1, FALSE); 
 
  for (col = cinfo->image_width; col > 0; col--) { 
    val = GETJSAMPLE(*src_row++); 
    *dest_row++ = (JSAMPLE) (colormap[val      ] >> 8); 
    *dest_row++ = (JSAMPLE) (colormap[val + 256] >> 8); 
    *dest_row++ = (JSAMPLE) (colormap[val + 512] >> 8); 
  } 
 
  return 1; 
} 
 
 
/* 
 * Load the image into a virtual array.  We have to do this because RLE 
 * files start at the lower left while the JPEG standard has them starting 
 * in the upper left.  This is called the first time we want to get a row 
 * of input.  What we do is load the RLE data into the array and then call 
 * the appropriate routine to read one row from the array.  Before returning, 
 * we set source->pub.get_pixel_rows so that subsequent calls go straight to 
 * the appropriate row-reading routine. 
 */ 
 
METHODDEF(JDIMENSION) 
load_image (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) 
{ 
  rle_source_ptr source = (rle_source_ptr) sinfo; 
  JDIMENSION row, col; 
  JSAMPROW  scanline, red_ptr, green_ptr, blue_ptr; 
  rle_pixel **rle_row; 
  rle_map *colormap; 
  char channel; 
#ifdef PROGRESS_REPORT 
  cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress; 
#endif 
 
  colormap = source->header.cmap; 
  rle_row = source->rle_row; 
 
  /* Read the RLE data into our virtual array. 
   * We assume here that (a) rle_pixel is represented the same as JSAMPLE, 
   * and (b) we are not on a machine where FAR pointers differ from regular. 
   */ 
  RLE_CLR_BIT(source->header, RLE_ALPHA); /* don't read the alpha channel */ 
 
#ifdef PROGRESS_REPORT 
  if (progress != NULL) { 
    progress->pub.pass_limit = cinfo->image_height; 
    progress->pub.pass_counter = 0; 
    (*progress->pub.progress_monitor) ((j_common_ptr) cinfo); 
  } 
#endif 
 
  switch (source->visual) { 
 
  case GRAYSCALE: 
  case PSEUDOCOLOR: 
    for (row = 0; row < cinfo->image_height; row++) { 
      rle_row = (rle_pixel **) (*cinfo->mem->access_virt_sarray) 
         ((j_common_ptr) cinfo, source->image, row, (JDIMENSION) 1, TRUE); 
      rle_getrow(&source->header, rle_row); 
#ifdef PROGRESS_REPORT 
      if (progress != NULL) { 
        progress->pub.pass_counter++; 
        (*progress->pub.progress_monitor) ((j_common_ptr) cinfo); 
      } 
#endif 
    } 
    break; 
 
  case MAPPEDGRAY: 
  case TRUECOLOR: 
    for (row = 0; row < cinfo->image_height; row++) { 
      scanline = * (*cinfo->mem->access_virt_sarray) 
        ((j_common_ptr) cinfo, source->image, row, (JDIMENSION) 1, TRUE); 
      rle_row = source->rle_row; 
      rle_getrow(&source->header, rle_row); 
 
      for (col = 0; col < cinfo->image_width; col++) { 
        for (channel = 0; channel < source->header.ncolors; channel++) { 
          *scanline++ = (JSAMPLE) 
            (colormap[GETJSAMPLE(rle_row[channel][col]) + 256 * channel] >> 8); 
        } 
      } 
 
#ifdef PROGRESS_REPORT 
      if (progress != NULL) { 
        progress->pub.pass_counter++; 
        (*progress->pub.progress_monitor) ((j_common_ptr) cinfo); 
      } 
#endif 
    } 
    break; 
 
  case DIRECTCOLOR: 
    for (row = 0; row < cinfo->image_height; row++) { 
      scanline = * (*cinfo->mem->access_virt_sarray) 
        ((j_common_ptr) cinfo, source->image, row, (JDIMENSION) 1, TRUE); 
      rle_getrow(&source->header, rle_row); 
 
      red_ptr   = rle_row[0]; 
      green_ptr = rle_row[1]; 
      blue_ptr  = rle_row[2]; 
 
      for (col = cinfo->image_width; col > 0; col--) { 
        *scanline++ = *red_ptr++; 
        *scanline++ = *green_ptr++; 
        *scanline++ = *blue_ptr++; 
      } 
 
#ifdef PROGRESS_REPORT 
      if (progress != NULL) { 
        progress->pub.pass_counter++; 
        (*progress->pub.progress_monitor) ((j_common_ptr) cinfo); 
      } 
#endif 
    } 
  } 
 
#ifdef PROGRESS_REPORT 
  if (progress != NULL) 
    progress->completed_extra_passes++; 
#endif 
 
  /* Set up to call proper row-extraction routine in future */ 
  if (source->visual == PSEUDOCOLOR) { 
    source->pub.buffer = source->rle_row; 
    source->pub.get_pixel_rows = get_pseudocolor_row; 
  } else { 
    source->pub.get_pixel_rows = get_rle_row; 
  } 
  source->row = cinfo->image_height; 
 
  /* And fetch the topmost (bottommost) row */ 
  return (*source->pub.get_pixel_rows) (cinfo, sinfo);    
} 
 
 
/* 
 * Finish up at the end of the file. 
 */ 
 
METHODDEF(void) 
finish_input_rle (j_compress_ptr cinfo, cjpeg_source_ptr sinfo) 
{ 
  /* no work */ 
} 
 
 
/* 
 * The module selection routine for RLE format input. 
 */ 
 
GLOBAL(cjpeg_source_ptr) 
jinit_read_rle (j_compress_ptr cinfo) 
{ 
  rle_source_ptr source; 
 
  /* Create module interface object */ 
  source = (rle_source_ptr) 
      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, 
                                  SIZEOF(rle_source_struct)); 
  /* Fill in method ptrs */ 
  source->pub.start_input = start_input_rle; 
  source->pub.finish_input = finish_input_rle; 
  source->pub.get_pixel_rows = load_image; 
 
  return (cjpeg_source_ptr) source; 
} 
 
#endif /* RLE_SUPPORTED */ 
