/*

 * transupp.c

 *

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

 * 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 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 <ctype.h>		/* to declare isdigit() */</ctype.h>

#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)

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_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

   * is a pretty straightforward analog of horizontal flip.

   * Within a DCT block, vertical mirroring is done by changing the signs

   * of odd-numbered rows.

   * Partial iMCUs at the bottom edge are copied verbatim.

   */

  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_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 (y_crop_blocks + dst_blk_y < comp_height) {

	/* Row is within the mirrorable area. */

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

	  ((j_common_ptr) srcinfo, src_coef_arrays[ci],

	   comp_height - y_crop_blocks - dst_blk_y -

	   (JDIMENSION) compptr->v_samp_factor,

	   (JDIMENSION) compptr->v_samp_factor, FALSE);

      } else {

	/* Bottom-edge blocks will be copied verbatim. */

	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 (y_crop_blocks + dst_blk_y < comp_height) {

	  /* Row is within the mirrorable area. */

	  dst_row_ptr = dst_buffer[offset_y];

	  src_row_ptr = src_buffer[compptr->v_samp_factor - offset_y - 1];

	  src_row_ptr += x_crop_blocks;

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

	       dst_blk_x++) {

	    dst_ptr = dst_row_ptr[dst_blk_x];

	    src_ptr = src_row_ptr[dst_blk_x];

	    for (i = 0; i < DCTSIZE; i += 2) {

	      /* copy even row */

	      for (j = 0; j < DCTSIZE; j++)

		*dst_ptr++ = *src_ptr++;

	      /* copy odd row with sign change */

	      for (j = 0; j < DCTSIZE; j++)

		*dst_ptr++ = - *src_ptr++;

	    }

	  }

	} else {

	  /* Just copy row verbatim. */

	  jcopy_block_row(src_buffer[offset_y] + x_crop_blocks,

			  dst_buffer[offset_y],

			  compptr->width_in_blocks);

	}

      }

    }

  }

}

LOCAL(void)

do_transpose (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)

/* Transpose source into destination */

{

  JDIMENSION dst_blk_x, dst_blk_y, x_crop_blocks, y_crop_blocks;

  int ci, i, j, offset_x, offset_y;

  JBLOCKARRAY src_buffer, dst_buffer;

  JCOEFPTR src_ptr, dst_ptr;

  jpeg_component_info *compptr;

  /* Transposing pixels within a block just requires transposing the

   * DCT coefficients.

   * Partial iMCUs at the edges require no special treatment; we simply

   * process all the available DCT blocks for every component.

   */

  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);

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

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

	     dst_blk_x += compptr->h_samp_factor) {

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

	    ((j_common_ptr) srcinfo, src_coef_arrays[ci],

	     dst_blk_x + x_crop_blocks,

	     (JDIMENSION) compptr->h_samp_factor, FALSE);

	  for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) {

	    dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x];

	    src_ptr = src_buffer[offset_x][dst_blk_y + offset_y + y_crop_blocks];

	    for (i = 0; i < DCTSIZE; i++)

	      for (j = 0; j < DCTSIZE; j++)

		dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];

	  }

	}

      }

    }

  }

}

LOCAL(void)

do_rot_90 (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)

/* 90 degree rotation is equivalent to

 *   1. Transposing the image;

 *   2. Horizontal mirroring.

 * These two steps are merged into a single processing routine.

 */

{

  JDIMENSION MCU_cols, comp_width, dst_blk_x, dst_blk_y;

  JDIMENSION x_crop_blocks, y_crop_blocks;

  int ci, i, j, offset_x, offset_y;

  JBLOCKARRAY src_buffer, dst_buffer;

  JCOEFPTR src_ptr, dst_ptr;

  jpeg_component_info *compptr;

  /* Because of the horizontal mirror step, we can't process partial iMCUs

   * at the (output) right edge properly.  They just get transposed and

   * not mirrored.

   */

  MCU_cols = srcinfo->output_height /

    (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);

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

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

	     dst_blk_x += compptr->h_samp_factor) {

	  if (x_crop_blocks + dst_blk_x < comp_width) {

	    /* Block is within the mirrorable area. */

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

	      ((j_common_ptr) srcinfo, src_coef_arrays[ci],

	       comp_width - x_crop_blocks - dst_blk_x -

	       (JDIMENSION) compptr->h_samp_factor,

	       (JDIMENSION) compptr->h_samp_factor, FALSE);

	  } else {

	    /* Edge blocks are transposed but not mirrored. */

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

	      ((j_common_ptr) srcinfo, src_coef_arrays[ci],

	       dst_blk_x + x_crop_blocks,

	       (JDIMENSION) compptr->h_samp_factor, FALSE);

	  }

	  for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) {

	    dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x];

	    if (x_crop_blocks + dst_blk_x < comp_width) {

	      /* Block is within the mirrorable area. */

	      src_ptr = src_buffer[compptr->h_samp_factor - offset_x - 1]

		[dst_blk_y + offset_y + y_crop_blocks];

	      for (i = 0; i < DCTSIZE; i++) {

		for (j = 0; j < DCTSIZE; j++)

		  dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];

		i++;

		for (j = 0; j < DCTSIZE; j++)

		  dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];

	      }

	    } else {

	      /* Edge blocks are transposed but not mirrored. */

	      src_ptr = src_buffer[offset_x]

		[dst_blk_y + offset_y + y_crop_blocks];

	      for (i = 0; i < DCTSIZE; i++)

		for (j = 0; j < DCTSIZE; j++)

		  dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];

	    }

	  }

	}

      }

    }

  }

}

