Add ValueBase::get_string() for debugging. Barely tested, but not used either.
[synfig.git] / gtkmm-osx / trunk / jpeg-6b / 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  */
14
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
19
20 #include "jinclude.h"
21 #include "jpeglib.h"
22 #include "transupp.h"           /* My own external interface */
23
24
25 #if TRANSFORMS_SUPPORTED
26
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  */
63
64
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;
76
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);
83
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 }
112
113
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;
126
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);
135
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 }
183
184
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;
196
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 }
227
228
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;
244
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);
250
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 }
291
292
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;
308
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);
314
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 }
355
356
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;
373
374   MCU_cols = dstinfo->image_width / (dstinfo->max_h_samp_factor * DCTSIZE);
375   MCU_rows = dstinfo->image_height / (dstinfo->max_v_samp_factor * DCTSIZE);
376
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 }
456
457
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;
477
478   MCU_cols = dstinfo->image_width / (dstinfo->max_h_samp_factor * DCTSIZE);
479   MCU_rows = dstinfo->image_height / (dstinfo->max_v_samp_factor * DCTSIZE);
480
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 }
555
556
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  */
566
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;
574
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   }
584
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 }
635
636
637 /* Transpose destination image parameters */
638
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;
647
648   /* Transpose basic image dimensions */
649   dtemp = dstinfo->image_width;
650   dstinfo->image_width = dstinfo->image_height;
651   dstinfo->image_height = dtemp;
652
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   }
660
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 }
675
676
677 /* Trim off any partial iMCUs on the indicated destination edge */
678
679 LOCAL(void)
680 trim_right_edge (j_compress_ptr dstinfo)
681 {
682   int ci, max_h_samp_factor;
683   JDIMENSION MCU_cols;
684
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 }
698
699 LOCAL(void)
700 trim_bottom_edge (j_compress_ptr dstinfo)
701 {
702   int ci, max_v_samp_factor;
703   JDIMENSION MCU_rows;
704
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 }
718
719
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  */
730
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   }
759
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   }
801
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 }
807
808
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  */
817
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;
825
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 }
852
853 #endif /* TRANSFORMS_SUPPORTED */
854
855
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  */
859
860 GLOBAL(void)
861 jcopy_markers_setup (j_decompress_ptr srcinfo, JCOPY_OPTION option)
862 {
863 #ifdef SAVE_MARKERS_SUPPORTED
864   int m;
865
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 }
877
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  */
884
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;
890
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 }