w32tex
About: TeX Live provides a comprehensive TeX system including all the major TeX-related programs, macro packages, and fonts that are free software. Windows sources.
  Fossies Dox: w32tex-src.tar.xz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

transupp.c
Go to the documentation of this file.
1 /*
2  * transupp.c
3  *
4  * Copyright (C) 1997, Thomas G. Lane.
5  * This file is part of the Independent JPEG Group's software.
6  * For conditions of distribution and use, see the accompanying README file.
7  *
8  * This file contains image transformation routines and other utility code
9  * used by the jpegtran sample application. These are NOT part of the core
10  * JPEG library. But we keep these routines separate from jpegtran.c to
11  * ease the task of maintaining jpegtran-like programs that have other user
12  * interfaces.
13  */
14 
15 /* Although this file really shouldn't have access to the library internals,
16  * it's helpful to let it call jround_up() and jcopy_block_row().
17  */
18 #define JPEG_INTERNALS
19 
20 #include "jinclude.h"
21 #include "jpeglib.h"
22 #include "transupp.h" /* My own external interface */
23 
24 
25 #if TRANSFORMS_SUPPORTED
26 
27 /*
28  * Lossless image transformation routines. These routines work on DCT
29  * coefficient arrays and thus do not require any lossy decompression
30  * or recompression of the image.
31  * Thanks to Guido Vollbeding for the initial design and code of this feature.
32  *
33  * Horizontal flipping is done in-place, using a single top-to-bottom
34  * pass through the virtual source array. It will thus be much the
35  * fastest option for images larger than main memory.
36  *
37  * The other routines require a set of destination virtual arrays, so they
38  * need twice as much memory as jpegtran normally does. The destination
39  * arrays are always written in normal scan order (top to bottom) because
40  * the virtual array manager expects this. The source arrays will be scanned
41  * in the corresponding order, which means multiple passes through the source
42  * arrays for most of the transforms. That could result in much thrashing
43  * if the image is larger than main memory.
44  *
45  * Some notes about the operating environment of the individual transform
46  * routines:
47  * 1. Both the source and destination virtual arrays are allocated from the
48  * source JPEG object, and therefore should be manipulated by calling the
49  * source's memory manager.
50  * 2. The destination's component count should be used. It may be smaller
51  * than the source's when forcing to grayscale.
52  * 3. Likewise the destination's sampling factors should be used. When
53  * forcing to grayscale the destination's sampling factors will be all 1,
54  * and we may as well take that as the effective iMCU size.
55  * 4. When "trim" is in effect, the destination's dimensions will be the
56  * trimmed values but the source's will be untrimmed.
57  * 5. All the routines assume that the source and destination buffers are
58  * padded out to a full iMCU boundary. This is true, although for the
59  * source buffer it is an undocumented property of jdcoefct.c.
60  * Notes 2,3,4 boil down to this: generally we should use the destination's
61  * dimensions and ignore the source's.
62  */
63 
64 
65 LOCAL(void)
66 do_flip_h (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
67  jvirt_barray_ptr *src_coef_arrays)
68 /* Horizontal flip; done in-place, so no separate dest array is required */
69 {
70  JDIMENSION MCU_cols, comp_width, blk_x, blk_y;
71  int ci, k, offset_y;
73  JCOEFPTR ptr1, ptr2;
74  JCOEF temp1, temp2;
76 
77  /* Horizontal mirroring of DCT blocks is accomplished by swapping
78  * pairs of blocks in-place. Within a DCT block, we perform horizontal
79  * mirroring by changing the signs of odd-numbered columns.
80  * Partial iMCUs at the right edge are left untouched.
81  */
83 
84  for (ci = 0; ci < dstinfo->num_components; ci++) {
85  compptr = dstinfo->comp_info + ci;
86  comp_width = MCU_cols * compptr->h_samp_factor;
87  for (blk_y = 0; blk_y < compptr->height_in_blocks;
88  blk_y += compptr->v_samp_factor) {
89  buffer = (*srcinfo->mem->access_virt_barray)
90  ((j_common_ptr) srcinfo, src_coef_arrays[ci], blk_y,
93  for (blk_x = 0; blk_x * 2 < comp_width; blk_x++) {
94  ptr1 = buffer[offset_y][blk_x];
95  ptr2 = buffer[offset_y][comp_width - blk_x - 1];
96  /* this unrolled loop doesn't need to know which row it's on... */
97  for (k = 0; k < DCTSIZE2; k += 2) {
98  temp1 = *ptr1; /* swap even column */
99  temp2 = *ptr2;
100  *ptr1++ = temp2;
101  *ptr2++ = temp1;
102  temp1 = *ptr1; /* swap odd column with sign change */
103  temp2 = *ptr2;
104  *ptr1++ = -temp2;
105  *ptr2++ = -temp1;
106  }
107  }
108  }
109  }
110  }
111 }
112 
113 
114 LOCAL(void)
115 do_flip_v (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
116  jvirt_barray_ptr *src_coef_arrays,
117  jvirt_barray_ptr *dst_coef_arrays)
118 /* Vertical flip */
119 {
120  JDIMENSION MCU_rows, comp_height, dst_blk_x, dst_blk_y;
121  int ci, i, j, offset_y;
122  JBLOCKARRAY src_buffer, dst_buffer;
123  JBLOCKROW src_row_ptr, dst_row_ptr;
124  JCOEFPTR src_ptr, dst_ptr;
126 
127  /* We output into a separate array because we can't touch different
128  * rows of the source virtual array simultaneously. Otherwise, this
129  * is a pretty straightforward analog of horizontal flip.
130  * Within a DCT block, vertical mirroring is done by changing the signs
131  * of odd-numbered rows.
132  * Partial iMCUs at the bottom edge are copied verbatim.
133  */
135 
136  for (ci = 0; ci < dstinfo->num_components; ci++) {
137  compptr = dstinfo->comp_info + ci;
138  comp_height = MCU_rows * compptr->v_samp_factor;
139  for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
140  dst_blk_y += compptr->v_samp_factor) {
141  dst_buffer = (*srcinfo->mem->access_virt_barray)
142  ((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
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,
150  } else {
151  /* Bottom-edge blocks will be copied verbatim. */
152  src_buffer = (*srcinfo->mem->access_virt_barray)
153  ((j_common_ptr) srcinfo, src_coef_arrays[ci], dst_blk_y,
155  }
156  for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
157  if (dst_blk_y < comp_height) {
158  /* Row is within the mirrorable area. */
159  dst_row_ptr = dst_buffer[offset_y];
160  src_row_ptr = src_buffer[compptr->v_samp_factor - offset_y - 1];
161  for (dst_blk_x = 0; dst_blk_x < compptr->width_in_blocks;
162  dst_blk_x++) {
163  dst_ptr = dst_row_ptr[dst_blk_x];
164  src_ptr = src_row_ptr[dst_blk_x];
165  for (i = 0; i < DCTSIZE; i += 2) {
166  /* copy even row */
167  for (j = 0; j < DCTSIZE; j++)
168  *dst_ptr++ = *src_ptr++;
169  /* copy odd row with sign change */
170  for (j = 0; j < DCTSIZE; j++)
171  *dst_ptr++ = - *src_ptr++;
172  }
173  }
174  } else {
175  /* Just copy row verbatim. */
176  jcopy_block_row(src_buffer[offset_y], dst_buffer[offset_y],
178  }
179  }
180  }
181  }
182 }
183 
184 
185 LOCAL(void)
186 do_transpose (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
187  jvirt_barray_ptr *src_coef_arrays,
188  jvirt_barray_ptr *dst_coef_arrays)
189 /* Transpose source into destination */
190 {
191  JDIMENSION dst_blk_x, dst_blk_y;
192  int ci, i, j, offset_x, offset_y;
193  JBLOCKARRAY src_buffer, dst_buffer;
194  JCOEFPTR src_ptr, dst_ptr;
196 
197  /* Transposing pixels within a block just requires transposing the
198  * DCT coefficients.
199  * Partial iMCUs at the edges require no special treatment; we simply
200  * process all the available DCT blocks for every component.
201  */
202  for (ci = 0; ci < dstinfo->num_components; ci++) {
203  compptr = dstinfo->comp_info + ci;
204  for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
205  dst_blk_y += compptr->v_samp_factor) {
206  dst_buffer = (*srcinfo->mem->access_virt_barray)
207  ((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
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,
215  for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) {
216  src_ptr = src_buffer[offset_x][dst_blk_y + offset_y];
217  dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x];
218  for (i = 0; i < DCTSIZE; i++)
219  for (j = 0; j < DCTSIZE; j++)
220  dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
221  }
222  }
223  }
224  }
225  }
226 }
227 
228 
229 LOCAL(void)
230 do_rot_90 (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
231  jvirt_barray_ptr *src_coef_arrays,
232  jvirt_barray_ptr *dst_coef_arrays)
233 /* 90 degree rotation is equivalent to
234  * 1. Transposing the image;
235  * 2. Horizontal mirroring.
236  * These two steps are merged into a single processing routine.
237  */
238 {
239  JDIMENSION MCU_cols, comp_width, dst_blk_x, dst_blk_y;
240  int ci, i, j, offset_x, offset_y;
241  JBLOCKARRAY src_buffer, dst_buffer;
242  JCOEFPTR src_ptr, dst_ptr;
244 
245  /* Because of the horizontal mirror step, we can't process partial iMCUs
246  * at the (output) right edge properly. They just get transposed and
247  * not mirrored.
248  */
250 
251  for (ci = 0; ci < dstinfo->num_components; ci++) {
252  compptr = dstinfo->comp_info + ci;
253  comp_width = MCU_cols * compptr->h_samp_factor;
254  for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
255  dst_blk_y += compptr->v_samp_factor) {
256  dst_buffer = (*srcinfo->mem->access_virt_barray)
257  ((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
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,
265  for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) {
266  src_ptr = src_buffer[offset_x][dst_blk_y + offset_y];
267  if (dst_blk_x < comp_width) {
268  /* Block is within the mirrorable area. */
269  dst_ptr = dst_buffer[offset_y]
270  [comp_width - dst_blk_x - offset_x - 1];
271  for (i = 0; i < DCTSIZE; i++) {
272  for (j = 0; j < DCTSIZE; j++)
273  dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
274  i++;
275  for (j = 0; j < DCTSIZE; j++)
276  dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
277  }
278  } else {
279  /* Edge blocks are transposed but not mirrored. */
280  dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x];
281  for (i = 0; i < DCTSIZE; i++)
282  for (j = 0; j < DCTSIZE; j++)
283  dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
284  }
285  }
286  }
287  }
288  }
289  }
290 }
291 
292 
293 LOCAL(void)
294 do_rot_270 (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
295  jvirt_barray_ptr *src_coef_arrays,
296  jvirt_barray_ptr *dst_coef_arrays)
297 /* 270 degree rotation is equivalent to
298  * 1. Horizontal mirroring;
299  * 2. Transposing the image.
300  * These two steps are merged into a single processing routine.
301  */
302 {
303  JDIMENSION MCU_rows, comp_height, dst_blk_x, dst_blk_y;
304  int ci, i, j, offset_x, offset_y;
305  JBLOCKARRAY src_buffer, dst_buffer;
306  JCOEFPTR src_ptr, dst_ptr;
308 
309  /* Because of the horizontal mirror step, we can't process partial iMCUs
310  * at the (output) bottom edge properly. They just get transposed and
311  * not mirrored.
312  */
314 
315  for (ci = 0; ci < dstinfo->num_components; ci++) {
316  compptr = dstinfo->comp_info + ci;
317  comp_height = MCU_rows * compptr->v_samp_factor;
318  for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
319  dst_blk_y += compptr->v_samp_factor) {
320  dst_buffer = (*srcinfo->mem->access_virt_barray)
321  ((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
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,
329  for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) {
330  dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x];
331  if (dst_blk_y < comp_height) {
332  /* Block is within the mirrorable area. */
333  src_ptr = src_buffer[offset_x]
334  [comp_height - dst_blk_y - offset_y - 1];
335  for (i = 0; i < DCTSIZE; i++) {
336  for (j = 0; j < DCTSIZE; j++) {
337  dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
338  j++;
339  dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
340  }
341  }
342  } else {
343  /* Edge blocks are transposed but not mirrored. */
344  src_ptr = src_buffer[offset_x][dst_blk_y + offset_y];
345  for (i = 0; i < DCTSIZE; i++)
346  for (j = 0; j < DCTSIZE; j++)
347  dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
348  }
349  }
350  }
351  }
352  }
353  }
354 }
355 
356 
357 LOCAL(void)
358 do_rot_180 (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
359  jvirt_barray_ptr *src_coef_arrays,
360  jvirt_barray_ptr *dst_coef_arrays)
361 /* 180 degree rotation is equivalent to
362  * 1. Vertical mirroring;
363  * 2. Horizontal mirroring.
364  * These two steps are merged into a single processing routine.
365  */
366 {
367  JDIMENSION MCU_cols, MCU_rows, comp_width, comp_height, dst_blk_x, dst_blk_y;
368  int ci, i, j, offset_y;
369  JBLOCKARRAY src_buffer, dst_buffer;
370  JBLOCKROW src_row_ptr, dst_row_ptr;
371  JCOEFPTR src_ptr, dst_ptr;
373 
376 
377  for (ci = 0; ci < dstinfo->num_components; ci++) {
378  compptr = dstinfo->comp_info + ci;
379  comp_width = MCU_cols * compptr->h_samp_factor;
380  comp_height = MCU_rows * compptr->v_samp_factor;
381  for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
382  dst_blk_y += compptr->v_samp_factor) {
383  dst_buffer = (*srcinfo->mem->access_virt_barray)
384  ((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
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,
392  } else {
393  /* Bottom-edge rows are only mirrored horizontally. */
394  src_buffer = (*srcinfo->mem->access_virt_barray)
395  ((j_common_ptr) srcinfo, src_coef_arrays[ci], dst_blk_y,
397  }
398  for (offset_y = 0; offset_y < compptr->v_samp_factor; offset_y++) {
399  if (dst_blk_y < comp_height) {
400  /* Row is within the mirrorable area. */
401  dst_row_ptr = dst_buffer[offset_y];
402  src_row_ptr = src_buffer[compptr->v_samp_factor - offset_y - 1];
403  /* Process the blocks that can be mirrored both ways. */
404  for (dst_blk_x = 0; dst_blk_x < comp_width; dst_blk_x++) {
405  dst_ptr = dst_row_ptr[dst_blk_x];
406  src_ptr = src_row_ptr[comp_width - dst_blk_x - 1];
407  for (i = 0; i < DCTSIZE; i += 2) {
408  /* For even row, negate every odd column. */
409  for (j = 0; j < DCTSIZE; j += 2) {
410  *dst_ptr++ = *src_ptr++;
411  *dst_ptr++ = - *src_ptr++;
412  }
413  /* For odd row, negate every even column. */
414  for (j = 0; j < DCTSIZE; j += 2) {
415  *dst_ptr++ = - *src_ptr++;
416  *dst_ptr++ = *src_ptr++;
417  }
418  }
419  }
420  /* Any remaining right-edge blocks are only mirrored vertically. */
421  for (; dst_blk_x < compptr->width_in_blocks; dst_blk_x++) {
422  dst_ptr = dst_row_ptr[dst_blk_x];
423  src_ptr = src_row_ptr[dst_blk_x];
424  for (i = 0; i < DCTSIZE; i += 2) {
425  for (j = 0; j < DCTSIZE; j++)
426  *dst_ptr++ = *src_ptr++;
427  for (j = 0; j < DCTSIZE; j++)
428  *dst_ptr++ = - *src_ptr++;
429  }
430  }
431  } else {
432  /* Remaining rows are just mirrored horizontally. */
433  dst_row_ptr = dst_buffer[offset_y];
434  src_row_ptr = src_buffer[offset_y];
435  /* Process the blocks that can be mirrored. */
436  for (dst_blk_x = 0; dst_blk_x < comp_width; dst_blk_x++) {
437  dst_ptr = dst_row_ptr[dst_blk_x];
438  src_ptr = src_row_ptr[comp_width - dst_blk_x - 1];
439  for (i = 0; i < DCTSIZE2; i += 2) {
440  *dst_ptr++ = *src_ptr++;
441  *dst_ptr++ = - *src_ptr++;
442  }
443  }
444  /* Any remaining right-edge blocks are only copied. */
445  for (; dst_blk_x < compptr->width_in_blocks; dst_blk_x++) {
446  dst_ptr = dst_row_ptr[dst_blk_x];
447  src_ptr = src_row_ptr[dst_blk_x];
448  for (i = 0; i < DCTSIZE2; i++)
449  *dst_ptr++ = *src_ptr++;
450  }
451  }
452  }
453  }
454  }
455 }
456 
457 
458 LOCAL(void)
459 do_transverse (j_decompress_ptr srcinfo, j_compress_ptr dstinfo,
460  jvirt_barray_ptr *src_coef_arrays,
461  jvirt_barray_ptr *dst_coef_arrays)
462 /* Transverse transpose is equivalent to
463  * 1. 180 degree rotation;
464  * 2. Transposition;
465  * or
466  * 1. Horizontal mirroring;
467  * 2. Transposition;
468  * 3. Horizontal mirroring.
469  * These steps are merged into a single processing routine.
470  */
471 {
472  JDIMENSION MCU_cols, MCU_rows, comp_width, comp_height, dst_blk_x, dst_blk_y;
473  int ci, i, j, offset_x, offset_y;
474  JBLOCKARRAY src_buffer, dst_buffer;
475  JCOEFPTR src_ptr, dst_ptr;
477 
480 
481  for (ci = 0; ci < dstinfo->num_components; ci++) {
482  compptr = dstinfo->comp_info + ci;
483  comp_width = MCU_cols * compptr->h_samp_factor;
484  comp_height = MCU_rows * compptr->v_samp_factor;
485  for (dst_blk_y = 0; dst_blk_y < compptr->height_in_blocks;
486  dst_blk_y += compptr->v_samp_factor) {
487  dst_buffer = (*srcinfo->mem->access_virt_barray)
488  ((j_common_ptr) srcinfo, dst_coef_arrays[ci], dst_blk_y,
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,
496  for (offset_x = 0; offset_x < compptr->h_samp_factor; offset_x++) {
497  if (dst_blk_y < comp_height) {
498  src_ptr = src_buffer[offset_x]
499  [comp_height - dst_blk_y - offset_y - 1];
500  if (dst_blk_x < comp_width) {
501  /* Block is within the mirrorable area. */
502  dst_ptr = dst_buffer[offset_y]
503  [comp_width - dst_blk_x - offset_x - 1];
504  for (i = 0; i < DCTSIZE; i++) {
505  for (j = 0; j < DCTSIZE; j++) {
506  dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
507  j++;
508  dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
509  }
510  i++;
511  for (j = 0; j < DCTSIZE; j++) {
512  dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
513  j++;
514  dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
515  }
516  }
517  } else {
518  /* Right-edge blocks are mirrored in y only */
519  dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x];
520  for (i = 0; i < DCTSIZE; i++) {
521  for (j = 0; j < DCTSIZE; j++) {
522  dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
523  j++;
524  dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
525  }
526  }
527  }
528  } else {
529  src_ptr = src_buffer[offset_x][dst_blk_y + offset_y];
530  if (dst_blk_x < comp_width) {
531  /* Bottom-edge blocks are mirrored in x only */
532  dst_ptr = dst_buffer[offset_y]
533  [comp_width - dst_blk_x - offset_x - 1];
534  for (i = 0; i < DCTSIZE; i++) {
535  for (j = 0; j < DCTSIZE; j++)
536  dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
537  i++;
538  for (j = 0; j < DCTSIZE; j++)
539  dst_ptr[j*DCTSIZE+i] = -src_ptr[i*DCTSIZE+j];
540  }
541  } else {
542  /* At lower right corner, just transpose, no mirroring */
543  dst_ptr = dst_buffer[offset_y][dst_blk_x + offset_x];
544  for (i = 0; i < DCTSIZE; i++)
545  for (j = 0; j < DCTSIZE; j++)
546  dst_ptr[j*DCTSIZE+i] = src_ptr[i*DCTSIZE+j];
547  }
548  }
549  }
550  }
551  }
552  }
553  }
554 }
555 
556 
557 /* Request any required workspace.
558  *
559  * We allocate the workspace virtual arrays from the source decompression
560  * object, so that all the arrays (both the original data and the workspace)
561  * will be taken into account while making memory management decisions.
562  * Hence, this routine must be called after jpeg_read_header (which reads
563  * the image dimensions) and before jpeg_read_coefficients (which realizes
564  * the source's virtual arrays).
565  */
566 
567 GLOBAL(void)
568 jtransform_request_workspace (j_decompress_ptr srcinfo,
570 {
571  jvirt_barray_ptr *coef_arrays = NULL;
573  int ci;
574 
575  if (info->force_grayscale &&
576  srcinfo->jpeg_color_space == JCS_YCbCr &&
577  srcinfo->num_components == 3) {
578  /* We'll only process the first component */
579  info->num_components = 1;
580  } else {
581  /* Process all the components */
582  info->num_components = srcinfo->num_components;
583  }
584 
585  switch (info->transform) {
586  case JXFORM_NONE:
587  case JXFORM_FLIP_H:
588  /* Don't need a workspace array */
589  break;
590  case JXFORM_FLIP_V:
591  case JXFORM_ROT_180:
592  /* Need workspace arrays having same dimensions as source image.
593  * Note that we allocate arrays padded out to the next iMCU boundary,
594  * so that transform routines need not worry about missing edge blocks.
595  */
596  coef_arrays = (jvirt_barray_ptr *)
597  (*srcinfo->mem->alloc_small) ((j_common_ptr) srcinfo, JPOOL_IMAGE,
598  SIZEOF(jvirt_barray_ptr) * info->num_components);
599  for (ci = 0; ci < info->num_components; ci++) {
600  compptr = srcinfo->comp_info + ci;
601  coef_arrays[ci] = (*srcinfo->mem->request_virt_barray)
602  ((j_common_ptr) srcinfo, JPOOL_IMAGE, FALSE,
604  (long) compptr->h_samp_factor),
606  (long) compptr->v_samp_factor),
608  }
609  break;
610  case JXFORM_TRANSPOSE:
611  case JXFORM_TRANSVERSE:
612  case JXFORM_ROT_90:
613  case JXFORM_ROT_270:
614  /* Need workspace arrays having transposed dimensions.
615  * Note that we allocate arrays padded out to the next iMCU boundary,
616  * so that transform routines need not worry about missing edge blocks.
617  */
618  coef_arrays = (jvirt_barray_ptr *)
619  (*srcinfo->mem->alloc_small) ((j_common_ptr) srcinfo, JPOOL_IMAGE,
620  SIZEOF(jvirt_barray_ptr) * info->num_components);
621  for (ci = 0; ci < info->num_components; ci++) {
622  compptr = srcinfo->comp_info + ci;
623  coef_arrays[ci] = (*srcinfo->mem->request_virt_barray)
624  ((j_common_ptr) srcinfo, JPOOL_IMAGE, FALSE,
626  (long) compptr->v_samp_factor),
628  (long) compptr->h_samp_factor),
630  }
631  break;
632  }
633  info->workspace_coef_arrays = coef_arrays;
634 }
635 
636 
637 /* Transpose destination image parameters */
638 
639 LOCAL(void)
640 transpose_critical_parameters (j_compress_ptr dstinfo)
641 {
642  int tblno, i, j, ci, itemp;
644  JQUANT_TBL *qtblptr;
645  JDIMENSION dtemp;
646  UINT16 qtemp;
647 
648  /* Transpose basic image dimensions */
649  dtemp = dstinfo->image_width;
651  dstinfo->image_height = dtemp;
652 
653  /* Transpose sampling factors */
654  for (ci = 0; ci < dstinfo->num_components; ci++) {
655  compptr = dstinfo->comp_info + ci;
656  itemp = compptr->h_samp_factor;
658  compptr->v_samp_factor = itemp;
659  }
660 
661  /* Transpose quantization tables */
662  for (tblno = 0; tblno < NUM_QUANT_TBLS; tblno++) {
663  qtblptr = dstinfo->quant_tbl_ptrs[tblno];
664  if (qtblptr != NULL) {
665  for (i = 0; i < DCTSIZE; i++) {
666  for (j = 0; j < i; j++) {
667  qtemp = qtblptr->quantval[i*DCTSIZE+j];
668  qtblptr->quantval[i*DCTSIZE+j] = qtblptr->quantval[j*DCTSIZE+i];
669  qtblptr->quantval[j*DCTSIZE+i] = qtemp;
670  }
671  }
672  }
673  }
674 }
675 
676 
677 /* Trim off any partial iMCUs on the indicated destination edge */
678 
679 LOCAL(void)
680 trim_right_edge (j_compress_ptr dstinfo)
681 {
682  int ci, max_h_samp_factor;
683  JDIMENSION MCU_cols;
684 
685  /* We have to compute max_h_samp_factor ourselves,
686  * because it hasn't been set yet in the destination
687  * (and we don't want to use the source's value).
688  */
689  max_h_samp_factor = 1;
690  for (ci = 0; ci < dstinfo->num_components; ci++) {
691  int h_samp_factor = dstinfo->comp_info[ci].h_samp_factor;
692  max_h_samp_factor = MAX(max_h_samp_factor, h_samp_factor);
693  }
694  MCU_cols = dstinfo->image_width / (max_h_samp_factor * DCTSIZE);
695  if (MCU_cols > 0) /* can't trim to 0 pixels */
696  dstinfo->image_width = MCU_cols * (max_h_samp_factor * DCTSIZE);
697 }
698 
699 LOCAL(void)
700 trim_bottom_edge (j_compress_ptr dstinfo)
701 {
702  int ci, max_v_samp_factor;
703  JDIMENSION MCU_rows;
704 
705  /* We have to compute max_v_samp_factor ourselves,
706  * because it hasn't been set yet in the destination
707  * (and we don't want to use the source's value).
708  */
709  max_v_samp_factor = 1;
710  for (ci = 0; ci < dstinfo->num_components; ci++) {
711  int v_samp_factor = dstinfo->comp_info[ci].v_samp_factor;
712  max_v_samp_factor = MAX(max_v_samp_factor, v_samp_factor);
713  }
714  MCU_rows = dstinfo->image_height / (max_v_samp_factor * DCTSIZE);
715  if (MCU_rows > 0) /* can't trim to 0 pixels */
716  dstinfo->image_height = MCU_rows * (max_v_samp_factor * DCTSIZE);
717 }
718 
719 
720 /* Adjust output image parameters as needed.
721  *
722  * This must be called after jpeg_copy_critical_parameters()
723  * and before jpeg_write_coefficients().
724  *
725  * The return value is the set of virtual coefficient arrays to be written
726  * (either the ones allocated by jtransform_request_workspace, or the
727  * original source data arrays). The caller will need to pass this value
728  * to jpeg_write_coefficients().
729  */
730 
732 jtransform_adjust_parameters (j_decompress_ptr srcinfo,
734  jvirt_barray_ptr *src_coef_arrays,
736 {
737  /* If force-to-grayscale is requested, adjust destination parameters */
738  if (info->force_grayscale) {
739  /* We use jpeg_set_colorspace to make sure subsidiary settings get fixed
740  * properly. Among other things, the target h_samp_factor & v_samp_factor
741  * will get set to 1, which typically won't match the source.
742  * In fact we do this even if the source is already grayscale; that
743  * provides an easy way of coercing a grayscale JPEG with funny sampling
744  * factors to the customary 1,1. (Some decoders fail on other factors.)
745  */
747  dstinfo->num_components == 3) ||
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;
753  dstinfo->comp_info[0].quant_tbl_no = sv_quant_tbl_no;
754  } else {
755  /* Sorry, can't do it */
757  }
758  }
759 
760  /* Correct the destination's image dimensions etc if necessary */
761  switch (info->transform) {
762  case JXFORM_NONE:
763  /* Nothing to do */
764  break;
765  case JXFORM_FLIP_H:
766  if (info->trim)
767  trim_right_edge(dstinfo);
768  break;
769  case JXFORM_FLIP_V:
770  if (info->trim)
771  trim_bottom_edge(dstinfo);
772  break;
773  case JXFORM_TRANSPOSE:
774  transpose_critical_parameters(dstinfo);
775  /* transpose does NOT have to trim anything */
776  break;
777  case JXFORM_TRANSVERSE:
778  transpose_critical_parameters(dstinfo);
779  if (info->trim) {
780  trim_right_edge(dstinfo);
781  trim_bottom_edge(dstinfo);
782  }
783  break;
784  case JXFORM_ROT_90:
785  transpose_critical_parameters(dstinfo);
786  if (info->trim)
787  trim_right_edge(dstinfo);
788  break;
789  case JXFORM_ROT_180:
790  if (info->trim) {
791  trim_right_edge(dstinfo);
792  trim_bottom_edge(dstinfo);
793  }
794  break;
795  case JXFORM_ROT_270:
796  transpose_critical_parameters(dstinfo);
797  if (info->trim)
798  trim_bottom_edge(dstinfo);
799  break;
800  }
801 
802  /* Return the appropriate output data set */
803  if (info->workspace_coef_arrays != NULL)
804  return info->workspace_coef_arrays;
805  return src_coef_arrays;
806 }
807 
808 
809 /* Execute the actual transformation, if any.
810  *
811  * This must be called *after* jpeg_write_coefficients, because it depends
812  * on jpeg_write_coefficients to have computed subsidiary values such as
813  * the per-component width and height fields in the destination object.
814  *
815  * Note that some transformations will modify the source data arrays!
816  */
817 
818 GLOBAL(void)
819 jtransform_execute_transformation (j_decompress_ptr srcinfo,
821  jvirt_barray_ptr *src_coef_arrays,
823 {
824  jvirt_barray_ptr *dst_coef_arrays = info->workspace_coef_arrays;
825 
826  switch (info->transform) {
827  case JXFORM_NONE:
828  break;
829  case JXFORM_FLIP_H:
830  do_flip_h(srcinfo, dstinfo, src_coef_arrays);
831  break;
832  case JXFORM_FLIP_V:
833  do_flip_v(srcinfo, dstinfo, src_coef_arrays, dst_coef_arrays);
834  break;
835  case JXFORM_TRANSPOSE:
836  do_transpose(srcinfo, dstinfo, src_coef_arrays, dst_coef_arrays);
837  break;
838  case JXFORM_TRANSVERSE:
839  do_transverse(srcinfo, dstinfo, src_coef_arrays, dst_coef_arrays);
840  break;
841  case JXFORM_ROT_90:
842  do_rot_90(srcinfo, dstinfo, src_coef_arrays, dst_coef_arrays);
843  break;
844  case JXFORM_ROT_180:
845  do_rot_180(srcinfo, dstinfo, src_coef_arrays, dst_coef_arrays);
846  break;
847  case JXFORM_ROT_270:
848  do_rot_270(srcinfo, dstinfo, src_coef_arrays, dst_coef_arrays);
849  break;
850  }
851 }
852 
853 #endif /* TRANSFORMS_SUPPORTED */
854 
855 
856 /* Setup decompression object to save desired markers in memory.
857  * This must be called before jpeg_read_header() to have the desired effect.
858  */
859 
860 GLOBAL(void)
862 {
863 #ifdef SAVE_MARKERS_SUPPORTED
864  int m;
865 
866  /* Save comments except under NONE option */
867  if (option != JCOPYOPT_NONE) {
868  jpeg_save_markers(srcinfo, JPEG_COM, 0xFFFF);
869  }
870  /* Save all types of APPn markers iff ALL option */
871  if (option == JCOPYOPT_ALL) {
872  for (m = 0; m < 16; m++)
873  jpeg_save_markers(srcinfo, JPEG_APP0 + m, 0xFFFF);
874  }
875 #endif /* SAVE_MARKERS_SUPPORTED */
876 }
877 
878 /* Copy markers saved in the given source object to the destination object.
879  * This should be called just after jpeg_start_compress() or
880  * jpeg_write_coefficients().
881  * Note that those routines will have written the SOI, and also the
882  * JFIF APP0 or Adobe APP14 markers if selected.
883  */
884 
885 GLOBAL(void)
888 {
889  jpeg_saved_marker_ptr marker;
890 
891  /* In the current implementation, we don't actually need to examine the
892  * option flag here; we just copy everything that got saved.
893  * But to avoid confusion, we do not output JFIF and Adobe APP14 markers
894  * if the encoder library already wrote one.
895  */
896  for (marker = srcinfo->marker_list; marker != NULL; marker = marker->next) {
897  if (dstinfo->write_JFIF_header &&
898  marker->marker == JPEG_APP0 &&
899  marker->data_length >= 5 &&
900  GETJOCTET(marker->data[0]) == 0x4A &&
901  GETJOCTET(marker->data[1]) == 0x46 &&
902  GETJOCTET(marker->data[2]) == 0x49 &&
903  GETJOCTET(marker->data[3]) == 0x46 &&
904  GETJOCTET(marker->data[4]) == 0)
905  continue; /* reject duplicate JFIF */
907  marker->marker == JPEG_APP0+14 &&
908  marker->data_length >= 5 &&
909  GETJOCTET(marker->data[0]) == 0x41 &&
910  GETJOCTET(marker->data[1]) == 0x64 &&
911  GETJOCTET(marker->data[2]) == 0x6F &&
912  GETJOCTET(marker->data[3]) == 0x62 &&
913  GETJOCTET(marker->data[4]) == 0x65)
914  continue; /* reject duplicate Adobe */
915 #ifdef NEED_FAR_POINTERS
916  /* We could use jpeg_write_marker if the data weren't FAR... */
917  {
918  unsigned int i;
919  jpeg_write_m_header(dstinfo, marker->marker, marker->data_length);
920  for (i = 0; i < marker->data_length; i++)
921  jpeg_write_m_byte(dstinfo, marker->data[i]);
922  }
923 #else
925  marker->data, marker->data_length);
926 #endif
927  }
928 }
@ FALSE
Definition: dd.h:101
@ TRUE
Definition: dd.h:102
#define info
Definition: dviinfo.c:42
int offset_x
Definition: hbf2gf.c:415
int offset_y
Definition: hbf2gf.c:416
void jpeg_write_marker(j_compress_ptr cinfo, int marker, const JOCTET *dataptr, unsigned int datalen)
Definition: jcapimin.c:192
void jpeg_write_m_header(j_compress_ptr cinfo, int marker, unsigned int datalen)
Definition: jcapimin.c:214
void jpeg_write_m_byte(j_compress_ptr cinfo, int val)
Definition: jcapimin.c:226
boolean int tblno
Definition: jchuff.h:42
void jpeg_set_colorspace(j_compress_ptr cinfo, J_COLOR_SPACE colorspace)
Definition: jcparam.c:391
jpeg_component_info * compptr
Definition: jdct.h:102
void jpeg_save_markers(j_decompress_ptr cinfo, int marker_code, unsigned int length_limit)
Definition: jdmarker.c:1300
#define ERREXIT(cinfo, code)
Definition: jerror.h:205
@ JERR_CONVERSION_NOTIMPL
Definition: jerror.h:73
#define SIZEOF(object)
Definition: jinclude.h:80
unsigned int JDIMENSION
Definition: jmorecfg.h:171
unsigned int UINT16
Definition: jmorecfg.h:149
#define LOCAL(type)
Definition: jmorecfg.h:186
#define GETJOCTET(value)
Definition: jmorecfg.h:119
short JCOEF
Definition: jmorecfg.h:99
#define GLOBAL(type)
Definition: jmorecfg.h:188
#define MAX(a, b)
Definition: jpegint.h:267
struct jpeg_common_struct * j_common_ptr
Definition: jpeglib.h:261
#define DCTSIZE
Definition: jpeglib.h:41
JCOEF * JCOEFPTR
Definition: jpeglib.h:75
@ JCS_YCbCr
Definition: jpeglib.h:210
@ JCS_GRAYSCALE
Definition: jpeglib.h:208
JBLOCKROW * JBLOCKARRAY
Definition: jpeglib.h:72
#define JPEG_COM
Definition: jpeglib.h:1048
#define NUM_QUANT_TBLS
Definition: jpeglib.h:43
JBLOCK * JBLOCKROW
Definition: jpeglib.h:71
#define JPOOL_IMAGE
Definition: jpeglib.h:749
#define JPEG_APP0
Definition: jpeglib.h:1047
#define DCTSIZE2
Definition: jpeglib.h:42
long jround_up(long a, long b)
Definition: jutils.c:81
void jcopy_block_row(JBLOCKROW input_row, JBLOCKROW output_row, JDIMENSION num_blocks)
Definition: jutils.c:145
void jcopy_markers_execute(j_decompress_ptr srcinfo, j_compress_ptr dstinfo, JCOPY_OPTION option)
Definition: transupp.c:886
void jcopy_markers_setup(j_decompress_ptr srcinfo, JCOPY_OPTION option)
Definition: transupp.c:861
@ JXFORM_FLIP_H
Definition: transupp.h:42
@ JXFORM_ROT_270
Definition: transupp.h:48
@ JXFORM_TRANSPOSE
Definition: transupp.h:44
@ JXFORM_TRANSVERSE
Definition: transupp.h:45
@ JXFORM_NONE
Definition: transupp.h:41
@ JXFORM_ROT_180
Definition: transupp.h:47
@ JXFORM_FLIP_V
Definition: transupp.h:43
@ JXFORM_ROT_90
Definition: transupp.h:46
JCOPY_OPTION
Definition: transupp.h:121
@ JCOPYOPT_NONE
Definition: transupp.h:122
@ JCOPYOPT_ALL
Definition: transupp.h:124
j_compress_ptr dstinfo
Definition: transupp.h:134
#define NULL
Definition: ftobjs.h:61
small capitals from c petite p scientific i
Definition: afcover.h:80
#define JDIMENSION
Definition: gd_topal.c:67
int k
Definition: otp-parser.c:70
UINT16 quantval[64]
Definition: jpeglib.h:88
Definition: utils.c:300
JDIMENSION width_in_blocks
Definition: jpeglib.h:139
JDIMENSION height_in_blocks
Definition: jpeglib.h:140
boolean write_JFIF_header
Definition: jpeglib.h:337
JDIMENSION image_height
Definition: jpeglib.h:280
boolean write_Adobe_marker
Definition: jpeglib.h:347
J_COLOR_SPACE jpeg_color_space
Definition: jpeglib.h:297
JQUANT_TBL * quant_tbl_ptrs[4]
Definition: jpeglib.h:302
jpeg_component_info * comp_info
Definition: jpeglib.h:299
JDIMENSION image_width
Definition: jpeglib.h:279
jpeg_component_info * comp_info
Definition: jpeglib.h:535
struct jpeg_memory_mgr * mem
Definition: jpeglib.h:412
J_COLOR_SPACE jpeg_color_space
Definition: jpeglib.h:423
JOCTET * data
Definition: jpeglib.h:200
jpeg_saved_marker_ptr next
Definition: jpeglib.h:196
unsigned int data_length
Definition: jpeglib.h:199
jvirt_barray_ptr(* request_virt_barray)(j_common_ptr cinfo, int pool_id, boolean pre_zero, JDIMENSION blocksperrow, JDIMENSION numrows, JDIMENSION maxaccess)
Definition: jpeglib.h:779
void *(* alloc_small)(j_common_ptr cinfo, int pool_id, size_t sizeofobject)
Definition: jpeglib.h:759
JBLOCKARRAY(* access_virt_barray)(j_common_ptr cinfo, jvirt_barray_ptr ptr, JDIMENSION start_row, JDIMENSION num_rows, boolean writable)
Definition: jpeglib.h:790
Definition: getopt.h:95
int j
Definition: t4ht.c:1589
m
Definition: tex4ht.c:3990
#define buffer
Definition: xmlparse.c:611