/*

 * transupp.c

 *

 * This file was part of the Independent JPEG Group's software:

 * Copyright (C) 1997-2019, Thomas G. Lane, Guido Vollbeding.

 * libjpeg-turbo Modifications:

 * Copyright (C) 2010, 2017, 2021-2022, 2024, 2026, D. R. Commander.

 * For conditions of distribution and use, see the accompanying README.ijg

 * file.

 *

 * This file contains image transformation routines and other utility code

 * used by the jpegtran sample application.  These are NOT part of the core

 * JPEG library.  But we keep these routines separate from jpegtran.c to

 * ease the task of maintaining jpegtran-like programs that have other user

 * interfaces.

 */

/* Although this file really shouldn't have access to the library internals,

 * it's helpful to let it call jround_up() and jcopy_block_row().

 */

#define JPEG_INTERNALS

#include "jinclude.h"

#include "jpeglib.h"

#include "transupp.h"           /* My own external interface */

#include "jpegapicomp.h"

#include <ctype.h>              /* to declare isdigit() */

#if JPEG_LIB_VERSION >= 70

#define dstinfo_min_DCT_h_scaled_size  dstinfo->min_DCT_h_scaled_size

#define dstinfo_min_DCT_v_scaled_size  dstinfo->min_DCT_v_scaled_size

#else

#define dstinfo_min_DCT_h_scaled_size  DCTSIZE

#define dstinfo_min_DCT_v_scaled_size  DCTSIZE

#endif

#if TRANSFORMS_SUPPORTED

/*

 * Lossless image transformation routines.  These routines work on DCT

 * coefficient arrays and thus do not require any lossy decompression

 * or recompression of the image.

 * Thanks to Guido Vollbeding for the initial design and code of this feature,

 * and to Ben Jackson for introducing the cropping feature.

 *

 * Horizontal flipping is done in-place, using a single top-to-bottom

 * pass through the virtual source array.  It will thus be much the

 * fastest option for images larger than main memory.

 *

 * The other routines require a set of destination virtual arrays, so they

 * need twice as much memory as jpegtran normally does.  The destination

 * arrays are always written in normal scan order (top to bottom) because

 * the virtual array manager expects this.  The source arrays will be scanned

 * in the corresponding order, which means multiple passes through the source

 * arrays for most of the transforms.  That could result in much thrashing

 * if the image is larger than main memory.

 *

 * If cropping or trimming is involved, the destination arrays may be smaller

 * than the source arrays.  Note it is not possible to do horizontal flip

 * in-place when a nonzero Y crop offset is specified, since we'd have to move

 * data from one block row to another but the virtual array manager doesn't

 * guarantee we can touch more than one row at a time.  So in that case,

 * we have to use a separate destination array.

 *

 * Some notes about the operating environment of the individual transform

 * routines:

 * 1. Both the source and destination virtual arrays are allocated from the

 *    source JPEG object, and therefore should be manipulated by calling the

 *    source's memory manager.

 * 2. The destination's component count should be used.  It may be smaller

 *    than the source's when forcing to grayscale.

 * 3. Likewise the destination's sampling factors should be used.  When

 *    forcing to grayscale the destination's sampling factors will be all 1,

 *    and we may as well take that as the effective iMCU size.

 * 4. When "trim" is in effect, the destination's dimensions will be the

 *    trimmed values but the source's will be untrimmed.

 * 5. When "crop" is in effect, the destination's dimensions will be the

 *    cropped values but the source's will be uncropped.  Each transform

 *    routine is responsible for picking up source data starting at the

 *    correct X and Y offset for the crop region.  (The X and Y offsets

 *    passed to the transform routines are measured in iMCU blocks of the

 *    destination.)

 * 6. All the routines assume that the source and destination buffers are

 *    padded out to a full iMCU boundary.  This is true, although for the

 *    source buffer it is an undocumented property of jdcoefct.c.

 */

LOCAL(void)

dequant_comp(j_decompress_ptr cinfo, jpeg_component_info *compptr,

             jvirt_barray_ptr coef_array, JQUANT_TBL *qtblptr1)

{

  JDIMENSION blk_x, blk_y;

  int offset_y, k;

  JQUANT_TBL *qtblptr;

  JBLOCKARRAY buffer;

  JBLOCKROW block;

  JCOEFPTR ptr;

  qtblptr = compptr->quant_table;

  for (blk_y = 0; blk_y < compptr->height_in_blocks;

       blk_y += compptr->v_samp_factor) {

    buffer = (*cinfo->mem->access_virt_barray)

      ((j_common_ptr)cinfo, coef_array, blk_y,

       (JDIMENSION)compptr->v_samp_factor, TRUE);

    for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {

      block = buffer[offset_y];

      for (blk_x = 0; blk_x < compptr->width_in_blocks; blk_x++) {

        ptr = block[blk_x];

        for (k = 0; k < DCTSIZE2; k++)

          if (qtblptr->quantval[k] != qtblptr1->quantval[k]) {

            ptr[k] *= qtblptr->quantval[k];

            if (qtblptr1->quantval[k] != 0)

              ptr[k] /= qtblptr1->quantval[k];

          }

      }

    }

  }

}

