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 }