3rdparty/libjpeg/jcsample.c

/*
 * jcsample.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 downsampling routines.
 *
 * Downsampling input data is counted in "row groups".  A row group
 * is defined to be max_v_samp_factor pixel rows of each component,
 * from which the downsampler produces v_samp_factor sample rows.
 * A single row group is processed in each call to the downsampler module.
 *
 * The downsampler is responsible for edge-expansion of its output data
 * to fill an integral number of DCT blocks horizontally.  The source buffer
 * may be modified if it is helpful for this purpose (the source buffer is
 * allocated wide enough to correspond to the desired output width).
 * The caller (the prep controller) is responsible for vertical padding.
 *
 * The downsampler may request "context rows" by setting need_context_rows
 * during startup.  In this case, the input arrays will contain at least
 * one row group's worth of pixels above and below the passed-in data;
 * the caller will create dummy rows at image top and bottom by replicating
 * the first or last real pixel row.
 *
 * An excellent reference for image resampling is
 *   Digital Image Warping, George Wolberg, 1990.
 *   Pub. by IEEE Computer Society Press, Los Alamitos, CA. ISBN 0-8186-8944-7.
 *
 * The downsampling algorithm used here is a simple average of the source
 * pixels covered by the output pixel.  The hi-falutin sampling literature
 * refers to this as a "box filter".  In general the characteristics of a box
 * filter are not very good, but for the specific cases we normally use (1:1
 * and 2:1 ratios) the box is equivalent to a "triangle filter" which is not
 * nearly so bad.  If you intend to use other sampling ratios, you'd be well
 * advised to improve this code.
 *
 * A simple input-smoothing capability is provided.  This is mainly intended
 * for cleaning up color-dithered GIF input files (if you find it inadequate,
 * we suggest using an external filtering program such as pnmconvol).  When
 * enabled, each input pixel P is replaced by a weighted sum of itself and its
 * eight neighbors.  P's weight is 1-8*SF and each neighbor's weight is SF,
 * where SF = (smoothing_factor / 1024).
 * Currently, smoothing is only supported for 2h2v sampling factors.
 */

#define JPEG_INTERNALS
#include "jinclude.h"
#include "jpeglib.h"


/* Pointer to routine to downsample a single component */
typedef JMETHOD(void, downsample1_ptr,
                (j_compress_ptr cinfo, jpeg_component_info * compptr,
                 JSAMPARRAY input_data, JSAMPARRAY output_data));

/* Private subobject */

typedef struct {
  struct jpeg_downsampler pub;  /* public fields */

  /* Downsampling method pointers, one per component */
  downsample1_ptr methods[MAX_COMPONENTS];

  /* Height of an output row group for each component. */
  int rowgroup_height[MAX_COMPONENTS];

  /* These arrays save pixel expansion factors so that int_downsample need not
   * recompute them each time.  They are unused for other downsampling methods.
   */
  UINT8 h_expand[MAX_COMPONENTS];
  UINT8 v_expand[MAX_COMPONENTS];
} my_downsampler;

typedef my_downsampler * my_downsample_ptr;


/*
 * Initialize for a downsampling pass.
 */

METHODDEF(void)
start_pass_downsample (j_compress_ptr cinfo)
{
  /* no work for now */
}


/*
 * Expand a component horizontally from width input_cols to width output_cols,
 * by duplicating the rightmost samples.
 */

LOCAL(void)
expand_right_edge (JSAMPARRAY image_data, int num_rows,
                   JDIMENSION input_cols, JDIMENSION output_cols)
{
  register JSAMPROW ptr;
  register JSAMPLE pixval;
  register int count;
  int row;
  int numcols = (int) (output_cols - input_cols);

  if (numcols > 0) {
    for (row = 0; row < num_rows; row++) {
      ptr = image_data[row] + input_cols;
      pixval = ptr[-1];         /* don't need GETJSAMPLE() here */
      for (count = numcols; count > 0; count--)
        *ptr++ = pixval;
    }
  }
}


/*
 * Do downsampling for a whole row group (all components).
 *
 * In this version we simply downsample each component independently.
 */

METHODDEF(void)
sep_downsample (j_compress_ptr cinfo,
                JSAMPIMAGE input_buf, JDIMENSION in_row_index,
                JSAMPIMAGE output_buf, JDIMENSION out_row_group_index)
{
  my_downsample_ptr downsample = (my_downsample_ptr) cinfo->downsample;
  int ci;
  jpeg_component_info * compptr;
  JSAMPARRAY in_ptr, out_ptr;

  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
       ci++, compptr++) {
    in_ptr = input_buf[ci] + in_row_index;
    out_ptr = output_buf[ci] +
              (out_row_group_index * downsample->rowgroup_height[ci]);
    (*downsample->methods[ci]) (cinfo, compptr, in_ptr, out_ptr);
  }
}


/*
 * Downsample pixel values of a single component.
 * One row group is processed per call.
 * This version handles arbitrary integral sampling ratios, without smoothing.
 * Note that this version is not actually used for customary sampling ratios.
 */