LOCAL(void)

requant_comp(j_decompress_ptr cinfo, jpeg_component_info *compptr,

             jvirt_barray_ptr coef_array, JQUANT_TBL *qtblptr1)

{

  JDIMENSION blk_x, blk_y;

  int offset_y, k;

  JQUANT_TBL *qtblptr;

  JBLOCKARRAY buffer;

  JBLOCKROW block;

  JCOEFPTR ptr;

  JCOEF temp, qval;

  qtblptr = compptr->quant_table;

  for (blk_y = 0; blk_y < compptr->height_in_blocks;

       blk_y += compptr->v_samp_factor) {

    buffer = (*cinfo->mem->access_virt_barray)

      ((j_common_ptr)cinfo, coef_array, blk_y,

       (JDIMENSION)compptr->v_samp_factor, TRUE);

    for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {

      block = buffer[offset_y];

      for (blk_x = 0; blk_x < compptr->width_in_blocks; blk_x++) {

        ptr = block[blk_x];

        for (k = 0; k < DCTSIZE2; k++) {

          temp = qtblptr->quantval[k];

          qval = qtblptr1->quantval[k];

          if (temp != qval && qval != 0) {

            temp *= ptr[k];

            /* The following quantization code is copied from jcdctmgr.c */

#ifdef FAST_DIVIDE

#define DIVIDE_BY(a, b)  a /= b

#else

#define DIVIDE_BY(a, b)  if (a >= b) a /= b;  else a = 0

#endif

            if (temp < 0) {

              temp = -temp;

              temp += qval >> 1; /* for rounding */

              DIVIDE_BY(temp, qval);

              temp = -temp;

            } else {

              temp += qval >> 1; /* for rounding */

              DIVIDE_BY(temp, qval);

            }

            ptr[k] = temp;

          }

        }

      }

    }

  }

}

/*

 * Calculate largest common denominator using Euclid's algorithm.

 */

LOCAL(JCOEF)

largest_common_denominator(JCOEF a, JCOEF b)

{

  JCOEF c;

  if (a == 0) return b;

  if (b == 0) return a;

  do {

    c = a % b;

    a = b;

    b = c;

  } while (c);

  return a;

}

LOCAL(void)

adjust_quant(j_decompress_ptr srcinfo, jvirt_barray_ptr *src_coef_arrays,

             j_decompress_ptr dropinfo, jvirt_barray_ptr *drop_coef_arrays,

             boolean trim, j_compress_ptr dstinfo)

{

  jpeg_component_info *compptr1, *compptr2;

  JQUANT_TBL *qtblptr1, *qtblptr2, *qtblptr3;

  int ci, k;

  for (ci = 0; ci < dstinfo->num_components && ci < dropinfo->num_components;

       ci++) {

    compptr1 = srcinfo->comp_info + ci;

    compptr2 = dropinfo->comp_info + ci;

    qtblptr1 = compptr1->quant_table;

    if (qtblptr1 == NULL)

      ERREXIT1(srcinfo, JERR_NO_QUANT_TABLE, compptr1->quant_tbl_no);

    qtblptr2 = compptr2->quant_table;

    if (qtblptr2 == NULL)

      ERREXIT1(dropinfo, JERR_NO_QUANT_TABLE, compptr2->quant_tbl_no);

    for (k = 0; k < DCTSIZE2; k++) {

      if (qtblptr1->quantval[k] != qtblptr2->quantval[k]) {

        if (trim)

          requant_comp(dropinfo, compptr2, drop_coef_arrays[ci], qtblptr1);

        else {

          qtblptr3 = dstinfo->quant_tbl_ptrs[compptr1->quant_tbl_no];

          for (k = 0; k < DCTSIZE2; k++)

            if (qtblptr1->quantval[k] != qtblptr2->quantval[k])

              qtblptr3->quantval[k] =

                largest_common_denominator(qtblptr1->quantval[k],

                                           qtblptr2->quantval[k]);

          dequant_comp(srcinfo, compptr1, src_coef_arrays[ci], qtblptr3);

          dequant_comp(dropinfo, compptr2, drop_coef_arrays[ci], qtblptr3);

        }

        break;

      }

    }

  }

}

LOCAL(void)

do_drop(j_decompress_ptr srcinfo, j_compress_ptr dstinfo,

        JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,

        jvirt_barray_ptr *src_coef_arrays,

        j_decompress_ptr dropinfo, jvirt_barray_ptr *drop_coef_arrays,

        JDIMENSION drop_width, JDIMENSION drop_height)

/* Drop (insert) the contents of another image into the source image.  If the

 * number of components in the drop image is smaller than the number of

 * components in the destination image, then we fill in the remaining

 * components with zero.  This allows for dropping the contents of grayscale

 * images into (arbitrarily sampled) color images.

 */

