jcpipe.c

EVM板JPEG实现,Texas Instruments TMS320C54x EVM JPEG

/*
 * jcpipe.c
 *
 * Copyright (C) 1991, 1992, 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 compression pipeline controllers.
 * These routines are invoked via the c_pipeline_controller method.
 *
 * There are four basic pipeline controllers, one for each combination of:
 *      single-scan JPEG file (single component or fully interleaved)
 *  vs. multiple-scan JPEG file (noninterleaved or partially interleaved).
 *
 *      optimization of entropy encoding parameters
 *  vs. usage of default encoding parameters.
 *
 * Note that these conditions determine the needs for "big" arrays:
 * multiple scans imply a big array for splitting the color components;
 * entropy encoding optimization needs a big array for the MCU data.
 *
 * All but the simplest controller (single-scan, no optimization) can be
 * compiled out through configuration options, if you need to make a minimal
 * implementation.
 */

/* This file was changed to eliminate any error messages.  Many functions
   were deleted from here.  I left only the controller that was needed
   for a single scan, no optimization controller.  If you wish to use
   somthing else, please refer to the host version. Christopher Chang,
   Summer 1993
*/

#include "jinclude.h"


/*
 * About the data structures:
 *
 * The processing chunk size for downsampling is referred to in this file as
 * a "row group": a row group is defined as Vk (v_samp_factor) sample rows of
 * any component after downsampling, or Vmax (max_v_samp_factor) unsubsampled
 * rows.  In an interleaved scan each MCU row contains exactly DCTSIZE row
 * groups of each component in the scan.  In a noninterleaved scan an MCU row
 * is one row of blocks, which might not be an integral number of row groups;
 * for convenience we use a buffer of the same size as in interleaved scans,
 * and process Vk MCU rows in each burst of downsampling.
 * To provide context for the downsampling step, we have to retain the last
 * two row groups of the previous MCU row while reading in the next MCU row
 * (or set of Vk MCU rows).  To do this without copying data about, we create
 * a rather strange data structure.  Exactly DCTSIZE+2 row groups of samples
 * are allocated, but we create two different sets of pointers to this array.
 * The second set swaps the last two pairs of row groups.  By working
 * alternately with the two sets of pointers, we can access the data in the
 * desired order.
 */



/*
 * Utility routines: common code for pipeline controllers
 */

LOCAL void
interleaved_scan_setup (compress_info_ptr cinfo)
/* Compute all derived info for an interleaved (multi-component) scan */
/* On entry, cinfo->comps_in_scan and cinfo->cur_comp_info[] are set up */
{
  short ci, mcublks;
  jpeg_component_info *compptr;

/**************************DID NOT SUPPORT THIS ERROR**********************
if (cinfo->comps_in_scan > MAX_COMPS_IN_SCAN)
	ERREXIT(cinfo->emethods, "Too many components for interleaved scan");
***************************************************************************/

  cinfo->MCUs_per_row = (cinfo->image_width
			 + cinfo->max_h_samp_factor*DCTSIZE - 1)
			/ (cinfo->max_h_samp_factor*DCTSIZE);

  cinfo->MCU_rows_in_scan = (cinfo->image_height
				 + cinfo->max_v_samp_factor*DCTSIZE - 1)
				/ (cinfo->max_v_samp_factor*DCTSIZE);
  
  cinfo->blocks_in_MCU = 0;

  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
	compptr = cinfo->cur_comp_info[ci];
	/* for interleaved scan, sampling factors give # of blocks per component */
	compptr->MCU_width = compptr->h_samp_factor;
	compptr->MCU_height = compptr->v_samp_factor;
	compptr->MCU_blocks = compptr->MCU_width * compptr->MCU_height;
	/* compute physical dimensions of component */
	compptr->downsampled_width = jround_up(compptr->true_comp_width,
					   (long) (compptr->MCU_width*DCTSIZE));
	compptr->downsampled_height = jround_up(compptr->true_comp_height,
						(long) (compptr->MCU_height*DCTSIZE));
	/* Sanity check */

/*****************************DID NOT SUPPORT THIS ERROR*********************  
if (compptr->downsampled_width !=
	(cinfo->MCUs_per_row * (compptr->MCU_width*DCTSIZE)))
	  ERREXIT(cinfo->emethods, "I'm confused about the image width");
****************************************************************************/

	/* Prepare array describing MCU composition */
	mcublks = compptr->MCU_blocks;

/*****************************DID NOT SUPPORT THIS ERROR*********************  
if (cinfo->blocks_in_MCU + mcublks > MAX_BLOCKS_IN_MCU)
	  ERREXIT(cinfo->emethods, "Sampling factors too large for interleaved scan");
***************************************************************************/

	while (mcublks-- > 0) {
	  cinfo->MCU_membership[cinfo->blocks_in_MCU++] = ci;
	}
  }

  /* Convert restart specified in rows to actual MCU count. */
  /* Note that count must fit in 16 bits, so we provide limiting. */
  if (cinfo->restart_in_rows > 0) {
	long nominal = cinfo->restart_in_rows * cinfo->MCUs_per_row;
	cinfo->restart_interval = (UINT16) MIN(nominal, 65535L);
  }

  (*cinfo->methods->c_per_scan_method_selection) (cinfo);
}