METHODDEF(void)
int_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
                JSAMPARRAY input_data, JSAMPARRAY output_data)
{
  my_downsample_ptr downsample = (my_downsample_ptr) cinfo->downsample;
  int inrow, outrow, h_expand, v_expand, numpix, numpix2, h, v;
  JDIMENSION outcol, outcol_h;  /* outcol_h == outcol*h_expand */
  JDIMENSION output_cols = compptr->width_in_blocks * compptr->DCT_h_scaled_size;
  JSAMPROW inptr, outptr;
  INT32 outvalue;

  h_expand = downsample->h_expand[compptr->component_index];
  v_expand = downsample->v_expand[compptr->component_index];
  numpix = h_expand * v_expand;
  numpix2 = numpix/2;

  /* Expand input data enough to let all the output samples be generated
   * by the standard loop.  Special-casing padded output would be more
   * efficient.
   */
  expand_right_edge(input_data, cinfo->max_v_samp_factor,
                    cinfo->image_width, output_cols * h_expand);

  inrow = outrow = 0;
  while (inrow < cinfo->max_v_samp_factor) {
    outptr = output_data[outrow];
    for (outcol = 0, outcol_h = 0; outcol < output_cols;
         outcol++, outcol_h += h_expand) {
      outvalue = 0;
      for (v = 0; v < v_expand; v++) {
        inptr = input_data[inrow+v] + outcol_h;
        for (h = 0; h < h_expand; h++) {
          outvalue += (INT32) GETJSAMPLE(*inptr++);
        }
      }
      *outptr++ = (JSAMPLE) ((outvalue + numpix2) / numpix);
    }
    inrow += v_expand;
    outrow++;
  }
}


/*
 * Downsample pixel values of a single component.
 * This version handles the special case of a full-size component,
 * without smoothing.
 */

METHODDEF(void)
fullsize_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
                     JSAMPARRAY input_data, JSAMPARRAY output_data)
{
  /* Copy the data */
  jcopy_sample_rows(input_data, 0, output_data, 0,
                    cinfo->max_v_samp_factor, cinfo->image_width);
  /* Edge-expand */
  expand_right_edge(output_data, cinfo->max_v_samp_factor, cinfo->image_width,
                    compptr->width_in_blocks * compptr->DCT_h_scaled_size);
}


/*
 * Downsample pixel values of a single component.
 * This version handles the common case of 2:1 horizontal and 1:1 vertical,
 * without smoothing.
 *
 * A note about the "bias" calculations: when rounding fractional values to
 * integer, we do not want to always round 0.5 up to the next integer.
 * If we did that, we'd introduce a noticeable bias towards larger values.
 * Instead, this code is arranged so that 0.5 will be rounded up or down at
 * alternate pixel locations (a simple ordered dither pattern).
 */

METHODDEF(void)
h2v1_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
                 JSAMPARRAY input_data, JSAMPARRAY output_data)
{
  int inrow;
  JDIMENSION outcol;
  JDIMENSION output_cols = compptr->width_in_blocks * compptr->DCT_h_scaled_size;
  register JSAMPROW inptr, outptr;
  register int bias;

  /* Expand input data enough to let all the output samples be generated
   * by the standard loop.  Special-casing padded output would be more
   * efficient.
   */
  expand_right_edge(input_data, cinfo->max_v_samp_factor,
                    cinfo->image_width, output_cols * 2);

  for (inrow = 0; inrow < cinfo->max_v_samp_factor; inrow++) {
    outptr = output_data[inrow];
    inptr = input_data[inrow];
    bias = 0;                   /* bias = 0,1,0,1,... for successive samples */
    for (outcol = 0; outcol < output_cols; outcol++) {
      *outptr++ = (JSAMPLE) ((GETJSAMPLE(*inptr) + GETJSAMPLE(inptr[1])
                              + bias) >> 1);
      bias ^= 1;                /* 0=>1, 1=>0 */
      inptr += 2;
    }
  }
}


/*
 * Downsample pixel values of a single component.
 * This version handles the standard case of 2:1 horizontal and 2:1 vertical,
 * without smoothing.
 */

METHODDEF(void)
h2v2_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
                 JSAMPARRAY input_data, JSAMPARRAY output_data)
{
  int inrow, outrow;
  JDIMENSION outcol;
  JDIMENSION output_cols = compptr->width_in_blocks * compptr->DCT_h_scaled_size;
  register JSAMPROW inptr0, inptr1, outptr;
  register int bias;

  /* Expand input data enough to let all the output samples be generated
   * by the standard loop.  Special-casing padded output would be more
   * efficient.
   */
  expand_right_edge(input_data, cinfo->max_v_samp_factor,
                    cinfo->image_width, output_cols * 2);

  inrow = outrow = 0;
  while (inrow < cinfo->max_v_samp_factor) {
    outptr = output_data[outrow];
    inptr0 = input_data[inrow];
    inptr1 = input_data[inrow+1];
    bias = 1;                   /* bias = 1,2,1,2,... for successive samples */
    for (outcol = 0; outcol < output_cols; outcol++) {
      *outptr++ = (JSAMPLE) ((GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
                              GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1])
                              + bias) >> 2);
      bias ^= 3;                /* 1=>2, 2=>1 */
      inptr0 += 2; inptr1 += 2;
    }
    inrow += 2;
    outrow++;
  }
}


#ifdef INPUT_SMOOTHING_SUPPORTED

/*
 * Downsample pixel values of a single component.
 * This version handles the standard case of 2:1 horizontal and 2:1 vertical,
 * with smoothing.  One row of context is required.
 */