{

  JDIMENSION comp_width, comp_height;

  JDIMENSION blk_y, x_drop_blocks, y_drop_blocks;

  int ci, offset_y;

  JBLOCKARRAY src_buffer, dst_buffer;

  jpeg_component_info *compptr;

  for (ci = 0; ci < dstinfo->num_components; ci++) {

    compptr = dstinfo->comp_info + ci;

    comp_width = drop_width * compptr->h_samp_factor;

    comp_height = drop_height * compptr->v_samp_factor;

    x_drop_blocks = x_crop_offset * compptr->h_samp_factor;

    y_drop_blocks = y_crop_offset * compptr->v_samp_factor;

    for (blk_y = 0; blk_y < comp_height; blk_y += compptr->v_samp_factor) {

      dst_buffer = (*srcinfo->mem->access_virt_barray)

        ((j_common_ptr)srcinfo, src_coef_arrays[ci], blk_y + y_drop_blocks,

         (JDIMENSION)compptr->v_samp_factor, TRUE);

      if (ci < dropinfo->num_components) {

        src_buffer = (*dropinfo->mem->access_virt_barray)

          ((j_common_ptr)dropinfo, drop_coef_arrays[ci], blk_y,

           (JDIMENSION)compptr->v_samp_factor, FALSE);

        for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {

          jcopy_block_row(src_buffer[offset_y],

                          dst_buffer[offset_y] + x_drop_blocks, comp_width);

        }

      } else {

        for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {

          memset(dst_buffer[offset_y] + x_drop_blocks, 0,

                 comp_width * sizeof(JBLOCK));

        }

      }

    }

  }

}

LOCAL(void)

do_crop(j_decompress_ptr srcinfo, j_compress_ptr dstinfo,

        JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,

        jvirt_barray_ptr *src_coef_arrays,

        jvirt_barray_ptr *dst_coef_arrays)

/* Crop.  This is only used when no rotate/flip is requested with the crop. */

{

  JDIMENSION dst_blk_y, x_crop_blocks, y_crop_blocks;

  int ci, offset_y;

  JBLOCKARRAY src_buffer, dst_buffer;

  jpeg_component_info *compptr;

  /* We simply have to copy the right amount of data (the destination's

   * image size) starting at the given X and Y offsets in the source.

   */

  for (ci = 0; ci < dstinfo->num_components; ci++) {

    compptr = dstinfo->comp_info + ci;

    x_crop_blocks = x_crop_offset * compptr->h_samp_factor;

    y_crop_blocks = y_crop_offset * compptr->v_samp_factor;

    for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;

         dst_blk_y += compptr->v_samp_factor) {

      dst_buffer = (*srcinfo->mem->access_virt_barray)

        ((j_common_ptr)srcinfo, dst_coef_arrays[ci], dst_blk_y,

         (JDIMENSION)compptr->v_samp_factor, TRUE);

      src_buffer = (*srcinfo->mem->access_virt_barray)

        ((j_common_ptr)srcinfo, src_coef_arrays[ci], dst_blk_y + y_crop_blocks,

         (JDIMENSION)compptr->v_samp_factor, FALSE);

      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {

        jcopy_block_row(src_buffer[offset_y] + x_crop_blocks,

                        dst_buffer[offset_y], compptr->width_in_blocks);

      }

    }

  }

}

LOCAL(void)

do_crop_ext_zero(j_decompress_ptr srcinfo, j_compress_ptr dstinfo,

                 JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,

                 jvirt_barray_ptr *src_coef_arrays,

                 jvirt_barray_ptr *dst_coef_arrays)

/* Crop.  This is only used when no rotate/flip is requested with the crop.

 * Extension: If the destination size is larger than the source, we fill in the

 * expanded region with zero (neutral gray).  Note that we also have to zero

 * partial iMCUs at the right and bottom edge of the source image area in this

 * case.

 */

