jcmainct.c (9287B)
1 /* 2 * jcmainct.c 3 * 4 * Copyright (C) 1994-1995, 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 compression. 9 * The main buffer lies between the pre-processor and the JPEG 10 * compressor proper; it holds downsampled data in the JPEG colorspace. 11 */ 12 13 #define JPEG_INTERNALS 14 #include "jinclude.h" 15 #include "jpeglib.h" 16 17 18 /* Note: currently, there is no operating mode in which a full-image buffer 19 * is needed at this step. If there were, that mode could not be used with 20 * "raw data" input, since this module is bypassed in that case. However, 21 * we've left the code here for possible use in special applications. 22 */ 23 #undef FULL_MAIN_BUFFER_SUPPORTED 24 25 26 /* Private buffer controller object */ 27 28 typedef struct { 29 struct jpeg_c_main_controller pub; /* public fields */ 30 31 JDIMENSION cur_iMCU_row; /* number of current iMCU row */ 32 JDIMENSION rowgroup_ctr; /* counts row groups received in iMCU row */ 33 boolean suspended; /* remember if we suspended output */ 34 J_BUF_MODE pass_mode; /* current operating mode */ 35 36 /* If using just a strip buffer, this points to the entire set of buffers 37 * (we allocate one for each component). In the full-image case, this 38 * points to the currently accessible strips of the virtual arrays. 39 */ 40 JSAMPARRAY buffer[MAX_COMPONENTS]; 41 42 #ifdef FULL_MAIN_BUFFER_SUPPORTED 43 /* If using full-image storage, this array holds pointers to virtual-array 44 * control blocks for each component. Unused if not full-image storage. 45 */ 46 jvirt_sarray_ptr whole_image[MAX_COMPONENTS]; 47 #endif 48 } my_main_controller; 49 50 typedef my_main_controller * my_main_ptr; 51 52 53 /* Forward declarations */ 54 METHODDEF void process_data_simple_main 55 JPP((j_compress_ptr cinfo, JSAMPARRAY input_buf, 56 JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail)); 57 #ifdef FULL_MAIN_BUFFER_SUPPORTED 58 METHODDEF void process_data_buffer_main 59 JPP((j_compress_ptr cinfo, JSAMPARRAY input_buf, 60 JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail)); 61 #endif 62 63 64 /* 65 * Initialize for a processing pass. 66 */ 67 68 METHODDEF void 69 start_pass_main (j_compress_ptr cinfo, J_BUF_MODE pass_mode) 70 { 71 // bk001204 - don't use main... 72 my_main_ptr jmain = (my_main_ptr) cinfo->main; 73 74 /* Do nothing in raw-data mode. */ 75 if (cinfo->raw_data_in) 76 return; 77 78 jmain->cur_iMCU_row = 0; /* initialize counters */ 79 jmain->rowgroup_ctr = 0; 80 jmain->suspended = FALSE; 81 jmain->pass_mode = pass_mode; /* save mode for use by process_data */ 82 83 switch (pass_mode) { 84 case JBUF_PASS_THRU: 85 #ifdef FULL_MAIN_BUFFER_SUPPORTED 86 if (jmain->whole_image[0] != NULL) 87 ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); 88 #endif 89 jmain->pub.process_data = process_data_simple_main; 90 break; 91 #ifdef FULL_MAIN_BUFFER_SUPPORTED 92 case JBUF_SAVE_SOURCE: 93 case JBUF_CRANK_DEST: 94 case JBUF_SAVE_AND_PASS: 95 if (jmain->whole_image[0] == NULL) 96 ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); 97 jmain->pub.process_data = process_data_buffer_main; 98 break; 99 #endif 100 default: 101 ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); 102 break; 103 } 104 } 105 106 107 /* 108 * Process some data. 109 * This routine handles the simple pass-through mode, 110 * where we have only a strip buffer. 111 */ 112 113 METHODDEF void 114 process_data_simple_main (j_compress_ptr cinfo, 115 JSAMPARRAY input_buf, JDIMENSION *in_row_ctr, 116 JDIMENSION in_rows_avail) 117 { 118 // bk001204 - don't use main 119 my_main_ptr jmain = (my_main_ptr) cinfo->main; 120 121 while (jmain->cur_iMCU_row < cinfo->total_iMCU_rows) { 122 /* Read input data if we haven't filled the main buffer yet */ 123 if (jmain->rowgroup_ctr < DCTSIZE) 124 (*cinfo->prep->pre_process_data) (cinfo, 125 input_buf, in_row_ctr, in_rows_avail, 126 jmain->buffer, &jmain->rowgroup_ctr, 127 (JDIMENSION) DCTSIZE); 128 129 /* If we don't have a full iMCU row buffered, return to application for 130 * more data. Note that preprocessor will always pad to fill the iMCU row 131 * at the bottom of the image. 132 */ 133 if (jmain->rowgroup_ctr != DCTSIZE) 134 return; 135 136 /* Send the completed row to the compressor */ 137 if (! (*cinfo->coef->compress_data) (cinfo, jmain->buffer)) { 138 /* If compressor did not consume the whole row, then we must need to 139 * suspend processing and return to the application. In this situation 140 * we pretend we didn't yet consume the last input row; otherwise, if 141 * it happened to be the last row of the image, the application would 142 * think we were done. 143 */ 144 if (! jmain->suspended) { 145 (*in_row_ctr)--; 146 jmain->suspended = TRUE; 147 } 148 return; 149 } 150 /* We did finish the row. Undo our little suspension hack if a previous 151 * call suspended; then mark the main buffer empty. 152 */ 153 if (jmain->suspended) { 154 (*in_row_ctr)++; 155 jmain->suspended = FALSE; 156 } 157 jmain->rowgroup_ctr = 0; 158 jmain->cur_iMCU_row++; 159 } 160 } 161 162 163 #ifdef FULL_MAIN_BUFFER_SUPPORTED 164 165 /* 166 * Process some data. 167 * This routine handles all of the modes that use a full-size buffer. 168 */ 169 170 METHODDEF void 171 process_data_buffer_main (j_compress_ptr cinfo, 172 JSAMPARRAY input_buf, JDIMENSION *in_row_ctr, 173 JDIMENSION in_rows_avail) 174 { 175 my_main_ptr main = (my_main_ptr) cinfo->main; 176 int ci; 177 jpeg_component_info *compptr; 178 boolean writing = (main->pass_mode != JBUF_CRANK_DEST); 179 180 while (main->cur_iMCU_row < cinfo->total_iMCU_rows) { 181 /* Realign the virtual buffers if at the start of an iMCU row. */ 182 if (main->rowgroup_ctr == 0) { 183 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; 184 ci++, compptr++) { 185 main->buffer[ci] = (*cinfo->mem->access_virt_sarray) 186 ((j_common_ptr) cinfo, main->whole_image[ci], 187 main->cur_iMCU_row * (compptr->v_samp_factor * DCTSIZE), 188 (JDIMENSION) (compptr->v_samp_factor * DCTSIZE), writing); 189 } 190 /* In a read pass, pretend we just read some source data. */ 191 if (! writing) { 192 *in_row_ctr += cinfo->max_v_samp_factor * DCTSIZE; 193 main->rowgroup_ctr = DCTSIZE; 194 } 195 } 196 197 /* If a write pass, read input data until the current iMCU row is full. */ 198 /* Note: preprocessor will pad if necessary to fill the last iMCU row. */ 199 if (writing) { 200 (*cinfo->prep->pre_process_data) (cinfo, 201 input_buf, in_row_ctr, in_rows_avail, 202 main->buffer, &main->rowgroup_ctr, 203 (JDIMENSION) DCTSIZE); 204 /* Return to application if we need more data to fill the iMCU row. */ 205 if (main->rowgroup_ctr < DCTSIZE) 206 return; 207 } 208 209 /* Emit data, unless this is a sink-only pass. */ 210 if (main->pass_mode != JBUF_SAVE_SOURCE) { 211 if (! (*cinfo->coef->compress_data) (cinfo, main->buffer)) { 212 /* If compressor did not consume the whole row, then we must need to 213 * suspend processing and return to the application. In this situation 214 * we pretend we didn't yet consume the last input row; otherwise, if 215 * it happened to be the last row of the image, the application would 216 * think we were done. 217 */ 218 if (! main->suspended) { 219 (*in_row_ctr)--; 220 main->suspended = TRUE; 221 } 222 return; 223 } 224 /* We did finish the row. Undo our little suspension hack if a previous 225 * call suspended; then mark the main buffer empty. 226 */ 227 if (main->suspended) { 228 (*in_row_ctr)++; 229 main->suspended = FALSE; 230 } 231 } 232 233 /* If get here, we are done with this iMCU row. Mark buffer empty. */ 234 main->rowgroup_ctr = 0; 235 main->cur_iMCU_row++; 236 } 237 } 238 239 #endif /* FULL_MAIN_BUFFER_SUPPORTED */ 240 241 242 /* 243 * Initialize main buffer controller. 244 */ 245 246 GLOBAL void 247 jinit_c_main_controller (j_compress_ptr cinfo, boolean need_full_buffer) 248 { 249 // bk001204 - don't use main 250 my_main_ptr jmain; 251 int ci; 252 jpeg_component_info *compptr; 253 254 jmain = (my_main_ptr) 255 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, 256 SIZEOF(my_main_controller)); 257 cinfo->main = (struct jpeg_c_main_controller *) jmain; 258 jmain->pub.start_pass = start_pass_main; 259 260 /* We don't need to create a buffer in raw-data mode. */ 261 if (cinfo->raw_data_in) 262 return; 263 264 /* Create the buffer. It holds downsampled data, so each component 265 * may be of a different size. 266 */ 267 if (need_full_buffer) { 268 #ifdef FULL_MAIN_BUFFER_SUPPORTED 269 /* Allocate a full-image virtual array for each component */ 270 /* Note we pad the bottom to a multiple of the iMCU height */ 271 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; 272 ci++, compptr++) { 273 jmain->whole_image[ci] = (*cinfo->mem->request_virt_sarray) 274 ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE, 275 compptr->width_in_blocks * DCTSIZE, 276 (JDIMENSION) jround_up((long) compptr->height_in_blocks, 277 (long) compptr->v_samp_factor) * DCTSIZE, 278 (JDIMENSION) (compptr->v_samp_factor * DCTSIZE)); 279 } 280 #else 281 ERREXIT(cinfo, JERR_BAD_BUFFER_MODE); 282 #endif 283 } else { 284 #ifdef FULL_MAIN_BUFFER_SUPPORTED 285 jmain->whole_image[0] = NULL; /* flag for no virtual arrays */ 286 #endif 287 /* Allocate a strip buffer for each component */ 288 for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components; 289 ci++, compptr++) { 290 jmain->buffer[ci] = (*cinfo->mem->alloc_sarray) 291 ((j_common_ptr) cinfo, JPOOL_IMAGE, 292 compptr->width_in_blocks * DCTSIZE, 293 (JDIMENSION) (compptr->v_samp_factor * DCTSIZE)); 294 } 295 } 296 }