ReactOS  0.4.14-dev-358-gbef841c
jdpostct.c
Go to the documentation of this file.
1 /*
2  * jdpostct.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 decompression postprocessing controller.
9  * This controller manages the upsampling, color conversion, and color
10  * quantization/reduction steps; specifically, it controls the buffering
11  * between upsample/color conversion and color quantization/reduction.
12  *
13  * If no color quantization/reduction is required, then this module has no
14  * work to do, and it just hands off to the upsample/color conversion code.
15  * An integrated upsample/convert/quantize process would replace this module
16  * entirely.
17  */
18 
19 #define JPEG_INTERNALS
20 #include "jinclude.h"
21 #include "jpeglib.h"
22 
23 
24 /* Private buffer controller object */
25 
26 typedef struct {
27  struct jpeg_d_post_controller pub; /* public fields */
28 
29  /* Color quantization source buffer: this holds output data from
30  * the upsample/color conversion step to be passed to the quantizer.
31  * For two-pass color quantization, we need a full-image buffer;
32  * for one-pass operation, a strip buffer is sufficient.
33  */
34  jvirt_sarray_ptr whole_image; /* virtual array, or NULL if one-pass */
35  JSAMPARRAY buffer; /* strip buffer, or current strip of virtual */
36  JDIMENSION strip_height; /* buffer size in rows */
37  /* for two-pass mode only: */
38  JDIMENSION starting_row; /* row # of first row in current strip */
39  JDIMENSION next_row; /* index of next row to fill/empty in strip */
41 
43 
44 
45 /* Forward declarations */
47  JPP((j_decompress_ptr cinfo,
48  JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
49  JDIMENSION in_row_groups_avail,
50  JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
51  JDIMENSION out_rows_avail));
52 #ifdef QUANT_2PASS_SUPPORTED
53 METHODDEF(void) post_process_prepass
54  JPP((j_decompress_ptr cinfo,
55  JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
56  JDIMENSION in_row_groups_avail,
57  JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
58  JDIMENSION out_rows_avail));
59 METHODDEF(void) post_process_2pass
60  JPP((j_decompress_ptr cinfo,
61  JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
62  JDIMENSION in_row_groups_avail,
63  JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
64  JDIMENSION out_rows_avail));
65 #endif
66 
67 
68 /*
69  * Initialize for a processing pass.
70  */
71 
72 METHODDEF(void)
73 start_pass_dpost (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)
74 {
75  my_post_ptr post = (my_post_ptr) cinfo->post;
76 
77  switch (pass_mode) {
78  case JBUF_PASS_THRU:
79  if (cinfo->quantize_colors) {
80  /* Single-pass processing with color quantization. */
81  post->pub.post_process_data = post_process_1pass;
82  /* We could be doing buffered-image output before starting a 2-pass
83  * color quantization; in that case, jinit_d_post_controller did not
84  * allocate a strip buffer. Use the virtual-array buffer as workspace.
85  */
86  if (post->buffer == NULL) {
87  post->buffer = (*cinfo->mem->access_virt_sarray)
88  ((j_common_ptr) cinfo, post->whole_image,
89  (JDIMENSION) 0, post->strip_height, TRUE);
90  }
91  } else {
92  /* For single-pass processing without color quantization,
93  * I have no work to do; just call the upsampler directly.
94  */
95  post->pub.post_process_data = cinfo->upsample->upsample;
96  }
97  break;
98 #ifdef QUANT_2PASS_SUPPORTED
99  case JBUF_SAVE_AND_PASS:
100  /* First pass of 2-pass quantization */
101  if (post->whole_image == NULL)
102  ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
103  post->pub.post_process_data = post_process_prepass;
104  break;
105  case JBUF_CRANK_DEST:
106  /* Second pass of 2-pass quantization */
107  if (post->whole_image == NULL)
108  ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
109  post->pub.post_process_data = post_process_2pass;
110  break;
111 #endif /* QUANT_2PASS_SUPPORTED */
112  default:
113  ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
114  break;
115  }
116  post->starting_row = post->next_row = 0;
117 }
118 
119 
120 /*
121  * Process some data in the one-pass (strip buffer) case.
122  * This is used for color precision reduction as well as one-pass quantization.
123  */
124 
125 METHODDEF(void)
127  JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
128  JDIMENSION in_row_groups_avail,
129  JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
130  JDIMENSION out_rows_avail)
131 {
132  my_post_ptr post = (my_post_ptr) cinfo->post;
133  JDIMENSION num_rows, max_rows;
134 
135  /* Fill the buffer, but not more than what we can dump out in one go. */
136  /* Note we rely on the upsampler to detect bottom of image. */
137  max_rows = out_rows_avail - *out_row_ctr;
138  if (max_rows > post->strip_height)
139  max_rows = post->strip_height;
140  num_rows = 0;
141  (*cinfo->upsample->upsample) (cinfo,
142  input_buf, in_row_group_ctr, in_row_groups_avail,
143  post->buffer, &num_rows, max_rows);
144  /* Quantize and emit data. */
145  (*cinfo->cquantize->color_quantize) (cinfo,
146  post->buffer, output_buf + *out_row_ctr, (int) num_rows);
147  *out_row_ctr += num_rows;
148 }
149 
150 
151 #ifdef QUANT_2PASS_SUPPORTED
152 
153 /*
154  * Process some data in the first pass of 2-pass quantization.
155  */
156 
157 METHODDEF(void)
158 post_process_prepass (j_decompress_ptr cinfo,
159  JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
160  JDIMENSION in_row_groups_avail,
161  JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
162  JDIMENSION out_rows_avail)
163 {
164  my_post_ptr post = (my_post_ptr) cinfo->post;
165  JDIMENSION old_next_row, num_rows;
166 
167  /* Reposition virtual buffer if at start of strip. */
168  if (post->next_row == 0) {
169  post->buffer = (*cinfo->mem->access_virt_sarray)
170  ((j_common_ptr) cinfo, post->whole_image,
171  post->starting_row, post->strip_height, TRUE);
172  }
173 
174  /* Upsample some data (up to a strip height's worth). */
175  old_next_row = post->next_row;
176  (*cinfo->upsample->upsample) (cinfo,
177  input_buf, in_row_group_ctr, in_row_groups_avail,
178  post->buffer, &post->next_row, post->strip_height);
179 
180  /* Allow quantizer to scan new data. No data is emitted, */
181  /* but we advance out_row_ctr so outer loop can tell when we're done. */
182  if (post->next_row > old_next_row) {
183  num_rows = post->next_row - old_next_row;
184  (*cinfo->cquantize->color_quantize) (cinfo, post->buffer + old_next_row,
185  (JSAMPARRAY) NULL, (int) num_rows);
186  *out_row_ctr += num_rows;
187  }
188 
189  /* Advance if we filled the strip. */
190  if (post->next_row >= post->strip_height) {
191  post->starting_row += post->strip_height;
192  post->next_row = 0;
193  }
194 }
195 
196 
197 /*
198  * Process some data in the second pass of 2-pass quantization.
199  */
200 
201 METHODDEF(void)
202 post_process_2pass (j_decompress_ptr cinfo,
203  JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
204  JDIMENSION in_row_groups_avail,
205  JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
206  JDIMENSION out_rows_avail)
207 {
208  my_post_ptr post = (my_post_ptr) cinfo->post;
209  JDIMENSION num_rows, max_rows;
210 
211  /* Reposition virtual buffer if at start of strip. */
212  if (post->next_row == 0) {
213  post->buffer = (*cinfo->mem->access_virt_sarray)
214  ((j_common_ptr) cinfo, post->whole_image,
215  post->starting_row, post->strip_height, FALSE);
216  }
217 
218  /* Determine number of rows to emit. */
219  num_rows = post->strip_height - post->next_row; /* available in strip */
220  max_rows = out_rows_avail - *out_row_ctr; /* available in output area */
221  if (num_rows > max_rows)
222  num_rows = max_rows;
223  /* We have to check bottom of image here, can't depend on upsampler. */
224  max_rows = cinfo->output_height - post->starting_row;
225  if (num_rows > max_rows)
226  num_rows = max_rows;
227 
228  /* Quantize and emit data. */
229  (*cinfo->cquantize->color_quantize) (cinfo,
230  post->buffer + post->next_row, output_buf + *out_row_ctr,
231  (int) num_rows);
232  *out_row_ctr += num_rows;
233 
234  /* Advance if we filled the strip. */
235  post->next_row += num_rows;
236  if (post->next_row >= post->strip_height) {
237  post->starting_row += post->strip_height;
238  post->next_row = 0;
239  }
240 }
241 
242 #endif /* QUANT_2PASS_SUPPORTED */
243 
244 
245 /*
246  * Initialize postprocessing controller.
247  */
248 
249 GLOBAL(void)
251 {
252  my_post_ptr post;
253 
254  post = (my_post_ptr)
255  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
257  cinfo->post = (struct jpeg_d_post_controller *) post;
258  post->pub.start_pass = start_pass_dpost;
259  post->whole_image = NULL; /* flag for no virtual arrays */
260  post->buffer = NULL; /* flag for no strip buffer */
261 
262  /* Create the quantization buffer, if needed */
263  if (cinfo->quantize_colors) {
264  /* The buffer strip height is max_v_samp_factor, which is typically
265  * an efficient number of rows for upsampling to return.
266  * (In the presence of output rescaling, we might want to be smarter?)
267  */
268  post->strip_height = (JDIMENSION) cinfo->max_v_samp_factor;
269  if (need_full_buffer) {
270  /* Two-pass color quantization: need full-image storage. */
271  /* We round up the number of rows to a multiple of the strip height. */
272 #ifdef QUANT_2PASS_SUPPORTED
273  post->whole_image = (*cinfo->mem->request_virt_sarray)
274  ((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
275  cinfo->output_width * cinfo->out_color_components,
276  (JDIMENSION) jround_up((long) cinfo->output_height,
277  (long) post->strip_height),
278  post->strip_height);
279 #else
280  ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
281 #endif /* QUANT_2PASS_SUPPORTED */
282  } else {
283  /* One-pass color quantization: just make a strip buffer. */
284  post->buffer = (*cinfo->mem->alloc_sarray)
285  ((j_common_ptr) cinfo, JPOOL_IMAGE,
286  cinfo->output_width * cinfo->out_color_components,
287  post->strip_height);
288  }
289  }
290 }
#define TRUE
Definition: types.h:120
JDIMENSION output_height
Definition: jpeglib.h:508
#define ERREXIT(msg)
Definition: rdjpgcom.c:72
struct jpeg_d_post_controller * post
Definition: jpeglib.h:681
struct jpeg_common_struct * j_common_ptr
Definition: jpeglib.h:284
boolean quantize_colors
Definition: jpeglib.h:491
Definition: jpegint.h:180
jinit_d_post_controller(j_decompress_ptr cinfo, boolean need_full_buffer)
Definition: jdpostct.c:250
JDIMENSION strip_height
Definition: jdpostct.c:36
boolean need_full_buffer
Definition: jpegint.h:377
struct jpeg_d_post_controller pub
Definition: jdpostct.c:27
#define SIZEOF(_ar)
Definition: calc.h:97
#define JPOOL_IMAGE
Definition: jpeglib.h:808
jround_up(long a, long b)
Definition: jutils.c:133
smooth NULL
Definition: ftsmooth.c:416
switch(r->id)
Definition: btrfs.c:2904
struct jpeg_color_quantizer * cquantize
Definition: jpeglib.h:688
METHODDEF(void)
Definition: jdpostct.c:46
if(!(yy_init))
Definition: macro.lex.yy.c:714
int JSAMPARRAY int int num_rows
Definition: jpegint.h:412
JDIMENSION next_row
Definition: jdpostct.c:39
#define JPP(arglist)
Definition: jpeglib.h:877
JSAMPARRAY * JSAMPIMAGE
Definition: jpeglib.h:77
JDIMENSION starting_row
Definition: jdpostct.c:38
JSAMPROW * JSAMPARRAY
Definition: jpeglib.h:76
#define GLOBAL(type)
Definition: jmorecfg.h:291
post_process_1pass(j_decompress_ptr cinfo, JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr, JDIMENSION in_row_groups_avail, JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)
Definition: jdpostct.c:126
struct jpeg_upsampler * upsample
Definition: jpeglib.h:686
JSAMPARRAY buffer
Definition: jdpostct.c:35
#define long
Definition: qsort.c:33
J_BUF_MODE
Definition: jpegint.h:17
Definition: jdpostct.c:26
jpeg_component_info JCOEFPTR JSAMPARRAY output_buf
Definition: jdct.h:238
unsigned int JDIMENSION
Definition: jmorecfg.h:229
jvirt_sarray_ptr whole_image
Definition: jdpostct.c:34
my_post_controller * my_post_ptr
Definition: jdpostct.c:42
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31