source: trunk/third/jpeg/jccoefct.c @ 15227

Revision 15227, 16.0 KB checked in by ghudson, 24 years ago (diff)
This commit was generated by cvs2svn to compensate for changes in r15226, which included commits to RCS files with non-trunk default branches.
Line 
1/*
2 * jccoefct.c
3 *
4 * Copyright (C) 1994-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 the coefficient buffer controller for compression.
9 * This controller is the top level of the JPEG compressor proper.
10 * The coefficient buffer lies between forward-DCT and entropy encoding steps.
11 */
12
13#define JPEG_INTERNALS
14#include "jinclude.h"
15#include "jpeglib.h"
16
17
18/* We use a full-image coefficient buffer when doing Huffman optimization,
19 * and also for writing multiple-scan JPEG files.  In all cases, the DCT
20 * step is run during the first pass, and subsequent passes need only read
21 * the buffered coefficients.
22 */
23#ifdef ENTROPY_OPT_SUPPORTED
24#define FULL_COEF_BUFFER_SUPPORTED
25#else
26#ifdef C_MULTISCAN_FILES_SUPPORTED
27#define FULL_COEF_BUFFER_SUPPORTED
28#endif
29#endif
30
31
32/* Private buffer controller object */
33
34typedef struct {
35  struct jpeg_c_coef_controller pub; /* public fields */
36
37  JDIMENSION iMCU_row_num;      /* iMCU row # within image */
38  JDIMENSION mcu_ctr;           /* counts MCUs processed in current row */
39  int MCU_vert_offset;          /* counts MCU rows within iMCU row */
40  int MCU_rows_per_iMCU_row;    /* number of such rows needed */
41
42  /* For single-pass compression, it's sufficient to buffer just one MCU
43   * (although this may prove a bit slow in practice).  We allocate a
44   * workspace of C_MAX_BLOCKS_IN_MCU coefficient blocks, and reuse it for each
45   * MCU constructed and sent.  (On 80x86, the workspace is FAR even though
46   * it's not really very big; this is to keep the module interfaces unchanged
47   * when a large coefficient buffer is necessary.)
48   * In multi-pass modes, this array points to the current MCU's blocks
49   * within the virtual arrays.
50   */
51  JBLOCKROW MCU_buffer[C_MAX_BLOCKS_IN_MCU];
52
53  /* In multi-pass modes, we need a virtual block array for each component. */
54  jvirt_barray_ptr whole_image[MAX_COMPONENTS];
55} my_coef_controller;
56
57typedef my_coef_controller * my_coef_ptr;
58
59
60/* Forward declarations */
61METHODDEF(boolean) compress_data
62    JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
63#ifdef FULL_COEF_BUFFER_SUPPORTED
64METHODDEF(boolean) compress_first_pass
65    JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
66METHODDEF(boolean) compress_output
67    JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
68#endif
69
70
71LOCAL(void)
72start_iMCU_row (j_compress_ptr cinfo)
73/* Reset within-iMCU-row counters for a new row */
74{
75  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
76
77  /* In an interleaved scan, an MCU row is the same as an iMCU row.
78   * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
79   * But at the bottom of the image, process only what's left.
80   */
81  if (cinfo->comps_in_scan > 1) {
82    coef->MCU_rows_per_iMCU_row = 1;
83  } else {
84    if (coef->iMCU_row_num < (cinfo->total_iMCU_rows-1))
85      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
86    else
87      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
88  }
89
90  coef->mcu_ctr = 0;
91  coef->MCU_vert_offset = 0;
92}
93
94
95/*
96 * Initialize for a processing pass.
97 */
98
99METHODDEF(void)
100start_pass_coef (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
101{
102  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
103
104  coef->iMCU_row_num = 0;
105  start_iMCU_row(cinfo);
106
107  switch (pass_mode) {
108  case JBUF_PASS_THRU:
109    if (coef->whole_image[0] != NULL)
110      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
111    coef->pub.compress_data = compress_data;
112    break;
113#ifdef FULL_COEF_BUFFER_SUPPORTED
114  case JBUF_SAVE_AND_PASS:
115    if (coef->whole_image[0] == NULL)
116      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
117    coef->pub.compress_data = compress_first_pass;
118    break;
119  case JBUF_CRANK_DEST:
120    if (coef->whole_image[0] == NULL)
121      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
122    coef->pub.compress_data = compress_output;
123    break;
124#endif
125  default:
126    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
127    break;
128  }
129}
130
131
132/*
133 * Process some data in the single-pass case.
134 * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
135 * per call, ie, v_samp_factor block rows for each component in the image.
136 * Returns TRUE if the iMCU row is completed, FALSE if suspended.
137 *
138 * NB: input_buf contains a plane for each component in image,
139 * which we index according to the component's SOF position.
140 */
141
142METHODDEF(boolean)
143compress_data (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
144{
145  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
146  JDIMENSION MCU_col_num;       /* index of current MCU within row */
147  JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
148  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
149  int blkn, bi, ci, yindex, yoffset, blockcnt;
150  JDIMENSION ypos, xpos;
151  jpeg_component_info *compptr;
152
153  /* Loop to write as much as one whole iMCU row */
154  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
155       yoffset++) {
156    for (MCU_col_num = coef->mcu_ctr; MCU_col_num <= last_MCU_col;
157         MCU_col_num++) {
158      /* Determine where data comes from in input_buf and do the DCT thing.
159       * Each call on forward_DCT processes a horizontal row of DCT blocks
160       * as wide as an MCU; we rely on having allocated the MCU_buffer[] blocks
161       * sequentially.  Dummy blocks at the right or bottom edge are filled in
162       * specially.  The data in them does not matter for image reconstruction,
163       * so we fill them with values that will encode to the smallest amount of
164       * data, viz: all zeroes in the AC entries, DC entries equal to previous
165       * block's DC value.  (Thanks to Thomas Kinsman for this idea.)
166       */
167      blkn = 0;
168      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
169        compptr = cinfo->cur_comp_info[ci];
170        blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
171                                                : compptr->last_col_width;
172        xpos = MCU_col_num * compptr->MCU_sample_width;
173        ypos = yoffset * DCTSIZE; /* ypos == (yoffset+yindex) * DCTSIZE */
174        for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
175          if (coef->iMCU_row_num < last_iMCU_row ||
176              yoffset+yindex < compptr->last_row_height) {
177            (*cinfo->fdct->forward_DCT) (cinfo, compptr,
178                                         input_buf[compptr->component_index],
179                                         coef->MCU_buffer[blkn],
180                                         ypos, xpos, (JDIMENSION) blockcnt);
181            if (blockcnt < compptr->MCU_width) {
182              /* Create some dummy blocks at the right edge of the image. */
183              jzero_far((void FAR *) coef->MCU_buffer[blkn + blockcnt],
184                        (compptr->MCU_width - blockcnt) * SIZEOF(JBLOCK));
185              for (bi = blockcnt; bi < compptr->MCU_width; bi++) {
186                coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn+bi-1][0][0];
187              }
188            }
189          } else {
190            /* Create a row of dummy blocks at the bottom of the image. */
191            jzero_far((void FAR *) coef->MCU_buffer[blkn],
192                      compptr->MCU_width * SIZEOF(JBLOCK));
193            for (bi = 0; bi < compptr->MCU_width; bi++) {
194              coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn-1][0][0];
195            }
196          }
197          blkn += compptr->MCU_width;
198          ypos += DCTSIZE;
199        }
200      }
201      /* Try to write the MCU.  In event of a suspension failure, we will
202       * re-DCT the MCU on restart (a bit inefficient, could be fixed...)
203       */
204      if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
205        /* Suspension forced; update state counters and exit */
206        coef->MCU_vert_offset = yoffset;
207        coef->mcu_ctr = MCU_col_num;
208        return FALSE;
209      }
210    }
211    /* Completed an MCU row, but perhaps not an iMCU row */
212    coef->mcu_ctr = 0;
213  }
214  /* Completed the iMCU row, advance counters for next one */
215  coef->iMCU_row_num++;
216  start_iMCU_row(cinfo);
217  return TRUE;
218}
219
220
221#ifdef FULL_COEF_BUFFER_SUPPORTED
222
223/*
224 * Process some data in the first pass of a multi-pass case.
225 * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
226 * per call, ie, v_samp_factor block rows for each component in the image.
227 * This amount of data is read from the source buffer, DCT'd and quantized,
228 * and saved into the virtual arrays.  We also generate suitable dummy blocks
229 * as needed at the right and lower edges.  (The dummy blocks are constructed
230 * in the virtual arrays, which have been padded appropriately.)  This makes
231 * it possible for subsequent passes not to worry about real vs. dummy blocks.
232 *
233 * We must also emit the data to the entropy encoder.  This is conveniently
234 * done by calling compress_output() after we've loaded the current strip
235 * of the virtual arrays.
236 *
237 * NB: input_buf contains a plane for each component in image.  All
238 * components are DCT'd and loaded into the virtual arrays in this pass.
239 * However, it may be that only a subset of the components are emitted to
240 * the entropy encoder during this first pass; be careful about looking
241 * at the scan-dependent variables (MCU dimensions, etc).
242 */
243
244METHODDEF(boolean)
245compress_first_pass (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
246{
247  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
248  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
249  JDIMENSION blocks_across, MCUs_across, MCUindex;
250  int bi, ci, h_samp_factor, block_row, block_rows, ndummy;
251  JCOEF lastDC;
252  jpeg_component_info *compptr;
253  JBLOCKARRAY buffer;
254  JBLOCKROW thisblockrow, lastblockrow;
255
256  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
257       ci++, compptr++) {
258    /* Align the virtual buffer for this component. */
259    buffer = (*cinfo->mem->access_virt_barray)
260      ((j_common_ptr) cinfo, coef->whole_image[ci],
261       coef->iMCU_row_num * compptr->v_samp_factor,
262       (JDIMENSION) compptr->v_samp_factor, TRUE);
263    /* Count non-dummy DCT block rows in this iMCU row. */
264    if (coef->iMCU_row_num < last_iMCU_row)
265      block_rows = compptr->v_samp_factor;
266    else {
267      /* NB: can't use last_row_height here, since may not be set! */
268      block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
269      if (block_rows == 0) block_rows = compptr->v_samp_factor;
270    }
271    blocks_across = compptr->width_in_blocks;
272    h_samp_factor = compptr->h_samp_factor;
273    /* Count number of dummy blocks to be added at the right margin. */
274    ndummy = (int) (blocks_across % h_samp_factor);
275    if (ndummy > 0)
276      ndummy = h_samp_factor - ndummy;
277    /* Perform DCT for all non-dummy blocks in this iMCU row.  Each call
278     * on forward_DCT processes a complete horizontal row of DCT blocks.
279     */
280    for (block_row = 0; block_row < block_rows; block_row++) {
281      thisblockrow = buffer[block_row];
282      (*cinfo->fdct->forward_DCT) (cinfo, compptr,
283                                   input_buf[ci], thisblockrow,
284                                   (JDIMENSION) (block_row * DCTSIZE),
285                                   (JDIMENSION) 0, blocks_across);
286      if (ndummy > 0) {
287        /* Create dummy blocks at the right edge of the image. */
288        thisblockrow += blocks_across; /* => first dummy block */
289        jzero_far((void FAR *) thisblockrow, ndummy * SIZEOF(JBLOCK));
290        lastDC = thisblockrow[-1][0];
291        for (bi = 0; bi < ndummy; bi++) {
292          thisblockrow[bi][0] = lastDC;
293        }
294      }
295    }
296    /* If at end of image, create dummy block rows as needed.
297     * The tricky part here is that within each MCU, we want the DC values
298     * of the dummy blocks to match the last real block's DC value.
299     * This squeezes a few more bytes out of the resulting file...
300     */
301    if (coef->iMCU_row_num == last_iMCU_row) {
302      blocks_across += ndummy;  /* include lower right corner */
303      MCUs_across = blocks_across / h_samp_factor;
304      for (block_row = block_rows; block_row < compptr->v_samp_factor;
305           block_row++) {
306        thisblockrow = buffer[block_row];
307        lastblockrow = buffer[block_row-1];
308        jzero_far((void FAR *) thisblockrow,
309                  (size_t) (blocks_across * SIZEOF(JBLOCK)));
310        for (MCUindex = 0; MCUindex < MCUs_across; MCUindex++) {
311          lastDC = lastblockrow[h_samp_factor-1][0];
312          for (bi = 0; bi < h_samp_factor; bi++) {
313            thisblockrow[bi][0] = lastDC;
314          }
315          thisblockrow += h_samp_factor; /* advance to next MCU in row */
316          lastblockrow += h_samp_factor;
317        }
318      }
319    }
320  }
321  /* NB: compress_output will increment iMCU_row_num if successful.
322   * A suspension return will result in redoing all the work above next time.
323   */
324
325  /* Emit data to the entropy encoder, sharing code with subsequent passes */
326  return compress_output(cinfo, input_buf);
327}
328
329
330/*
331 * Process some data in subsequent passes of a multi-pass case.
332 * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
333 * per call, ie, v_samp_factor block rows for each component in the scan.
334 * The data is obtained from the virtual arrays and fed to the entropy coder.
335 * Returns TRUE if the iMCU row is completed, FALSE if suspended.
336 *
337 * NB: input_buf is ignored; it is likely to be a NULL pointer.
338 */
339
340METHODDEF(boolean)
341compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
342{
343  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
344  JDIMENSION MCU_col_num;       /* index of current MCU within row */
345  int blkn, ci, xindex, yindex, yoffset;
346  JDIMENSION start_col;
347  JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
348  JBLOCKROW buffer_ptr;
349  jpeg_component_info *compptr;
350
351  /* Align the virtual buffers for the components used in this scan.
352   * NB: during first pass, this is safe only because the buffers will
353   * already be aligned properly, so jmemmgr.c won't need to do any I/O.
354   */
355  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
356    compptr = cinfo->cur_comp_info[ci];
357    buffer[ci] = (*cinfo->mem->access_virt_barray)
358      ((j_common_ptr) cinfo, coef->whole_image[compptr->component_index],
359       coef->iMCU_row_num * compptr->v_samp_factor,
360       (JDIMENSION) compptr->v_samp_factor, FALSE);
361  }
362
363  /* Loop to process one whole iMCU row */
364  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
365       yoffset++) {
366    for (MCU_col_num = coef->mcu_ctr; MCU_col_num < cinfo->MCUs_per_row;
367         MCU_col_num++) {
368      /* Construct list of pointers to DCT blocks belonging to this MCU */
369      blkn = 0;                 /* index of current DCT block within MCU */
370      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
371        compptr = cinfo->cur_comp_info[ci];
372        start_col = MCU_col_num * compptr->MCU_width;
373        for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
374          buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
375          for (xindex = 0; xindex < compptr->MCU_width; xindex++) {
376            coef->MCU_buffer[blkn++] = buffer_ptr++;
377          }
378        }
379      }
380      /* Try to write the MCU. */
381      if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
382        /* Suspension forced; update state counters and exit */
383        coef->MCU_vert_offset = yoffset;
384        coef->mcu_ctr = MCU_col_num;
385        return FALSE;
386      }
387    }
388    /* Completed an MCU row, but perhaps not an iMCU row */
389    coef->mcu_ctr = 0;
390  }
391  /* Completed the iMCU row, advance counters for next one */
392  coef->iMCU_row_num++;
393  start_iMCU_row(cinfo);
394  return TRUE;
395}
396
397#endif /* FULL_COEF_BUFFER_SUPPORTED */
398
399
400/*
401 * Initialize coefficient buffer controller.
402 */
403
404GLOBAL(void)
405jinit_c_coef_controller (j_compress_ptr cinfo, boolean need_full_buffer)
406{
407  my_coef_ptr coef;
408
409  coef = (my_coef_ptr)
410    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
411                                SIZEOF(my_coef_controller));
412  cinfo->coef = (struct jpeg_c_coef_controller *) coef;
413  coef->pub.start_pass = start_pass_coef;
414
415  /* Create the coefficient buffer. */
416  if (need_full_buffer) {
417#ifdef FULL_COEF_BUFFER_SUPPORTED
418    /* Allocate a full-image virtual array for each component, */
419    /* padded to a multiple of samp_factor DCT blocks in each direction. */
420    int ci;
421    jpeg_component_info *compptr;
422
423    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
424         ci++, compptr++) {
425      coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
426        ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
427         (JDIMENSION) jround_up((long) compptr->width_in_blocks,
428                                (long) compptr->h_samp_factor),
429         (JDIMENSION) jround_up((long) compptr->height_in_blocks,
430                                (long) compptr->v_samp_factor),
431         (JDIMENSION) compptr->v_samp_factor);
432    }
433#else
434    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
435#endif
436  } else {
437    /* We only need a single-MCU buffer. */
438    JBLOCKROW buffer;
439    int i;
440
441    buffer = (JBLOCKROW)
442      (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
443                                  C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
444    for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
445      coef->MCU_buffer[i] = buffer + i;
446    }
447    coef->whole_image[0] = NULL; /* flag for no virtual arrays */
448  }
449}
Note: See TracBrowser for help on using the repository browser.