开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图象 > 查看源码
transupp.c
资源名称：jpegsr6b.zip　[点击查看]
上传用户：wuyixingx
上传日期：2007-01-08
资源大小：745k
文件大小：33k
源码类别：

图形图象

开发平台：

C/C++

transupp.c：源码内容
  1. /*
  2.  * transupp.c
  3.  *
  4.  * Copyright (C) 1997, 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 image transformation routines and other utility code
  9.  * used by the jpegtran sample application.  These are NOT part of the core
  10.  * JPEG library.  But we keep these routines separate from jpegtran.c to
  11.  * ease the task of maintaining jpegtran-like programs that have other user
  12.  * interfaces.
  13.  */
  15. /* Although this file really shouldn't have access to the library internals,
  16.  * it's helpful to let it call jround_up() and jcopy_block_row().
  17.  */
  18. #define JPEG_INTERNALS
  20. #include "jinclude.h"
  21. #include "jpeglib.h"
  22. #include "transupp.h" /* My own external interface */
  25. #if TRANSFORMS_SUPPORTED
  27. /*
  28.  * Lossless image transformation routines.  These routines work on DCT
  29.  * coefficient arrays and thus do not require any lossy decompression
  30.  * or recompression of the image.
  31.  * Thanks to Guido Vollbeding for the initial design and code of this feature.
  32.  *
  33.  * Horizontal flipping is done in-place, using a single top-to-bottom
  34.  * pass through the virtual source array.  It will thus be much the
  35.  * fastest option for images larger than main memory.
  36.  *
  37.  * The other routines require a set of destination virtual arrays, so they
  38.  * need twice as much memory as jpegtran normally does.  The destination
  39.  * arrays are always written in normal scan order (top to bottom) because
  40.  * the virtual array manager expects this.  The source arrays will be scanned
  41.  * in the corresponding order, which means multiple passes through the source
  42.  * arrays for most of the transforms.  That could result in much thrashing
  43.  * if the image is larger than main memory.
  44.  *
  45.  * Some notes about the operating environment of the individual transform
  46.  * routines:
  47.  * 1. Both the source and destination virtual arrays are allocated from the
  48.  *    source JPEG object, and therefore should be manipulated by calling the
  49.  *    source's memory manager.
  50.  * 2. The destination's component count should be used.  It may be smaller
  51.  *    than the source's when forcing to grayscale.
  52.  * 3. Likewise the destination's sampling factors should be used.  When
  53.  *    forcing to grayscale the destination's sampling factors will be all 1,
  54.  *    and we may as well take that as the effective iMCU size.
  55.  * 4. When "trim" is in effect, the destination's dimensions will be the
  56.  *    trimmed values but the source's will be untrimmed.
  57.  * 5. All the routines assume that the source and destination buffers are
  58.  *    padded out to a full iMCU boundary.  This is true, although for the
  59.  *    source buffer it is an undocumented property of jdcoefct.c.
  60.  * Notes 2,3,4 boil down to this: generally we should use the destination's
  61.  * dimensions and ignore the source's.
  62.  */
  65. LOCAL(void)
  66. do_flip_h (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
  67.    jvirt_barray_ptr *src_coef_arrays)
  68. /* Horizontal flip; done in-place, so no separate dest array is required */
  69. {
  70.   JDIMENSION MCU_cols, comp_width, blk_x, blk_y;
  71.   int ci, k, offset_y;
  72.   JBLOCKARRAY buffer;
  73.   JCOEFPTR ptr1, ptr2;
  74.   JCOEF temp1, temp2;
  75.   jpeg_component_info *compptr;
  77.   /* Horizontal mirroring of DCT blocks is accomplished by swapping
  78.    * pairs of blocks in-place.  Within a DCT block, we perform horizontal
  79.    * mirroring by changing the signs of odd-numbered columns.
  80.    * Partial iMCUs at the right edge are left untouched.
  81.    */
  82.   MCU_cols = dstinfo->image_width / (dstinfo->max_h_samp_factor * DCTSIZE);
  84.   for (ci = 0; ci < dstinfo->num_components; ci++) {
  85.     compptr = dstinfo->comp_info + ci;
  86.     comp_width = MCU_cols * compptr->h_samp_factor;
  87.     for (blk_y = 0; blk_y < compptr->height_in_blocks;
  88.  blk_y += compptr->v_samp_factor) {
  89.       buffer = (*srcinfo->mem->access_virt_barray)
  90. ((j_common_ptr) srcinfo, src_coef_arrays[ci], blk_y,
  91.  (JDIMENSION) compptr->v_samp_factor, TRUE);
  92.       for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
  93. for (blk_x = 0; blk_x * 2 < comp_width; blk_x++) {
  94.   ptr1 = buffer[offset_y][blk_x];
  95.   ptr2 = buffer[offset_y][comp_width - blk_x - 1];
  96.   /* this unrolled loop doesn't need to know which row it's on... */
  97.   for (k = 0; k < DCTSIZE2; k += 2) {
  98.     temp1 = *ptr1; /* swap even column */
  99.     temp2 = *ptr2;
  100.     *ptr1++ = temp2;
  101.     *ptr2++ = temp1;
  102.     temp1 = *ptr1; /* swap odd column with sign change */
  103.     temp2 = *ptr2;
  104.     *ptr1++ = -temp2;
  105.     *ptr2++ = -temp1;
  106.   }
  107. }
  108.       }
  109.     }
  110.   }
  111. }
  114. LOCAL(void)
  115. do_flip_v (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
  116.    jvirt_barray_ptr *src_coef_arrays,
  117.    jvirt_barray_ptr *dst_coef_arrays)
  118. /* Vertical flip */
  119. {
  120.   JDIMENSION MCU_rows, comp_height, dst_blk_x, dst_blk_y;
  121.   int ci, i, j, offset_y;
  122.   JBLOCKARRAY src_buffer, dst_buffer;
  123.   JBLOCKROW src_row_ptr, dst_row_ptr;
  124.   JCOEFPTR src_ptr, dst_ptr;
  125.   jpeg_component_info *compptr;
  127.   /* We output into a separate array because we can't touch different
  128.    * rows of the source virtual array simultaneously.  Otherwise, this
  129.    * is a pretty straightforward analog of horizontal flip.
  130.    * Within a DCT block, vertical mirroring is done by changing the signs
  131.    * of odd-numbered rows.
  132.    * Partial iMCUs at the bottom edge are copied verbatim.
  133.    */
  134.   MCU_rows = dstinfo->image_height / (dstinfo->max_v_samp_factor * DCTSIZE);
  136.   for (ci = 0; ci < dstinfo->num_components; ci++) {
  137.     compptr = dstinfo->comp_info + ci;
  138.     comp_height = MCU_rows * compptr->v_samp_factor;
  139.     for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
  140.  dst_blk_y += compptr->v_samp_factor) {
  141.       dst_buffer = (*srcinfo->mem->access_virt_barray)
  142. ((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
  143.  (JDIMENSION) compptr->v_samp_factor, TRUE);
  144.       if (dst_blk_y < comp_height) {
  145. /* Row is within the mirrorable area. */
  146. src_buffer = (*srcinfo->mem->access_virt_barray)
  147.   ((j_common_ptr) srcinfo, src_coef_arrays[ci],
  148.    comp_height - dst_blk_y - (JDIMENSION) compptr->v_samp_factor,
  149.    (JDIMENSION) compptr->v_samp_factor, FALSE);
  150.       } else {
  151. /* Bottom-edge blocks will be copied verbatim. */
  152. src_buffer = (*srcinfo->mem->access_virt_barray)
  153.   ((j_common_ptr) srcinfo, src_coef_arrays[ci], dst_blk_y,
  154.    (JDIMENSION) compptr->v_samp_factor, FALSE);
  155.       }
  156.       for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
  157. if (dst_blk_y < comp_height) {
  158.   /* Row is within the mirrorable area. */
  159.   dst_row_ptr = dst_buffer[offset_y];
  160.   src_row_ptr = src_buffer[compptr->v_samp_factor - offset_y - 1];
  161.   for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks;
  162.        dst_blk_x++) {
  163.     dst_ptr = dst_row_ptr[dst_blk_x];
  164.     src_ptr = src_row_ptr[dst_blk_x];
  165.     for (i = 0; i < DCTSIZE; i += 2) {
  166.       /* copy even row */
  167.       for (j = 0; j < DCTSIZE; j++)
  168. *dst_ptr++ = *src_ptr++;
  169.       /* copy odd row with sign change */
  170.       for (j = 0; j < DCTSIZE; j++)
  171. *dst_ptr++ = - *src_ptr++;
  172.     }
  173.   }
  174. } else {
  175.   /* Just copy row verbatim. */
  176.   jcopy_block_row(src_buffer[offset_y], dst_buffer[offset_y],
  177.   compptr->width_in_blocks);
  178. }
  179.       }
  180.     }
  181.   }
  182. }
  185. LOCAL(void)
  186. do_transpose (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
  187.       jvirt_barray_ptr *src_coef_arrays,
  188.       jvirt_barray_ptr *dst_coef_arrays)
  189. /* Transpose source into destination */
  190. {
  191.   JDIMENSION dst_blk_x, dst_blk_y;
  192.   int ci, i, j, offset_x, offset_y;
  193.   JBLOCKARRAY src_buffer, dst_buffer;
  194.   JCOEFPTR src_ptr, dst_ptr;
  195.   jpeg_component_info *compptr;
  197.   /* Transposing pixels within a block just requires transposing the
  198.    * DCT coefficients.
  199.    * Partial iMCUs at the edges require no special treatment; we simply
  200.    * process all the available DCT blocks for every component.
  201.    */
  202.   for (ci = 0; ci < dstinfo->num_components; ci++) {
  203.     compptr = dstinfo->comp_info + ci;
  204.     for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
  205.  dst_blk_y += compptr->v_samp_factor) {
  206.       dst_buffer = (*srcinfo->mem->access_virt_barray)
  207. ((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
  208.  (JDIMENSION) compptr->v_samp_factor, TRUE);
  209.       for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
  210. for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks;
  211.      dst_blk_x += compptr->h_samp_factor) {
  212.   src_buffer = (*srcinfo->mem->access_virt_barray)
  213.     ((j_common_ptr) srcinfo, src_coef_arrays[ci], dst_blk_x,
  214.      (JDIMENSION) compptr->h_samp_factor, FALSE);
  215.   for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) {
  216.     src_ptr = src_buffer[offset_x][dst_blk_y + offset_y];
  217.     dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x];
  218.     for (i = 0; i < DCTSIZE; i++)
  219.       for (j = 0; j < DCTSIZE; j++)
  220. dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
  221.   }
  222. }
  223.       }
  224.     }
  225.   }
  226. }
  229. LOCAL(void)
  230. do_rot_90 (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
  231.    jvirt_barray_ptr *src_coef_arrays,
  232.    jvirt_barray_ptr *dst_coef_arrays)
  233. /* 90 degree rotation is equivalent to
  234.  *   1. Transposing the image;
  235.  *   2. Horizontal mirroring.
  236.  * These two steps are merged into a single processing routine.
  237.  */
  238. {
  239.   JDIMENSION MCU_cols, comp_width, dst_blk_x, dst_blk_y;
  240.   int ci, i, j, offset_x, offset_y;
  241.   JBLOCKARRAY src_buffer, dst_buffer;
  242.   JCOEFPTR src_ptr, dst_ptr;
  243.   jpeg_component_info *compptr;
  245.   /* Because of the horizontal mirror step, we can't process partial iMCUs
  246.    * at the (output) right edge properly.  They just get transposed and
  247.    * not mirrored.
  248.    */
  249.   MCU_cols = dstinfo->image_width / (dstinfo->max_h_samp_factor * DCTSIZE);
  251.   for (ci = 0; ci < dstinfo->num_components; ci++) {
  252.     compptr = dstinfo->comp_info + ci;
  253.     comp_width = MCU_cols * compptr->h_samp_factor;
  254.     for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
  255.  dst_blk_y += compptr->v_samp_factor) {
  256.       dst_buffer = (*srcinfo->mem->access_virt_barray)
  257. ((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
  258.  (JDIMENSION) compptr->v_samp_factor, TRUE);
  259.       for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
  260. for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks;
  261.      dst_blk_x += compptr->h_samp_factor) {
  262.   src_buffer = (*srcinfo->mem->access_virt_barray)
  263.     ((j_common_ptr) srcinfo, src_coef_arrays[ci], dst_blk_x,
  264.      (JDIMENSION) compptr->h_samp_factor, FALSE);
  265.   for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) {
  266.     src_ptr = src_buffer[offset_x][dst_blk_y + offset_y];
  267.     if (dst_blk_x < comp_width) {
  268.       /* Block is within the mirrorable area. */
  269.       dst_ptr = dst_buffer[offset_y]
  270. [comp_width - dst_blk_x - offset_x - 1];
  271.       for (i = 0; i < DCTSIZE; i++) {
  272. for (j = 0; j < DCTSIZE; j++)
  273.   dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
  274. i++;
  275. for (j = 0; j < DCTSIZE; j++)
  276.   dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
  277.       }
  278.     } else {
  279.       /* Edge blocks are transposed but not mirrored. */
  280.       dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x];
  281.       for (i = 0; i < DCTSIZE; i++)
  282. for (j = 0; j < DCTSIZE; j++)
  283.   dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
  284.     }
  285.   }
  286. }
  287.       }
  288.     }
  289.   }
  290. }
  293. LOCAL(void)
  294. do_rot_270 (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
  295.     jvirt_barray_ptr *src_coef_arrays,
  296.     jvirt_barray_ptr *dst_coef_arrays)
  297. /* 270 degree rotation is equivalent to
  298.  *   1. Horizontal mirroring;
  299.  *   2. Transposing the image.
  300.  * These two steps are merged into a single processing routine.
  301.  */
  302. {
  303.   JDIMENSION MCU_rows, comp_height, dst_blk_x, dst_blk_y;
  304.   int ci, i, j, offset_x, offset_y;
  305.   JBLOCKARRAY src_buffer, dst_buffer;
  306.   JCOEFPTR src_ptr, dst_ptr;
  307.   jpeg_component_info *compptr;
  309.   /* Because of the horizontal mirror step, we can't process partial iMCUs
  310.    * at the (output) bottom edge properly.  They just get transposed and
  311.    * not mirrored.
  312.    */
  313.   MCU_rows = dstinfo->image_height / (dstinfo->max_v_samp_factor * DCTSIZE);
  315.   for (ci = 0; ci < dstinfo->num_components; ci++) {
  316.     compptr = dstinfo->comp_info + ci;
  317.     comp_height = MCU_rows * compptr->v_samp_factor;
  318.     for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
  319.  dst_blk_y += compptr->v_samp_factor) {
  320.       dst_buffer = (*srcinfo->mem->access_virt_barray)
  321. ((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
  322.  (JDIMENSION) compptr->v_samp_factor, TRUE);
  323.       for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
  324. for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks;
  325.      dst_blk_x += compptr->h_samp_factor) {
  326.   src_buffer = (*srcinfo->mem->access_virt_barray)
  327.     ((j_common_ptr) srcinfo, src_coef_arrays[ci], dst_blk_x,
  328.      (JDIMENSION) compptr->h_samp_factor, FALSE);
  329.   for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) {
  330.     dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x];
  331.     if (dst_blk_y < comp_height) {
  332.       /* Block is within the mirrorable area. */
  333.       src_ptr = src_buffer[offset_x]
  334. [comp_height - dst_blk_y - offset_y - 1];
  335.       for (i = 0; i < DCTSIZE; i++) {
  336. for (j = 0; j < DCTSIZE; j++) {
  337.   dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
  338.   j++;
  339.   dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
  340. }
  341.       }
  342.     } else {
  343.       /* Edge blocks are transposed but not mirrored. */
  344.       src_ptr = src_buffer[offset_x][dst_blk_y + offset_y];
  345.       for (i = 0; i < DCTSIZE; i++)
  346. for (j = 0; j < DCTSIZE; j++)
  347.   dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
  348.     }
  349.   }
  350. }
  351.       }
  352.     }
  353.   }
  354. }
  357. LOCAL(void)
  358. do_rot_180 (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
  359.     jvirt_barray_ptr *src_coef_arrays,
  360.     jvirt_barray_ptr *dst_coef_arrays)
  361. /* 180 degree rotation is equivalent to
  362.  *   1. Vertical mirroring;
  363.  *   2. Horizontal mirroring.
  364.  * These two steps are merged into a single processing routine.
  365.  */
  366. {
  367.   JDIMENSION MCU_cols, MCU_rows, comp_width, comp_height, dst_blk_x, dst_blk_y;
  368.   int ci, i, j, offset_y;
  369.   JBLOCKARRAY src_buffer, dst_buffer;
  370.   JBLOCKROW src_row_ptr, dst_row_ptr;
  371.   JCOEFPTR src_ptr, dst_ptr;
  372.   jpeg_component_info *compptr;
  374.   MCU_cols = dstinfo->image_width / (dstinfo->max_h_samp_factor * DCTSIZE);
  375.   MCU_rows = dstinfo->image_height / (dstinfo->max_v_samp_factor * DCTSIZE);
  377.   for (ci = 0; ci < dstinfo->num_components; ci++) {
  378.     compptr = dstinfo->comp_info + ci;
  379.     comp_width = MCU_cols * compptr->h_samp_factor;
  380.     comp_height = MCU_rows * compptr->v_samp_factor;
  381.     for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
  382.  dst_blk_y += compptr->v_samp_factor) {
  383.       dst_buffer = (*srcinfo->mem->access_virt_barray)
  384. ((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
  385.  (JDIMENSION) compptr->v_samp_factor, TRUE);
  386.       if (dst_blk_y < comp_height) {
  387. /* Row is within the vertically mirrorable area. */
  388. src_buffer = (*srcinfo->mem->access_virt_barray)
  389.   ((j_common_ptr) srcinfo, src_coef_arrays[ci],
  390.    comp_height - dst_blk_y - (JDIMENSION) compptr->v_samp_factor,
  391.    (JDIMENSION) compptr->v_samp_factor, FALSE);
  392.       } else {
  393. /* Bottom-edge rows are only mirrored horizontally. */
  394. src_buffer = (*srcinfo->mem->access_virt_barray)
  395.   ((j_common_ptr) srcinfo, src_coef_arrays[ci], dst_blk_y,
  396.    (JDIMENSION) compptr->v_samp_factor, FALSE);
  397.       }
  398.       for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
  399. if (dst_blk_y < comp_height) {
  400.   /* Row is within the mirrorable area. */
  401.   dst_row_ptr = dst_buffer[offset_y];
  402.   src_row_ptr = src_buffer[compptr->v_samp_factor - offset_y - 1];
  403.   /* Process the blocks that can be mirrored both ways. */
  404.   for (dst_blk_x = 0; dst_blk_x < comp_width; dst_blk_x++) {
  405.     dst_ptr = dst_row_ptr[dst_blk_x];
  406.     src_ptr = src_row_ptr[comp_width - dst_blk_x - 1];
  407.     for (i = 0; i < DCTSIZE; i += 2) {
  408.       /* For even row, negate every odd column. */
  409.       for (j = 0; j < DCTSIZE; j += 2) {
  410. *dst_ptr++ = *src_ptr++;
  411. *dst_ptr++ = - *src_ptr++;
  412.       }
  413.       /* For odd row, negate every even column. */
  414.       for (j = 0; j < DCTSIZE; j += 2) {
  415. *dst_ptr++ = - *src_ptr++;
  416. *dst_ptr++ = *src_ptr++;
  417.       }
  418.     }
  419.   }
  420.   /* Any remaining right-edge blocks are only mirrored vertically. */
  421.   for (; dst_blk_x < compptr->width_in_blocks; dst_blk_x++) {
  422.     dst_ptr = dst_row_ptr[dst_blk_x];
  423.     src_ptr = src_row_ptr[dst_blk_x];
  424.     for (i = 0; i < DCTSIZE; i += 2) {
  425.       for (j = 0; j < DCTSIZE; j++)
  426. *dst_ptr++ = *src_ptr++;
  427.       for (j = 0; j < DCTSIZE; j++)
  428. *dst_ptr++ = - *src_ptr++;
  429.     }
  430.   }
  431. } else {
  432.   /* Remaining rows are just mirrored horizontally. */
  433.   dst_row_ptr = dst_buffer[offset_y];
  434.   src_row_ptr = src_buffer[offset_y];
  435.   /* Process the blocks that can be mirrored. */
  436.   for (dst_blk_x = 0; dst_blk_x < comp_width; dst_blk_x++) {
  437.     dst_ptr = dst_row_ptr[dst_blk_x];
  438.     src_ptr = src_row_ptr[comp_width - dst_blk_x - 1];
  439.     for (i = 0; i < DCTSIZE2; i += 2) {
  440.       *dst_ptr++ = *src_ptr++;
  441.       *dst_ptr++ = - *src_ptr++;
  442.     }
  443.   }
  444.   /* Any remaining right-edge blocks are only copied. */
  445.   for (; dst_blk_x < compptr->width_in_blocks; dst_blk_x++) {
  446.     dst_ptr = dst_row_ptr[dst_blk_x];
  447.     src_ptr = src_row_ptr[dst_blk_x];
  448.     for (i = 0; i < DCTSIZE2; i++)
  449.       *dst_ptr++ = *src_ptr++;
  450.   }
  451. }
  452.       }
  453.     }
  454.   }
  455. }
  458. LOCAL(void)
  459. do_transverse (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
  460.        jvirt_barray_ptr *src_coef_arrays,
  461.        jvirt_barray_ptr *dst_coef_arrays)
  462. /* Transverse transpose is equivalent to
  463.  *   1. 180 degree rotation;
  464.  *   2. Transposition;
  465.  * or
  466.  *   1. Horizontal mirroring;
  467.  *   2. Transposition;
  468.  *   3. Horizontal mirroring.
  469.  * These steps are merged into a single processing routine.
  470.  */
  471. {
  472.   JDIMENSION MCU_cols, MCU_rows, comp_width, comp_height, dst_blk_x, dst_blk_y;
  473.   int ci, i, j, offset_x, offset_y;
  474.   JBLOCKARRAY src_buffer, dst_buffer;
  475.   JCOEFPTR src_ptr, dst_ptr;
  476.   jpeg_component_info *compptr;
  478.   MCU_cols = dstinfo->image_width / (dstinfo->max_h_samp_factor * DCTSIZE);
  479.   MCU_rows = dstinfo->image_height / (dstinfo->max_v_samp_factor * DCTSIZE);
  481.   for (ci = 0; ci < dstinfo->num_components; ci++) {
  482.     compptr = dstinfo->comp_info + ci;
  483.     comp_width = MCU_cols * compptr->h_samp_factor;
  484.     comp_height = MCU_rows * compptr->v_samp_factor;
  485.     for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
  486.  dst_blk_y += compptr->v_samp_factor) {
  487.       dst_buffer = (*srcinfo->mem->access_virt_barray)
  488. ((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
  489.  (JDIMENSION) compptr->v_samp_factor, TRUE);
  490.       for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
  491. for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks;
  492.      dst_blk_x += compptr->h_samp_factor) {
  493.   src_buffer = (*srcinfo->mem->access_virt_barray)
  494.     ((j_common_ptr) srcinfo, src_coef_arrays[ci], dst_blk_x,
  495.      (JDIMENSION) compptr->h_samp_factor, FALSE);
  496.   for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) {
  497.     if (dst_blk_y < comp_height) {
  498.       src_ptr = src_buffer[offset_x]
  499. [comp_height - dst_blk_y - offset_y - 1];
  500.       if (dst_blk_x < comp_width) {
  501. /* Block is within the mirrorable area. */
  502. dst_ptr = dst_buffer[offset_y]
  503.   [comp_width - dst_blk_x - offset_x - 1];
  504. for (i = 0; i < DCTSIZE; i++) {
  505.   for (j = 0; j < DCTSIZE; j++) {
  506.     dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
  507.     j++;
  508.     dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
  509.   }
  510.   i++;
  511.   for (j = 0; j < DCTSIZE; j++) {
  512.     dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
  513.     j++;
  514.     dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
  515.   }
  516. }
  517.       } else {
  518. /* Right-edge blocks are mirrored in y only */
  519. dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x];
  520. for (i = 0; i < DCTSIZE; i++) {
  521.   for (j = 0; j < DCTSIZE; j++) {
  522.     dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
  523.     j++;
  524.     dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
  525.   }
  526. }
  527.       }
  528.     } else {
  529.       src_ptr = src_buffer[offset_x][dst_blk_y + offset_y];
  530.       if (dst_blk_x < comp_width) {
  531. /* Bottom-edge blocks are mirrored in x only */
  532. dst_ptr = dst_buffer[offset_y]
  533.   [comp_width - dst_blk_x - offset_x - 1];
  534. for (i = 0; i < DCTSIZE; i++) {
  535.   for (j = 0; j < DCTSIZE; j++)
  536.     dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
  537.   i++;
  538.   for (j = 0; j < DCTSIZE; j++)
  539.     dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
  540. }
  541.       } else {
  542. /* At lower right corner, just transpose, no mirroring */
  543. dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x];
  544. for (i = 0; i < DCTSIZE; i++)
  545.   for (j = 0; j < DCTSIZE; j++)
  546.     dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
  547.       }
  548.     }
  549.   }
  550. }
  551.       }
  552.     }
  553.   }
  554. }
  557. /* Request any required workspace.
  558.  *
  559.  * We allocate the workspace virtual arrays from the source decompression
  560.  * object, so that all the arrays (both the original data and the workspace)
  561.  * will be taken into account while making memory management decisions.
  562.  * Hence, this routine must be called after jpeg_read_header (which reads
  563.  * the image dimensions) and before jpeg_read_coefficients (which realizes
  564.  * the source's virtual arrays).
  565.  */
  567. GLOBAL(void)
  568. jtransform_request_workspace (j_decompress_ptr srcinfo,
  569.       jpeg_transform_info *info)
  570. {
  571.   jvirt_barray_ptr *coef_arrays = NULL;
  572.   jpeg_component_info *compptr;
  573.   int ci;
  575.   if (info->force_grayscale &&
  576.       srcinfo->jpeg_color_space == JCS_YCbCr &&
  577.       srcinfo->num_components == 3) {
  578.     /* We'll only process the first component */
  579.     info->num_components = 1;
  580.   } else {
  581.     /* Process all the components */
  582.     info->num_components = srcinfo->num_components;
  583.   }
  585.   switch (info->transform) {
  586.   case JXFORM_NONE:
  587.   case JXFORM_FLIP_H:
  588.     /* Don't need a workspace array */
  589.     break;
  590.   case JXFORM_FLIP_V:
  591.   case JXFORM_ROT_180:
  592.     /* Need workspace arrays having same dimensions as source image.
  593.      * Note that we allocate arrays padded out to the next iMCU boundary,
  594.      * so that transform routines need not worry about missing edge blocks.
  595.      */
  596.     coef_arrays = (jvirt_barray_ptr *)
  597.       (*srcinfo->mem->alloc_small) ((j_common_ptr) srcinfo, JPOOL_IMAGE,
  598. SIZEOF(jvirt_barray_ptr) * info->num_components);
  599.     for (ci = 0; ci < info->num_components; ci++) {
  600.       compptr = srcinfo->comp_info + ci;
  601.       coef_arrays[ci] = (*srcinfo->mem->request_virt_barray)
  602. ((j_common_ptr) srcinfo, JPOOL_IMAGE, FALSE,
  603.  (JDIMENSION) jround_up((long) compptr->width_in_blocks,
  604. (long) compptr->h_samp_factor),
  605.  (JDIMENSION) jround_up((long) compptr->height_in_blocks,
  606. (long) compptr->v_samp_factor),
  607.  (JDIMENSION) compptr->v_samp_factor);
  608.     }
  609.     break;
  610.   case JXFORM_TRANSPOSE:
  611.   case JXFORM_TRANSVERSE:
  612.   case JXFORM_ROT_90:
  613.   case JXFORM_ROT_270:
  614.     /* Need workspace arrays having transposed dimensions.
  615.      * Note that we allocate arrays padded out to the next iMCU boundary,
  616.      * so that transform routines need not worry about missing edge blocks.
  617.      */
  618.     coef_arrays = (jvirt_barray_ptr *)
  619.       (*srcinfo->mem->alloc_small) ((j_common_ptr) srcinfo, JPOOL_IMAGE,
  620. SIZEOF(jvirt_barray_ptr) * info->num_components);
  621.     for (ci = 0; ci < info->num_components; ci++) {
  622.       compptr = srcinfo->comp_info + ci;
  623.       coef_arrays[ci] = (*srcinfo->mem->request_virt_barray)
  624. ((j_common_ptr) srcinfo, JPOOL_IMAGE, FALSE,
  625.  (JDIMENSION) jround_up((long) compptr->height_in_blocks,
  626. (long) compptr->v_samp_factor),
  627.  (JDIMENSION) jround_up((long) compptr->width_in_blocks,
  628. (long) compptr->h_samp_factor),
  629.  (JDIMENSION) compptr->h_samp_factor);
  630.     }
  631.     break;
  632.   }
  633.   info->workspace_coef_arrays = coef_arrays;
  634. }
  637. /* Transpose destination image parameters */
  639. LOCAL(void)
  640. transpose_critical_parameters (j_compress_ptr dstinfo)
  641. {
  642.   int tblno, i, j, ci, itemp;
  643.   jpeg_component_info *compptr;
  644.   JQUANT_TBL *qtblptr;
  645.   JDIMENSION dtemp;
  646.   UINT16 qtemp;
  648.   /* Transpose basic image dimensions */
  649.   dtemp = dstinfo->image_width;
  650.   dstinfo->image_width = dstinfo->image_height;
  651.   dstinfo->image_height = dtemp;
  653.   /* Transpose sampling factors */
  654.   for (ci = 0; ci < dstinfo->num_components; ci++) {
  655.     compptr = dstinfo->comp_info + ci;
  656.     itemp = compptr->h_samp_factor;
  657.     compptr->h_samp_factor = compptr->v_samp_factor;
  658.     compptr->v_samp_factor = itemp;
  659.   }
  661.   /* Transpose quantization tables */
  662.   for (tblno = 0; tblno < NUM_QUANT_TBLS; tblno++) {
  663.     qtblptr = dstinfo->quant_tbl_ptrs[tblno];
  664.     if (qtblptr != NULL) {
  665.       for (i = 0; i < DCTSIZE; i++) {
  666. for (j = 0; j < i; j++) {
  667.   qtemp = qtblptr->quantval[i*DCTSIZE+j];
  668.   qtblptr->quantval[i*DCTSIZE+j] = qtblptr->quantval[j*DCTSIZE+i];
  669.   qtblptr->quantval[j*DCTSIZE+i] = qtemp;
  670. }
  671.       }
  672.     }
  673.   }
  674. }
  677. /* Trim off any partial iMCUs on the indicated destination edge */
  679. LOCAL(void)
  680. trim_right_edge (j_compress_ptr dstinfo)
  681. {
  682.   int ci, max_h_samp_factor;
  683.   JDIMENSION MCU_cols;
  685.   /* We have to compute max_h_samp_factor ourselves,
  686.    * because it hasn't been set yet in the destination
  687.    * (and we don't want to use the source's value).
  688.    */
  689.   max_h_samp_factor = 1;
  690.   for (ci = 0; ci < dstinfo->num_components; ci++) {
  691.     int h_samp_factor = dstinfo->comp_info[ci].h_samp_factor;
  692.     max_h_samp_factor = MAX(max_h_samp_factor, h_samp_factor);
  693.   }
  694.   MCU_cols = dstinfo->image_width / (max_h_samp_factor * DCTSIZE);
  695.   if (MCU_cols > 0) /* can't trim to 0 pixels */
  696.     dstinfo->image_width = MCU_cols * (max_h_samp_factor * DCTSIZE);
  697. }
  699. LOCAL(void)
  700. trim_bottom_edge (j_compress_ptr dstinfo)
  701. {
  702.   int ci, max_v_samp_factor;
  703.   JDIMENSION MCU_rows;
  705.   /* We have to compute max_v_samp_factor ourselves,
  706.    * because it hasn't been set yet in the destination
  707.    * (and we don't want to use the source's value).
  708.    */
  709.   max_v_samp_factor = 1;
  710.   for (ci = 0; ci < dstinfo->num_components; ci++) {
  711.     int v_samp_factor = dstinfo->comp_info[ci].v_samp_factor;
  712.     max_v_samp_factor = MAX(max_v_samp_factor, v_samp_factor);
  713.   }
  714.   MCU_rows = dstinfo->image_height / (max_v_samp_factor * DCTSIZE);
  715.   if (MCU_rows > 0) /* can't trim to 0 pixels */
  716.     dstinfo->image_height = MCU_rows * (max_v_samp_factor * DCTSIZE);
  717. }
  720. /* Adjust output image parameters as needed.
  721.  *
  722.  * This must be called after jpeg_copy_critical_parameters()
  723.  * and before jpeg_write_coefficients().
  724.  *
  725.  * The return value is the set of virtual coefficient arrays to be written
  726.  * (either the ones allocated by jtransform_request_workspace, or the
  727.  * original source data arrays).  The caller will need to pass this value
  728.  * to jpeg_write_coefficients().
  729.  */
  731. GLOBAL(jvirt_barray_ptr *)
  732. jtransform_adjust_parameters (j_decompress_ptr srcinfo,
  733.       j_compress_ptr dstinfo,
  734.       jvirt_barray_ptr *src_coef_arrays,
  735.       jpeg_transform_info *info)
  736. {
  737.   /* If force-to-grayscale is requested, adjust destination parameters */
  738.   if (info->force_grayscale) {
  739.     /* We use jpeg_set_colorspace to make sure subsidiary settings get fixed
  740.      * properly.  Among other things, the target h_samp_factor & v_samp_factor
  741.      * will get set to 1, which typically won't match the source.
  742.      * In fact we do this even if the source is already grayscale; that
  743.      * provides an easy way of coercing a grayscale JPEG with funny sampling
  744.      * factors to the customary 1,1.  (Some decoders fail on other factors.)
  745.      */
  746.     if ((dstinfo->jpeg_color_space == JCS_YCbCr &&
  747.  dstinfo->num_components == 3) ||
  748. (dstinfo->jpeg_color_space == JCS_GRAYSCALE &&
  749.  dstinfo->num_components == 1)) {
  750.       /* We have to preserve the source's quantization table number. */
  751.       int sv_quant_tbl_no = dstinfo->comp_info[0].quant_tbl_no;
  752.       jpeg_set_colorspace(dstinfo, JCS_GRAYSCALE);
  753.       dstinfo->comp_info[0].quant_tbl_no = sv_quant_tbl_no;
  754.     } else {
  755.       /* Sorry, can't do it */
  756.       ERREXIT(dstinfo, JERR_CONVERSION_NOTIMPL);
  757.     }
  758.   }
  760.   /* Correct the destination's image dimensions etc if necessary */
  761.   switch (info->transform) {
  762.   case JXFORM_NONE:
  763.     /* Nothing to do */
  764.     break;
  765.   case JXFORM_FLIP_H:
  766.     if (info->trim)
  767.       trim_right_edge(dstinfo);
  768.     break;
  769.   case JXFORM_FLIP_V:
  770.     if (info->trim)
  771.       trim_bottom_edge(dstinfo);
  772.     break;
  773.   case JXFORM_TRANSPOSE:
  774.     transpose_critical_parameters(dstinfo);
  775.     /* transpose does NOT have to trim anything */
  776.     break;
  777.   case JXFORM_TRANSVERSE:
  778.     transpose_critical_parameters(dstinfo);
  779.     if (info->trim) {
  780.       trim_right_edge(dstinfo);
  781.       trim_bottom_edge(dstinfo);
  782.     }
  783.     break;
  784.   case JXFORM_ROT_90:
  785.     transpose_critical_parameters(dstinfo);
  786.     if (info->trim)
  787.       trim_right_edge(dstinfo);
  788.     break;
  789.   case JXFORM_ROT_180:
  790.     if (info->trim) {
  791.       trim_right_edge(dstinfo);
  792.       trim_bottom_edge(dstinfo);
  793.     }
  794.     break;
  795.   case JXFORM_ROT_270:
  796.     transpose_critical_parameters(dstinfo);
  797.     if (info->trim)
  798.       trim_bottom_edge(dstinfo);
  799.     break;
  800.   }
  802.   /* Return the appropriate output data set */
  803.   if (info->workspace_coef_arrays != NULL)
  804.     return info->workspace_coef_arrays;
  805.   return src_coef_arrays;
  806. }
  809. /* Execute the actual transformation, if any.
  810.  *
  811.  * This must be called *after* jpeg_write_coefficients, because it depends
  812.  * on jpeg_write_coefficients to have computed subsidiary values such as
  813.  * the per-component width and height fields in the destination object.
  814.  *
  815.  * Note that some transformations will modify the source data arrays!
  816.  */
  818. GLOBAL(void)
  819. jtransform_execute_transformation (j_decompress_ptr srcinfo,
  820.    j_compress_ptr dstinfo,
  821.    jvirt_barray_ptr *src_coef_arrays,
  822.    jpeg_transform_info *info)
  823. {
  824.   jvirt_barray_ptr *dst_coef_arrays = info->workspace_coef_arrays;
  826.   switch (info->transform) {
  827.   case JXFORM_NONE:
  828.     break;
  829.   case JXFORM_FLIP_H:
  830.     do_flip_h(srcinfo, dstinfo, src_coef_arrays);
  831.     break;
  832.   case JXFORM_FLIP_V:
  833.     do_flip_v(srcinfo, dstinfo, src_coef_arrays, dst_coef_arrays);
  834.     break;
  835.   case JXFORM_TRANSPOSE:
  836.     do_transpose(srcinfo, dstinfo, src_coef_arrays, dst_coef_arrays);
  837.     break;
  838.   case JXFORM_TRANSVERSE:
  839.     do_transverse(srcinfo, dstinfo, src_coef_arrays, dst_coef_arrays);
  840.     break;
  841.   case JXFORM_ROT_90:
  842.     do_rot_90(srcinfo, dstinfo, src_coef_arrays, dst_coef_arrays);
  843.     break;
  844.   case JXFORM_ROT_180:
  845.     do_rot_180(srcinfo, dstinfo, src_coef_arrays, dst_coef_arrays);
  846.     break;
  847.   case JXFORM_ROT_270:
  848.     do_rot_270(srcinfo, dstinfo, src_coef_arrays, dst_coef_arrays);
  849.     break;
  850.   }
  851. }
  853. #endif /* TRANSFORMS_SUPPORTED */
  856. /* Setup decompression object to save desired markers in memory.
  857.  * This must be called before jpeg_read_header() to have the desired effect.
  858.  */
  860. GLOBAL(void)
  861. jcopy_markers_setup (j_decompress_ptr srcinfo, JCOPY_OPTION option)
  862. {
  863. #ifdef SAVE_MARKERS_SUPPORTED
  864.   int m;
  866.   /* Save comments except under NONE option */
  867.   if (option != JCOPYOPT_NONE) {
  868.     jpeg_save_markers(srcinfo, JPEG_COM, 0xFFFF);
  869.   }
  870.   /* Save all types of APPn markers iff ALL option */
  871.   if (option == JCOPYOPT_ALL) {
  872.     for (m = 0; m < 16; m++)
  873.       jpeg_save_markers(srcinfo, JPEG_APP0 + m, 0xFFFF);
  874.   }
  875. #endif /* SAVE_MARKERS_SUPPORTED */
  876. }
  878. /* Copy markers saved in the given source object to the destination object.
  879.  * This should be called just after jpeg_start_compress() or
  880.  * jpeg_write_coefficients().
  881.  * Note that those routines will have written the SOI, and also the
  882.  * JFIF APP0 or Adobe APP14 markers if selected.
  883.  */
  885. GLOBAL(void)
  886. jcopy_markers_execute (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
  887.        JCOPY_OPTION option)
  888. {
  889.   jpeg_saved_marker_ptr marker;
  891.   /* In the current implementation, we don't actually need to examine the
  892.    * option flag here; we just copy everything that got saved.
  893.    * But to avoid confusion, we do not output JFIF and Adobe APP14 markers
  894.    * if the encoder library already wrote one.
  895.    */
  896.   for (marker = srcinfo->marker_list; marker != NULL; marker = marker->next) {
  897.     if (dstinfo->write_JFIF_header &&
  898. marker->marker == JPEG_APP0 &&
  899. marker->data_length >= 5 &&
  900. GETJOCTET(marker->data[0]) == 0x4A &&
  901. GETJOCTET(marker->data[1]) == 0x46 &&
  902. GETJOCTET(marker->data[2]) == 0x49 &&
  903. GETJOCTET(marker->data[3]) == 0x46 &&
  904. GETJOCTET(marker->data[4]) == 0)
  905.       continue; /* reject duplicate JFIF */
  906.     if (dstinfo->write_Adobe_marker &&
  907. marker->marker == JPEG_APP0+14 &&
  908. marker->data_length >= 5 &&
  909. GETJOCTET(marker->data[0]) == 0x41 &&
  910. GETJOCTET(marker->data[1]) == 0x64 &&
  911. GETJOCTET(marker->data[2]) == 0x6F &&
  912. GETJOCTET(marker->data[3]) == 0x62 &&
  913. GETJOCTET(marker->data[4]) == 0x65)
  914.       continue; /* reject duplicate Adobe */
  915. #ifdef NEED_FAR_POINTERS
  916.     /* We could use jpeg_write_marker if the data weren't FAR... */
  917.     {
  918.       unsigned int i;
  919.       jpeg_write_m_header(dstinfo, marker->marker, marker->data_length);
  920.       for (i = 0; i < marker->data_length; i++)
  921. jpeg_write_m_byte(dstinfo, marker->data[i]);
  922.     }
  923. #else
  924.     jpeg_write_marker(dstinfo, marker->marker,
  925.       marker->data, marker->data_length);
  926. #endif
  927.   }
  928. }