{

  JDIMENSION MCU_cols, MCU_rows, comp_width, comp_height;

  JDIMENSION dst_blk_y, x_crop_blocks, y_crop_blocks;

  int ci, offset_y;

  JBLOCKARRAY src_buffer, dst_buffer;

  jpeg_component_info *compptr;

  MCU_cols = srcinfo->output_width /

             (dstinfo->max_h_samp_factor * dstinfo_min_DCT_h_scaled_size);

  MCU_rows = srcinfo->output_height /

             (dstinfo->max_v_samp_factor * dstinfo_min_DCT_v_scaled_size);

  for (ci = 0; ci < dstinfo->num_components; ci++) {

    compptr = dstinfo->comp_info + ci;

    comp_width = MCU_cols * compptr->h_samp_factor;

    comp_height = MCU_rows * compptr->v_samp_factor;

    x_crop_blocks = x_crop_offset * compptr->h_samp_factor;

    y_crop_blocks = y_crop_offset * compptr->v_samp_factor;

    for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;

         dst_blk_y += compptr->v_samp_factor) {

      dst_buffer = (*srcinfo->mem->access_virt_barray)

        ((j_common_ptr)srcinfo, dst_coef_arrays[ci], dst_blk_y,

         (JDIMENSION)compptr->v_samp_factor, TRUE);

      if (dstinfo->_jpeg_height > srcinfo->output_height) {

        if (dst_blk_y < y_crop_blocks ||

            dst_blk_y >= y_crop_blocks + comp_height) {

          for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {

            memset(dst_buffer[offset_y], 0,

                   compptr->width_in_blocks * sizeof(JBLOCK));

          }

          continue;

        }

        src_buffer = (*srcinfo->mem->access_virt_barray)

          ((j_common_ptr)srcinfo, src_coef_arrays[ci],

           dst_blk_y - y_crop_blocks, (JDIMENSION)compptr->v_samp_factor,

           FALSE);

      } else {

        src_buffer = (*srcinfo->mem->access_virt_barray)

          ((j_common_ptr)srcinfo, src_coef_arrays[ci],

           dst_blk_y + y_crop_blocks, (JDIMENSION)compptr->v_samp_factor,

           FALSE);

      }

      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {

        if (dstinfo->_jpeg_width > srcinfo->output_width) {

          if (x_crop_blocks > 0) {

            memset(dst_buffer[offset_y], 0, x_crop_blocks * sizeof(JBLOCK));

          }

          jcopy_block_row(src_buffer[offset_y],

                          dst_buffer[offset_y] + x_crop_blocks, comp_width);

          if (compptr->width_in_blocks > x_crop_blocks + comp_width) {

            memset(dst_buffer[offset_y] + x_crop_blocks + comp_width, 0,

                   (compptr->width_in_blocks - x_crop_blocks - comp_width) *

                   sizeof(JBLOCK));

          }

        } else {

          jcopy_block_row(src_buffer[offset_y] + x_crop_blocks,

                          dst_buffer[offset_y], compptr->width_in_blocks);

        }

      }

    }

  }

}

LOCAL(void)

do_crop_ext_flat(j_decompress_ptr srcinfo, j_compress_ptr dstinfo,

                 JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,

                 jvirt_barray_ptr *src_coef_arrays,

                 jvirt_barray_ptr *dst_coef_arrays)

/* Crop.  This is only used when no rotate/flip is requested with the crop.

 * Extension: The destination width is larger than the source, and we fill in

 * the expanded region with the DC coefficient of the adjacent block.  Note

 * that we also have to fill partial iMCUs at the right and bottom edge of the

 * source image area in this case.

 */

{

  JDIMENSION MCU_cols, MCU_rows, comp_width, comp_height;

  JDIMENSION dst_blk_x, dst_blk_y, x_crop_blocks, y_crop_blocks;

  int ci, offset_y;

  JCOEF dc;

  JBLOCKARRAY src_buffer, dst_buffer;

  jpeg_component_info *compptr;

  MCU_cols = srcinfo->output_width /

             (dstinfo->max_h_samp_factor * dstinfo_min_DCT_h_scaled_size);

  MCU_rows = srcinfo->output_height /

             (dstinfo->max_v_samp_factor * dstinfo_min_DCT_v_scaled_size);

  for (ci = 0; ci < dstinfo->num_components; ci++) {

    compptr = dstinfo->comp_info + ci;

    comp_width = MCU_cols * compptr->h_samp_factor;

    /* Prevent buffer overrun */

    if (comp_width == 0)

      ERREXIT(srcinfo, JERR_BAD_CROP_SPEC);

    comp_height = MCU_rows * compptr->v_samp_factor;

    x_crop_blocks = x_crop_offset * compptr->h_samp_factor;

    y_crop_blocks = y_crop_offset * compptr->v_samp_factor;

    for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;

         dst_blk_y += compptr->v_samp_factor) {

      dst_buffer = (*srcinfo->mem->access_virt_barray)

        ((j_common_ptr)srcinfo, dst_coef_arrays[ci], dst_blk_y,

         (JDIMENSION)compptr->v_samp_factor, TRUE);

      if (dstinfo->_jpeg_height > srcinfo->output_height) {

        if (dst_blk_y < y_crop_blocks ||

            dst_blk_y >= y_crop_blocks + comp_height) {

          for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {

            memset(dst_buffer[offset_y], 0,

                   compptr->width_in_blocks * sizeof(JBLOCK));

          }

          continue;

        }

        src_buffer = (*srcinfo->mem->access_virt_barray)

          ((j_common_ptr)srcinfo, src_coef_arrays[ci],

           dst_blk_y - y_crop_blocks, (JDIMENSION)compptr->v_samp_factor,

           FALSE);

      } else {

        src_buffer = (*srcinfo->mem->access_virt_barray)

          ((j_common_ptr)srcinfo, src_coef_arrays[ci],

           dst_blk_y + y_crop_blocks, (JDIMENSION)compptr->v_samp_factor,

          FALSE);

      }

      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {

        if (x_crop_blocks > 0) {

          memset(dst_buffer[offset_y], 0, x_crop_blocks * sizeof(JBLOCK));

          dc = src_buffer[offset_y][0][0];

          for (dst_blk_x = 0; dst_blk_x < x_crop_blocks; dst_blk_x++) {

            dst_buffer[offset_y][dst_blk_x][0] = dc;

          }

        }

        jcopy_block_row(src_buffer[offset_y],

                        dst_buffer[offset_y] + x_crop_blocks, comp_width);

        if (compptr->width_in_blocks > x_crop_blocks + comp_width) {

          memset(dst_buffer[offset_y] + x_crop_blocks + comp_width, 0,

                 (compptr->width_in_blocks - x_crop_blocks - comp_width) *

                 sizeof(JBLOCK));

          dc = src_buffer[offset_y][comp_width - 1][0];

          for (dst_blk_x = x_crop_blocks + comp_width;

               dst_blk_x < compptr->width_in_blocks; dst_blk_x++) {

            dst_buffer[offset_y][dst_blk_x][0] = dc;

          }

        }

      }

    }

  }

}

