Home | History | Annotate | Download | only in jpeg-6b
      1 /*
      2  * jcprepct.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 compression preprocessing controller.
      9  * This controller manages the color conversion, downsampling,
     10  * and edge expansion steps.
     11  *
     12  * Most of the complexity here is associated with buffering input rows
     13  * as required by the downsampler.  See the comments at the head of
     14  * jcsample.c for the downsampler's needs.
     15  */
     16 
     17 #define JPEG_INTERNALS
     18 #include "jinclude.h"
     19 #include "jpeglib.h"
     20 
     21 
     22 /* At present, jcsample.c can request context rows only for smoothing.
     23  * In the future, we might also need context rows for CCIR601 sampling
     24  * or other more-complex downsampling procedures.  The code to support
     25  * context rows should be compiled only if needed.
     26  */
     27 #ifdef INPUT_SMOOTHING_SUPPORTED
     28 #define CONTEXT_ROWS_SUPPORTED
     29 #endif
     30 
     31 
     32 /*
     33  * For the simple (no-context-row) case, we just need to buffer one
     34  * row group's worth of pixels for the downsampling step.  At the bottom of
     35  * the image, we pad to a full row group by replicating the last pixel row.
     36  * The downsampler's last output row is then replicated if needed to pad
     37  * out to a full iMCU row.
     38  *
     39  * When providing context rows, we must buffer three row groups' worth of
     40  * pixels.  Three row groups are physically allocated, but the row pointer
     41  * arrays are made five row groups high, with the extra pointers above and
     42  * below "wrapping around" to point to the last and first real row groups.
     43  * This allows the downsampler to access the proper context rows.
     44  * At the top and bottom of the image, we create dummy context rows by
     45  * copying the first or last real pixel row.  This copying could be avoided
     46  * by pointer hacking as is done in jdmainct.c, but it doesn't seem worth the
     47  * trouble on the compression side.
     48  */
     49 
     50 
     51 /* Private buffer controller object */
     52 
     53 typedef struct {
     54   struct jpeg_c_prep_controller pub; /* public fields */
     55 
     56   /* Downsampling input buffer.  This buffer holds color-converted data
     57    * until we have enough to do a downsample step.
     58    */
     59   JSAMPARRAY color_buf[MAX_COMPONENTS];
     60 
     61   JDIMENSION rows_to_go;	/* counts rows remaining in source image */
     62   int next_buf_row;		/* index of next row to store in color_buf */
     63 
     64 #ifdef CONTEXT_ROWS_SUPPORTED	/* only needed for context case */
     65   int this_row_group;		/* starting row index of group to process */
     66   int next_buf_stop;		/* downsample when we reach this index */
     67 #endif
     68 } my_prep_controller;
     69 
     70 typedef my_prep_controller * my_prep_ptr;
     71 
     72 
     73 /*
     74  * Initialize for a processing pass.
     75  */
     76 
     77 METHODDEF(void)
     78 start_pass_prep (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
     79 {
     80   my_prep_ptr prep = (my_prep_ptr) cinfo->prep;
     81 
     82   if (pass_mode != JBUF_PASS_THRU)
     83     ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
     84 
     85   /* Initialize total-height counter for detecting bottom of image */
     86   prep->rows_to_go = cinfo->image_height;
     87   /* Mark the conversion buffer empty */
     88   prep->next_buf_row = 0;
     89 #ifdef CONTEXT_ROWS_SUPPORTED
     90   /* Preset additional state variables for context mode.
     91    * These aren't used in non-context mode, so we needn't test which mode.
     92    */
     93   prep->this_row_group = 0;
     94   /* Set next_buf_stop to stop after two row groups have been read in. */
     95   prep->next_buf_stop = 2 * cinfo->max_v_samp_factor;
     96 #endif
     97 }
     98 
     99 
    100 /*
    101  * Expand an image vertically from height input_rows to height output_rows,
    102  * by duplicating the bottom row.
    103  */
    104 
    105 LOCAL(void)
    106 expand_bottom_edge (JSAMPARRAY image_data, JDIMENSION num_cols,
    107 		    int input_rows, int output_rows)
    108 {
    109   register int row;
    110 
    111   for (row = input_rows; row < output_rows; row++) {
    112     jcopy_sample_rows(image_data, input_rows-1, image_data, row,
    113 		      1, num_cols);
    114   }
    115 }
    116 
    117 
    118 /*
    119  * Process some data in the simple no-context case.
    120  *
    121  * Preprocessor output data is counted in "row groups".  A row group
    122  * is defined to be v_samp_factor sample rows of each component.
    123  * Downsampling will produce this much data from each max_v_samp_factor
    124  * input rows.
    125  */
    126 
    127 METHODDEF(void)
    128 pre_process_data (j_compress_ptr cinfo,
    129 		  JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
    130 		  JDIMENSION in_rows_avail,
    131 		  JSAMPIMAGE output_buf, JDIMENSION *out_row_group_ctr,
    132 		  JDIMENSION out_row_groups_avail)
    133 {
    134   my_prep_ptr prep = (my_prep_ptr) cinfo->prep;
    135   int numrows, ci;
    136   JDIMENSION inrows;
    137   jpeg_component_info * compptr;
    138 
    139   while (*in_row_ctr < in_rows_avail &&
    140 	 *out_row_group_ctr < out_row_groups_avail) {
    141     /* Do color conversion to fill the conversion buffer. */
    142     inrows = in_rows_avail - *in_row_ctr;
    143     numrows = cinfo->max_v_samp_factor - prep->next_buf_row;
    144     numrows = (int) MIN((JDIMENSION) numrows, inrows);
    145     (*cinfo->cconvert->color_convert) (cinfo, input_buf + *in_row_ctr,
    146 				       prep->color_buf,
    147 				       (JDIMENSION) prep->next_buf_row,
    148 				       numrows);
    149     *in_row_ctr += numrows;
    150     prep->next_buf_row += numrows;
    151     prep->rows_to_go -= numrows;
    152     /* If at bottom of image, pad to fill the conversion buffer. */
    153     if (prep->rows_to_go == 0 &&
    154 	prep->next_buf_row < cinfo->max_v_samp_factor) {
    155       for (ci = 0; ci < cinfo->num_components; ci++) {
    156 	expand_bottom_edge(prep->color_buf[ci], cinfo->image_width,
    157 			   prep->next_buf_row, cinfo->max_v_samp_factor);
    158       }
    159       prep->next_buf_row = cinfo->max_v_samp_factor;
    160     }
    161     /* If we've filled the conversion buffer, empty it. */
    162     if (prep->next_buf_row == cinfo->max_v_samp_factor) {
    163       (*cinfo->downsample->downsample) (cinfo,
    164 					prep->color_buf, (JDIMENSION) 0,
    165 					output_buf, *out_row_group_ctr);
    166       prep->next_buf_row = 0;
    167       (*out_row_group_ctr)++;
    168     }
    169     /* If at bottom of image, pad the output to a full iMCU height.
    170      * Note we assume the caller is providing a one-iMCU-height output buffer!
    171      */
    172     if (prep->rows_to_go == 0 &&
    173 	*out_row_group_ctr < out_row_groups_avail) {
    174       for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
    175 	   ci++, compptr++) {
    176 	expand_bottom_edge(output_buf[ci],
    177 			   compptr->width_in_blocks * DCTSIZE,
    178 			   (int) (*out_row_group_ctr * compptr->v_samp_factor),
    179 			   (int) (out_row_groups_avail * compptr->v_samp_factor));
    180       }
    181       *out_row_group_ctr = out_row_groups_avail;
    182       break;			/* can exit outer loop without test */
    183     }
    184   }
    185 }
    186 
    187 
    188 #ifdef CONTEXT_ROWS_SUPPORTED
    189 
    190 /*
    191  * Process some data in the context case.
    192  */
    193 
    194 METHODDEF(void)
    195 pre_process_context (j_compress_ptr cinfo,
    196 		     JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
    197 		     JDIMENSION in_rows_avail,
    198 		     JSAMPIMAGE output_buf, JDIMENSION *out_row_group_ctr,
    199 		     JDIMENSION out_row_groups_avail)
    200 {
    201   my_prep_ptr prep = (my_prep_ptr) cinfo->prep;
    202   int numrows, ci;
    203   int buf_height = cinfo->max_v_samp_factor * 3;
    204   JDIMENSION inrows;
    205 
    206   while (*out_row_group_ctr < out_row_groups_avail) {
    207     if (*in_row_ctr < in_rows_avail) {
    208       /* Do color conversion to fill the conversion buffer. */
    209       inrows = in_rows_avail - *in_row_ctr;
    210       numrows = prep->next_buf_stop - prep->next_buf_row;
    211       numrows = (int) MIN((JDIMENSION) numrows, inrows);
    212       (*cinfo->cconvert->color_convert) (cinfo, input_buf + *in_row_ctr,
    213 					 prep->color_buf,
    214 					 (JDIMENSION) prep->next_buf_row,
    215 					 numrows);
    216       /* Pad at top of image, if first time through */
    217       if (prep->rows_to_go == cinfo->image_height) {
    218 	for (ci = 0; ci < cinfo->num_components; ci++) {
    219 	  int row;
    220 	  for (row = 1; row <= cinfo->max_v_samp_factor; row++) {
    221 	    jcopy_sample_rows(prep->color_buf[ci], 0,
    222 			      prep->color_buf[ci], -row,
    223 			      1, cinfo->image_width);
    224 	  }
    225 	}
    226       }
    227       *in_row_ctr += numrows;
    228       prep->next_buf_row += numrows;
    229       prep->rows_to_go -= numrows;
    230     } else {
    231       /* Return for more data, unless we are at the bottom of the image. */
    232       if (prep->rows_to_go != 0)
    233 	break;
    234       /* When at bottom of image, pad to fill the conversion buffer. */
    235       if (prep->next_buf_row < prep->next_buf_stop) {
    236 	for (ci = 0; ci < cinfo->num_components; ci++) {
    237 	  expand_bottom_edge(prep->color_buf[ci], cinfo->image_width,
    238 			     prep->next_buf_row, prep->next_buf_stop);
    239 	}
    240 	prep->next_buf_row = prep->next_buf_stop;
    241       }
    242     }
    243     /* If we've gotten enough data, downsample a row group. */
    244     if (prep->next_buf_row == prep->next_buf_stop) {
    245       (*cinfo->downsample->downsample) (cinfo,
    246 					prep->color_buf,
    247 					(JDIMENSION) prep->this_row_group,
    248 					output_buf, *out_row_group_ctr);
    249       (*out_row_group_ctr)++;
    250       /* Advance pointers with wraparound as necessary. */
    251       prep->this_row_group += cinfo->max_v_samp_factor;
    252       if (prep->this_row_group >= buf_height)
    253 	prep->this_row_group = 0;
    254       if (prep->next_buf_row >= buf_height)
    255 	prep->next_buf_row = 0;
    256       prep->next_buf_stop = prep->next_buf_row + cinfo->max_v_samp_factor;
    257     }
    258   }
    259 }
    260 
    261 
    262 /*
    263  * Create the wrapped-around downsampling input buffer needed for context mode.
    264  */
    265 
    266 LOCAL(void)
    267 create_context_buffer (j_compress_ptr cinfo)
    268 {
    269   my_prep_ptr prep = (my_prep_ptr) cinfo->prep;
    270   int rgroup_height = cinfo->max_v_samp_factor;
    271   int ci, i;
    272   jpeg_component_info * compptr;
    273   JSAMPARRAY true_buffer, fake_buffer;
    274 
    275   /* Grab enough space for fake row pointers for all the components;
    276    * we need five row groups' worth of pointers for each component.
    277    */
    278   fake_buffer = (JSAMPARRAY)
    279     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
    280 				(cinfo->num_components * 5 * rgroup_height) *
    281 				SIZEOF(JSAMPROW));
    282 
    283   for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
    284        ci++, compptr++) {
    285     /* Allocate the actual buffer space (3 row groups) for this component.
    286      * We make the buffer wide enough to allow the downsampler to edge-expand
    287      * horizontally within the buffer, if it so chooses.
    288      */
    289     true_buffer = (*cinfo->mem->alloc_sarray)
    290       ((j_common_ptr) cinfo, JPOOL_IMAGE,
    291        (JDIMENSION) (((long) compptr->width_in_blocks * DCTSIZE *
    292 		      cinfo->max_h_samp_factor) / compptr->h_samp_factor),
    293        (JDIMENSION) (3 * rgroup_height));
    294     /* Copy true buffer row pointers into the middle of the fake row array */
    295     MEMCOPY(fake_buffer + rgroup_height, true_buffer,
    296 	    3 * rgroup_height * SIZEOF(JSAMPROW));
    297     /* Fill in the above and below wraparound pointers */
    298     for (i = 0; i < rgroup_height; i++) {
    299       fake_buffer[i] = true_buffer[2 * rgroup_height + i];
    300       fake_buffer[4 * rgroup_height + i] = true_buffer[i];
    301     }
    302     prep->color_buf[ci] = fake_buffer + rgroup_height;
    303     fake_buffer += 5 * rgroup_height; /* point to space for next component */
    304   }
    305 }
    306 
    307 #endif /* CONTEXT_ROWS_SUPPORTED */
    308 
    309 
    310 /*
    311  * Initialize preprocessing controller.
    312  */
    313 
    314 GLOBAL(void)
    315 jinit_c_prep_controller (j_compress_ptr cinfo, boolean need_full_buffer)
    316 {
    317   my_prep_ptr prep;
    318   int ci;
    319   jpeg_component_info * compptr;
    320 
    321   if (need_full_buffer)		/* safety check */
    322     ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
    323 
    324   prep = (my_prep_ptr)
    325     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
    326 				SIZEOF(my_prep_controller));
    327   cinfo->prep = (struct jpeg_c_prep_controller *) prep;
    328   prep->pub.start_pass = start_pass_prep;
    329 
    330   /* Allocate the color conversion buffer.
    331    * We make the buffer wide enough to allow the downsampler to edge-expand
    332    * horizontally within the buffer, if it so chooses.
    333    */
    334   if (cinfo->downsample->need_context_rows) {
    335     /* Set up to provide context rows */
    336 #ifdef CONTEXT_ROWS_SUPPORTED
    337     prep->pub.pre_process_data = pre_process_context;
    338     create_context_buffer(cinfo);
    339 #else
    340     ERREXIT(cinfo, JERR_NOT_COMPILED);
    341 #endif
    342   } else {
    343     /* No context, just make it tall enough for one row group */
    344     prep->pub.pre_process_data = pre_process_data;
    345     for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
    346 	 ci++, compptr++) {
    347       prep->color_buf[ci] = (*cinfo->mem->alloc_sarray)
    348 	((j_common_ptr) cinfo, JPOOL_IMAGE,
    349 	 (JDIMENSION) (((long) compptr->width_in_blocks * DCTSIZE *
    350 			cinfo->max_h_samp_factor) / compptr->h_samp_factor),
    351 	 (JDIMENSION) cinfo->max_v_samp_factor);
    352     }
    353   }
    354 }
    355