« back to all changes in this revision
Viewing changes to jpegutils/transupp-8a.c
- browse files at revision 98
- compare with another revision
- download diff
- download tarball
- view history from revision 98
- Committer: Bazaar Package Importer
- Author(s): Sebastien Bacher
- Date: 2010-05-20 15:09:47 UTC
- mfrom: (1.14.6 upstream) (2.1.9 squeeze)
- Revision ID: james.westby@ubuntu.com-20100520150947-esb0vjp9p72g74qt
Tags: 2.30.1-1ubuntu1
* Resync on Debian
* debian/control.in,
debian/rules:
- build with python
* debian/control.in,
debian/patches/01_lpi.patch,
debian/patches/99_autoconf.patch:
- launchpad integration changes
* debian/patches/02_toolbar_edit_button.patch:
- change by Ryan Lortie to add an edit button to the toolbar
- set /apps/eog/ui/external_editor to f-spot-viewer, it can't do editing
right now but that will be changed in lucid
* debian/control.in,
debian/rules:
- build with python
* debian/control.in,
debian/patches/01_lpi.patch,
debian/patches/99_autoconf.patch:
- launchpad integration changes
* debian/patches/02_toolbar_edit_button.patch:
- change by Ryan Lortie to add an edit button to the toolbar
- set /apps/eog/ui/external_editor to f-spot-viewer, it can't do editing
right now but that will be changed in lucid
- files added:
- .pc
- .pc/01_lpi.patch
- .pc/01_lpi.patch/data
- .pc/01_lpi.patch/src
- .pc/01_nodisplay.patch
- .pc/01_nodisplay.patch/data
- .pc/02_toolbar_edit_button.patch
- .pc/02_toolbar_edit_button.patch/data
- .pc/02_toolbar_edit_button.patch/src
- .pc/99_autoconf.patch
- debian/source
- files removed:
- doc/reference/html/EogApplication.html
- files modified:
- ChangeLog
added
removed
jpegutils/transupp-8a.c
1
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
2
3
/*
4
* GThumb
5
*
6
* Copyright (C) 2001, 2002 The Free Software Foundation, Inc.
7
*
8
* This program is free software; you can redistribute it and/or modify
9
* it under the terms of the GNU General Public License as published by
10
* the Free Software Foundation; either version 2 of the License, or
11
* (at your option) any later version.
12
*
13
* This program is distributed in the hope that it will be useful,
14
* but WITHOUT ANY WARRANTY; without even the implied warranty of
15
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16
* GNU General Public License for more details.
17
*
18
* You should have received a copy of the GNU General Public License
19
* along with this program; if not, write to the Free Software
20
* Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
21
*/
22
23
/* based upon file transupp.c from the libjpeg package, original copyright
24
* note follows:
25
*
26
*
27
* transupp.c
28
*
29
* Copyright (C) 1997-2009, Thomas G. Lane, Guido Vollbeding.
30
* This file is part of the Independent JPEG Group's software.
31
* For conditions of distribution and use, see the accompanying README file.
32
*
33
* This file contains image transformation routines and other utility code
34
* used by the jpegtran sample application. These are NOT part of the core
35
* JPEG library. But we keep these routines separate from jpegtran.c to
36
* ease the task of maintaining jpegtran-like programs that have other user
37
* interfaces.
38
*/
39
40
/* Although this file really shouldn't have access to the library internals,
41
* it's helpful to let it call jround_up() and jcopy_block_row().
42
*/
43
#define JPEG_INTERNALS
44
45
#include <config.h>
46
#include <stdio.h>
47
#include <jpeglib.h>
48
#include "transupp-8a.h" /* My own external interface */
49
#include <ctype.h> /* to declare isdigit() */
50
51
52
#if TRANSFORMS_SUPPORTED
53
54
/*
55
* Lossless image transformation routines. These routines work on DCT
56
* coefficient arrays and thus do not require any lossy decompression
57
* or recompression of the image.
58
* Thanks to Guido Vollbeding for the initial design and code of this feature,
59
* and to Ben Jackson for introducing the cropping feature.
60
*
61
* Horizontal flipping is done in-place, using a single top-to-bottom
62
* pass through the virtual source array. It will thus be much the
63
* fastest option for images larger than main memory.
64
*
65
* The other routines require a set of destination virtual arrays, so they
66
* need twice as much memory as jpegtran normally does. The destination
67
* arrays are always written in normal scan order (top to bottom) because
68
* the virtual array manager expects this. The source arrays will be scanned
69
* in the corresponding order, which means multiple passes through the source
70
* arrays for most of the transforms. That could result in much thrashing
71
* if the image is larger than main memory.
72
*
73
* If cropping or trimming is involved, the destination arrays may be smaller
74
* than the source arrays. Note it is not possible to do horizontal flip
75
* in-place when a nonzero Y crop offset is specified, since we'd have to move
76
* data from one block row to another but the virtual array manager doesn't
77
* guarantee we can touch more than one row at a time. So in that case,
78
* we have to use a separate destination array.
79
*
80
* Some notes about the operating environment of the individual transform
81
* routines:
82
* 1. Both the source and destination virtual arrays are allocated from the
83
* source JPEG object, and therefore should be manipulated by calling the
84
* source's memory manager.
85
* 2. The destination's component count should be used. It may be smaller
86
* than the source's when forcing to grayscale.
87
* 3. Likewise the destination's sampling factors should be used. When
88
* forcing to grayscale the destination's sampling factors will be all 1,
89
* and we may as well take that as the effective iMCU size.
90
* 4. When "trim" is in effect, the destination's dimensions will be the
91
* trimmed values but the source's will be untrimmed.
92
* 5. When "crop" is in effect, the destination's dimensions will be the
93
* cropped values but the source's will be uncropped. Each transform
94
* routine is responsible for picking up source data starting at the
95
* correct X and Y offset for the crop region. (The X and Y offsets
96
* passed to the transform routines are measured in iMCU blocks of the
97
* destination.)
98
* 6. All the routines assume that the source and destination buffers are
99
* padded out to a full iMCU boundary. This is true, although for the
100
* source buffer it is an undocumented property of jdcoefct.c.
101
*/
102
103
104
LOCAL(void)
105
do_crop (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
106
JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
107
jvirt_barray_ptr *src_coef_arrays,
108
jvirt_barray_ptr *dst_coef_arrays)
109
/* Crop. This is only used when no rotate/flip is requested with the crop. */
110
{
111
JDIMENSION dst_blk_y, x_crop_blocks, y_crop_blocks;
112
int ci, offset_y;
113
JBLOCKARRAY src_buffer, dst_buffer;
114
jpeg_component_info *compptr;
115
116
/* We simply have to copy the right amount of data (the destination's
117
* image size) starting at the given X and Y offsets in the source.
118
*/
119
for (ci = 0; ci < dstinfo->num_components; ci++) {
120
compptr = dstinfo->comp_info + ci;
121
x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
122
y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
123
for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
124
dst_blk_y += compptr->v_samp_factor) {
125
dst_buffer = (*srcinfo->mem->access_virt_barray)
126
((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
127
(JDIMENSION) compptr->v_samp_factor, TRUE);
128
src_buffer = (*srcinfo->mem->access_virt_barray)
129
((j_common_ptr) srcinfo, src_coef_arrays[ci],
130
dst_blk_y + y_crop_blocks,
131
(JDIMENSION) compptr->v_samp_factor, FALSE);
132
for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
133
jcopy_block_row(src_buffer[offset_y] + x_crop_blocks,
134
dst_buffer[offset_y],
135
compptr->width_in_blocks);
136
}
137
}
138
}
139
}
140
141
142
LOCAL(void)
143
do_flip_h_no_crop (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
144
JDIMENSION x_crop_offset,
145
jvirt_barray_ptr *src_coef_arrays)
146
/* Horizontal flip; done in-place, so no separate dest array is required.
147
* NB: this only works when y_crop_offset is zero.
148
*/
149
{
150
JDIMENSION MCU_cols, comp_width, blk_x, blk_y, x_crop_blocks;
151
int ci, k, offset_y;
152
JBLOCKARRAY buffer;
153
JCOEFPTR ptr1, ptr2;
154
JCOEF temp1, temp2;
155
jpeg_component_info *compptr;
156
157
/* Horizontal mirroring of DCT blocks is accomplished by swapping
158
* pairs of blocks in-place. Within a DCT block, we perform horizontal
159
* mirroring by changing the signs of odd-numbered columns.
160
* Partial iMCUs at the right edge are left untouched.
161
*/
162
MCU_cols = srcinfo->output_width /
163
(dstinfo->max_h_samp_factor * dstinfo->min_DCT_h_scaled_size);
164
165
for (ci = 0; ci < dstinfo->num_components; ci++) {
166
compptr = dstinfo->comp_info + ci;
167
comp_width = MCU_cols * compptr->h_samp_factor;
168
x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
169
for (blk_y = 0; blk_y < compptr->height_in_blocks;
170
blk_y += compptr->v_samp_factor) {
171
buffer = (*srcinfo->mem->access_virt_barray)
172
((j_common_ptr) srcinfo, src_coef_arrays[ci], blk_y,
173
(JDIMENSION) compptr->v_samp_factor, TRUE);
174
for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
175
/* Do the mirroring */
176
for (blk_x = 0; blk_x * 2 < comp_width; blk_x++) {
177
ptr1 = buffer[offset_y][blk_x];
178
ptr2 = buffer[offset_y][comp_width - blk_x - 1];
179
/* this unrolled loop doesn't need to know which row it's on... */
180
for (k = 0; k < DCTSIZE2; k += 2) {
181
temp1 = *ptr1; /* swap even column */
182
temp2 = *ptr2;
183
*ptr1++ = temp2;
184
*ptr2++ = temp1;
185
temp1 = *ptr1; /* swap odd column with sign change */
186
temp2 = *ptr2;
187
*ptr1++ = -temp2;
188
*ptr2++ = -temp1;
189
}
190
}
191
if (x_crop_blocks > 0) {
192
/* Now left-justify the portion of the data to be kept.
193
* We can't use a single jcopy_block_row() call because that routine
194
* depends on memcpy(), whose behavior is unspecified for overlapping
195
* source and destination areas. Sigh.
196
*/
197
for (blk_x = 0; blk_x < compptr->width_in_blocks; blk_x++) {
198
jcopy_block_row(buffer[offset_y] + blk_x + x_crop_blocks,
199
buffer[offset_y] + blk_x,
200
(JDIMENSION) 1);
201
}
202
}
203
}
204
}
205
}
206
}
207
208
209
LOCAL(void)
210
do_flip_h (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
211
JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
212
jvirt_barray_ptr *src_coef_arrays,
213
jvirt_barray_ptr *dst_coef_arrays)
214
/* Horizontal flip in general cropping case */
215
{
216
JDIMENSION MCU_cols, comp_width, dst_blk_x, dst_blk_y;
217
JDIMENSION x_crop_blocks, y_crop_blocks;
218
int ci, k, offset_y;
219
JBLOCKARRAY src_buffer, dst_buffer;
220
JBLOCKROW src_row_ptr, dst_row_ptr;
221
JCOEFPTR src_ptr, dst_ptr;
222
jpeg_component_info *compptr;
223
224
/* Here we must output into a separate array because we can't touch
225
* different rows of a single virtual array simultaneously. Otherwise,
226
* this is essentially the same as the routine above.
227
*/
228
MCU_cols = srcinfo->output_width /
229
(dstinfo->max_h_samp_factor * dstinfo->min_DCT_h_scaled_size);
230
231
for (ci = 0; ci < dstinfo->num_components; ci++) {
232
compptr = dstinfo->comp_info + ci;
233
comp_width = MCU_cols * compptr->h_samp_factor;
234
x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
235
y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
236
for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
237
dst_blk_y += compptr->v_samp_factor) {
238
dst_buffer = (*srcinfo->mem->access_virt_barray)
239
((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
240
(JDIMENSION) compptr->v_samp_factor, TRUE);
241
src_buffer = (*srcinfo->mem->access_virt_barray)
242
((j_common_ptr) srcinfo, src_coef_arrays[ci],
243
dst_blk_y + y_crop_blocks,
244
(JDIMENSION) compptr->v_samp_factor, FALSE);
245
for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
246
dst_row_ptr = dst_buffer[offset_y];
247
src_row_ptr = src_buffer[offset_y];
248
for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks; dst_blk_x++) {
249
if (x_crop_blocks + dst_blk_x < comp_width) {
250
/* Do the mirrorable blocks */
251
dst_ptr = dst_row_ptr[dst_blk_x];
252
src_ptr = src_row_ptr[comp_width - x_crop_blocks - dst_blk_x - 1];
253
/* this unrolled loop doesn't need to know which row it's on... */
254
for (k = 0; k < DCTSIZE2; k += 2) {
255
*dst_ptr++ = *src_ptr++; /* copy even column */
256
*dst_ptr++ = - *src_ptr++; /* copy odd column with sign change */
257
}
258
} else {
259
/* Copy last partial block(s) verbatim */
260
jcopy_block_row(src_row_ptr + dst_blk_x + x_crop_blocks,
261
dst_row_ptr + dst_blk_x,
262
(JDIMENSION) 1);
263
}
264
}
265
}
266
}
267
}
268
}
269
270
271
LOCAL(void)
272
do_flip_v (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
273
JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
274
jvirt_barray_ptr *src_coef_arrays,
275
jvirt_barray_ptr *dst_coef_arrays)
276
/* Vertical flip */
277
{
278
JDIMENSION MCU_rows, comp_height, dst_blk_x, dst_blk_y;
279
JDIMENSION x_crop_blocks, y_crop_blocks;
280
int ci, i, j, offset_y;
281
JBLOCKARRAY src_buffer, dst_buffer;
282
JBLOCKROW src_row_ptr, dst_row_ptr;
283
JCOEFPTR src_ptr, dst_ptr;
284
jpeg_component_info *compptr;
285
286
/* We output into a separate array because we can't touch different
287
* rows of the source virtual array simultaneously. Otherwise, this
288
* is a pretty straightforward analog of horizontal flip.
289
* Within a DCT block, vertical mirroring is done by changing the signs
290
* of odd-numbered rows.
291
* Partial iMCUs at the bottom edge are copied verbatim.
292
*/
293
MCU_rows = srcinfo->output_height /
294
(dstinfo->max_v_samp_factor * dstinfo->min_DCT_v_scaled_size);
295
296
for (ci = 0; ci < dstinfo->num_components; ci++) {
297
compptr = dstinfo->comp_info + ci;
298
comp_height = MCU_rows * compptr->v_samp_factor;
299
x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
300
y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
301
for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
302
dst_blk_y += compptr->v_samp_factor) {
303
dst_buffer = (*srcinfo->mem->access_virt_barray)
304
((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
305
(JDIMENSION) compptr->v_samp_factor, TRUE);
306
if (y_crop_blocks + dst_blk_y < comp_height) {
307
/* Row is within the mirrorable area. */
308
src_buffer = (*srcinfo->mem->access_virt_barray)
309
((j_common_ptr) srcinfo, src_coef_arrays[ci],
310
comp_height - y_crop_blocks - dst_blk_y -
311
(JDIMENSION) compptr->v_samp_factor,
312
(JDIMENSION) compptr->v_samp_factor, FALSE);
313
} else {
314
/* Bottom-edge blocks will be copied verbatim. */
315
src_buffer = (*srcinfo->mem->access_virt_barray)
316
((j_common_ptr) srcinfo, src_coef_arrays[ci],
317
dst_blk_y + y_crop_blocks,
318
(JDIMENSION) compptr->v_samp_factor, FALSE);
319
}
320
for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
321
if (y_crop_blocks + dst_blk_y < comp_height) {
322
/* Row is within the mirrorable area. */
323
dst_row_ptr = dst_buffer[offset_y];
324
src_row_ptr = src_buffer[compptr->v_samp_factor - offset_y - 1];
325
src_row_ptr += x_crop_blocks;
326
for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks;
327
dst_blk_x++) {
328
dst_ptr = dst_row_ptr[dst_blk_x];
329
src_ptr = src_row_ptr[dst_blk_x];
330
for (i = 0; i < DCTSIZE; i += 2) {
331
/* copy even row */
332
for (j = 0; j < DCTSIZE; j++)
333
*dst_ptr++ = *src_ptr++;
334
/* copy odd row with sign change */
335
for (j = 0; j < DCTSIZE; j++)
336
*dst_ptr++ = - *src_ptr++;
337
}
338
}
339
} else {
340
/* Just copy row verbatim. */
341
jcopy_block_row(src_buffer[offset_y] + x_crop_blocks,
342
dst_buffer[offset_y],
343
compptr->width_in_blocks);
344
}
345
}
346
}
347
}
348
}
349
350
351
LOCAL(void)
352
do_transpose (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
353
JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
354
jvirt_barray_ptr *src_coef_arrays,
355
jvirt_barray_ptr *dst_coef_arrays)
356
/* Transpose source into destination */
357
{
358
JDIMENSION dst_blk_x, dst_blk_y, x_crop_blocks, y_crop_blocks;
359
int ci, i, j, offset_x, offset_y;
360
JBLOCKARRAY src_buffer, dst_buffer;
361
JCOEFPTR src_ptr, dst_ptr;
362
jpeg_component_info *compptr;
363
364
/* Transposing pixels within a block just requires transposing the
365
* DCT coefficients.
366
* Partial iMCUs at the edges require no special treatment; we simply
367
* process all the available DCT blocks for every component.
368
*/
369
for (ci = 0; ci < dstinfo->num_components; ci++) {
370
compptr = dstinfo->comp_info + ci;
371
x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
372
y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
373
for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
374
dst_blk_y += compptr->v_samp_factor) {
375
dst_buffer = (*srcinfo->mem->access_virt_barray)
376
((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
377
(JDIMENSION) compptr->v_samp_factor, TRUE);
378
for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
379
for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks;
380
dst_blk_x += compptr->h_samp_factor) {
381
src_buffer = (*srcinfo->mem->access_virt_barray)
382
((j_common_ptr) srcinfo, src_coef_arrays[ci],
383
dst_blk_x + x_crop_blocks,
384
(JDIMENSION) compptr->h_samp_factor, FALSE);
385
for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) {
386
dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x];
387
src_ptr = src_buffer[offset_x][dst_blk_y + offset_y + y_crop_blocks];
388
for (i = 0; i < DCTSIZE; i++)
389
for (j = 0; j < DCTSIZE; j++)
390
dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
391
}
392
}
393
}
394
}
395
}
396
}
397
398
399
LOCAL(void)
400
do_rot_90 (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
401
JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
402
jvirt_barray_ptr *src_coef_arrays,
403
jvirt_barray_ptr *dst_coef_arrays)
404
/* 90 degree rotation is equivalent to
405
* 1. Transposing the image;
406
* 2. Horizontal mirroring.
407
* These two steps are merged into a single processing routine.
408
*/
409
{
410
JDIMENSION MCU_cols, comp_width, dst_blk_x, dst_blk_y;
411
JDIMENSION x_crop_blocks, y_crop_blocks;
412
int ci, i, j, offset_x, offset_y;
413
JBLOCKARRAY src_buffer, dst_buffer;
414
JCOEFPTR src_ptr, dst_ptr;
415
jpeg_component_info *compptr;
416
417
/* Because of the horizontal mirror step, we can't process partial iMCUs
418
* at the (output) right edge properly. They just get transposed and
419
* not mirrored.
420
*/
421
MCU_cols = srcinfo->output_height /
422
(dstinfo->max_h_samp_factor * dstinfo->min_DCT_h_scaled_size);
423
424
for (ci = 0; ci < dstinfo->num_components; ci++) {
425
compptr = dstinfo->comp_info + ci;
426
comp_width = MCU_cols * compptr->h_samp_factor;
427
x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
428
y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
429
for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
430
dst_blk_y += compptr->v_samp_factor) {
431
dst_buffer = (*srcinfo->mem->access_virt_barray)
432
((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
433
(JDIMENSION) compptr->v_samp_factor, TRUE);
434
for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
435
for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks;
436
dst_blk_x += compptr->h_samp_factor) {
437
if (x_crop_blocks + dst_blk_x < comp_width) {
438
/* Block is within the mirrorable area. */
439
src_buffer = (*srcinfo->mem->access_virt_barray)
440
((j_common_ptr) srcinfo, src_coef_arrays[ci],
441
comp_width - x_crop_blocks - dst_blk_x -
442
(JDIMENSION) compptr->h_samp_factor,
443
(JDIMENSION) compptr->h_samp_factor, FALSE);
444
} else {
445
/* Edge blocks are transposed but not mirrored. */
446
src_buffer = (*srcinfo->mem->access_virt_barray)
447
((j_common_ptr) srcinfo, src_coef_arrays[ci],
448
dst_blk_x + x_crop_blocks,
449
(JDIMENSION) compptr->h_samp_factor, FALSE);
450
}
451
for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) {
452
dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x];
453
if (x_crop_blocks + dst_blk_x < comp_width) {
454
/* Block is within the mirrorable area. */
455
src_ptr = src_buffer[compptr->h_samp_factor - offset_x - 1]
456
[dst_blk_y + offset_y + y_crop_blocks];
457
for (i = 0; i < DCTSIZE; i++) {
458
for (j = 0; j < DCTSIZE; j++)
459
dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
460
i++;
461
for (j = 0; j < DCTSIZE; j++)
462
dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
463
}
464
} else {
465
/* Edge blocks are transposed but not mirrored. */
466
src_ptr = src_buffer[offset_x]
467
[dst_blk_y + offset_y + y_crop_blocks];
468
for (i = 0; i < DCTSIZE; i++)
469
for (j = 0; j < DCTSIZE; j++)
470
dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
471
}
472
}
473
}
474
}
475
}
476
}
477
}
478
479
480
LOCAL(void)
481
do_rot_270 (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
482
JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
483
jvirt_barray_ptr *src_coef_arrays,
484
jvirt_barray_ptr *dst_coef_arrays)
485
/* 270 degree rotation is equivalent to
486
* 1. Horizontal mirroring;
487
* 2. Transposing the image.
488
* These two steps are merged into a single processing routine.
489
*/
490
{
491
JDIMENSION MCU_rows, comp_height, dst_blk_x, dst_blk_y;
492
JDIMENSION x_crop_blocks, y_crop_blocks;
493
int ci, i, j, offset_x, offset_y;
494
JBLOCKARRAY src_buffer, dst_buffer;
495
JCOEFPTR src_ptr, dst_ptr;
496
jpeg_component_info *compptr;
497
498
/* Because of the horizontal mirror step, we can't process partial iMCUs
499
* at the (output) bottom edge properly. They just get transposed and
500
* not mirrored.
501
*/
502
MCU_rows = srcinfo->output_width /
503
(dstinfo->max_v_samp_factor * dstinfo->min_DCT_v_scaled_size);
504
505
for (ci = 0; ci < dstinfo->num_components; ci++) {
506
compptr = dstinfo->comp_info + ci;
507
comp_height = MCU_rows * compptr->v_samp_factor;
508
x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
509
y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
510
for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
511
dst_blk_y += compptr->v_samp_factor) {
512
dst_buffer = (*srcinfo->mem->access_virt_barray)
513
((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
514
(JDIMENSION) compptr->v_samp_factor, TRUE);
515
for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
516
for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks;
517
dst_blk_x += compptr->h_samp_factor) {
518
src_buffer = (*srcinfo->mem->access_virt_barray)
519
((j_common_ptr) srcinfo, src_coef_arrays[ci],
520
dst_blk_x + x_crop_blocks,
521
(JDIMENSION) compptr->h_samp_factor, FALSE);
522
for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) {
523
dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x];
524
if (y_crop_blocks + dst_blk_y < comp_height) {
525
/* Block is within the mirrorable area. */
526
src_ptr = src_buffer[offset_x]
527
[comp_height - y_crop_blocks - dst_blk_y - offset_y - 1];
528
for (i = 0; i < DCTSIZE; i++) {
529
for (j = 0; j < DCTSIZE; j++) {
530
dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
531
j++;
532
dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
533
}
534
}
535
} else {
536
/* Edge blocks are transposed but not mirrored. */
537
src_ptr = src_buffer[offset_x]
538
[dst_blk_y + offset_y + y_crop_blocks];
539
for (i = 0; i < DCTSIZE; i++)
540
for (j = 0; j < DCTSIZE; j++)
541
dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
542
}
543
}
544
}
545
}
546
}
547
}
548
}
549
550
551
LOCAL(void)
552
do_rot_180 (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
553
JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
554
jvirt_barray_ptr *src_coef_arrays,
555
jvirt_barray_ptr *dst_coef_arrays)
556
/* 180 degree rotation is equivalent to
557
* 1. Vertical mirroring;
558
* 2. Horizontal mirroring.
559
* These two steps are merged into a single processing routine.
560
*/
561
{
562
JDIMENSION MCU_cols, MCU_rows, comp_width, comp_height, dst_blk_x, dst_blk_y;
563
JDIMENSION x_crop_blocks, y_crop_blocks;
564
int ci, i, j, offset_y;
565
JBLOCKARRAY src_buffer, dst_buffer;
566
JBLOCKROW src_row_ptr, dst_row_ptr;
567
JCOEFPTR src_ptr, dst_ptr;
568
jpeg_component_info *compptr;
569
570
MCU_cols = srcinfo->output_width /
571
(dstinfo->max_h_samp_factor * dstinfo->min_DCT_h_scaled_size);
572
MCU_rows = srcinfo->output_height /
573
(dstinfo->max_v_samp_factor * dstinfo->min_DCT_v_scaled_size);
574
575
for (ci = 0; ci < dstinfo->num_components; ci++) {
576
compptr = dstinfo->comp_info + ci;
577
comp_width = MCU_cols * compptr->h_samp_factor;
578
comp_height = MCU_rows * compptr->v_samp_factor;
579
x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
580
y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
581
for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
582
dst_blk_y += compptr->v_samp_factor) {
583
dst_buffer = (*srcinfo->mem->access_virt_barray)
584
((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
585
(JDIMENSION) compptr->v_samp_factor, TRUE);
586
if (y_crop_blocks + dst_blk_y < comp_height) {
587
/* Row is within the vertically mirrorable area. */
588
src_buffer = (*srcinfo->mem->access_virt_barray)
589
((j_common_ptr) srcinfo, src_coef_arrays[ci],
590
comp_height - y_crop_blocks - dst_blk_y -
591
(JDIMENSION) compptr->v_samp_factor,
592
(JDIMENSION) compptr->v_samp_factor, FALSE);
593
} else {
594
/* Bottom-edge rows are only mirrored horizontally. */
595
src_buffer = (*srcinfo->mem->access_virt_barray)
596
((j_common_ptr) srcinfo, src_coef_arrays[ci],
597
dst_blk_y + y_crop_blocks,
598
(JDIMENSION) compptr->v_samp_factor, FALSE);
599
}
600
for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
601
dst_row_ptr = dst_buffer[offset_y];
602
if (y_crop_blocks + dst_blk_y < comp_height) {
603
/* Row is within the mirrorable area. */
604
src_row_ptr = src_buffer[compptr->v_samp_factor - offset_y - 1];
605
for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks; dst_blk_x++) {
606
dst_ptr = dst_row_ptr[dst_blk_x];
607
if (x_crop_blocks + dst_blk_x < comp_width) {
608
/* Process the blocks that can be mirrored both ways. */
609
src_ptr = src_row_ptr[comp_width - x_crop_blocks - dst_blk_x - 1];
610
for (i = 0; i < DCTSIZE; i += 2) {
611
/* For even row, negate every odd column. */
612
for (j = 0; j < DCTSIZE; j += 2) {
613
*dst_ptr++ = *src_ptr++;
614
*dst_ptr++ = - *src_ptr++;
615
}
616
/* For odd row, negate every even column. */
617
for (j = 0; j < DCTSIZE; j += 2) {
618
*dst_ptr++ = - *src_ptr++;
619
*dst_ptr++ = *src_ptr++;
620
}
621
}
622
} else {
623
/* Any remaining right-edge blocks are only mirrored vertically. */
624
src_ptr = src_row_ptr[x_crop_blocks + dst_blk_x];
625
for (i = 0; i < DCTSIZE; i += 2) {
626
for (j = 0; j < DCTSIZE; j++)
627
*dst_ptr++ = *src_ptr++;
628
for (j = 0; j < DCTSIZE; j++)
629
*dst_ptr++ = - *src_ptr++;
630
}
631
}
632
}
633
} else {
634
/* Remaining rows are just mirrored horizontally. */
635
src_row_ptr = src_buffer[offset_y];
636
for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks; dst_blk_x++) {
637
if (x_crop_blocks + dst_blk_x < comp_width) {
638
/* Process the blocks that can be mirrored. */
639
dst_ptr = dst_row_ptr[dst_blk_x];
640
src_ptr = src_row_ptr[comp_width - x_crop_blocks - dst_blk_x - 1];
641
for (i = 0; i < DCTSIZE2; i += 2) {
642
*dst_ptr++ = *src_ptr++;
643
*dst_ptr++ = - *src_ptr++;
644
}
645
} else {
646
/* Any remaining right-edge blocks are only copied. */
647
jcopy_block_row(src_row_ptr + dst_blk_x + x_crop_blocks,
648
dst_row_ptr + dst_blk_x,
649
(JDIMENSION) 1);
650
}
651
}
652
}
653
}
654
}
655
}
656
}
657
658
659
LOCAL(void)
660
do_transverse (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
661
JDIMENSION x_crop_offset, JDIMENSION y_crop_offset,
662
jvirt_barray_ptr *src_coef_arrays,
663
jvirt_barray_ptr *dst_coef_arrays)
664
/* Transverse transpose is equivalent to
665
* 1. 180 degree rotation;
666
* 2. Transposition;
667
* or
668
* 1. Horizontal mirroring;
669
* 2. Transposition;
670
* 3. Horizontal mirroring.
671
* These steps are merged into a single processing routine.
672
*/
673
{
674
JDIMENSION MCU_cols, MCU_rows, comp_width, comp_height, dst_blk_x, dst_blk_y;
675
JDIMENSION x_crop_blocks, y_crop_blocks;
676
int ci, i, j, offset_x, offset_y;
677
JBLOCKARRAY src_buffer, dst_buffer;
678
JCOEFPTR src_ptr, dst_ptr;
679
jpeg_component_info *compptr;
680
681
MCU_cols = srcinfo->output_height /
682
(dstinfo->max_h_samp_factor * dstinfo->min_DCT_h_scaled_size);
683
MCU_rows = srcinfo->output_width /
684
(dstinfo->max_v_samp_factor * dstinfo->min_DCT_v_scaled_size);
685
686
for (ci = 0; ci < dstinfo->num_components; ci++) {
687
compptr = dstinfo->comp_info + ci;
688
comp_width = MCU_cols * compptr->h_samp_factor;
689
comp_height = MCU_rows * compptr->v_samp_factor;
690
x_crop_blocks = x_crop_offset * compptr->h_samp_factor;
691
y_crop_blocks = y_crop_offset * compptr->v_samp_factor;
692
for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
693
dst_blk_y += compptr->v_samp_factor) {
694
dst_buffer = (*srcinfo->mem->access_virt_barray)
695
((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
696
(JDIMENSION) compptr->v_samp_factor, TRUE);
697
for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
698
for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks;
699
dst_blk_x += compptr->h_samp_factor) {
700
if (x_crop_blocks + dst_blk_x < comp_width) {
701
/* Block is within the mirrorable area. */
702
src_buffer = (*srcinfo->mem->access_virt_barray)
703
((j_common_ptr) srcinfo, src_coef_arrays[ci],
704
comp_width - x_crop_blocks - dst_blk_x -
705
(JDIMENSION) compptr->h_samp_factor,
706
(JDIMENSION) compptr->h_samp_factor, FALSE);
707
} else {
708
src_buffer = (*srcinfo->mem->access_virt_barray)
709
((j_common_ptr) srcinfo, src_coef_arrays[ci],
710
dst_blk_x + x_crop_blocks,
711
(JDIMENSION) compptr->h_samp_factor, FALSE);
712
}
713
for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) {
714
dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x];
715
if (y_crop_blocks + dst_blk_y < comp_height) {
716
if (x_crop_blocks + dst_blk_x < comp_width) {
717
/* Block is within the mirrorable area. */
718
src_ptr = src_buffer[compptr->h_samp_factor - offset_x - 1]
719
[comp_height - y_crop_blocks - dst_blk_y - offset_y - 1];
720
for (i = 0; i < DCTSIZE; i++) {
721
for (j = 0; j < DCTSIZE; j++) {
722
dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
723
j++;
724
dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
725
}
726
i++;
727
for (j = 0; j < DCTSIZE; j++) {
728
dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
729
j++;
730
dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
731
}
732
}
733
} else {
734
/* Right-edge blocks are mirrored in y only */
735
src_ptr = src_buffer[offset_x]
736
[comp_height - y_crop_blocks - dst_blk_y - offset_y - 1];
737
for (i = 0; i < DCTSIZE; i++) {
738
for (j = 0; j < DCTSIZE; j++) {
739
dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
740
j++;
741
dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
742
}
743
}
744
}
745
} else {
746
if (x_crop_blocks + dst_blk_x < comp_width) {
747
/* Bottom-edge blocks are mirrored in x only */
748
src_ptr = src_buffer[compptr->h_samp_factor - offset_x - 1]
749
[dst_blk_y + offset_y + y_crop_blocks];
750
for (i = 0; i < DCTSIZE; i++) {
751
for (j = 0; j < DCTSIZE; j++)
752
dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
753
i++;
754
for (j = 0; j < DCTSIZE; j++)
755
dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
756
}
757
} else {
758
/* At lower right corner, just transpose, no mirroring */
759
src_ptr = src_buffer[offset_x]
760
[dst_blk_y + offset_y + y_crop_blocks];
761
for (i = 0; i < DCTSIZE; i++)
762
for (j = 0; j < DCTSIZE; j++)
763
dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
764
}
765
}
766
}
767
}
768
}
769
}
770
}
771
}
772
773
774
/* Parse an unsigned integer: subroutine for jtransform_parse_crop_spec.
775
* Returns TRUE if valid integer found, FALSE if not.
776
* *strptr is advanced over the digit string, and *result is set to its value.
777
*/
778
779
LOCAL(boolean)
780
jt_read_integer (const char ** strptr, JDIMENSION * result)
781
{
782
const char * ptr = *strptr;
783
JDIMENSION val = 0;
784
785
for (; isdigit(*ptr); ptr++) {
786
val = val * 10 + (JDIMENSION) (*ptr - '0');
787
}
788
*result = val;
789
if (ptr == *strptr)
790
return FALSE; /* oops, no digits */
791
*strptr = ptr;
792
return TRUE;
793
}
794
795
796
/* Parse a crop specification (written in X11 geometry style).
797
* The routine returns TRUE if the spec string is valid, FALSE if not.
798
*
799
* The crop spec string should have the format
800
* <width>x<height>{+-}<xoffset>{+-}<yoffset>
801
* where width, height, xoffset, and yoffset are unsigned integers.
802
* Each of the elements can be omitted to indicate a default value.
803
* (A weakness of this style is that it is not possible to omit xoffset
804
* while specifying yoffset, since they look alike.)
805
*
806
* This code is loosely based on XParseGeometry from the X11 distribution.
807
*/
808
809
GLOBAL(boolean)
810
jtransform_parse_crop_spec (jpeg_transform_info *info, const char *spec)
811
{
812
info->crop = FALSE;
813
info->crop_width_set = JCROP_UNSET;
814
info->crop_height_set = JCROP_UNSET;
815
info->crop_xoffset_set = JCROP_UNSET;
816
info->crop_yoffset_set = JCROP_UNSET;
817
818
if (isdigit(*spec)) {
819
/* fetch width */
820
if (! jt_read_integer(&spec, &info->crop_width))
821
return FALSE;
822
info->crop_width_set = JCROP_POS;
823
}
824
if (*spec == 'x' || *spec == 'X') {
825
/* fetch height */
826
spec++;
827
if (! jt_read_integer(&spec, &info->crop_height))
828
return FALSE;
829
info->crop_height_set = JCROP_POS;
830
}
831
if (*spec == '+' || *spec == '-') {
832
/* fetch xoffset */
833
info->crop_xoffset_set = (*spec == '-') ? JCROP_NEG : JCROP_POS;
834
spec++;
835
if (! jt_read_integer(&spec, &info->crop_xoffset))
836
return FALSE;
837
}
838
if (*spec == '+' || *spec == '-') {
839
/* fetch yoffset */
840
info->crop_yoffset_set = (*spec == '-') ? JCROP_NEG : JCROP_POS;
841
spec++;
842
if (! jt_read_integer(&spec, &info->crop_yoffset))
843
return FALSE;
844
}
845
/* We had better have gotten to the end of the string. */
846
if (*spec != '\0')
847
return FALSE;
848
info->crop = TRUE;
849
return TRUE;
850
}
851
852
853
/* Trim off any partial iMCUs on the indicated destination edge */
854
855
LOCAL(void)
856
trim_right_edge (jpeg_transform_info *info, JDIMENSION full_width)
857
{
858
JDIMENSION MCU_cols;
859
860
MCU_cols = info->output_width / info->iMCU_sample_width;
861
if (MCU_cols > 0 && info->x_crop_offset + MCU_cols ==
862
full_width / info->iMCU_sample_width)
863
info->output_width = MCU_cols * info->iMCU_sample_width;
864
}
865
866
LOCAL(void)
867
trim_bottom_edge (jpeg_transform_info *info, JDIMENSION full_height)
868
{
869
JDIMENSION MCU_rows;
870
871
MCU_rows = info->output_height / info->iMCU_sample_height;
872
if (MCU_rows > 0 && info->y_crop_offset + MCU_rows ==
873
full_height / info->iMCU_sample_height)
874
info->output_height = MCU_rows * info->iMCU_sample_height;
875
}
876
877
878
/* Request any required workspace.
879
*
880
* This routine figures out the size that the output image will be
881
* (which implies that all the transform parameters must be set before
882
* it is called).
883
*
884
* We allocate the workspace virtual arrays from the source decompression
885
* object, so that all the arrays (both the original data and the workspace)
886
* will be taken into account while making memory management decisions.
887
* Hence, this routine must be called after jpeg_read_header (which reads
888
* the image dimensions) and before jpeg_read_coefficients (which realizes
889
* the source's virtual arrays).
890
*
891
* This function returns FALSE right away if -perfect is given
892
* and transformation is not perfect. Otherwise returns TRUE.
893
*/
894
895
GLOBAL(boolean)
896
jtransform_request_workspace (j_decompress_ptr srcinfo,
897
jpeg_transform_info *info)
898
{
899
jvirt_barray_ptr *coef_arrays;
900
boolean need_workspace, transpose_it;
901
jpeg_component_info *compptr;
902
JDIMENSION xoffset, yoffset;
903
JDIMENSION width_in_iMCUs, height_in_iMCUs;
904
JDIMENSION width_in_blocks, height_in_blocks;
905
int ci, h_samp_factor, v_samp_factor;
906
907
/* Determine number of components in output image */
908
if (info->force_grayscale &&
909
srcinfo->jpeg_color_space == JCS_YCbCr &&
910
srcinfo->num_components == 3)
911
/* We'll only process the first component */
912
info->num_components = 1;
913
else
914
/* Process all the components */
915
info->num_components = srcinfo->num_components;
916
917
/* Compute output image dimensions and related values. */
918
jpeg_core_output_dimensions(srcinfo);
919
920
/* Return right away if -perfect is given and transformation is not perfect.
921
*/
922
if (info->perfect) {
923
if (info->num_components == 1) {
924
if (!jtransform_perfect_transform(srcinfo->output_width,
925
srcinfo->output_height,
926
srcinfo->min_DCT_h_scaled_size,
927
srcinfo->min_DCT_v_scaled_size,
928
info->transform))
929
return FALSE;
930
} else {
931
if (!jtransform_perfect_transform(srcinfo->output_width,
932
srcinfo->output_height,
933
srcinfo->max_h_samp_factor * srcinfo->min_DCT_h_scaled_size,
934
srcinfo->max_v_samp_factor * srcinfo->min_DCT_v_scaled_size,
935
info->transform))
936
return FALSE;
937
}
938
}
939
940
/* If there is only one output component, force the iMCU size to be 1;
941
* else use the source iMCU size. (This allows us to do the right thing
942
* when reducing color to grayscale, and also provides a handy way of
943
* cleaning up "funny" grayscale images whose sampling factors are not 1x1.)
944
*/
945
switch (info->transform) {
946
case JXFORM_TRANSPOSE:
947
case JXFORM_TRANSVERSE:
948
case JXFORM_ROT_90:
949
case JXFORM_ROT_270:
950
info->output_width = srcinfo->output_height;
951
info->output_height = srcinfo->output_width;
952
if (info->num_components == 1) {
953
info->iMCU_sample_width = srcinfo->min_DCT_v_scaled_size;
954
info->iMCU_sample_height = srcinfo->min_DCT_h_scaled_size;
955
} else {
956
info->iMCU_sample_width =
957
srcinfo->max_v_samp_factor * srcinfo->min_DCT_v_scaled_size;
958
info->iMCU_sample_height =
959
srcinfo->max_h_samp_factor * srcinfo->min_DCT_h_scaled_size;
960
}
961
break;
962
default:
963
info->output_width = srcinfo->output_width;
964
info->output_height = srcinfo->output_height;
965
if (info->num_components == 1) {
966
info->iMCU_sample_width = srcinfo->min_DCT_h_scaled_size;
967
info->iMCU_sample_height = srcinfo->min_DCT_v_scaled_size;
968
} else {
969
info->iMCU_sample_width =
970
srcinfo->max_h_samp_factor * srcinfo->min_DCT_h_scaled_size;
971
info->iMCU_sample_height =
972
srcinfo->max_v_samp_factor * srcinfo->min_DCT_v_scaled_size;
973
}
974
break;
975
}
976
977
/* If cropping has been requested, compute the crop area's position and
978
* dimensions, ensuring that its upper left corner falls at an iMCU boundary.
979
*/
980
if (info->crop) {
981
/* Insert default values for unset crop parameters */
982
if (info->crop_xoffset_set == JCROP_UNSET)
983
info->crop_xoffset = 0; /* default to +0 */
984
if (info->crop_yoffset_set == JCROP_UNSET)
985
info->crop_yoffset = 0; /* default to +0 */
986
if (info->crop_xoffset >= info->output_width ||
987
info->crop_yoffset >= info->output_height)
988
ERREXIT(srcinfo, JERR_BAD_CROP_SPEC);
989
if (info->crop_width_set == JCROP_UNSET)
990
info->crop_width = info->output_width - info->crop_xoffset;
991
if (info->crop_height_set == JCROP_UNSET)
992
info->crop_height = info->output_height - info->crop_yoffset;
993
/* Ensure parameters are valid */
994
if (info->crop_width <= 0 || info->crop_width > info->output_width ||
995
info->crop_height <= 0 || info->crop_height > info->output_height ||
996
info->crop_xoffset > info->output_width - info->crop_width ||
997
info->crop_yoffset > info->output_height - info->crop_height)
998
ERREXIT(srcinfo, JERR_BAD_CROP_SPEC);
999
/* Convert negative crop offsets into regular offsets */
1000
if (info->crop_xoffset_set == JCROP_NEG)
1001
xoffset = info->output_width - info->crop_width - info->crop_xoffset;
1002
else
1003
xoffset = info->crop_xoffset;
1004
if (info->crop_yoffset_set == JCROP_NEG)
1005
yoffset = info->output_height - info->crop_height - info->crop_yoffset;
1006
else
1007
yoffset = info->crop_yoffset;
1008
/* Now adjust so that upper left corner falls at an iMCU boundary */
1009
info->output_width =
1010
info->crop_width + (xoffset % info->iMCU_sample_width);
1011
info->output_height =
1012
info->crop_height + (yoffset % info->iMCU_sample_height);
1013
/* Save x/y offsets measured in iMCUs */
1014
info->x_crop_offset = xoffset / info->iMCU_sample_width;
1015
info->y_crop_offset = yoffset / info->iMCU_sample_height;
1016
} else {
1017
info->x_crop_offset = 0;
1018
info->y_crop_offset = 0;
1019
}
1020
1021
/* Figure out whether we need workspace arrays,
1022
* and if so whether they are transposed relative to the source.
1023
*/
1024
need_workspace = FALSE;
1025
transpose_it = FALSE;
1026
switch (info->transform) {
1027
case JXFORM_NONE:
1028
if (info->x_crop_offset != 0 || info->y_crop_offset != 0)
1029
need_workspace = TRUE;
1030
/* No workspace needed if neither cropping nor transforming */
1031
break;
1032
case JXFORM_FLIP_H:
1033
if (info->trim)
1034
trim_right_edge(info, srcinfo->output_width);
1035
if (info->y_crop_offset != 0)
1036
need_workspace = TRUE;
1037
/* do_flip_h_no_crop doesn't need a workspace array */
1038
break;
1039
case JXFORM_FLIP_V:
1040
if (info->trim)
1041
trim_bottom_edge(info, srcinfo->output_height);
1042
/* Need workspace arrays having same dimensions as source image. */
1043
need_workspace = TRUE;
1044
break;
1045
case JXFORM_TRANSPOSE:
1046
/* transpose does NOT have to trim anything */
1047
/* Need workspace arrays having transposed dimensions. */
1048
need_workspace = TRUE;
1049
transpose_it = TRUE;
1050
break;
1051
case JXFORM_TRANSVERSE:
1052
if (info->trim) {
1053
trim_right_edge(info, srcinfo->output_height);
1054
trim_bottom_edge(info, srcinfo->output_width);
1055
}
1056
/* Need workspace arrays having transposed dimensions. */
1057
need_workspace = TRUE;
1058
transpose_it = TRUE;
1059
break;
1060
case JXFORM_ROT_90:
1061
if (info->trim)
1062
trim_right_edge(info, srcinfo->output_height);
1063
/* Need workspace arrays having transposed dimensions. */
1064
need_workspace = TRUE;
1065
transpose_it = TRUE;
1066
break;
1067
case JXFORM_ROT_180:
1068
if (info->trim) {
1069
trim_right_edge(info, srcinfo->output_width);
1070
trim_bottom_edge(info, srcinfo->output_height);
1071
}
1072
/* Need workspace arrays having same dimensions as source image. */
1073
need_workspace = TRUE;
1074
break;
1075
case JXFORM_ROT_270:
1076
if (info->trim)
1077
trim_bottom_edge(info, srcinfo->output_width);
1078
/* Need workspace arrays having transposed dimensions. */
1079
need_workspace = TRUE;
1080
transpose_it = TRUE;
1081
break;
1082
}
1083
1084
/* Allocate workspace if needed.
1085
* Note that we allocate arrays padded out to the next iMCU boundary,
1086
* so that transform routines need not worry about missing edge blocks.
1087
*/
1088
if (need_workspace) {
1089
coef_arrays = (jvirt_barray_ptr *)
1090
(*srcinfo->mem->alloc_small) ((j_common_ptr) srcinfo, JPOOL_IMAGE,
1091
sizeof(jvirt_barray_ptr) * info->num_components);
1092
width_in_iMCUs = (JDIMENSION)
1093
jdiv_round_up((long) info->output_width,
1094
(long) info->iMCU_sample_width);
1095
height_in_iMCUs = (JDIMENSION)
1096
jdiv_round_up((long) info->output_height,
1097
(long) info->iMCU_sample_height);
1098
for (ci = 0; ci < info->num_components; ci++) {
1099
compptr = srcinfo->comp_info + ci;
1100
if (info->num_components == 1) {
1101
/* we're going to force samp factors to 1x1 in this case */
1102
h_samp_factor = v_samp_factor = 1;
1103
} else if (transpose_it) {
1104
h_samp_factor = compptr->v_samp_factor;
1105
v_samp_factor = compptr->h_samp_factor;
1106
} else {
1107
h_samp_factor = compptr->h_samp_factor;
1108
v_samp_factor = compptr->v_samp_factor;
1109
}
1110
width_in_blocks = width_in_iMCUs * h_samp_factor;
1111
height_in_blocks = height_in_iMCUs * v_samp_factor;
1112
coef_arrays[ci] = (*srcinfo->mem->request_virt_barray)
1113
((j_common_ptr) srcinfo, JPOOL_IMAGE, FALSE,
1114
width_in_blocks, height_in_blocks, (JDIMENSION) v_samp_factor);
1115
}
1116
info->workspace_coef_arrays = coef_arrays;
1117
} else
1118
info->workspace_coef_arrays = NULL;
1119
1120
return TRUE;
1121
}
1122
1123
1124
/* Transpose destination image parameters */
1125
1126
LOCAL(void)
1127
transpose_critical_parameters (j_compress_ptr dstinfo)
1128
{
1129
int tblno, i, j, ci, itemp;
1130
jpeg_component_info *compptr;
1131
JQUANT_TBL *qtblptr;
1132
JDIMENSION jtemp;
1133
UINT16 qtemp;
1134
1135
/* Transpose image dimensions */
1136
jtemp = dstinfo->image_width;
1137
dstinfo->image_width = dstinfo->image_height;
1138
dstinfo->image_height = jtemp;
1139
itemp = dstinfo->min_DCT_h_scaled_size;
1140
dstinfo->min_DCT_h_scaled_size = dstinfo->min_DCT_v_scaled_size;
1141
dstinfo->min_DCT_v_scaled_size = itemp;
1142
1143
/* Transpose sampling factors */
1144
for (ci = 0; ci < dstinfo->num_components; ci++) {
1145
compptr = dstinfo->comp_info + ci;
1146
itemp = compptr->h_samp_factor;
1147
compptr->h_samp_factor = compptr->v_samp_factor;
1148
compptr->v_samp_factor = itemp;
1149
}
1150
1151
/* Transpose quantization tables */
1152
for (tblno = 0; tblno < NUM_QUANT_TBLS; tblno++) {
1153
qtblptr = dstinfo->quant_tbl_ptrs[tblno];
1154
if (qtblptr != NULL) {
1155
for (i = 0; i < DCTSIZE; i++) {
1156
for (j = 0; j < i; j++) {
1157
qtemp = qtblptr->quantval[i*DCTSIZE+j];
1158
qtblptr->quantval[i*DCTSIZE+j] = qtblptr->quantval[j*DCTSIZE+i];
1159
qtblptr->quantval[j*DCTSIZE+i] = qtemp;
1160
}
1161
}
1162
}
1163
}
1164
}
1165
1166
1167
/* Adjust Exif image parameters.
1168
*
1169
* We try to adjust the Tags ExifImageWidth and ExifImageHeight if possible.
1170
*/
1171
1172
LOCAL(void)
1173
adjust_exif_parameters (JOCTET FAR * data, unsigned int length,
1174
JDIMENSION new_width, JDIMENSION new_height)
1175
{
1176
boolean is_motorola; /* Flag for byte order */
1177
unsigned int number_of_tags, tagnum;
1178
unsigned int firstoffset, offset;
1179
JDIMENSION new_value;
1180
1181
if (length < 12) return; /* Length of an IFD entry */
1182
1183
/* Discover byte order */
1184
if (GETJOCTET(data[0]) == 0x49 && GETJOCTET(data[1]) == 0x49)
1185
is_motorola = FALSE;
1186
else if (GETJOCTET(data[0]) == 0x4D && GETJOCTET(data[1]) == 0x4D)
1187
is_motorola = TRUE;
1188
else
1189
return;
1190
1191
/* Check Tag Mark */
1192
if (is_motorola) {
1193
if (GETJOCTET(data[2]) != 0) return;
1194
if (GETJOCTET(data[3]) != 0x2A) return;
1195
} else {
1196
if (GETJOCTET(data[3]) != 0) return;
1197
if (GETJOCTET(data[2]) != 0x2A) return;
1198
}
1199
1200
/* Get first IFD offset (offset to IFD0) */
1201
if (is_motorola) {
1202
if (GETJOCTET(data[4]) != 0) return;
1203
if (GETJOCTET(data[5]) != 0) return;
1204
firstoffset = GETJOCTET(data[6]);
1205
firstoffset <<= 8;
1206
firstoffset += GETJOCTET(data[7]);
1207
} else {
1208
if (GETJOCTET(data[7]) != 0) return;
1209
if (GETJOCTET(data[6]) != 0) return;
1210
firstoffset = GETJOCTET(data[5]);
1211
firstoffset <<= 8;
1212
firstoffset += GETJOCTET(data[4]);
1213
}
1214
if (firstoffset > length - 2) return; /* check end of data segment */
1215
1216
/* Get the number of directory entries contained in this IFD */
1217
if (is_motorola) {
1218
number_of_tags = GETJOCTET(data[firstoffset]);
1219
number_of_tags <<= 8;
1220
number_of_tags += GETJOCTET(data[firstoffset+1]);
1221
} else {
1222
number_of_tags = GETJOCTET(data[firstoffset+1]);
1223
number_of_tags <<= 8;
1224
number_of_tags += GETJOCTET(data[firstoffset]);
1225
}
1226
if (number_of_tags == 0) return;
1227
firstoffset += 2;
1228
1229
/* Search for ExifSubIFD offset Tag in IFD0 */
1230
for (;;) {
1231
if (firstoffset > length - 12) return; /* check end of data segment */
1232
/* Get Tag number */
1233
if (is_motorola) {
1234
tagnum = GETJOCTET(data[firstoffset]);
1235
tagnum <<= 8;
1236
tagnum += GETJOCTET(data[firstoffset+1]);
1237
} else {
1238
tagnum = GETJOCTET(data[firstoffset+1]);
1239
tagnum <<= 8;
1240
tagnum += GETJOCTET(data[firstoffset]);
1241
}
1242
if (tagnum == 0x8769) break; /* found ExifSubIFD offset Tag */
1243
if (--number_of_tags == 0) return;
1244
firstoffset += 12;
1245
}
1246
1247
/* Get the ExifSubIFD offset */
1248
if (is_motorola) {
1249
if (GETJOCTET(data[firstoffset+8]) != 0) return;
1250
if (GETJOCTET(data[firstoffset+9]) != 0) return;
1251
offset = GETJOCTET(data[firstoffset+10]);
1252
offset <<= 8;
1253
offset += GETJOCTET(data[firstoffset+11]);
1254
} else {
1255
if (GETJOCTET(data[firstoffset+11]) != 0) return;
1256
if (GETJOCTET(data[firstoffset+10]) != 0) return;
1257
offset = GETJOCTET(data[firstoffset+9]);
1258
offset <<= 8;
1259
offset += GETJOCTET(data[firstoffset+8]);
1260
}
1261
if (offset > length - 2) return; /* check end of data segment */
1262
1263
/* Get the number of directory entries contained in this SubIFD */
1264
if (is_motorola) {
1265
number_of_tags = GETJOCTET(data[offset]);
1266
number_of_tags <<= 8;
1267
number_of_tags += GETJOCTET(data[offset+1]);
1268
} else {
1269
number_of_tags = GETJOCTET(data[offset+1]);
1270
number_of_tags <<= 8;
1271
number_of_tags += GETJOCTET(data[offset]);
1272
}
1273
if (number_of_tags < 2) return;
1274
offset += 2;
1275
1276
/* Search for ExifImageWidth and ExifImageHeight Tags in this SubIFD */
1277
do {
1278
if (offset > length - 12) return; /* check end of data segment */
1279
/* Get Tag number */
1280
if (is_motorola) {
1281
tagnum = GETJOCTET(data[offset]);
1282
tagnum <<= 8;
1283
tagnum += GETJOCTET(data[offset+1]);
1284
} else {
1285
tagnum = GETJOCTET(data[offset+1]);
1286
tagnum <<= 8;
1287
tagnum += GETJOCTET(data[offset]);
1288
}
1289
if (tagnum == 0xA002 || tagnum == 0xA003) {
1290
if (tagnum == 0xA002)
1291
new_value = new_width; /* ExifImageWidth Tag */
1292
else
1293
new_value = new_height; /* ExifImageHeight Tag */
1294
if (is_motorola) {
1295
data[offset+2] = 0; /* Format = unsigned long (4 octets) */
1296
data[offset+3] = 4;
1297
data[offset+4] = 0; /* Number Of Components = 1 */
1298
data[offset+5] = 0;
1299
data[offset+6] = 0;
1300
data[offset+7] = 1;
1301
data[offset+8] = 0;
1302
data[offset+9] = 0;
1303
data[offset+10] = (JOCTET)((new_value >> 8) & 0xFF);
1304
data[offset+11] = (JOCTET)(new_value & 0xFF);
1305
} else {
1306
data[offset+2] = 4; /* Format = unsigned long (4 octets) */
1307
data[offset+3] = 0;
1308
data[offset+4] = 1; /* Number Of Components = 1 */
1309
data[offset+5] = 0;
1310
data[offset+6] = 0;
1311
data[offset+7] = 0;
1312
data[offset+8] = (JOCTET)(new_value & 0xFF);
1313
data[offset+9] = (JOCTET)((new_value >> 8) & 0xFF);
1314
data[offset+10] = 0;
1315
data[offset+11] = 0;
1316
}
1317
}
1318
offset += 12;
1319
} while (--number_of_tags);
1320
}
1321
1322
1323
/* Adjust output image parameters as needed.
1324
*
1325
* This must be called after jpeg_copy_critical_parameters()
1326
* and before jpeg_write_coefficients().
1327
*
1328
* The return value is the set of virtual coefficient arrays to be written
1329
* (either the ones allocated by jtransform_request_workspace, or the
1330
* original source data arrays). The caller will need to pass this value
1331
* to jpeg_write_coefficients().
1332
*/
1333
1334
GLOBAL(jvirt_barray_ptr *)
1335
jtransform_adjust_parameters (j_decompress_ptr srcinfo,
1336
j_compress_ptr dstinfo,
1337
jvirt_barray_ptr *src_coef_arrays,
1338
jpeg_transform_info *info)
1339
{
1340
/* If force-to-grayscale is requested, adjust destination parameters */
1341
if (info->force_grayscale) {
1342
/* First, ensure we have YCbCr or grayscale data, and that the source's
1343
* Y channel is full resolution. (No reasonable person would make Y
1344
* be less than full resolution, so actually coping with that case
1345
* isn't worth extra code space. But we check it to avoid crashing.)
1346
*/
1347
if (((dstinfo->jpeg_color_space == JCS_YCbCr &&
1348
dstinfo->num_components == 3) ||
1349
(dstinfo->jpeg_color_space == JCS_GRAYSCALE &&
1350
dstinfo->num_components == 1)) &&
1351
srcinfo->comp_info[0].h_samp_factor == srcinfo->max_h_samp_factor &&
1352
srcinfo->comp_info[0].v_samp_factor == srcinfo->max_v_samp_factor) {
1353
/* We use jpeg_set_colorspace to make sure subsidiary settings get fixed
1354
* properly. Among other things, it sets the target h_samp_factor &
1355
* v_samp_factor to 1, which typically won't match the source.
1356
* We have to preserve the source's quantization table number, however.
1357
*/
1358
int sv_quant_tbl_no = dstinfo->comp_info[0].quant_tbl_no;
1359
jpeg_set_colorspace(dstinfo, JCS_GRAYSCALE);
1360
dstinfo->comp_info[0].quant_tbl_no = sv_quant_tbl_no;
1361
} else {
1362
/* Sorry, can't do it */
1363
ERREXIT(dstinfo, JERR_CONVERSION_NOTIMPL);
1364
}
1365
} else if (info->num_components == 1) {
1366
/* For a single-component source, we force the destination sampling factors
1367
* to 1x1, with or without force_grayscale. This is useful because some
1368
* decoders choke on grayscale images with other sampling factors.
1369
*/
1370
dstinfo->comp_info[0].h_samp_factor = 1;
1371
dstinfo->comp_info[0].v_samp_factor = 1;
1372
}
1373
1374
/* Correct the destination's image dimensions as necessary
1375
* for rotate/flip, resize, and crop operations.
1376
*/
1377
dstinfo->jpeg_width = info->output_width;
1378
dstinfo->jpeg_height = info->output_height;
1379
1380
/* Transpose destination image parameters */
1381
switch (info->transform) {
1382
case JXFORM_TRANSPOSE:
1383
case JXFORM_TRANSVERSE:
1384
case JXFORM_ROT_90:
1385
case JXFORM_ROT_270:
1386
transpose_critical_parameters(dstinfo);
1387
break;
1388
default:
1389
break;
1390
}
1391
1392
/* Adjust Exif properties */
1393
if (srcinfo->marker_list != NULL &&
1394
srcinfo->marker_list->marker == JPEG_APP0+1 &&
1395
srcinfo->marker_list->data_length >= 6 &&
1396
GETJOCTET(srcinfo->marker_list->data[0]) == 0x45 &&
1397
GETJOCTET(srcinfo->marker_list->data[1]) == 0x78 &&
1398
GETJOCTET(srcinfo->marker_list->data[2]) == 0x69 &&
1399
GETJOCTET(srcinfo->marker_list->data[3]) == 0x66 &&
1400
GETJOCTET(srcinfo->marker_list->data[4]) == 0 &&
1401
GETJOCTET(srcinfo->marker_list->data[5]) == 0) {
1402
/* Suppress output of JFIF marker */
1403
dstinfo->write_JFIF_header = FALSE;
1404
/* Adjust Exif image parameters */
1405
if (dstinfo->jpeg_width != srcinfo->image_width ||
1406
dstinfo->jpeg_height != srcinfo->image_height)
1407
/* Align data segment to start of TIFF structure for parsing */
1408
adjust_exif_parameters(srcinfo->marker_list->data + 6,
1409
srcinfo->marker_list->data_length - 6,
1410
dstinfo->jpeg_width, dstinfo->jpeg_height);
1411
}
1412
1413
/* Return the appropriate output data set */
1414
if (info->workspace_coef_arrays != NULL)
1415
return info->workspace_coef_arrays;
1416
return src_coef_arrays;
1417
}
1418
1419
1420
/* Execute the actual transformation, if any.
1421
*
1422
* This must be called *after* jpeg_write_coefficients, because it depends
1423
* on jpeg_write_coefficients to have computed subsidiary values such as
1424
* the per-component width and height fields in the destination object.
1425
*
1426
* Note that some transformations will modify the source data arrays!
1427
*/
1428
1429
GLOBAL(void)
1430
jtransform_execute_transform (j_decompress_ptr srcinfo,
1431
j_compress_ptr dstinfo,
1432
jvirt_barray_ptr *src_coef_arrays,
1433
jpeg_transform_info *info)
1434
{
1435
jvirt_barray_ptr *dst_coef_arrays = info->workspace_coef_arrays;
1436
1437
/* Note: conditions tested here should match those in switch statement
1438
* in jtransform_request_workspace()
1439
*/
1440
switch (info->transform) {
1441
case JXFORM_NONE:
1442
if (info->x_crop_offset != 0 || info->y_crop_offset != 0)
1443
do_crop(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
1444
src_coef_arrays, dst_coef_arrays);
1445
break;
1446
case JXFORM_FLIP_H:
1447
if (info->y_crop_offset != 0)
1448
do_flip_h(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
1449
src_coef_arrays, dst_coef_arrays);
1450
else
1451
do_flip_h_no_crop(srcinfo, dstinfo, info->x_crop_offset,
1452
src_coef_arrays);
1453
break;
1454
case JXFORM_FLIP_V:
1455
do_flip_v(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
1456
src_coef_arrays, dst_coef_arrays);
1457
break;
1458
case JXFORM_TRANSPOSE:
1459
do_transpose(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
1460
src_coef_arrays, dst_coef_arrays);
1461
break;
1462
case JXFORM_TRANSVERSE:
1463
do_transverse(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
1464
src_coef_arrays, dst_coef_arrays);
1465
break;
1466
case JXFORM_ROT_90:
1467
do_rot_90(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
1468
src_coef_arrays, dst_coef_arrays);
1469
break;
1470
case JXFORM_ROT_180:
1471
do_rot_180(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
1472
src_coef_arrays, dst_coef_arrays);
1473
break;
1474
case JXFORM_ROT_270:
1475
do_rot_270(srcinfo, dstinfo, info->x_crop_offset, info->y_crop_offset,
1476
src_coef_arrays, dst_coef_arrays);
1477
break;
1478
}
1479
}
1480
1481
/* jtransform_perfect_transform
1482
*
1483
* Determine whether lossless transformation is perfectly
1484
* possible for a specified image and transformation.
1485
*
1486
* Inputs:
1487
* image_width, image_height: source image dimensions.
1488
* MCU_width, MCU_height: pixel dimensions of MCU.
1489
* transform: transformation identifier.
1490
* Parameter sources from initialized jpeg_struct
1491
* (after reading source header):
1492
* image_width = cinfo.image_width
1493
* image_height = cinfo.image_height
1494
* MCU_width = cinfo.max_h_samp_factor * cinfo.block_size
1495
* MCU_height = cinfo.max_v_samp_factor * cinfo.block_size
1496
* Result:
1497
* TRUE = perfect transformation possible
1498
* FALSE = perfect transformation not possible
1499
* (may use custom action then)
1500
*/
1501
1502
GLOBAL(boolean)
1503
jtransform_perfect_transform(JDIMENSION image_width, JDIMENSION image_height,
1504
int MCU_width, int MCU_height,
1505
JXFORM_CODE transform)
1506
{
1507
boolean result = TRUE; /* initialize TRUE */
1508
1509
switch (transform) {
1510
case JXFORM_FLIP_H:
1511
case JXFORM_ROT_270:
1512
if (image_width % (JDIMENSION) MCU_width)
1513
result = FALSE;
1514
break;
1515
case JXFORM_FLIP_V:
1516
case JXFORM_ROT_90:
1517
if (image_height % (JDIMENSION) MCU_height)
1518
result = FALSE;
1519
break;
1520
case JXFORM_TRANSVERSE:
1521
case JXFORM_ROT_180:
1522
if (image_width % (JDIMENSION) MCU_width)
1523
result = FALSE;
1524
if (image_height % (JDIMENSION) MCU_height)
1525
result = FALSE;
1526
break;
1527
default:
1528
break;
1529
}
1530
1531
return result;
1532
}
1533
1534
#endif /* TRANSFORMS_SUPPORTED */
1535
1536
1537
/* Setup decompression object to save desired markers in memory.
1538
* This must be called before jpeg_read_header() to have the desired effect.
1539
*/
1540
1541
GLOBAL(void)
1542
jcopy_markers_setup (j_decompress_ptr srcinfo, JCOPY_OPTION option)
1543
{
1544
#ifdef SAVE_MARKERS_SUPPORTED
1545
int m;
1546
1547
/* Save comments except under NONE option */
1548
if (option != JCOPYOPT_NONE) {
1549
jpeg_save_markers(srcinfo, JPEG_COM, 0xFFFF);
1550
}
1551
/* Save all types of APPn markers iff ALL option */
1552
if (option == JCOPYOPT_ALL) {
1553
for (m = 0; m < 16; m++)
1554
jpeg_save_markers(srcinfo, JPEG_APP0 + m, 0xFFFF);
1555
}
1556
#endif /* SAVE_MARKERS_SUPPORTED */
1557
}
1558
1559
/* Copy markers saved in the given source object to the destination object.
1560
* This should be called just after jpeg_start_compress() or
1561
* jpeg_write_coefficients().
1562
* Note that those routines will have written the SOI, and also the
1563
* JFIF APP0 or Adobe APP14 markers if selected.
1564
*/
1565
1566
GLOBAL(void)
1567
jcopy_markers_execute (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
1568
JCOPY_OPTION option)
1569
{
1570
jpeg_saved_marker_ptr marker;
1571
1572
/* In the current implementation, we don't actually need to examine the
1573
* option flag here; we just copy everything that got saved.
1574
* But to avoid confusion, we do not output JFIF and Adobe APP14 markers
1575
* if the encoder library already wrote one.
1576
*/
1577
for (marker = srcinfo->marker_list; marker != NULL; marker = marker->next) {
1578
if (dstinfo->write_JFIF_header &&
1579
marker->marker == JPEG_APP0 &&
1580
marker->data_length >= 5 &&
1581
GETJOCTET(marker->data[0]) == 0x4A &&
1582
GETJOCTET(marker->data[1]) == 0x46 &&
1583
GETJOCTET(marker->data[2]) == 0x49 &&
1584
GETJOCTET(marker->data[3]) == 0x46 &&
1585
GETJOCTET(marker->data[4]) == 0)
1586
continue; /* reject duplicate JFIF */
1587
if (dstinfo->write_Adobe_marker &&
1588
marker->marker == JPEG_APP0+14 &&
1589
marker->data_length >= 5 &&
1590
GETJOCTET(marker->data[0]) == 0x41 &&
1591
GETJOCTET(marker->data[1]) == 0x64 &&
1592
GETJOCTET(marker->data[2]) == 0x6F &&
1593
GETJOCTET(marker->data[3]) == 0x62 &&
1594
GETJOCTET(marker->data[4]) == 0x65)
1595
continue; /* reject duplicate Adobe */
1596
#ifdef NEED_FAR_POINTERS
1597
/* We could use jpeg_write_marker if the data weren't FAR... */
1598
{
1599
unsigned int i;
1600
jpeg_write_m_header(dstinfo, marker->marker, marker->data_length);
1601
for (i = 0; i < marker->data_length; i++)
1602
jpeg_write_m_byte(dstinfo, marker->data[i]);
1603
}
1604
#else
1605
jpeg_write_marker(dstinfo, marker->marker,
1606
marker->data, marker->data_length);
1607
#endif
1608
}
1609
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1