LOCAL(void)

do_crop_ext_reflect(j_decompress_ptr srcinfo, j_compress_ptr dstinfo,

                    JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,

                    jvirt_barray_ptr *src_coef_arrays,

                    jvirt_barray_ptr *dst_coef_arrays)

/* Crop.  This is only used when no rotate/flip is requested with the crop.

 * Extension: The destination width is larger than the source, and we fill in

 * the expanded region with repeated reflections of the source image.  Note

 * that we also have to fill partial iMCUs at the right and bottom edge of the

 * source image area in this case.

 */

{

  JDIMENSION MCU_cols, MCU_rows, comp_width, comp_height, src_blk_x;

  JDIMENSION dst_blk_x, dst_blk_y, x_crop_blocks, y_crop_blocks;

  int ci, k, offset_y;

  JBLOCKARRAY src_buffer, dst_buffer;

  JBLOCKROW src_row_ptr, dst_row_ptr;

  JCOEFPTR src_ptr, dst_ptr;

  jpeg_component_info *compptr;

  MCU_cols = srcinfo->output_width /

             (dstinfo->max_h_samp_factor * dstinfo_min_DCT_h_scaled_size);

  MCU_rows = srcinfo->output_height /

             (dstinfo->max_v_samp_factor * dstinfo_min_DCT_v_scaled_size);

  for (ci = 0; ci < dstinfo->num_components; ci++) {

    compptr = dstinfo->comp_info + ci;

    comp_width = MCU_cols * compptr->h_samp_factor;

    /* Prevent infinite loop */

    if (comp_width == 0)

      ERREXIT(srcinfo, JERR_BAD_CROP_SPEC);

    comp_height = MCU_rows * compptr->v_samp_factor;

    x_crop_blocks = x_crop_offset * compptr->h_samp_factor;

    y_crop_blocks = y_crop_offset * compptr->v_samp_factor;

    for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;

         dst_blk_y += compptr->v_samp_factor) {

      dst_buffer = (*srcinfo->mem->access_virt_barray)

        ((j_common_ptr)srcinfo, dst_coef_arrays[ci], dst_blk_y,

         (JDIMENSION)compptr->v_samp_factor, TRUE);

      if (dstinfo->_jpeg_height > srcinfo->output_height) {

        if (dst_blk_y < y_crop_blocks ||

            dst_blk_y >= y_crop_blocks + comp_height) {

          for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {

            memset(dst_buffer[offset_y], 0,

                   compptr->width_in_blocks * sizeof(JBLOCK));

          }

          continue;

        }

        src_buffer = (*srcinfo->mem->access_virt_barray)

          ((j_common_ptr)srcinfo, src_coef_arrays[ci],

           dst_blk_y - y_crop_blocks, (JDIMENSION)compptr->v_samp_factor,

           FALSE);

      } else {

        src_buffer = (*srcinfo->mem->access_virt_barray)

          ((j_common_ptr)srcinfo, src_coef_arrays[ci],

           dst_blk_y + y_crop_blocks, (JDIMENSION)compptr->v_samp_factor,

           FALSE);

      }

      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {

        /* Copy source region */

        jcopy_block_row(src_buffer[offset_y],

                        dst_buffer[offset_y] + x_crop_blocks, comp_width);

        if (x_crop_blocks > 0) {

          /* Reflect to left */

          dst_row_ptr = dst_buffer[offset_y] + x_crop_blocks;

          for (dst_blk_x = x_crop_blocks; dst_blk_x > 0;) {

            src_row_ptr = dst_row_ptr;      /* (re)set axis of reflection */

            for (src_blk_x = comp_width; src_blk_x > 0 && dst_blk_x > 0;

                 src_blk_x--, dst_blk_x--) {

              dst_ptr = *(--dst_row_ptr);   /* destination goes left */

              src_ptr = *src_row_ptr++;     /* source goes right */

              /* This unrolled loop doesn't need to know which row it's on. */

              for (k = 0; k < DCTSIZE2; k += 2) {

                *dst_ptr++ = *src_ptr++;    /* copy even column */

                *dst_ptr++ = -(*src_ptr++); /* copy odd column with sign

                                               change */

              }

            }

          }

        }

        if (compptr->width_in_blocks > x_crop_blocks + comp_width) {

          /* Reflect to right */

          dst_row_ptr = dst_buffer[offset_y] + x_crop_blocks + comp_width;

          for (dst_blk_x = compptr->width_in_blocks - x_crop_blocks - comp_width;

               dst_blk_x > 0;) {

            src_row_ptr = dst_row_ptr;      /* (re)set axis of reflection */

            for (src_blk_x = comp_width; src_blk_x > 0 && dst_blk_x > 0;

                 src_blk_x--, dst_blk_x--) {

              dst_ptr = *dst_row_ptr++;     /* destination goes right */

              src_ptr = *(--src_row_ptr);   /* source goes left */

              /* This unrolled loop doesn't need to know which row it's on. */

              for (k = 0; k < DCTSIZE2; k += 2) {

                *dst_ptr++ = *src_ptr++;    /* copy even column */

                *dst_ptr++ = -(*src_ptr++); /* copy odd column with sign

                                               change */

              }

            }

          }

        }

      }

    }

  }

}

