#define JPEG_INTERNALS#include "jpeglib.h"/* Pointer to routine to upsample a single component */typedef JMETHOD(void, upsample1_ptr,		(j_decompress_ptr cinfo, jpeg_component_info * compptr,		 JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr));/* Private subobject */typedef struct {  struct jpeg_upsampler pub;	/* public fields */  /* Color conversion buffer.  When using separate upsampling and color   * conversion steps, this buffer holds one upsampled row group until it   * has been color converted and output.   * Note: we do not allocate any storage for component(s) which are full-size,   * ie do not need rescaling.  The corresponding entry of color_buf[] is   * simply set to point to the input data array, thereby avoiding copying.   */  JSAMPARRAY color_buf[MAX_COMPONENTS];  /* Per-component upsampling method pointers */  upsample1_ptr methods[MAX_COMPONENTS];  int next_row_out;		/* counts rows emitted from color_buf */  JDIMENSION rows_to_go;	/* counts rows remaining in image */  /* Height of an input row group for each component. */  int rowgroup_height[MAX_COMPONENTS];  /* These arrays save pixel expansion factors so that int_expand need not   * recompute them each time.  They are unused for other upsampling methods.   */  UINT8 h_expand[MAX_COMPONENTS];  UINT8 v_expand[MAX_COMPONENTS];} my_upsampler;typedef my_upsampler * my_upsample_ptr;/* * Initialize for an upsampling pass. */METHODDEF(void)start_pass_upsample (j_decompress_ptr cinfo){  my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;  /* Mark the conversion buffer empty */  upsample->next_row_out = cinfo->max_v_samp_factor;  /* Initialize total-height counter for detecting bottom of image */  upsample->rows_to_go = cinfo->output_height;}/* * Control routine to do upsampling (and color conversion). * * In this version we upsample each component independently. * We upsample one row group into the conversion buffer, then apply * color conversion a row at a time. */METHODDEF(void)sep_upsample (j_decompress_ptr cinfo,	      JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,	      JDIMENSION in_row_groups_avail,	      JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,	      JDIMENSION out_rows_avail){  my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;  int ci;  jpeg_component_info * compptr;  JDIMENSION num_rows;  /* Fill the conversion buffer, if it's empty */  if (upsample->next_row_out >= cinfo->max_v_samp_factor) {    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;	 ci++, compptr++) {      /* Invoke per-component upsample method.  Notice we pass a POINTER       * to color_buf[ci], so that fullsize_upsample can change it.       */      (*upsample->methods[ci]) (cinfo, compptr,	input_buf[ci] + (*in_row_group_ctr * upsample->rowgroup_height[ci]),	upsample->color_buf + ci);    }    upsample->next_row_out = 0;  }  /* Color-convert and emit rows */  /* How many we have in the buffer: */  num_rows = (JDIMENSION) (cinfo->max_v_samp_factor - upsample->next_row_out);  /* Not more than the distance to the end of the image.  Need this test   * in case the image height is not a multiple of max_v_samp_factor:   */  if (num_rows > upsample->rows_to_go)     num_rows = upsample->rows_to_go;  /* And not more than what the client can accept: */  out_rows_avail -= *out_row_ctr;  if (num_rows > out_rows_avail)    num_rows = out_rows_avail;  (*cinfo->cconvert->color_convert) (cinfo, upsample->color_buf,				     (JDIMENSION) upsample->next_row_out,				     output_buf + *out_row_ctr,				     (int) num_rows);  /* Adjust counts */  *out_row_ctr += num_rows;  upsample->rows_to_go -= num_rows;  upsample->next_row_out += num_rows;  /* When the buffer is emptied, declare this input row group consumed */  if (upsample->next_row_out >= cinfo->max_v_samp_factor)    (*in_row_group_ctr)++;}/* * These are the routines invoked by sep_upsample to upsample pixel values * of a single component.  One row group is processed per call. *//* * For full-size components, we just make color_buf[ci] point at the * input buffer, and thus avoid copying any data.  Note that this is * safe only because sep_upsample doesn't declare the input row group * "consumed" until we are done color converting and emitting it. */METHODDEF(void)fullsize_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,		   JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr){  *output_data_ptr = input_data;}/* * This is a no-op version used for "uninteresting" components. * These components will not be referenced by color conversion. */METHODDEF(void)noop_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,	       JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr){  *output_data_ptr = NULL;	/* safety check */}/* * This version handles any integral sampling ratios. * This is not used for typical JPEG files, so it need not be fast. * Nor, for that matter, is it particularly accurate: the algorithm is * simple replication of the input pixel onto the corresponding output * pixels.  The hi-falutin sampling literature refers to this as a * "box filter".  A box filter tends to introduce visible artifacts, * so if you are actually going to use 3:1 or 4:1 sampling ratios * you would be well advised to improve this code. */METHODDEF(void)int_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,	      JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr){  my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;  JSAMPARRAY output_data = *output_data_ptr;  register JSAMPROW inptr, outptr;  register JSAMPLE invalue;  register int h;  JSAMPROW outend;  int h_expand, v_expand;  int inrow, outrow;  h_expand = upsample->h_expand[compptr->component_index];  v_expand = upsample->v_expand[compptr->component_index];  inrow = outrow = 0;  while (outrow < cinfo->max_v_samp_factor) {    /* Generate one output row with proper horizontal expansion */    inptr = input_data[inrow];    outptr = output_data[outrow];    outend = outptr + cinfo->output_width;    while (outptr < outend) {      invalue = *inptr++;	/* don't need GETJSAMPLE() here */      for (h = h_expand; h > 0; h--) {	*outptr++ = invalue;      }    }    /* Generate any additional output rows by duplicating the first one */    if (v_expand > 1) {      jcopy_sample_rows(output_data, outrow, output_data, outrow+1,			v_expand-1, cinfo->output_width);    }    inrow++;    outrow += v_expand;  }}/* * Fast processing for the common case of 2:1 horizontal and 1:1 vertical. * It's still a box filter. */METHODDEF(void)h2v1_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,	       JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr){  JSAMPARRAY output_data = *output_data_ptr;  register JSAMPROW inptr, outptr;  register JSAMPLE invalue;  JSAMPROW outend;  int inrow;  for (inrow = 0; inrow < cinfo->max_v_samp_factor; inrow++) {    inptr = input_data[inrow];    outptr = output_data[inrow];    outend = outptr + cinfo->output_width;    while (outptr < outend) {      invalue = *inptr++;	/* don't need GETJSAMPLE() here */      *outptr++ = invalue;      *outptr++ = invalue;    }