Home | History | Annotate | Download | only in jpeg
      1 /*
      2  * jdmainct.c
      3  *
      4  * Copyright (C) 1994-1996, 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 main buffer controller for decompression.
      9  * The main buffer lies between the JPEG decompressor proper and the
     10  * post-processor; it holds downsampled data in the JPEG colorspace.
     11  *
     12  * Note that this code is bypassed in raw-data mode, since the application
     13  * supplies the equivalent of the main buffer in that case.
     14  */
     15 
     16 #define JPEG_INTERNALS
     17 #include "jinclude.h"
     18 #include "jpeglib.h"
     19 
     20 
     21 /*
     22  * In the current system design, the main buffer need never be a full-image
     23  * buffer; any full-height buffers will be found inside the coefficient or
     24  * postprocessing controllers.  Nonetheless, the main controller is not
     25  * trivial.  Its responsibility is to provide context rows for upsampling/
     26  * rescaling, and doing this in an efficient fashion is a bit tricky.
     27  *
     28  * Postprocessor input data is counted in "row groups".  A row group
     29  * is defined to be (v_samp_factor * DCT_scaled_size / min_DCT_scaled_size)
     30  * sample rows of each component.  (We require DCT_scaled_size values to be
     31  * chosen such that these numbers are integers.  In practice DCT_scaled_size
     32  * values will likely be powers of two, so we actually have the stronger
     33  * condition that DCT_scaled_size / min_DCT_scaled_size is an integer.)
     34  * Upsampling will typically produce max_v_samp_factor pixel rows from each
     35  * row group (times any additional scale factor that the upsampler is
     36  * applying).
     37  *
     38  * The coefficient controller will deliver data to us one iMCU row at a time;
     39  * each iMCU row contains v_samp_factor * DCT_scaled_size sample rows, or
     40  * exactly min_DCT_scaled_size row groups.  (This amount of data corresponds
     41  * to one row of MCUs when the image is fully interleaved.)  Note that the
     42  * number of sample rows varies across components, but the number of row
     43  * groups does not.  Some garbage sample rows may be included in the last iMCU
     44  * row at the bottom of the image.
     45  *
     46  * Depending on the vertical scaling algorithm used, the upsampler may need
     47  * access to the sample row(s) above and below its current input row group.
     48  * The upsampler is required to set need_context_rows TRUE at global selection
     49  * time if so.  When need_context_rows is FALSE, this controller can simply
     50  * obtain one iMCU row at a time from the coefficient controller and dole it
     51  * out as row groups to the postprocessor.
     52  *
     53  * When need_context_rows is TRUE, this controller guarantees that the buffer
     54  * passed to postprocessing contains at least one row group's worth of samples
     55  * above and below the row group(s) being processed.  Note that the context
     56  * rows "above" the first passed row group appear at negative row offsets in
     57  * the passed buffer.  At the top and bottom of the image, the required
     58  * context rows are manufactured by duplicating the first or last real sample
     59  * row; this avoids having special cases in the upsampling inner loops.
     60  *
     61  * The amount of context is fixed at one row group just because that's a
     62  * convenient number for this controller to work with.  The existing
     63  * upsamplers really only need one sample row of context.  An upsampler
     64  * supporting arbitrary output rescaling might wish for more than one row
     65  * group of context when shrinking the image; tough, we don't handle that.
     66  * (This is justified by the assumption that downsizing will be handled mostly
     67  * by adjusting the DCT_scaled_size values, so that the actual scale factor at
     68  * the upsample step needn't be much less than one.)
     69  *
     70  * To provide the desired context, we have to retain the last two row groups
     71  * of one iMCU row while reading in the next iMCU row.  (The last row group
     72  * can't be processed until we have another row group for its below-context,
     73  * and so we have to save the next-to-last group too for its above-context.)
     74  * We could do this most simply by copying data around in our buffer, but
     75  * that'd be very slow.  We can avoid copying any data by creating a rather
     76  * strange pointer structure.  Here's how it works.  We allocate a workspace
     77  * consisting of M+2 row groups (where M = min_DCT_scaled_size is the number
     78  * of row groups per iMCU row).  We create two sets of redundant pointers to
     79  * the workspace.  Labeling the physical row groups 0 to M+1, the synthesized
     80  * pointer lists look like this:
     81  *                   M+1                          M-1
     82  * master pointer --> 0         master pointer --> 0
     83  *                    1                            1
     84  *                   ...                          ...
     85  *                   M-3                          M-3
     86  *                   M-2                           M
     87  *                   M-1                          M+1
     88  *                    M                           M-2
     89  *                   M+1                          M-1
     90  *                    0                            0
     91  * We read alternate iMCU rows using each master pointer; thus the last two
     92  * row groups of the previous iMCU row remain un-overwritten in the workspace.
     93  * The pointer lists are set up so that the required context rows appear to
     94  * be adjacent to the proper places when we pass the pointer lists to the
     95  * upsampler.
     96  *
     97  * The above pictures describe the normal state of the pointer lists.
     98  * At top and bottom of the image, we diddle the pointer lists to duplicate
     99  * the first or last sample row as necessary (this is cheaper than copying
    100  * sample rows around).
    101  *
    102  * This scheme breaks down if M < 2, ie, min_DCT_scaled_size is 1.  In that
    103  * situation each iMCU row provides only one row group so the buffering logic
    104  * must be different (eg, we must read two iMCU rows before we can emit the
    105  * first row group).  For now, we simply do not support providing context
    106  * rows when min_DCT_scaled_size is 1.  That combination seems unlikely to
    107  * be worth providing --- if someone wants a 1/8th-size preview, they probably
    108  * want it quick and dirty, so a context-free upsampler is sufficient.
    109  */
    110 
    111 
    112 /* Private buffer controller object */
    113 
    114 typedef struct {
    115   struct jpeg_d_main_controller pub; /* public fields */
    116 
    117   /* Pointer to allocated workspace (M or M+2 row groups). */
    118   JSAMPARRAY buffer[MAX_COMPONENTS];
    119 
    120   boolean buffer_full;		/* Have we gotten an iMCU row from decoder? */
    121   JDIMENSION rowgroup_ctr;	/* counts row groups output to postprocessor */
    122 
    123   /* Remaining fields are only used in the context case. */
    124 
    125   /* These are the master pointers to the funny-order pointer lists. */
    126   JSAMPIMAGE xbuffer[2];	/* pointers to weird pointer lists */
    127 
    128   int whichptr;			/* indicates which pointer set is now in use */
    129   int context_state;		/* process_data state machine status */
    130   JDIMENSION rowgroups_avail;	/* row groups available to postprocessor */
    131   JDIMENSION iMCU_row_ctr;	/* counts iMCU rows to detect image top/bot */
    132 } my_main_controller;
    133 
    134 typedef my_main_controller * my_main_ptr;
    135 
    136 /* context_state values: */
    137 #define CTX_PREPARE_FOR_IMCU	0	/* need to prepare for MCU row */
    138 #define CTX_PROCESS_IMCU	1	/* feeding iMCU to postprocessor */
    139 #define CTX_POSTPONED_ROW	2	/* feeding postponed row group */
    140 
    141 
    142 /* Forward declarations */
    143 METHODDEF(void) process_data_simple_main
    144 	JPP((j_decompress_ptr cinfo, JSAMPARRAY output_buf,
    145 	     JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail));
    146 METHODDEF(void) process_data_context_main
    147 	JPP((j_decompress_ptr cinfo, JSAMPARRAY output_buf,
    148 	     JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail));
    149 #ifdef QUANT_2PASS_SUPPORTED
    150 METHODDEF(void) process_data_crank_post
    151 	JPP((j_decompress_ptr cinfo, JSAMPARRAY output_buf,
    152 	     JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail));
    153 #endif
    154 
    155 
    156 LOCAL(void)
    157 alloc_funny_pointers (j_decompress_ptr cinfo)
    158 /* Allocate space for the funny pointer lists.
    159  * This is done only once, not once per pass.
    160  */
    161 {
    162   my_main_ptr main = (my_main_ptr) cinfo->main;
    163   int ci, rgroup;
    164   int M = cinfo->min_DCT_scaled_size;
    165   jpeg_component_info *compptr;
    166   JSAMPARRAY xbuf;
    167 
    168   /* Get top-level space for component array pointers.
    169    * We alloc both arrays with one call to save a few cycles.
    170    */
    171   main->xbuffer[0] = (JSAMPIMAGE)
    172     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
    173 				cinfo->num_components * 2 * SIZEOF(JSAMPARRAY));
    174   main->xbuffer[1] = main->xbuffer[0] + cinfo->num_components;
    175 
    176   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
    177        ci++, compptr++) {
    178     rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
    179       cinfo->min_DCT_scaled_size; /* height of a row group of component */
    180     /* Get space for pointer lists --- M+4 row groups in each list.
    181      * We alloc both pointer lists with one call to save a few cycles.
    182      */
    183     xbuf = (JSAMPARRAY)
    184       (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
    185 				  2 * (rgroup * (M + 4)) * SIZEOF(JSAMPROW));
    186     xbuf += rgroup;		/* want one row group at negative offsets */
    187     main->xbuffer[0][ci] = xbuf;
    188     xbuf += rgroup * (M + 4);
    189     main->xbuffer[1][ci] = xbuf;
    190   }
    191 }
    192 
    193 
    194 LOCAL(void)
    195 make_funny_pointers (j_decompress_ptr cinfo)
    196 /* Create the funny pointer lists discussed in the comments above.
    197  * The actual workspace is already allocated (in main->buffer),
    198  * and the space for the pointer lists is allocated too.
    199  * This routine just fills in the curiously ordered lists.
    200  * This will be repeated at the beginning of each pass.
    201  */
    202 {
    203   my_main_ptr main = (my_main_ptr) cinfo->main;
    204   int ci, i, rgroup;
    205   int M = cinfo->min_DCT_scaled_size;
    206   jpeg_component_info *compptr;
    207   JSAMPARRAY buf, xbuf0, xbuf1;
    208 
    209   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
    210        ci++, compptr++) {
    211     rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
    212       cinfo->min_DCT_scaled_size; /* height of a row group of component */
    213     xbuf0 = main->xbuffer[0][ci];
    214     xbuf1 = main->xbuffer[1][ci];
    215     /* First copy the workspace pointers as-is */
    216     buf = main->buffer[ci];
    217     for (i = 0; i < rgroup * (M + 2); i++) {
    218       xbuf0[i] = xbuf1[i] = buf[i];
    219     }
    220     /* In the second list, put the last four row groups in swapped order */
    221     for (i = 0; i < rgroup * 2; i++) {
    222       xbuf1[rgroup*(M-2) + i] = buf[rgroup*M + i];
    223       xbuf1[rgroup*M + i] = buf[rgroup*(M-2) + i];
    224     }
    225     /* The wraparound pointers at top and bottom will be filled later
    226      * (see set_wraparound_pointers, below).  Initially we want the "above"
    227      * pointers to duplicate the first actual data line.  This only needs
    228      * to happen in xbuffer[0].
    229      */
    230     for (i = 0; i < rgroup; i++) {
    231       xbuf0[i - rgroup] = xbuf0[0];
    232     }
    233   }
    234 }
    235 
    236 
    237 LOCAL(void)
    238 set_wraparound_pointers (j_decompress_ptr cinfo)
    239 /* Set up the "wraparound" pointers at top and bottom of the pointer lists.
    240  * This changes the pointer list state from top-of-image to the normal state.
    241  */
    242 {
    243   my_main_ptr main = (my_main_ptr) cinfo->main;
    244   int ci, i, rgroup;
    245   int M = cinfo->min_DCT_scaled_size;
    246   jpeg_component_info *compptr;
    247   JSAMPARRAY xbuf0, xbuf1;
    248 
    249   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
    250        ci++, compptr++) {
    251     rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
    252       cinfo->min_DCT_scaled_size; /* height of a row group of component */
    253     xbuf0 = main->xbuffer[0][ci];
    254     xbuf1 = main->xbuffer[1][ci];
    255     for (i = 0; i < rgroup; i++) {
    256       xbuf0[i - rgroup] = xbuf0[rgroup*(M+1) + i];
    257       xbuf1[i - rgroup] = xbuf1[rgroup*(M+1) + i];
    258       xbuf0[rgroup*(M+2) + i] = xbuf0[i];
    259       xbuf1[rgroup*(M+2) + i] = xbuf1[i];
    260     }
    261   }
    262 }
    263 
    264 
    265 LOCAL(void)
    266 set_bottom_pointers (j_decompress_ptr cinfo)
    267 /* Change the pointer lists to duplicate the last sample row at the bottom
    268  * of the image.  whichptr indicates which xbuffer holds the final iMCU row.
    269  * Also sets rowgroups_avail to indicate number of nondummy row groups in row.
    270  */
    271 {
    272   my_main_ptr main = (my_main_ptr) cinfo->main;
    273   int ci, i, rgroup, iMCUheight, rows_left;
    274   jpeg_component_info *compptr;
    275   JSAMPARRAY xbuf;
    276 
    277   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
    278        ci++, compptr++) {
    279     /* Count sample rows in one iMCU row and in one row group */
    280     iMCUheight = compptr->v_samp_factor * compptr->DCT_scaled_size;
    281     rgroup = iMCUheight / cinfo->min_DCT_scaled_size;
    282     /* Count nondummy sample rows remaining for this component */
    283     rows_left = (int) (compptr->downsampled_height % (JDIMENSION) iMCUheight);
    284     if (rows_left == 0) rows_left = iMCUheight;
    285     /* Count nondummy row groups.  Should get same answer for each component,
    286      * so we need only do it once.
    287      */
    288     if (ci == 0) {
    289       main->rowgroups_avail = (JDIMENSION) ((rows_left-1) / rgroup + 1);
    290     }
    291     /* Duplicate the last real sample row rgroup*2 times; this pads out the
    292      * last partial rowgroup and ensures at least one full rowgroup of context.
    293      */
    294     xbuf = main->xbuffer[main->whichptr][ci];
    295     for (i = 0; i < rgroup * 2; i++) {
    296       xbuf[rows_left + i] = xbuf[rows_left-1];
    297     }
    298   }
    299 }
    300 
    301 
    302 /*
    303  * Initialize for a processing pass.
    304  */
    305 
    306 METHODDEF(void)
    307 start_pass_main (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)
    308 {
    309   my_main_ptr main = (my_main_ptr) cinfo->main;
    310 
    311   switch (pass_mode) {
    312   case JBUF_PASS_THRU:
    313     if (cinfo->upsample->need_context_rows) {
    314       main->pub.process_data = process_data_context_main;
    315       make_funny_pointers(cinfo); /* Create the xbuffer[] lists */
    316       main->whichptr = 0;	/* Read first iMCU row into xbuffer[0] */
    317       main->context_state = CTX_PREPARE_FOR_IMCU;
    318       main->iMCU_row_ctr = 0;
    319     } else {
    320       /* Simple case with no context needed */
    321       main->pub.process_data = process_data_simple_main;
    322     }
    323     main->buffer_full = FALSE;	/* Mark buffer empty */
    324     main->rowgroup_ctr = 0;
    325     break;
    326 #ifdef QUANT_2PASS_SUPPORTED
    327   case JBUF_CRANK_DEST:
    328     /* For last pass of 2-pass quantization, just crank the postprocessor */
    329     main->pub.process_data = process_data_crank_post;
    330     break;
    331 #endif
    332   default:
    333     ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
    334     break;
    335   }
    336 }
    337 
    338 
    339 /*
    340  * Process some data.
    341  * This handles the simple case where no context is required.
    342  */
    343 
    344 METHODDEF(void)
    345 process_data_simple_main (j_decompress_ptr cinfo,
    346 			  JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
    347 			  JDIMENSION out_rows_avail)
    348 {
    349   my_main_ptr main = (my_main_ptr) cinfo->main;
    350   JDIMENSION rowgroups_avail;
    351 
    352   /* Read input data if we haven't filled the main buffer yet */
    353   if (! main->buffer_full) {
    354     if (! (*cinfo->coef->decompress_data) (cinfo, main->buffer))
    355       return;			/* suspension forced, can do nothing more */
    356     main->buffer_full = TRUE;	/* OK, we have an iMCU row to work with */
    357   }
    358 
    359   /* There are always min_DCT_scaled_size row groups in an iMCU row. */
    360   rowgroups_avail = (JDIMENSION) cinfo->min_DCT_scaled_size;
    361   /* Note: at the bottom of the image, we may pass extra garbage row groups
    362    * to the postprocessor.  The postprocessor has to check for bottom
    363    * of image anyway (at row resolution), so no point in us doing it too.
    364    */
    365 
    366   /* Feed the postprocessor */
    367   (*cinfo->post->post_process_data) (cinfo, main->buffer,
    368 				     &main->rowgroup_ctr, rowgroups_avail,
    369 				     output_buf, out_row_ctr, out_rows_avail);
    370 
    371   /* Has postprocessor consumed all the data yet? If so, mark buffer empty */
    372   if (main->rowgroup_ctr >= rowgroups_avail) {
    373     main->buffer_full = FALSE;
    374     main->rowgroup_ctr = 0;
    375   }
    376 }
    377 
    378 
    379 /*
    380  * Process some data.
    381  * This handles the case where context rows must be provided.
    382  */
    383 
    384 METHODDEF(void)
    385 process_data_context_main (j_decompress_ptr cinfo,
    386 			   JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
    387 			   JDIMENSION out_rows_avail)
    388 {
    389   my_main_ptr main = (my_main_ptr) cinfo->main;
    390 
    391   /* Read input data if we haven't filled the main buffer yet */
    392   if (! main->buffer_full) {
    393     if (! (*cinfo->coef->decompress_data) (cinfo,
    394 					   main->xbuffer[main->whichptr]))
    395       return;			/* suspension forced, can do nothing more */
    396     main->buffer_full = TRUE;	/* OK, we have an iMCU row to work with */
    397     main->iMCU_row_ctr++;	/* count rows received */
    398   }
    399 
    400   /* Postprocessor typically will not swallow all the input data it is handed
    401    * in one call (due to filling the output buffer first).  Must be prepared
    402    * to exit and restart.  This switch lets us keep track of how far we got.
    403    * Note that each case falls through to the next on successful completion.
    404    */
    405   switch (main->context_state) {
    406   case CTX_POSTPONED_ROW:
    407     /* Call postprocessor using previously set pointers for postponed row */
    408     (*cinfo->post->post_process_data) (cinfo, main->xbuffer[main->whichptr],
    409 			&main->rowgroup_ctr, main->rowgroups_avail,
    410 			output_buf, out_row_ctr, out_rows_avail);
    411     if (main->rowgroup_ctr < main->rowgroups_avail)
    412       return;			/* Need to suspend */
    413     main->context_state = CTX_PREPARE_FOR_IMCU;
    414     if (*out_row_ctr >= out_rows_avail)
    415       return;			/* Postprocessor exactly filled output buf */
    416     /*FALLTHROUGH*/
    417   case CTX_PREPARE_FOR_IMCU:
    418     /* Prepare to process first M-1 row groups of this iMCU row */
    419     main->rowgroup_ctr = 0;
    420     main->rowgroups_avail = (JDIMENSION) (cinfo->min_DCT_scaled_size - 1);
    421     /* Check for bottom of image: if so, tweak pointers to "duplicate"
    422      * the last sample row, and adjust rowgroups_avail to ignore padding rows.
    423      */
    424     if (main->iMCU_row_ctr == cinfo->total_iMCU_rows)
    425       set_bottom_pointers(cinfo);
    426     main->context_state = CTX_PROCESS_IMCU;
    427     /*FALLTHROUGH*/
    428   case CTX_PROCESS_IMCU:
    429     /* Call postprocessor using previously set pointers */
    430     (*cinfo->post->post_process_data) (cinfo, main->xbuffer[main->whichptr],
    431 			&main->rowgroup_ctr, main->rowgroups_avail,
    432 			output_buf, out_row_ctr, out_rows_avail);
    433     if (main->rowgroup_ctr < main->rowgroups_avail)
    434       return;			/* Need to suspend */
    435     /* After the first iMCU, change wraparound pointers to normal state */
    436     if (main->iMCU_row_ctr == 1)
    437       set_wraparound_pointers(cinfo);
    438     /* Prepare to load new iMCU row using other xbuffer list */
    439     main->whichptr ^= 1;	/* 0=>1 or 1=>0 */
    440     main->buffer_full = FALSE;
    441     /* Still need to process last row group of this iMCU row, */
    442     /* which is saved at index M+1 of the other xbuffer */
    443     main->rowgroup_ctr = (JDIMENSION) (cinfo->min_DCT_scaled_size + 1);
    444     main->rowgroups_avail = (JDIMENSION) (cinfo->min_DCT_scaled_size + 2);
    445     main->context_state = CTX_POSTPONED_ROW;
    446   }
    447 }
    448 
    449 
    450 /*
    451  * Process some data.
    452  * Final pass of two-pass quantization: just call the postprocessor.
    453  * Source data will be the postprocessor controller's internal buffer.
    454  */
    455 
    456 #ifdef QUANT_2PASS_SUPPORTED
    457 
    458 METHODDEF(void)
    459 process_data_crank_post (j_decompress_ptr cinfo,
    460 			 JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
    461 			 JDIMENSION out_rows_avail)
    462 {
    463   (*cinfo->post->post_process_data) (cinfo, (JSAMPIMAGE) NULL,
    464 				     (JDIMENSION *) NULL, (JDIMENSION) 0,
    465 				     output_buf, out_row_ctr, out_rows_avail);
    466 }
    467 
    468 #endif /* QUANT_2PASS_SUPPORTED */
    469 
    470 
    471 /*
    472  * Initialize main buffer controller.
    473  */
    474 
    475 GLOBAL(void)
    476 jinit_d_main_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
    477 {
    478   my_main_ptr main;
    479   int ci, rgroup, ngroups;
    480   jpeg_component_info *compptr;
    481 
    482   main = (my_main_ptr)
    483     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
    484 				SIZEOF(my_main_controller));
    485   cinfo->main = (struct jpeg_d_main_controller *) main;
    486   main->pub.start_pass = start_pass_main;
    487 
    488   if (need_full_buffer)		/* shouldn't happen */
    489     ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
    490 
    491   /* Allocate the workspace.
    492    * ngroups is the number of row groups we need.
    493    */
    494   if (cinfo->upsample->need_context_rows) {
    495     if (cinfo->min_DCT_scaled_size < 2) /* unsupported, see comments above */
    496       ERREXIT(cinfo, JERR_NOTIMPL);
    497     alloc_funny_pointers(cinfo); /* Alloc space for xbuffer[] lists */
    498     ngroups = cinfo->min_DCT_scaled_size + 2;
    499   } else {
    500     ngroups = cinfo->min_DCT_scaled_size;
    501   }
    502 
    503   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
    504        ci++, compptr++) {
    505     rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
    506       cinfo->min_DCT_scaled_size; /* height of a row group of component */
    507     main->buffer[ci] = (*cinfo->mem->alloc_sarray)
    508 			((j_common_ptr) cinfo, JPOOL_IMAGE,
    509 			 compptr->width_in_blocks * compptr->DCT_scaled_size,
    510 			 (JDIMENSION) (rgroup * ngroups));
    511   }
    512 }
    513