METHODDEF(void)
h2v2_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
                        JSAMPARRAY input_data, JSAMPARRAY output_data)
{
  int inrow, outrow;
  JDIMENSION colctr;
  JDIMENSION output_cols = compptr->width_in_blocks * compptr->DCT_h_scaled_size;
  register JSAMPROW inptr0, inptr1, above_ptr, below_ptr, outptr;
  INT32 membersum, neighsum, memberscale, neighscale;

  /* Expand input data enough to let all the output samples be generated
   * by the standard loop.  Special-casing padded output would be more
   * efficient.
   */
  expand_right_edge(input_data - 1, cinfo->max_v_samp_factor + 2,
                    cinfo->image_width, output_cols * 2);

  /* We don't bother to form the individual "smoothed" input pixel values;
   * we can directly compute the output which is the average of the four
   * smoothed values.  Each of the four member pixels contributes a fraction
   * (1-8*SF) to its own smoothed image and a fraction SF to each of the three
   * other smoothed pixels, therefore a total fraction (1-5*SF)/4 to the final
   * output.  The four corner-adjacent neighbor pixels contribute a fraction
   * SF to just one smoothed pixel, or SF/4 to the final output; while the
   * eight edge-adjacent neighbors contribute SF to each of two smoothed
   * pixels, or SF/2 overall.  In order to use integer arithmetic, these
   * factors are scaled by 2^16 = 65536.
   * Also recall that SF = smoothing_factor / 1024.
   */

  memberscale = 16384 - cinfo->smoothing_factor * 80; /* scaled (1-5*SF)/4 */
  neighscale = cinfo->smoothing_factor * 16; /* scaled SF/4 */

  inrow = outrow = 0;
  while (inrow < cinfo->max_v_samp_factor) {
    outptr = output_data[outrow];
    inptr0 = input_data[inrow];
    inptr1 = input_data[inrow+1];
    above_ptr = input_data[inrow-1];
    below_ptr = input_data[inrow+2];

    /* Special case for first column: pretend column -1 is same as column 0 */
    membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
                GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
    neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
               GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
               GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[2]) +
               GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[2]);
    neighsum += neighsum;
    neighsum += GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[2]) +
                GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[2]);
    membersum = membersum * memberscale + neighsum * neighscale;
    *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
    inptr0 += 2; inptr1 += 2; above_ptr += 2; below_ptr += 2;

    for (colctr = output_cols - 2; colctr > 0; colctr--) {
      /* sum of pixels directly mapped to this output element */
      membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
                  GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
      /* sum of edge-neighbor pixels */
      neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
                 GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
                 GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[2]) +
                 GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[2]);
      /* The edge-neighbors count twice as much as corner-neighbors */
      neighsum += neighsum;
      /* Add in the corner-neighbors */
      neighsum += GETJSAMPLE(above_ptr[-1]) + GETJSAMPLE(above_ptr[2]) +
                  GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[2]);
      /* form final output scaled up by 2^16 */
      membersum = membersum * memberscale + neighsum * neighscale;
      /* round, descale and output it */
      *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
      inptr0 += 2; inptr1 += 2; above_ptr += 2; below_ptr += 2;
    }

    /* Special case for last column */
    membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
                GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
    neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
               GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
               GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[1]) +
               GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[1]);
    neighsum += neighsum;
    neighsum += GETJSAMPLE(above_ptr[-1]) + GETJSAMPLE(above_ptr[1]) +
                GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[1]);
    membersum = membersum * memberscale + neighsum * neighscale;
    *outptr = (JSAMPLE) ((membersum + 32768) >> 16);

    inrow += 2;
    outrow++;
  }
}


/*
 * Downsample pixel values of a single component.
 * This version handles the special case of a full-size component,
 * with smoothing.  One row of context is required.
 */

METHODDEF(void)
fullsize_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info *compptr,
                            JSAMPARRAY input_data, JSAMPARRAY output_data)
{
  int inrow;
  JDIMENSION colctr;
  JDIMENSION output_cols = compptr->width_in_blocks * compptr->DCT_h_scaled_size;
  register JSAMPROW inptr, above_ptr, below_ptr, outptr;
  INT32 membersum, neighsum, memberscale, neighscale;
  int colsum, lastcolsum, nextcolsum;

  /* Expand input data enough to let all the output samples be generated
   * by the standard loop.  Special-casing padded output would be more
   * efficient.
   */
  expand_right_edge(input_data - 1, cinfo->max_v_samp_factor + 2,
                    cinfo->image_width, output_cols);

  /* Each of the eight neighbor pixels contributes a fraction SF to the
   * smoothed pixel, while the main pixel contributes (1-8*SF).  In order
   * to use integer arithmetic, these factors are multiplied by 2^16 = 65536.
   * Also recall that SF = smoothing_factor / 1024.
   */

  memberscale = 65536L - cinfo->smoothing_factor * 512L; /* scaled 1-8*SF */
  neighscale = cinfo->smoothing_factor * 64; /* scaled SF */

  for (inrow = 0; inrow < cinfo->max_v_samp_factor; inrow++) {
    outptr = output_data[inrow];
    inptr = input_data[inrow];
    above_ptr = input_data[inrow-1];
    below_ptr = input_data[inrow+1];

    /* Special case for first column */
    colsum = GETJSAMPLE(*above_ptr++) + GETJSAMPLE(*below_ptr++) +
             GETJSAMPLE(*inptr);
    membersum = GETJSAMPLE(*inptr++);
    nextcolsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(*below_ptr) +
                 GETJSAMPLE(*inptr);
    neighsum = colsum + (colsum - membersum) + nextcolsum;
    membersum = membersum * memberscale + neighsum * neighscale;
    *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
    lastcolsum = colsum; colsum = nextcolsum;

    for (colctr = output_cols - 2; colctr > 0; colctr--) {
      membersum = GETJSAMPLE(*inptr++);
      above_ptr++; below_ptr++;
      nextcolsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(*below_ptr) +
                   GETJSAMPLE(*inptr);
      neighsum = lastcolsum + (colsum - membersum) + nextcolsum;
      membersum = membersum * memberscale + neighsum * neighscale;
      *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
      lastcolsum = colsum; colsum = nextcolsum;
    }

    /* Special case for last column */
    membersum = GETJSAMPLE(*inptr);
    neighsum = lastcolsum + (colsum - membersum) + colsum;
    membersum = membersum * memberscale + neighsum * neighscale;
    *outptr = (JSAMPLE) ((membersum + 32768) >> 16);

  }
}