LOCAL(void)

do_wipe(j_decompress_ptr srcinfo, j_compress_ptr dstinfo,

        JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,

        jvirt_barray_ptr *src_coef_arrays,

        JDIMENSION drop_width, JDIMENSION drop_height)

/* Wipe - discard image contents of specified region and fill with zero

 * (neutral gray)

 */

{

  JDIMENSION x_wipe_blocks, wipe_width;

  JDIMENSION y_wipe_blocks, wipe_bottom;

  int ci, offset_y;

  JBLOCKARRAY buffer;

  jpeg_component_info *compptr;

  for (ci = 0; ci < dstinfo->num_components; ci++) {

    compptr = dstinfo->comp_info + ci;

    x_wipe_blocks = x_crop_offset * compptr->h_samp_factor;

    wipe_width = drop_width * compptr->h_samp_factor;

    y_wipe_blocks = y_crop_offset * compptr->v_samp_factor;

    wipe_bottom = drop_height * compptr->v_samp_factor + y_wipe_blocks;

    for (; y_wipe_blocks < wipe_bottom;

         y_wipe_blocks += compptr->v_samp_factor) {

      buffer = (*srcinfo->mem->access_virt_barray)

        ((j_common_ptr)srcinfo, src_coef_arrays[ci], y_wipe_blocks,

         (JDIMENSION)compptr->v_samp_factor, TRUE);

      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {

        memset(buffer[offset_y] + x_wipe_blocks, 0,

               wipe_width * sizeof(JBLOCK));

      }

    }

  }

}

LOCAL(void)

do_flatten(j_decompress_ptr srcinfo, j_compress_ptr dstinfo,

           JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,

           jvirt_barray_ptr *src_coef_arrays,

           JDIMENSION drop_width, JDIMENSION drop_height)

/* Flatten - discard image contents of specified region, similarly to wipe,

 * but fill with the average of adjacent blocks instead of zero.

 */

{

  JDIMENSION x_wipe_blocks, wipe_width, wipe_right;

  JDIMENSION y_wipe_blocks, wipe_bottom, blk_x;

  int ci, offset_y, dc_left_value, dc_right_value, average;

  JBLOCKARRAY buffer;

  jpeg_component_info *compptr;

  for (ci = 0; ci < dstinfo->num_components; ci++) {

    compptr = dstinfo->comp_info + ci;

    x_wipe_blocks = x_crop_offset * compptr->h_samp_factor;

    wipe_width = drop_width * compptr->h_samp_factor;

    wipe_right = wipe_width + x_wipe_blocks;

    y_wipe_blocks = y_crop_offset * compptr->v_samp_factor;

    wipe_bottom = drop_height * compptr->v_samp_factor + y_wipe_blocks;

    for (; y_wipe_blocks < wipe_bottom;

         y_wipe_blocks += compptr->v_samp_factor) {

      buffer = (*srcinfo->mem->access_virt_barray)

        ((j_common_ptr)srcinfo, src_coef_arrays[ci], y_wipe_blocks,

         (JDIMENSION)compptr->v_samp_factor, TRUE);

      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {

        memset(buffer[offset_y] + x_wipe_blocks, 0,

               wipe_width * sizeof(JBLOCK));

        if (x_wipe_blocks > 0) {

          dc_left_value = buffer[offset_y][x_wipe_blocks - 1][0];

          if (wipe_right < compptr->width_in_blocks) {

            dc_right_value = buffer[offset_y][wipe_right][0];

            average = (dc_left_value + dc_right_value) >> 1;

          } else {

            average = dc_left_value;

          }

        } else if (wipe_right < compptr->width_in_blocks) {

          average = buffer[offset_y][wipe_right][0];

        } else continue;

        for (blk_x = x_wipe_blocks; blk_x < wipe_right; blk_x++) {

          buffer[offset_y][blk_x][0] = (JCOEF)average;

        }

      }

    }

  }

}

LOCAL(void)

do_reflect(j_decompress_ptr srcinfo, j_compress_ptr dstinfo,

           JDIMENSION x_crop_offset, jvirt_barray_ptr *src_coef_arrays,

           JDIMENSION drop_width, JDIMENSION drop_height)