LOCAL(void)

do_rot_270 (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)

/* 270 degree rotation is equivalent to

 *   1. Horizontal mirroring;

 *   2. Transposing the image.

 * These two steps are merged into a single processing routine.

 */

{

  JDIMENSION MCU_rows, comp_height, dst_blk_x, dst_blk_y;

  JDIMENSION x_crop_blocks, y_crop_blocks;

  int ci, i, j, offset_x, offset_y;

  JBLOCKARRAY src_buffer, dst_buffer;

  JCOEFPTR src_ptr, dst_ptr;

  jpeg_component_info *compptr;

  /* Because of the horizontal mirror step, we can't process partial iMCUs

   * at the (output) bottom edge properly.  They just get transposed and

   * not mirrored.

   */

  MCU_rows = srcinfo->output_width /

    (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_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);

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

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

	     dst_blk_x += compptr->h_samp_factor) {

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

	    ((j_common_ptr) srcinfo, src_coef_arrays[ci],

	     dst_blk_x + x_crop_blocks,

	     (JDIMENSION) compptr->h_samp_factor, FALSE);

	  for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) {

	    dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x];

	    if (y_crop_blocks + dst_blk_y < comp_height) {

	      /* Block is within the mirrorable area. */

	      src_ptr = src_buffer[offset_x]

		[comp_height - y_crop_blocks - dst_blk_y - offset_y - 1];

	      for (i = 0; i < DCTSIZE; i++) {

		for (j = 0; j < DCTSIZE; j++) {

		  dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];

		  j++;

		  dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];

		}

	      }

	    } else {

	      /* Edge blocks are transposed but not mirrored. */

	      src_ptr = src_buffer[offset_x]

		[dst_blk_y + offset_y + y_crop_blocks];

	      for (i = 0; i < DCTSIZE; i++)

		for (j = 0; j < DCTSIZE; j++)

		  dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];

	    }

	  }

	}

      }

    }

  }

}

LOCAL(void)

do_rot_180 (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)

/* 180 degree rotation is equivalent to

 *   1. Vertical mirroring;

 *   2. Horizontal mirroring.

 * These two steps are merged into a single processing routine.

 */

{

  JDIMENSION MCU_cols, MCU_rows, comp_width, 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;

  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 (y_crop_blocks + dst_blk_y < comp_height) {

	/* Row is within the vertically mirrorable area. */

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

	  ((j_common_ptr) srcinfo, src_coef_arrays[ci],

	   comp_height - y_crop_blocks - dst_blk_y -

	   (JDIMENSION) compptr->v_samp_factor,

	   (JDIMENSION) compptr->v_samp_factor, FALSE);

      } else {

	/* Bottom-edge rows are only mirrored horizontally. */

	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];

	if (y_crop_blocks + dst_blk_y < comp_height) {

	  /* Row is within the mirrorable area. */

	  src_row_ptr = src_buffer[compptr->v_samp_factor - offset_y - 1];

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

	    dst_ptr = dst_row_ptr[dst_blk_x];

	    if (x_crop_blocks + dst_blk_x < comp_width) {

	      /* Process the blocks that can be mirrored both ways. */

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

	      for (i = 0; i < DCTSIZE; i += 2) {

		/* For even row, negate every odd column. */

		for (j = 0; j < DCTSIZE; j += 2) {

		  *dst_ptr++ = *src_ptr++;

		  *dst_ptr++ = - *src_ptr++;

		}

		/* For odd row, negate every even column. */

		for (j = 0; j < DCTSIZE; j += 2) {

		  *dst_ptr++ = - *src_ptr++;

		  *dst_ptr++ = *src_ptr++;

		}

	      }

	    } else {

	      /* Any remaining right-edge blocks are only mirrored vertically. */

	      src_ptr = src_row_ptr[x_crop_blocks + dst_blk_x];

	      for (i = 0; i < DCTSIZE; i += 2) {

		for (j = 0; j < DCTSIZE; j++)

		  *dst_ptr++ = *src_ptr++;

		for (j = 0; j < DCTSIZE; j++)

		  *dst_ptr++ = - *src_ptr++;

	      }

	    }

	  }

	} else {

	  /* Remaining rows are just mirrored horizontally. */

	  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) {

	      /* Process the blocks that can be mirrored. */

	      dst_ptr = dst_row_ptr[dst_blk_x];

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

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

		*dst_ptr++ = *src_ptr++;

		*dst_ptr++ = - *src_ptr++;

	      }

	    } else {

	      /* Any remaining right-edge blocks are only copied. */

	      jcopy_block_row(src_row_ptr + dst_blk_x + x_crop_blocks,

			      dst_row_ptr + dst_blk_x,

			      (JDIMENSION) 1);

	    }

	  }

	}

      }

    }

  }

}