#endif /* INPUT_SMOOTHING_SUPPORTED */


/*
 * Module initialization routine for downsampling.
 * Note that we must select a routine for each component.
 */

GLOBAL(void)
jinit_downsampler (j_compress_ptr cinfo)
{
  my_downsample_ptr downsample;
  int ci;
  jpeg_component_info * compptr;
  boolean smoothok = TRUE;
  int h_in_group, v_in_group, h_out_group, v_out_group;

  downsample = (my_downsample_ptr)
    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
                                SIZEOF(my_downsampler));
  cinfo->downsample = (struct jpeg_downsampler *) downsample;
  downsample->pub.start_pass = start_pass_downsample;
  downsample->pub.downsample = sep_downsample;
  downsample->pub.need_context_rows = FALSE;

  if (cinfo->CCIR601_sampling)
    ERREXIT(cinfo, JERR_CCIR601_NOTIMPL);

  /* Verify we can handle the sampling factors, and set up method pointers */
  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
       ci++, compptr++) {
    /* Compute size of an "output group" for DCT scaling.  This many samples
     * are to be converted from max_h_samp_factor * max_v_samp_factor pixels.
     */
    h_out_group = (compptr->h_samp_factor * compptr->DCT_h_scaled_size) /
                  cinfo->min_DCT_h_scaled_size;
    v_out_group = (compptr->v_samp_factor * compptr->DCT_v_scaled_size) /
                  cinfo->min_DCT_v_scaled_size;
    h_in_group = cinfo->max_h_samp_factor;
    v_in_group = cinfo->max_v_samp_factor;
    downsample->rowgroup_height[ci] = v_out_group; /* save for use later */
    if (h_in_group == h_out_group && v_in_group == v_out_group) {
#ifdef INPUT_SMOOTHING_SUPPORTED
      if (cinfo->smoothing_factor) {
        downsample->methods[ci] = fullsize_smooth_downsample;
        downsample->pub.need_context_rows = TRUE;
      } else
#endif
        downsample->methods[ci] = fullsize_downsample;
    } else if (h_in_group == h_out_group * 2 &&
               v_in_group == v_out_group) {
      smoothok = FALSE;
      downsample->methods[ci] = h2v1_downsample;
    } else if (h_in_group == h_out_group * 2 &&
               v_in_group == v_out_group * 2) {
#ifdef INPUT_SMOOTHING_SUPPORTED
      if (cinfo->smoothing_factor) {
        downsample->methods[ci] = h2v2_smooth_downsample;
        downsample->pub.need_context_rows = TRUE;
      } else
#endif
        downsample->methods[ci] = h2v2_downsample;
    } else if ((h_in_group % h_out_group) == 0 &&
               (v_in_group % v_out_group) == 0) {
      smoothok = FALSE;
      downsample->methods[ci] = int_downsample;
      downsample->h_expand[ci] = (UINT8) (h_in_group / h_out_group);
      downsample->v_expand[ci] = (UINT8) (v_in_group / v_out_group);
    } else
      ERREXIT(cinfo, JERR_FRACT_SAMPLE_NOTIMPL);
  }

#ifdef INPUT_SMOOTHING_SUPPORTED
  if (cinfo->smoothing_factor && !smoothok)
    TRACEMS(cinfo, 0, JTRC_SMOOTH_NOTIMPL);
