1
by Bill Allombert
Import upstream version 6b |
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 |
}
|