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);
added
removed
src/imageutils/transupp.c