LOCAL void
alloc_sampling_buffer (compress_info_ptr cinfo, JSAMPIMAGE fullsize_data[2],
			   long fullsize_width)
/* Create a pre-downsampling data buffer having the desired structure */
/* (see comments at head of file) */
{
  short ci, vs, i;

  vs = cinfo->max_v_samp_factor; /* row group height */

  /* Get top-level space for array pointers */
  fullsize_data[0] = (JSAMPIMAGE) (*cinfo->emethods->alloc_small)
				(cinfo->num_components * SIZEOF(JSAMPARRAY));
  fullsize_data[1] = (JSAMPIMAGE) (*cinfo->emethods->alloc_small)
				(cinfo->num_components * SIZEOF(JSAMPARRAY));

  for (ci = 0; ci < cinfo->num_components; ci++) {
	/* Allocate the real storage */
	fullsize_data[0][ci] = (*cinfo->emethods->alloc_small_sarray)
				(fullsize_width,
				(long) (vs * (DCTSIZE+2)));
	/* Create space for the scrambled-order pointers */
	fullsize_data[1][ci] = (JSAMPARRAY) (*cinfo->emethods->alloc_small)
				(vs * (DCTSIZE+2) * SIZEOF(JSAMPROW));
	/* Duplicate the first DCTSIZE-2 row groups */
	for (i = 0; i < vs * (DCTSIZE-2); i++) {
	  fullsize_data[1][ci][i] = fullsize_data[0][ci][i];
	}
	/* Copy the last four row groups in swapped order */
	for (i = 0; i < vs * 2; i++) {
	  fullsize_data[1][ci][vs*DCTSIZE + i] = fullsize_data[0][ci][vs*(DCTSIZE-2) + i];
	  fullsize_data[1][ci][vs*(DCTSIZE-2) + i] = fullsize_data[0][ci][vs*DCTSIZE + i];
	}
  }
}

LOCAL void
downsample (compress_info_ptr cinfo,
		JSAMPIMAGE fullsize_data, JSAMPIMAGE sampled_data,
		long fullsize_width,
		short above, short current, short below, short out)
/* Do downsampling of a single row group (of each component). */
/* above, current, below are indexes of row groups in fullsize_data;      */
/* out is the index of the target row group in sampled_data.              */
/* Special case: above, below can be -1 to indicate top, bottom of image. */
{
  jpeg_component_info *compptr;
  JSAMPARRAY above_ptr, below_ptr;
  JSAMPROW dummy[MAX_SAMP_FACTOR]; /* for downsample expansion at top/bottom */
  short ci, vs, i;

  vs = cinfo->max_v_samp_factor; /* row group height */

  for (ci = 0; ci < cinfo->num_components; ci++) {
	compptr = & cinfo->comp_info[ci];

	if (above >= 0)
	  above_ptr = fullsize_data[ci] + above * vs;
	else {
	  /* Top of image: make a dummy above-context with copies of 1st row */
	  /* We assume current=0 in this case */
	  for (i = 0; i < vs; i++)
	dummy[i] = fullsize_data[ci][0];
	  above_ptr = (JSAMPARRAY) dummy; /* possible near->far pointer conv */
	}

	if (below >= 0)
	  below_ptr = fullsize_data[ci] + below * vs;
	else {
	  /* Bot of image: make a dummy below-context with copies of last row */
	  for (i = 0; i < vs; i++)
	dummy[i] = fullsize_data[ci][(current+1)*vs-1];
	  below_ptr = (JSAMPARRAY) dummy; /* possible near->far pointer conv */
	}

	(*cinfo->methods->downsample[ci])
		(cinfo, (int) ci,
		 fullsize_width, (int) vs,
		 compptr->downsampled_width, (int) compptr->v_samp_factor,
		 above_ptr,
		 fullsize_data[ci] + current * vs,
		 below_ptr,
		 sampled_data[ci] + out * compptr->v_samp_factor);
  }
}


/* These variables are initialized by the pipeline controller for use by
 * MCU_output_catcher.
 * To avoid a lot of row-pointer overhead, we cram as many MCUs into each
 * row of whole_scan_MCUs as we can get without exceeding 32Kbytes per row.
 * NOTE: the "arbitrary" constant here must not exceed MAX_ALLOC_CHUNK
 * defined in jmemsys.h, which is 64K-epsilon in most DOS implementations.
 */

#define MAX_WHOLE_ROW_BLOCKS    ((int) (32768L / SIZEOF(JBLOCK))) /* max blocks/row */

static big_barray_ptr whole_scan_MCUs; /* Big array for saving the MCUs */
static int MCUs_in_big_row;     /* # of MCUs in each row of whole_scan_MCUs */
static long next_whole_row;     /* next row to access in whole_scan_MCUs */
static int next_MCU_index;      /* next MCU in current row */


METHODDEF void
MCU_output_catcher (compress_info_ptr cinfo, JBLOCK *MCU_data)
/* Output method for siphoning off extract_MCUs output into a big array */
{