/* Reflect - discard image contents of specified region, similarly to wipe,

 * but fill with repeated reflections of the outside region instead of zero.

 * NB: y_crop_offset is assumed to be zero.

 */

{

  JDIMENSION x_wipe_blocks, wipe_width;

  JDIMENSION y_wipe_blocks, wipe_bottom;

  JDIMENSION src_blk_x, dst_blk_x;

  int ci, k, offset_y;

  JBLOCKARRAY buffer;

  JBLOCKROW src_row_ptr, dst_row_ptr;

  JCOEFPTR src_ptr, dst_ptr;

  jpeg_component_info *compptr;

  for (ci = 0; ci < dstinfo->num_components; ci++) {

    compptr = dstinfo->comp_info + ci;

    x_wipe_blocks = x_crop_offset * compptr->h_samp_factor;

    wipe_width = drop_width * compptr->h_samp_factor;

    wipe_bottom = drop_height * compptr->v_samp_factor;

    for (y_wipe_blocks = 0; y_wipe_blocks < wipe_bottom;

         y_wipe_blocks += compptr->v_samp_factor) {

      buffer = (*srcinfo->mem->access_virt_barray)

        ((j_common_ptr)srcinfo, src_coef_arrays[ci], y_wipe_blocks,

         (JDIMENSION)compptr->v_samp_factor, TRUE);

      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {

        if (x_wipe_blocks > 0) {

          /* Reflect from left */

          dst_row_ptr = buffer[offset_y] + x_wipe_blocks;

          for (dst_blk_x = wipe_width; dst_blk_x > 0;) {

            src_row_ptr = dst_row_ptr;     /* (re)set axis of reflection */

            for (src_blk_x = x_wipe_blocks;

                 src_blk_x > 0 && dst_blk_x > 0; src_blk_x--, dst_blk_x--) {

              dst_ptr = *dst_row_ptr++;    /* destination goes right */

              src_ptr = *(--src_row_ptr);  /* source goes left */

              /* this unrolled loop doesn't need to know which row it's on... */

              for (k = 0; k < DCTSIZE2; k += 2) {

                *dst_ptr++ = *src_ptr++;   /* copy even column */

                *dst_ptr++ = -(*src_ptr++); /* copy odd column with sign change */

              }

            }

          }

        } else if (compptr->width_in_blocks > x_wipe_blocks + wipe_width) {

          /* Reflect from right */

          dst_row_ptr = buffer[offset_y] + x_wipe_blocks + wipe_width;

          for (dst_blk_x = wipe_width; dst_blk_x > 0;) {

            src_row_ptr = dst_row_ptr;     /* (re)set axis of reflection */

            src_blk_x = compptr->width_in_blocks - x_wipe_blocks - wipe_width;

            for (; src_blk_x > 0 && dst_blk_x > 0; src_blk_x--, dst_blk_x--) {

              dst_ptr = *(--dst_row_ptr);  /* destination goes left */

              src_ptr = *src_row_ptr++;    /* source goes right */

              /* this unrolled loop doesn't need to know which row it's on... */

              for (k = 0; k < DCTSIZE2; k += 2) {

                *dst_ptr++ = *src_ptr++;   /* copy even column */

                *dst_ptr++ = -(*src_ptr++); /* copy odd column with sign change */

              }

            }

          }

        } else {

          memset(buffer[offset_y] + x_wipe_blocks, 0,

                 wipe_width * sizeof(JBLOCK));

        }

      }

    }

  }

}

LOCAL(void)

do_flip_h_no_crop(j_decompress_ptr srcinfo, j_compress_ptr dstinfo,

                  JDIMENSION x_crop_offset, jvirt_barray_ptr *src_coef_arrays)

/* Horizontal flip; done in-place, so no separate dest array is required.

 * NB: this only works when y_crop_offset is zero.

 */