LOCAL(void)

do_transverse (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)

/* Transverse transpose is equivalent to

 *   1. 180 degree rotation;

 *   2. Transposition;

 * or

 *   1. Horizontal mirroring;

 *   2. Transposition;

 *   3. Horizontal mirroring.

 * These steps are merged into a single processing routine.

 */

{

  JDIMENSION MCU_cols, MCU_rows, comp_width, comp_height, dst_blk_x, dst_blk_y;

  JDIMENSION x_crop_blocks, y_crop_blocks;

  int ci, i, j, offset_x, offset_y;

  JBLOCKARRAY src_buffer, dst_buffer;

  JCOEFPTR src_ptr, dst_ptr;

  jpeg_component_info *compptr;

  MCU_cols = srcinfo->output_height /

    (dstinfo->max_h_samp_factor * dstinfo->min_DCT_h_scaled_size);

  MCU_rows = srcinfo->output_width /

    (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);

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

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

	     dst_blk_x += compptr->h_samp_factor) {

	  if (x_crop_blocks + dst_blk_x < comp_width) {

	    /* Block is within the mirrorable area. */

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

	      ((j_common_ptr) srcinfo, src_coef_arrays[ci],

	       comp_width - x_crop_blocks - dst_blk_x -

	       (JDIMENSION) compptr->h_samp_factor,

	       (JDIMENSION) compptr->h_samp_factor, FALSE);

	  } else {

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

	      ((j_common_ptr) srcinfo, src_coef_arrays[ci],

	       dst_blk_x + x_crop_blocks,

	       (JDIMENSION) compptr->h_samp_factor, FALSE);

	  }

	  for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) {

	    dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x];

	    if (y_crop_blocks + dst_blk_y < comp_height) {

	      if (x_crop_blocks + dst_blk_x < comp_width) {

		/* Block is within the mirrorable area. */

		src_ptr = src_buffer[compptr->h_samp_factor - offset_x - 1]

		  [comp_height - y_crop_blocks - dst_blk_y - offset_y - 1];

		for (i = 0; i < DCTSIZE; i++) {

		  for (j = 0; j < DCTSIZE; j++) {

		    dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];

		    j++;

		    dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];

		  }

		  i++;

		  for (j = 0; j < DCTSIZE; j++) {

		    dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];

		    j++;

		    dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];

		  }

		}

	      } else {

		/* Right-edge blocks are mirrored in y only */

		src_ptr = src_buffer[offset_x]

		  [comp_height - y_crop_blocks - dst_blk_y - offset_y - 1];

		for (i = 0; i < DCTSIZE; i++) {

		  for (j = 0; j < DCTSIZE; j++) {

		    dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];

		    j++;

		    dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];

		  }

		}

	      }

	    } else {

	      if (x_crop_blocks + dst_blk_x < comp_width) {

		/* Bottom-edge blocks are mirrored in x only */

		src_ptr = src_buffer[compptr->h_samp_factor - offset_x - 1]

		  [dst_blk_y + offset_y + y_crop_blocks];

		for (i = 0; i < DCTSIZE; i++) {

		  for (j = 0; j < DCTSIZE; j++)

		    dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];

		  i++;

		  for (j = 0; j < DCTSIZE; j++)

		    dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];

		}

	      } else {

		/* At lower right corner, just transpose, no mirroring */

		src_ptr = src_buffer[offset_x]

		  [dst_blk_y + offset_y + y_crop_blocks];

		for (i = 0; i < DCTSIZE; i++)

		  for (j = 0; j < DCTSIZE; j++)

		    dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];

	      }

	    }

	  }

	}

      }

    }

  }

}

