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.
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
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().
18 #define JPEG_INTERNALS
22 #include "transupp.h" /* My own external interface */
25 #if TRANSFORMS_SUPPORTED
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.
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.
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.
45 * Some notes about the operating environment of the individual transform
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.
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 */
70 JDIMENSION MCU_cols
, comp_width
, blk_x
, blk_y
;
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.
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 */
102 temp1
= *ptr1
; /* swap odd column with sign change */
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
)
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.
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
);
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
);
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
;
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) {
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
++;
175 /* Just copy row verbatim. */
176 jcopy_block_row(src_buffer
[offset_y
], dst_buffer
[offset_y
],
177 compptr
->width_in_blocks
);
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 */
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
199 * Partial iMCUs at the edges require no special treatment; we simply
200 * process all the available DCT blocks for every component.
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
];
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.
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
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
];
275 for (j
= 0; j
< DCTSIZE
; j
++)
276 dst_ptr
[j
*DCTSIZE
+i
] = -src_ptr
[i
*DCTSIZE
+j
];
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
];
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.
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
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
];
339 dst_ptr
[j
*DCTSIZE
+i
] = -src_ptr
[i
*DCTSIZE
+j
];
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
];
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.
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
);
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
);
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
++;
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
++;
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
++;
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
++;
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
++;
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;
466 * 1. Horizontal mirroring;
468 * 3. Horizontal mirroring.
469 * These steps are merged into a single processing routine.
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
];
508 dst_ptr
[j
*DCTSIZE
+i
] = -src_ptr
[i
*DCTSIZE
+j
];
511 for (j
= 0; j
< DCTSIZE
; j
++) {
512 dst_ptr
[j
*DCTSIZE
+i
] = -src_ptr
[i
*DCTSIZE
+j
];
514 dst_ptr
[j
*DCTSIZE
+i
] = src_ptr
[i
*DCTSIZE
+j
];
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
];
524 dst_ptr
[j
*DCTSIZE
+i
] = -src_ptr
[i
*DCTSIZE
+j
];
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
];
538 for (j
= 0; j
< DCTSIZE
; j
++)
539 dst_ptr
[j
*DCTSIZE
+i
] = -src_ptr
[i
*DCTSIZE
+j
];
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
];
557 /* Request any required workspace.
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).
568 jtransform_request_workspace (j_decompress_ptr srcinfo
,
569 jpeg_transform_info
*info
)
571 jvirt_barray_ptr
*coef_arrays
= NULL
;
572 jpeg_component_info
*compptr
;
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;
581 /* Process all the components */
582 info
->num_components
= srcinfo
->num_components
;
585 switch (info
->transform
) {
588 /* Don't need a workspace array */
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.
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
);
610 case JXFORM_TRANSPOSE
:
611 case JXFORM_TRANSVERSE
:
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.
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
);
633 info
->workspace_coef_arrays
= coef_arrays
;
637 /* Transpose destination image parameters */
640 transpose_critical_parameters (j_compress_ptr dstinfo
)
642 int tblno
, i
, j
, ci
, itemp
;
643 jpeg_component_info
*compptr
;
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
;
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
;
677 /* Trim off any partial iMCUs on the indicated destination edge */
680 trim_right_edge (j_compress_ptr dstinfo
)
682 int ci
, max_h_samp_factor
;
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).
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
);
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
);
700 trim_bottom_edge (j_compress_ptr dstinfo
)
702 int ci
, max_v_samp_factor
;
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).
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
);
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
);
720 /* Adjust output image parameters as needed.
722 * This must be called after jpeg_copy_critical_parameters()
723 * and before jpeg_write_coefficients().
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().
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
)
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.)
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
;
755 /* Sorry, can't do it */
756 ERREXIT(dstinfo
, JERR_CONVERSION_NOTIMPL
);
760 /* Correct the destination's image dimensions etc if necessary */
761 switch (info
->transform
) {
767 trim_right_edge(dstinfo
);
771 trim_bottom_edge(dstinfo
);
773 case JXFORM_TRANSPOSE
:
774 transpose_critical_parameters(dstinfo
);
775 /* transpose does NOT have to trim anything */
777 case JXFORM_TRANSVERSE
:
778 transpose_critical_parameters(dstinfo
);
780 trim_right_edge(dstinfo
);
781 trim_bottom_edge(dstinfo
);
785 transpose_critical_parameters(dstinfo
);
787 trim_right_edge(dstinfo
);
791 trim_right_edge(dstinfo
);
792 trim_bottom_edge(dstinfo
);
796 transpose_critical_parameters(dstinfo
);
798 trim_bottom_edge(dstinfo
);
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
;
809 /* Execute the actual transformation, if any.
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.
815 * Note that some transformations will modify the source data arrays!
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
)
824 jvirt_barray_ptr
*dst_coef_arrays
= info
->workspace_coef_arrays
;
826 switch (info
->transform
) {
830 do_flip_h(srcinfo
, dstinfo
, src_coef_arrays
);
833 do_flip_v(srcinfo
, dstinfo
, src_coef_arrays
, dst_coef_arrays
);
835 case JXFORM_TRANSPOSE
:
836 do_transpose(srcinfo
, dstinfo
, src_coef_arrays
, dst_coef_arrays
);
838 case JXFORM_TRANSVERSE
:
839 do_transverse(srcinfo
, dstinfo
, src_coef_arrays
, dst_coef_arrays
);
842 do_rot_90(srcinfo
, dstinfo
, src_coef_arrays
, dst_coef_arrays
);
845 do_rot_180(srcinfo
, dstinfo
, src_coef_arrays
, dst_coef_arrays
);
848 do_rot_270(srcinfo
, dstinfo
, src_coef_arrays
, dst_coef_arrays
);
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.
861 jcopy_markers_setup (j_decompress_ptr srcinfo
, JCOPY_OPTION option
)
863 #ifdef SAVE_MARKERS_SUPPORTED
866 /* Save comments except under NONE option */
867 if (option
!= JCOPYOPT_NONE
) {
868 jpeg_save_markers(srcinfo
, JPEG_COM
, 0xFFFF);
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);
875 #endif /* SAVE_MARKERS_SUPPORTED */
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.
886 jcopy_markers_execute (j_decompress_ptr srcinfo
, j_compress_ptr dstinfo
,
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.
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... */
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
]);
924 jpeg_write_marker(dstinfo
, marker
->marker
,
925 marker
->data
, marker
->data_length
);