{

  JDIMENSION MCU_cols, comp_width, blk_x, blk_y, x_crop_blocks;

  int ci, k, offset_y;

  JBLOCKARRAY buffer;

  JCOEFPTR ptr1, ptr2;

  JCOEF temp1, temp2;

  jpeg_component_info *compptr;

  /* Horizontal mirroring of DCT blocks is accomplished by swapping

   * pairs of blocks in-place.  Within a DCT block, we perform horizontal

   * mirroring by changing the signs of odd-numbered columns.

   * Partial iMCUs at the right edge are left untouched.

   */

  MCU_cols = srcinfo->output_width /

             (dstinfo->max_h_samp_factor * dstinfo_min_DCT_h_scaled_size);

  for (ci = 0; ci < dstinfo->num_components; ci++) {

    compptr = dstinfo->comp_info + ci;

    comp_width = MCU_cols * compptr->h_samp_factor;

    x_crop_blocks = x_crop_offset * compptr->h_samp_factor;

    for (blk_y = 0; blk_y < compptr->height_in_blocks;

         blk_y += compptr->v_samp_factor) {

      buffer = (*srcinfo->mem->access_virt_barray)

        ((j_common_ptr)srcinfo, src_coef_arrays[ci], blk_y,

         (JDIMENSION)compptr->v_samp_factor, TRUE);

      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {

        /* Do the mirroring */

        for (blk_x = 0; blk_x * 2 < comp_width; blk_x++) {

          ptr1 = buffer[offset_y][blk_x];

          ptr2 = buffer[offset_y][comp_width - blk_x - 1];

          /* this unrolled loop doesn't need to know which row it's on... */

          for (k = 0; k < DCTSIZE2; k += 2) {

            temp1 = *ptr1;      /* swap even column */

            temp2 = *ptr2;

            *ptr1++ = temp2;

            *ptr2++ = temp1;

            temp1 = *ptr1;      /* swap odd column with sign change */

            temp2 = *ptr2;

            *ptr1++ = -temp2;

            *ptr2++ = -temp1;

          }

        }

        if (x_crop_blocks > 0) {

          /* Now left-justify the portion of the data to be kept.

           * We can't use a single jcopy_block_row() call because that routine

           * depends on memcpy(), whose behavior is unspecified for overlapping

           * source and destination areas.  Sigh.

           */

          for (blk_x = 0; blk_x < compptr->width_in_blocks; blk_x++) {

            jcopy_block_row(buffer[offset_y] + blk_x + x_crop_blocks,

                            buffer[offset_y] + blk_x, (JDIMENSION)1);

          }

        }

      }

    }

  }

}

LOCAL(void)

do_flip_h(j_decompress_ptr srcinfo, j_compress_ptr dstinfo,

          JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,

          jvirt_barray_ptr *src_coef_arrays,

          jvirt_barray_ptr *dst_coef_arrays)

/* Horizontal flip in general cropping case */

{

  JDIMENSION MCU_cols, comp_width, dst_blk_x, dst_blk_y;

  JDIMENSION x_crop_blocks, y_crop_blocks;

  int ci, k, offset_y;

  JBLOCKARRAY src_buffer, dst_buffer;

  JBLOCKROW src_row_ptr, dst_row_ptr;

  JCOEFPTR src_ptr, dst_ptr;

  jpeg_component_info *compptr;

  /* Here we must output into a separate array because we can't touch

   * different rows of a single virtual array simultaneously.  Otherwise,

   * this is essentially the same as the routine above.

   */

  MCU_cols = srcinfo->output_width /

             (dstinfo->max_h_samp_factor * dstinfo_min_DCT_h_scaled_size);

  for (ci = 0; ci < dstinfo->num_components; ci++) {

    compptr = dstinfo->comp_info + ci;

    comp_width = MCU_cols * compptr->h_samp_factor;

    x_crop_blocks = x_crop_offset * compptr->h_samp_factor;

    y_crop_blocks = y_crop_offset * compptr->v_samp_factor;

    for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;

         dst_blk_y += compptr->v_samp_factor) {

      dst_buffer = (*srcinfo->mem->access_virt_barray)

        ((j_common_ptr)srcinfo, dst_coef_arrays[ci], dst_blk_y,

         (JDIMENSION)compptr->v_samp_factor, TRUE);

      src_buffer = (*srcinfo->mem->access_virt_barray)

        ((j_common_ptr)srcinfo, src_coef_arrays[ci], dst_blk_y + y_crop_blocks,

         (JDIMENSION)compptr->v_samp_factor, FALSE);

      for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {

        dst_row_ptr = dst_buffer[offset_y];

        src_row_ptr = src_buffer[offset_y];

        for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks;

             dst_blk_x++) {

          if (x_crop_blocks + dst_blk_x < comp_width) {

            /* Do the mirrorable blocks */

            dst_ptr = dst_row_ptr[dst_blk_x];

            src_ptr = src_row_ptr[comp_width - x_crop_blocks - dst_blk_x - 1];

            /* this unrolled loop doesn't need to know which row it's on... */

            for (k = 0; k < DCTSIZE2; k += 2) {

              *dst_ptr++ = *src_ptr++;    /* copy even column */

              *dst_ptr++ = -(*src_ptr++); /* copy odd column with sign

                                             change */

            }

          } else {

            /* Copy last partial block(s) verbatim */

            jcopy_block_row(src_row_ptr + dst_blk_x + x_crop_blocks,

                            dst_row_ptr + dst_blk_x, (JDIMENSION)1);

          }

        }

      }

    }

  }

}

LOCAL(void)

do_flip_v(j_decompress_ptr srcinfo, j_compress_ptr dstinfo,

          JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,

          jvirt_barray_ptr *src_coef_arrays,

          jvirt_barray_ptr *dst_coef_arrays)

/* Vertical flip */

{

  JDIMENSION MCU_rows, comp_height, dst_blk_x, dst_blk_y;

  JDIMENSION x_crop_blocks, y_crop_blocks;

  int ci, i, j, offset_y;

  JBLOCKARRAY src_buffer, dst_buffer;

  JBLOCKROW src_row_ptr, dst_row_ptr;

  JCOEFPTR src_ptr, dst_ptr;

  jpeg_component_info *compptr;

  /* We output into a separate array because we can't touch different

   * rows of the source virtual array simultaneously.  Otherwise, this