#endif
}
1	/*
2	* jcsample.c
3	*
4	* Copyright (C) 1991-1996, 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 downsampling routines.
9	*
10	* Downsampling input data is counted in "row groups". A row group
11	* is defined to be max_v_samp_factor pixel rows of each component,
12	* from which the downsampler produces v_samp_factor sample rows.
13	* A single row group is processed in each call to the downsampler module.
14	*
15	* The downsampler is responsible for edge-expansion of its output data
16	* to fill an integral number of DCT blocks horizontally. The source buffer
17	* may be modified if it is helpful for this purpose (the source buffer is
18	* allocated wide enough to correspond to the desired output width).
19	* The caller (the prep controller) is responsible for vertical padding.
20	*
21	* The downsampler may request "context rows" by setting need_context_rows
22	* during startup. In this case, the input arrays will contain at least
23	* one row group's worth of pixels above and below the passed-in data;
24	* the caller will create dummy rows at image top and bottom by replicating
25	* the first or last real pixel row.
26	*
27	* An excellent reference for image resampling is
28	* Digital Image Warping, George Wolberg, 1990.
29	* Pub. by IEEE Computer Society Press, Los Alamitos, CA. ISBN 0-8186-8944-7.
30	*
31	* The downsampling algorithm used here is a simple average of the source
32	* pixels covered by the output pixel. The hi-falutin sampling literature
33	* refers to this as a "box filter". In general the characteristics of a box
34	* filter are not very good, but for the specific cases we normally use (1:1
35	* and 2:1 ratios) the box is equivalent to a "triangle filter" which is not
36	* nearly so bad. If you intend to use other sampling ratios, you'd be well
37	* advised to improve this code.
38	*
39	* A simple input-smoothing capability is provided. This is mainly intended
40	* for cleaning up color-dithered GIF input files (if you find it inadequate,
41	* we suggest using an external filtering program such as pnmconvol). When
42	* enabled, each input pixel P is replaced by a weighted sum of itself and its
43	* eight neighbors. P's weight is 1-8*SF and each neighbor's weight is SF,
44	* where SF = (smoothing_factor / 1024).
45	* Currently, smoothing is only supported for 2h2v sampling factors.
46	*/
47
48	#define JPEG_INTERNALS
49	#include "jinclude.h"
50	#include "jpeglib.h"
51
52
53	/* Pointer to routine to downsample a single component */
54	typedef JMETHOD(void, downsample1_ptr,
55	(j_compress_ptr cinfo, jpeg_component_info * compptr,
56	JSAMPARRAY input_data, JSAMPARRAY output_data));
57
58	/* Private subobject */
59
60	typedef struct {
61	struct jpeg_downsampler pub; /* public fields */
62
63	/* Downsampling method pointers, one per component */
64	downsample1_ptr methods[MAX_COMPONENTS];
65
66	/* Height of an output row group for each component. */
67	int rowgroup_height[MAX_COMPONENTS];
68
69	/* These arrays save pixel expansion factors so that int_downsample need not
70	* recompute them each time. They are unused for other downsampling methods.
71	*/
72	UINT8 h_expand[MAX_COMPONENTS];
73	UINT8 v_expand[MAX_COMPONENTS];
74	} my_downsampler;
75
76	typedef my_downsampler * my_downsample_ptr;
77
78
79	/*
80	* Initialize for a downsampling pass.
81	*/
82
83	METHODDEF(void)
84	start_pass_downsample (j_compress_ptr cinfo)
85	{
86	/* no work for now */
87	}
88
89
90	/*
91	* Expand a component horizontally from width input_cols to width output_cols,
92	* by duplicating the rightmost samples.
93	*/
94
95	LOCAL(void)
96	expand_right_edge (JSAMPARRAY image_data, int num_rows,
97	JDIMENSION input_cols, JDIMENSION output_cols)
98	{
99	register JSAMPROW ptr;
100	register JSAMPLE pixval;
101	register int count;
102	int row;
103	int numcols = (int) (output_cols - input_cols);
104
105	if (numcols > 0) {
106	for (row = 0; row < num_rows; row++) {
107	ptr = image_data[row] + input_cols;
108	pixval = ptr[-1]; /* don't need GETJSAMPLE() here */
109	for (count = numcols; count > 0; count--)
110	*ptr++ = pixval;
111	}
112	}
113	}
114
115
116	/*
117	* Do downsampling for a whole row group (all components).
118	*
119	* In this version we simply downsample each component independently.
120	*/
121
122	METHODDEF(void)
123	sep_downsample (j_compress_ptr cinfo,
124	JSAMPIMAGE input_buf, JDIMENSION in_row_index,
125	JSAMPIMAGE output_buf, JDIMENSION out_row_group_index)
126	{
127	my_downsample_ptr downsample = (my_downsample_ptr) cinfo->downsample;
128	int ci;
129	jpeg_component_info * compptr;
130	JSAMPARRAY in_ptr, out_ptr;
131
132	for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
133	ci++, compptr++) {
134	in_ptr = input_buf[ci] + in_row_index;
135	out_ptr = output_buf[ci] +
136	(out_row_group_index * downsample->rowgroup_height[ci]);
137	(*downsample->methods[ci]) (cinfo, compptr, in_ptr, out_ptr);
138	}
139	}
140
141
142	/*
143	* Downsample pixel values of a single component.
144	* One row group is processed per call.
145	* This version handles arbitrary integral sampling ratios, without smoothing.
146	* Note that this version is not actually used for customary sampling ratios.
147	*/
148
149	METHODDEF(void)
150	int_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
151	JSAMPARRAY input_data, JSAMPARRAY output_data)
152	{
153	my_downsample_ptr downsample = (my_downsample_ptr) cinfo->downsample;
154	int inrow, outrow, h_expand, v_expand, numpix, numpix2, h, v;
155	JDIMENSION outcol, outcol_h; /* outcol_h == outcolh_expand /
156	JDIMENSION output_cols = compptr->width_in_blocks * compptr->DCT_h_scaled_size;
157	JSAMPROW inptr, outptr;
158	INT32 outvalue;
159
160	h_expand = downsample->h_expand[compptr->component_index];
161	v_expand = downsample->v_expand[compptr->component_index];
162	numpix = h_expand * v_expand;
163	numpix2 = numpix/2;
164
165	/* Expand input data enough to let all the output samples be generated
166	* by the standard loop. Special-casing padded output would be more
167	* efficient.
168	*/
169	expand_right_edge(input_data, cinfo->max_v_samp_factor,
170	cinfo->image_width, output_cols * h_expand);
171
172	inrow = outrow = 0;
173	while (inrow < cinfo->max_v_samp_factor) {
174	outptr = output_data[outrow];
175	for (outcol = 0, outcol_h = 0; outcol < output_cols;
176	outcol++, outcol_h += h_expand) {
177	outvalue = 0;
178	for (v = 0; v < v_expand; v++) {
179	inptr = input_data[inrow+v] + outcol_h;
180	for (h = 0; h < h_expand; h++) {
181	outvalue += (INT32) GETJSAMPLE(*inptr++);
182	}
183	}
184	*outptr++ = (JSAMPLE) ((outvalue + numpix2) / numpix);
185	}
186	inrow += v_expand;
187	outrow++;
188	}
189	}
190
191
192	/*
193	* Downsample pixel values of a single component.
194	* This version handles the special case of a full-size component,
195	* without smoothing.
196	*/
197
198	METHODDEF(void)
199	fullsize_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
200	JSAMPARRAY input_data, JSAMPARRAY output_data)
201	{
202	/* Copy the data */
203	jcopy_sample_rows(input_data, 0, output_data, 0,
204	cinfo->max_v_samp_factor, cinfo->image_width);
205	/* Edge-expand */
206	expand_right_edge(output_data, cinfo->max_v_samp_factor, cinfo->image_width,
207	compptr->width_in_blocks * compptr->DCT_h_scaled_size);
208	}
209
210
211	/*
212	* Downsample pixel values of a single component.
213	* This version handles the common case of 2:1 horizontal and 1:1 vertical,
214	* without smoothing.
215	*
216	* A note about the "bias" calculations: when rounding fractional values to
217	* integer, we do not want to always round 0.5 up to the next integer.
218	* If we did that, we'd introduce a noticeable bias towards larger values.
219	* Instead, this code is arranged so that 0.5 will be rounded up or down at
220	* alternate pixel locations (a simple ordered dither pattern).
221	*/
222
223	METHODDEF(void)
224	h2v1_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
225	JSAMPARRAY input_data, JSAMPARRAY output_data)
226	{
227	int inrow;
228	JDIMENSION outcol;
229	JDIMENSION output_cols = compptr->width_in_blocks * compptr->DCT_h_scaled_size;
230	register JSAMPROW inptr, outptr;
231	register int bias;
232
233	/* Expand input data enough to let all the output samples be generated
234	* by the standard loop. Special-casing padded output would be more
235	* efficient.
236	*/
237	expand_right_edge(input_data, cinfo->max_v_samp_factor,
238	cinfo->image_width, output_cols * 2);
239
240	for (inrow = 0; inrow < cinfo->max_v_samp_factor; inrow++) {
241	outptr = output_data[inrow];
242	inptr = input_data[inrow];
243	bias = 0; /* bias = 0,1,0,1,... for successive samples */
244	for (outcol = 0; outcol < output_cols; outcol++) {
245	outptr++ = (JSAMPLE) ((GETJSAMPLE(inptr) + GETJSAMPLE(inptr[1])
246	+ bias) >> 1);
247	bias ^= 1; /* 0=>1, 1=>0 */
248	inptr += 2;
249	}
250	}
251	}
252
253
254	/*
255	* Downsample pixel values of a single component.
256	* This version handles the standard case of 2:1 horizontal and 2:1 vertical,
257	* without smoothing.
258	*/
259
260	METHODDEF(void)
261	h2v2_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
262	JSAMPARRAY input_data, JSAMPARRAY output_data)
263	{
264	int inrow, outrow;
265	JDIMENSION outcol;
266	JDIMENSION output_cols = compptr->width_in_blocks * compptr->DCT_h_scaled_size;
267	register JSAMPROW inptr0, inptr1, outptr;
268	register int bias;
269
270	/* Expand input data enough to let all the output samples be generated
271	* by the standard loop. Special-casing padded output would be more
272	* efficient.
273	*/
274	expand_right_edge(input_data, cinfo->max_v_samp_factor,
275	cinfo->image_width, output_cols * 2);
276
277	inrow = outrow = 0;
278	while (inrow < cinfo->max_v_samp_factor) {
279	outptr = output_data[outrow];
280	inptr0 = input_data[inrow];
281	inptr1 = input_data[inrow+1];
282	bias = 1; /* bias = 1,2,1,2,... for successive samples */
283	for (outcol = 0; outcol < output_cols; outcol++) {
284	outptr++ = (JSAMPLE) ((GETJSAMPLE(inptr0) + GETJSAMPLE(inptr0[1]) +
285	GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1])
286	+ bias) >> 2);
287	bias ^= 3; /* 1=>2, 2=>1 */
288	inptr0 += 2; inptr1 += 2;
289	}
290	inrow += 2;
291	outrow++;
292	}
293	}
294
295
296	#ifdef INPUT_SMOOTHING_SUPPORTED
297
298	/*
299	* Downsample pixel values of a single component.
300	* This version handles the standard case of 2:1 horizontal and 2:1 vertical,
301	* with smoothing. One row of context is required.
302	*/
303
304	METHODDEF(void)
305	h2v2_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
306	JSAMPARRAY input_data, JSAMPARRAY output_data)
307	{
308	int inrow, outrow;
309	JDIMENSION colctr;
310	JDIMENSION output_cols = compptr->width_in_blocks * compptr->DCT_h_scaled_size;
311	register JSAMPROW inptr0, inptr1, above_ptr, below_ptr, outptr;
312	INT32 membersum, neighsum, memberscale, neighscale;
313
314	/* Expand input data enough to let all the output samples be generated
315	* by the standard loop. Special-casing padded output would be more
316	* efficient.
317	*/
318	expand_right_edge(input_data - 1, cinfo->max_v_samp_factor + 2,
319	cinfo->image_width, output_cols * 2);
320
321	/* We don't bother to form the individual "smoothed" input pixel values;
322	* we can directly compute the output which is the average of the four
323	* smoothed values. Each of the four member pixels contributes a fraction
324	* (1-8*SF) to its own smoothed image and a fraction SF to each of the three
325	* other smoothed pixels, therefore a total fraction (1-5*SF)/4 to the final
326	* output. The four corner-adjacent neighbor pixels contribute a fraction
327	* SF to just one smoothed pixel, or SF/4 to the final output; while the
328	* eight edge-adjacent neighbors contribute SF to each of two smoothed
329	* pixels, or SF/2 overall. In order to use integer arithmetic, these
330	* factors are scaled by 2^16 = 65536.
331	* Also recall that SF = smoothing_factor / 1024.
332	*/
333
334	memberscale = 16384 - cinfo->smoothing_factor * 80; /* scaled (1-5SF)/4 /
335	neighscale = cinfo->smoothing_factor * 16; /* scaled SF/4 */
336
337	inrow = outrow = 0;
338	while (inrow < cinfo->max_v_samp_factor) {
339	outptr = output_data[outrow];
340	inptr0 = input_data[inrow];
341	inptr1 = input_data[inrow+1];
342	above_ptr = input_data[inrow-1];
343	below_ptr = input_data[inrow+2];
344
345	/* Special case for first column: pretend column -1 is same as column 0 */
346	membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
347	GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
348	neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
349	GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
350	GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[2]) +
351	GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[2]);
352	neighsum += neighsum;
353	neighsum += GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[2]) +
354	GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[2]);
355	membersum = membersum * memberscale + neighsum * neighscale;
356	*outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
357	inptr0 += 2; inptr1 += 2; above_ptr += 2; below_ptr += 2;
358
359	for (colctr = output_cols - 2; colctr > 0; colctr--) {
360	/* sum of pixels directly mapped to this output element */
361	membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
362	GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
363	/* sum of edge-neighbor pixels */
364	neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
365	GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
366	GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[2]) +
367	GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[2]);
368	/* The edge-neighbors count twice as much as corner-neighbors */
369	neighsum += neighsum;
370	/* Add in the corner-neighbors */
371	neighsum += GETJSAMPLE(above_ptr[-1]) + GETJSAMPLE(above_ptr[2]) +
372	GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[2]);
373	/* form final output scaled up by 2^16 */
374	membersum = membersum * memberscale + neighsum * neighscale;
375	/* round, descale and output it */
376	*outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
377	inptr0 += 2; inptr1 += 2; above_ptr += 2; below_ptr += 2;
378	}
379
380	/* Special case for last column */
381	membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
382	GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
383	neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
384	GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
385	GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[1]) +
386	GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[1]);
387	neighsum += neighsum;
388	neighsum += GETJSAMPLE(above_ptr[-1]) + GETJSAMPLE(above_ptr[1]) +
389	GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[1]);
390	membersum = membersum * memberscale + neighsum * neighscale;
391	*outptr = (JSAMPLE) ((membersum + 32768) >> 16);
392
393	inrow += 2;
394	outrow++;
395	}
396	}
397
398
399	/*
400	* Downsample pixel values of a single component.
401	* This version handles the special case of a full-size component,
402	* with smoothing. One row of context is required.
403	*/
404
405	METHODDEF(void)
406	fullsize_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info *compptr,
407	JSAMPARRAY input_data, JSAMPARRAY output_data)
408	{
409	int inrow;
410	JDIMENSION colctr;
411	JDIMENSION output_cols = compptr->width_in_blocks * compptr->DCT_h_scaled_size;
412	register JSAMPROW inptr, above_ptr, below_ptr, outptr;
413	INT32 membersum, neighsum, memberscale, neighscale;
414	int colsum, lastcolsum, nextcolsum;
415
416	/* Expand input data enough to let all the output samples be generated
417	* by the standard loop. Special-casing padded output would be more
418	* efficient.
419	*/
420	expand_right_edge(input_data - 1, cinfo->max_v_samp_factor + 2,
421	cinfo->image_width, output_cols);
422
423	/* Each of the eight neighbor pixels contributes a fraction SF to the
424	* smoothed pixel, while the main pixel contributes (1-8*SF). In order
425	* to use integer arithmetic, these factors are multiplied by 2^16 = 65536.
426	* Also recall that SF = smoothing_factor / 1024.
427	*/
428
429	memberscale = 65536L - cinfo->smoothing_factor * 512L; /* scaled 1-8SF /
430	neighscale = cinfo->smoothing_factor * 64; /* scaled SF */
431
432	for (inrow = 0; inrow < cinfo->max_v_samp_factor; inrow++) {
433	outptr = output_data[inrow];
434	inptr = input_data[inrow];
435	above_ptr = input_data[inrow-1];
436	below_ptr = input_data[inrow+1];
437
438	/* Special case for first column */
439	colsum = GETJSAMPLE(above_ptr++) + GETJSAMPLE(below_ptr++) +
440	GETJSAMPLE(*inptr);
441	membersum = GETJSAMPLE(*inptr++);
442	nextcolsum = GETJSAMPLE(above_ptr) + GETJSAMPLE(below_ptr) +
443	GETJSAMPLE(*inptr);
444	neighsum = colsum + (colsum - membersum) + nextcolsum;
445	membersum = membersum * memberscale + neighsum * neighscale;
446	*outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
447	lastcolsum = colsum; colsum = nextcolsum;
448
449	for (colctr = output_cols - 2; colctr > 0; colctr--) {
450	membersum = GETJSAMPLE(*inptr++);
451	above_ptr++; below_ptr++;
452	nextcolsum = GETJSAMPLE(above_ptr) + GETJSAMPLE(below_ptr) +
453	GETJSAMPLE(*inptr);
454	neighsum = lastcolsum + (colsum - membersum) + nextcolsum;
455	membersum = membersum * memberscale + neighsum * neighscale;
456	*outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
457	lastcolsum = colsum; colsum = nextcolsum;
458	}
459
460	/* Special case for last column */
461	membersum = GETJSAMPLE(*inptr);
462	neighsum = lastcolsum + (colsum - membersum) + colsum;
463	membersum = membersum * memberscale + neighsum * neighscale;
464	*outptr = (JSAMPLE) ((membersum + 32768) >> 16);
465
466	}
467	}
468
469	#endif /* INPUT_SMOOTHING_SUPPORTED */
470
471
472	/*
473	* Module initialization routine for downsampling.
474	* Note that we must select a routine for each component.
475	*/
476
477	GLOBAL(void)
478	jinit_downsampler (j_compress_ptr cinfo)
479	{
480	my_downsample_ptr downsample;
481	int ci;
482	jpeg_component_info * compptr;
483	boolean smoothok = TRUE;
484	int h_in_group, v_in_group, h_out_group, v_out_group;
485
486	downsample = (my_downsample_ptr)
487	(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
488	SIZEOF(my_downsampler));
489	cinfo->downsample = (struct jpeg_downsampler *) downsample;
490	downsample->pub.start_pass = start_pass_downsample;
491	downsample->pub.downsample = sep_downsample;
492	downsample->pub.need_context_rows = FALSE;
493
494	if (cinfo->CCIR601_sampling)
495	ERREXIT(cinfo, JERR_CCIR601_NOTIMPL);
496
497	/* Verify we can handle the sampling factors, and set up method pointers */
498	for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
499	ci++, compptr++) {
500	/* Compute size of an "output group" for DCT scaling. This many samples
501	* are to be converted from max_h_samp_factor * max_v_samp_factor pixels.
502	*/
503	h_out_group = (compptr->h_samp_factor * compptr->DCT_h_scaled_size) /
504	cinfo->min_DCT_h_scaled_size;
505	v_out_group = (compptr->v_samp_factor * compptr->DCT_v_scaled_size) /
506	cinfo->min_DCT_v_scaled_size;
507	h_in_group = cinfo->max_h_samp_factor;
508	v_in_group = cinfo->max_v_samp_factor;
509	downsample->rowgroup_height[ci] = v_out_group; /* save for use later */
510	if (h_in_group == h_out_group && v_in_group == v_out_group) {
511	#ifdef INPUT_SMOOTHING_SUPPORTED
512	if (cinfo->smoothing_factor) {
513	downsample->methods[ci] = fullsize_smooth_downsample;
514	downsample->pub.need_context_rows = TRUE;
515	} else
516	#endif
517	downsample->methods[ci] = fullsize_downsample;
518	} else if (h_in_group == h_out_group * 2 &&
519	v_in_group == v_out_group) {
520	smoothok = FALSE;
521	downsample->methods[ci] = h2v1_downsample;
522	} else if (h_in_group == h_out_group * 2 &&
523	v_in_group == v_out_group * 2) {
524	#ifdef INPUT_SMOOTHING_SUPPORTED
525	if (cinfo->smoothing_factor) {
526	downsample->methods[ci] = h2v2_smooth_downsample;
527	downsample->pub.need_context_rows = TRUE;
528	} else
529	#endif
530	downsample->methods[ci] = h2v2_downsample;
531	} else if ((h_in_group % h_out_group) == 0 &&
532	(v_in_group % v_out_group) == 0) {
533	smoothok = FALSE;
534	downsample->methods[ci] = int_downsample;
535	downsample->h_expand[ci] = (UINT8) (h_in_group / h_out_group);
536	downsample->v_expand[ci] = (UINT8) (v_in_group / v_out_group);
537	} else
538	ERREXIT(cinfo, JERR_FRACT_SAMPLE_NOTIMPL);
539	}
540
541	#ifdef INPUT_SMOOTHING_SUPPORTED
542	if (cinfo->smoothing_factor && !smoothok)
543	TRACEMS(cinfo, 0, JTRC_SMOOTH_NOTIMPL);
544	#endif
545	}