4 * Copyright (C) 1995-1998, Thomas G. Lane.
5 * Modified 2000-2013 by Guido Vollbeding.
6 * This file is part of the Independent JPEG Group's software.
7 * For conditions of distribution and use, see the accompanying README file.
9 * This file contains library routines for transcoding compression,
10 * that is, writing raw DCT coefficient arrays to an output JPEG file.
11 * The routines in jcapimin.c will also be needed by a transcoder.
14 #define JPEG_INTERNALS
19 /* Forward declarations */
20 LOCAL(void) transencode_master_selection
21 JPP((j_compress_ptr cinfo
, jvirt_barray_ptr
* coef_arrays
));
22 LOCAL(void) transencode_coef_controller
23 JPP((j_compress_ptr cinfo
, jvirt_barray_ptr
* coef_arrays
));
27 * Compression initialization for writing raw-coefficient data.
28 * Before calling this, all parameters and a data destination must be set up.
29 * Call jpeg_finish_compress() to actually write the data.
31 * The number of passed virtual arrays must match cinfo->num_components.
32 * Note that the virtual arrays need not be filled or even realized at
33 * the time write_coefficients is called; indeed, if the virtual arrays
34 * were requested from this compression object's memory manager, they
35 * typically will be realized during this routine and filled afterwards.
39 jpeg_write_coefficients (j_compress_ptr cinfo
, jvirt_barray_ptr
* coef_arrays
)
41 if (cinfo
->global_state
!= CSTATE_START
)
42 ERREXIT1(cinfo
, JERR_BAD_STATE
, cinfo
->global_state
);
43 /* Mark all tables to be written */
44 jpeg_suppress_tables(cinfo
, FALSE
);
45 /* (Re)initialize error mgr and destination modules */
46 (*cinfo
->err
->reset_error_mgr
) ((j_common_ptr
) cinfo
);
47 (*cinfo
->dest
->init_destination
) (cinfo
);
48 /* Perform master selection of active modules */
49 transencode_master_selection(cinfo
, coef_arrays
);
50 /* Wait for jpeg_finish_compress() call */
51 cinfo
->next_scanline
= 0; /* so jpeg_write_marker works */
52 cinfo
->global_state
= CSTATE_WRCOEFS
;
57 * Initialize the compression object with default parameters,
58 * then copy from the source object all parameters needed for lossless
59 * transcoding. Parameters that can be varied without loss (such as
60 * scan script and Huffman optimization) are left in their default states.
64 jpeg_copy_critical_parameters (j_decompress_ptr srcinfo
,
65 j_compress_ptr dstinfo
)
67 JQUANT_TBL
** qtblptr
;
68 jpeg_component_info
*incomp
, *outcomp
;
69 JQUANT_TBL
*c_quant
, *slot_quant
;
72 /* Safety check to ensure start_compress not called yet. */
73 if (dstinfo
->global_state
!= CSTATE_START
)
74 ERREXIT1(dstinfo
, JERR_BAD_STATE
, dstinfo
->global_state
);
75 /* Copy fundamental image dimensions */
76 dstinfo
->image_width
= srcinfo
->image_width
;
77 dstinfo
->image_height
= srcinfo
->image_height
;
78 dstinfo
->input_components
= srcinfo
->num_components
;
79 dstinfo
->in_color_space
= srcinfo
->jpeg_color_space
;
80 dstinfo
->jpeg_width
= srcinfo
->output_width
;
81 dstinfo
->jpeg_height
= srcinfo
->output_height
;
82 dstinfo
->min_DCT_h_scaled_size
= srcinfo
->min_DCT_h_scaled_size
;
83 dstinfo
->min_DCT_v_scaled_size
= srcinfo
->min_DCT_v_scaled_size
;
84 /* Initialize all parameters to default values */
85 jpeg_set_defaults(dstinfo
);
86 /* jpeg_set_defaults may choose wrong colorspace, eg YCbCr if input is RGB.
87 * Fix it to get the right header markers for the image colorspace.
88 * Note: Entropy table assignment in jpeg_set_colorspace depends
91 dstinfo
->color_transform
= srcinfo
->color_transform
;
92 jpeg_set_colorspace(dstinfo
, srcinfo
->jpeg_color_space
);
93 dstinfo
->data_precision
= srcinfo
->data_precision
;
94 dstinfo
->CCIR601_sampling
= srcinfo
->CCIR601_sampling
;
95 /* Copy the source's quantization tables. */
96 for (tblno
= 0; tblno
< NUM_QUANT_TBLS
; tblno
++) {
97 if (srcinfo
->quant_tbl_ptrs
[tblno
] != NULL
) {
98 qtblptr
= & dstinfo
->quant_tbl_ptrs
[tblno
];
100 *qtblptr
= jpeg_alloc_quant_table((j_common_ptr
) dstinfo
);
101 MEMCOPY((*qtblptr
)->quantval
,
102 srcinfo
->quant_tbl_ptrs
[tblno
]->quantval
,
103 SIZEOF((*qtblptr
)->quantval
));
104 (*qtblptr
)->sent_table
= FALSE
;
107 /* Copy the source's per-component info.
108 * Note we assume jpeg_set_defaults has allocated the dest comp_info array.
110 dstinfo
->num_components
= srcinfo
->num_components
;
111 if (dstinfo
->num_components
< 1 || dstinfo
->num_components
> MAX_COMPONENTS
)
112 ERREXIT2(dstinfo
, JERR_COMPONENT_COUNT
, dstinfo
->num_components
,
114 for (ci
= 0, incomp
= srcinfo
->comp_info
, outcomp
= dstinfo
->comp_info
;
115 ci
< dstinfo
->num_components
; ci
++, incomp
++, outcomp
++) {
116 outcomp
->component_id
= incomp
->component_id
;
117 outcomp
->h_samp_factor
= incomp
->h_samp_factor
;
118 outcomp
->v_samp_factor
= incomp
->v_samp_factor
;
119 outcomp
->quant_tbl_no
= incomp
->quant_tbl_no
;
120 /* Make sure saved quantization table for component matches the qtable
121 * slot. If not, the input file re-used this qtable slot.
122 * IJG encoder currently cannot duplicate this.
124 tblno
= outcomp
->quant_tbl_no
;
125 if (tblno
< 0 || tblno
>= NUM_QUANT_TBLS
||
126 srcinfo
->quant_tbl_ptrs
[tblno
] == NULL
)
127 ERREXIT1(dstinfo
, JERR_NO_QUANT_TABLE
, tblno
);
128 slot_quant
= srcinfo
->quant_tbl_ptrs
[tblno
];
129 c_quant
= incomp
->quant_table
;
130 if (c_quant
!= NULL
) {
131 for (coefi
= 0; coefi
< DCTSIZE2
; coefi
++) {
132 if (c_quant
->quantval
[coefi
] != slot_quant
->quantval
[coefi
])
133 ERREXIT1(dstinfo
, JERR_MISMATCHED_QUANT_TABLE
, tblno
);
136 /* Note: we do not copy the source's entropy table assignments;
137 * instead we rely on jpeg_set_colorspace to have made a suitable choice.
140 /* Also copy JFIF version and resolution information, if available.
141 * Strictly speaking this isn't "critical" info, but it's nearly
142 * always appropriate to copy it if available. In particular,
143 * if the application chooses to copy JFIF 1.02 extension markers from
144 * the source file, we need to copy the version to make sure we don't
145 * emit a file that has 1.02 extensions but a claimed version of 1.01.
147 if (srcinfo
->saw_JFIF_marker
) {
148 if (srcinfo
->JFIF_major_version
== 1 ||
149 srcinfo
->JFIF_major_version
== 2) {
150 dstinfo
->JFIF_major_version
= srcinfo
->JFIF_major_version
;
151 dstinfo
->JFIF_minor_version
= srcinfo
->JFIF_minor_version
;
153 dstinfo
->density_unit
= srcinfo
->density_unit
;
154 dstinfo
->X_density
= srcinfo
->X_density
;
155 dstinfo
->Y_density
= srcinfo
->Y_density
;
161 * Master selection of compression modules for transcoding.
162 * This substitutes for jcinit.c's initialization of the full compressor.
166 transencode_master_selection (j_compress_ptr cinfo
,
167 jvirt_barray_ptr
* coef_arrays
)
169 /* Initialize master control (includes parameter checking/processing) */
170 jinit_c_master_control(cinfo
, TRUE
/* transcode only */);
172 /* Entropy encoding: either Huffman or arithmetic coding. */
173 if (cinfo
->arith_code
)
174 jinit_arith_encoder(cinfo
);
176 jinit_huff_encoder(cinfo
);
179 /* We need a special coefficient buffer controller. */
180 transencode_coef_controller(cinfo
, coef_arrays
);
182 jinit_marker_writer(cinfo
);
184 /* We can now tell the memory manager to allocate virtual arrays. */
185 (*cinfo
->mem
->realize_virt_arrays
) ((j_common_ptr
) cinfo
);
187 /* Write the datastream header (SOI, JFIF) immediately.
188 * Frame and scan headers are postponed till later.
189 * This lets application insert special markers after the SOI.
191 (*cinfo
->marker
->write_file_header
) (cinfo
);
196 * The rest of this file is a special implementation of the coefficient
197 * buffer controller. This is similar to jccoefct.c, but it handles only
198 * output from presupplied virtual arrays. Furthermore, we generate any
199 * dummy padding blocks on-the-fly rather than expecting them to be present
203 /* Private buffer controller object */
206 struct jpeg_c_coef_controller pub
; /* public fields */
208 JDIMENSION iMCU_row_num
; /* iMCU row # within image */
209 JDIMENSION mcu_ctr
; /* counts MCUs processed in current row */
210 int MCU_vert_offset
; /* counts MCU rows within iMCU row */
211 int MCU_rows_per_iMCU_row
; /* number of such rows needed */
213 /* Virtual block array for each component. */
214 jvirt_barray_ptr
* whole_image
;
216 /* Workspace for constructing dummy blocks at right/bottom edges. */
217 JBLOCKROW dummy_buffer
[C_MAX_BLOCKS_IN_MCU
];
218 } my_coef_controller
;
220 typedef my_coef_controller
* my_coef_ptr
;
224 start_iMCU_row (j_compress_ptr cinfo
)
225 /* Reset within-iMCU-row counters for a new row */
227 my_coef_ptr coef
= (my_coef_ptr
) cinfo
->coef
;
229 /* In an interleaved scan, an MCU row is the same as an iMCU row.
230 * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
231 * But at the bottom of the image, process only what's left.
233 if (cinfo
->comps_in_scan
> 1) {
234 coef
->MCU_rows_per_iMCU_row
= 1;
236 if (coef
->iMCU_row_num
< (cinfo
->total_iMCU_rows
-1))
237 coef
->MCU_rows_per_iMCU_row
= cinfo
->cur_comp_info
[0]->v_samp_factor
;
239 coef
->MCU_rows_per_iMCU_row
= cinfo
->cur_comp_info
[0]->last_row_height
;
243 coef
->MCU_vert_offset
= 0;
248 * Initialize for a processing pass.
252 start_pass_coef (j_compress_ptr cinfo
, J_BUF_MODE pass_mode
)
254 my_coef_ptr coef
= (my_coef_ptr
) cinfo
->coef
;
256 if (pass_mode
!= JBUF_CRANK_DEST
)
257 ERREXIT(cinfo
, JERR_BAD_BUFFER_MODE
);
259 coef
->iMCU_row_num
= 0;
260 start_iMCU_row(cinfo
);
266 * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
267 * per call, ie, v_samp_factor block rows for each component in the scan.
268 * The data is obtained from the virtual arrays and fed to the entropy coder.
269 * Returns TRUE if the iMCU row is completed, FALSE if suspended.
271 * NB: input_buf is ignored; it is likely to be a NULL pointer.
275 compress_output (j_compress_ptr cinfo
, JSAMPIMAGE input_buf
)
277 my_coef_ptr coef
= (my_coef_ptr
) cinfo
->coef
;
278 JDIMENSION MCU_col_num
; /* index of current MCU within row */
279 JDIMENSION last_MCU_col
= cinfo
->MCUs_per_row
- 1;
280 JDIMENSION last_iMCU_row
= cinfo
->total_iMCU_rows
- 1;
281 int blkn
, ci
, xindex
, yindex
, yoffset
, blockcnt
;
282 JDIMENSION start_col
;
283 JBLOCKARRAY buffer
[MAX_COMPS_IN_SCAN
];
284 JBLOCKROW MCU_buffer
[C_MAX_BLOCKS_IN_MCU
];
285 JBLOCKROW buffer_ptr
;
286 jpeg_component_info
*compptr
;
288 /* Align the virtual buffers for the components used in this scan. */
289 for (ci
= 0; ci
< cinfo
->comps_in_scan
; ci
++) {
290 compptr
= cinfo
->cur_comp_info
[ci
];
291 buffer
[ci
] = (*cinfo
->mem
->access_virt_barray
)
292 ((j_common_ptr
) cinfo
, coef
->whole_image
[compptr
->component_index
],
293 coef
->iMCU_row_num
* compptr
->v_samp_factor
,
294 (JDIMENSION
) compptr
->v_samp_factor
, FALSE
);
297 /* Loop to process one whole iMCU row */
298 for (yoffset
= coef
->MCU_vert_offset
; yoffset
< coef
->MCU_rows_per_iMCU_row
;
300 for (MCU_col_num
= coef
->mcu_ctr
; MCU_col_num
< cinfo
->MCUs_per_row
;
302 /* Construct list of pointers to DCT blocks belonging to this MCU */
303 blkn
= 0; /* index of current DCT block within MCU */
304 for (ci
= 0; ci
< cinfo
->comps_in_scan
; ci
++) {
305 compptr
= cinfo
->cur_comp_info
[ci
];
306 start_col
= MCU_col_num
* compptr
->MCU_width
;
307 blockcnt
= (MCU_col_num
< last_MCU_col
) ? compptr
->MCU_width
308 : compptr
->last_col_width
;
309 for (yindex
= 0; yindex
< compptr
->MCU_height
; yindex
++) {
310 if (coef
->iMCU_row_num
< last_iMCU_row
||
311 yindex
+yoffset
< compptr
->last_row_height
) {
312 /* Fill in pointers to real blocks in this row */
313 buffer_ptr
= buffer
[ci
][yindex
+yoffset
] + start_col
;
314 for (xindex
= 0; xindex
< blockcnt
; xindex
++)
315 MCU_buffer
[blkn
++] = buffer_ptr
++;
317 /* At bottom of image, need a whole row of dummy blocks */
320 /* Fill in any dummy blocks needed in this row.
321 * Dummy blocks are filled in the same way as in jccoefct.c:
322 * all zeroes in the AC entries, DC entries equal to previous
323 * block's DC value. The init routine has already zeroed the
324 * AC entries, so we need only set the DC entries correctly.
326 for (; xindex
< compptr
->MCU_width
; xindex
++) {
327 MCU_buffer
[blkn
] = coef
->dummy_buffer
[blkn
];
328 MCU_buffer
[blkn
][0][0] = MCU_buffer
[blkn
-1][0][0];
333 /* Try to write the MCU. */
334 if (! (*cinfo
->entropy
->encode_mcu
) (cinfo
, MCU_buffer
)) {
335 /* Suspension forced; update state counters and exit */
336 coef
->MCU_vert_offset
= yoffset
;
337 coef
->mcu_ctr
= MCU_col_num
;
341 /* Completed an MCU row, but perhaps not an iMCU row */
344 /* Completed the iMCU row, advance counters for next one */
345 coef
->iMCU_row_num
++;
346 start_iMCU_row(cinfo
);
352 * Initialize coefficient buffer controller.
354 * Each passed coefficient array must be the right size for that
355 * coefficient: width_in_blocks wide and height_in_blocks high,
356 * with unitheight at least v_samp_factor.
360 transencode_coef_controller (j_compress_ptr cinfo
,
361 jvirt_barray_ptr
* coef_arrays
)
368 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_IMAGE
,
369 SIZEOF(my_coef_controller
));
370 cinfo
->coef
= &coef
->pub
;
371 coef
->pub
.start_pass
= start_pass_coef
;
372 coef
->pub
.compress_data
= compress_output
;
374 /* Save pointer to virtual arrays */
375 coef
->whole_image
= coef_arrays
;
377 /* Allocate and pre-zero space for dummy DCT blocks. */
379 (*cinfo
->mem
->alloc_large
) ((j_common_ptr
) cinfo
, JPOOL_IMAGE
,
380 C_MAX_BLOCKS_IN_MCU
* SIZEOF(JBLOCK
));
381 FMEMZERO((void FAR
*) buffer
, C_MAX_BLOCKS_IN_MCU
* SIZEOF(JBLOCK
));
382 for (i
= 0; i
< C_MAX_BLOCKS_IN_MCU
; i
++) {
383 coef
->dummy_buffer
[i
] = buffer
+ i
;