/* Parse an unsigned integer: subroutine for jtransform_parse_crop_spec.

 * Returns TRUE if valid integer found, FALSE if not.

 * *strptr is advanced over the digit string, and *result is set to its value.

 */

LOCAL(boolean)

jt_read_integer (const char ** strptr, JDIMENSION * result)

{

  const char * ptr = *strptr;

  JDIMENSION val = 0;

  for (; isdigit(*ptr); ptr++) {

    val = val * 10 + (JDIMENSION) (*ptr - '0');

  }

  *result = val;

  if (ptr == *strptr)

    return FALSE;		/* oops, no digits */

  *strptr = ptr;

  return TRUE;

}

/* Parse a crop specification (written in X11 geometry style).

 * The routine returns TRUE if the spec string is valid, FALSE if not.

 *

 * The crop spec string should have the format

 *	<width>[f]x<height>[f]{+-}<xoffset>{+-}<yoffset></yoffset></xoffset></height></width>

 * where width, height, xoffset, and yoffset are unsigned integers.

 * Each of the elements can be omitted to indicate a default value.

 * (A weakness of this style is that it is not possible to omit xoffset

 * while specifying yoffset, since they look alike.)

 *

 * This code is loosely based on XParseGeometry from the X11 distribution.

 */

GLOBAL(boolean)

jtransform_parse_crop_spec (jpeg_transform_info *info, const char *spec)

{

  info->crop = FALSE;

  info->crop_width_set = JCROP_UNSET;

  info->crop_height_set = JCROP_UNSET;

  info->crop_xoffset_set = JCROP_UNSET;

  info->crop_yoffset_set = JCROP_UNSET;

  if (isdigit(*spec)) {

    /* fetch width */

    if (! jt_read_integer(&spec, &info->crop_width))

      return FALSE;

    if (*spec == 'f' || *spec == 'F') {

      spec++;

      info->crop_width_set = JCROP_FORCE;

    } else

      info->crop_width_set = JCROP_POS;

  }

  if (*spec == 'x' || *spec == 'X') {

    /* fetch height */

    spec++;

    if (! jt_read_integer(&spec, &info->crop_height))

      return FALSE;

    if (*spec == 'f' || *spec == 'F') {

      spec++;

      info->crop_height_set = JCROP_FORCE;

    } else

      info->crop_height_set = JCROP_POS;

  }

  if (*spec == '+' || *spec == '-') {

    /* fetch xoffset */

    info->crop_xoffset_set = (*spec == '-') ? JCROP_NEG : JCROP_POS;

    spec++;

    if (! jt_read_integer(&spec, &info->crop_xoffset))

      return FALSE;

  }

  if (*spec == '+' || *spec == '-') {

    /* fetch yoffset */

    info->crop_yoffset_set = (*spec == '-') ? JCROP_NEG : JCROP_POS;

    spec++;

    if (! jt_read_integer(&spec, &info->crop_yoffset))

      return FALSE;

  }

  /* We had better have gotten to the end of the string. */

  if (*spec != '\0')

    return FALSE;

  info->crop = TRUE;

  return TRUE;

}

/* Trim off any partial iMCUs on the indicated destination edge */

LOCAL(void)

trim_right_edge (jpeg_transform_info *info, JDIMENSION full_width)

{

  JDIMENSION MCU_cols;

  MCU_cols = info->output_width / info->iMCU_sample_width;

  if (MCU_cols > 0 && info->x_crop_offset + MCU_cols ==

      full_width / info->iMCU_sample_width)

    info->output_width = MCU_cols * info->iMCU_sample_width;

}

LOCAL(void)

trim_bottom_edge (jpeg_transform_info *info, JDIMENSION full_height)

{

  JDIMENSION MCU_rows;

  MCU_rows = info->output_height / info->iMCU_sample_height;

  if (MCU_rows > 0 && info->y_crop_offset + MCU_rows ==

      full_height / info->iMCU_sample_height)

    info->output_height = MCU_rows * info->iMCU_sample_height;

}

/* Request any required workspace.

 *

 * This routine figures out the size that the output image will be

 * (which implies that all the transform parameters must be set before

 * it is called).

 *

 * We allocate the workspace virtual arrays from the source decompression

 * object, so that all the arrays (both the original data and the workspace)

 * will be taken into account while making memory management decisions.

 * Hence, this routine must be called after jpeg_read_header (which reads

 * the image dimensions) and before jpeg_read_coefficients (which realizes

 * the source's virtual arrays).

 *

 * This function returns FALSE right away if -perfect is given

 * and transformation is not perfect.  Otherwise returns TRUE.

 */

GLOBAL(boolean)

jtransform_request_workspace (j_decompress_ptr srcinfo,