jdmainct.c
Go to the documentation of this file.
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). */
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 */
133 
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 */
145  JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail));
147  JPP((j_decompress_ptr cinfo, JSAMPARRAY output_buf,
148  JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail));
149 #ifdef QUANT_2PASS_SUPPORTED
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;
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++) {
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)
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;
207  JSAMPARRAY buf, xbuf0, xbuf1;
208 
209  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
210  ci++, compptr++) {
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)
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;
247  JSAMPARRAY xbuf0, xbuf1;
248 
249  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
250  ci++, compptr++) {
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)
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;
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)
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] */
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)
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)
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 */
414  if (*out_row_ctr >= out_rows_avail)
415  return; /* Postprocessor exactly filled output buf */
416  /*FALLTHROUGH*/
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);
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)
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);
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)
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)
477 {
479  int ci, rgroup, ngroups;
481 
482  main = (my_main_ptr)
483  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
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 }
jinit_d_main_controller(j_decompress_ptr cinfo, boolean need_full_buffer)
Definition: jdmainct.c:476
struct jpeg_c_main_controller pub
Definition: jcmainct.c:29
JSAMPLE FAR * JSAMPROW
Definition: jpeglib.h:66
#define FALSE
Definition: OPC_IceHook.h:9
set_bottom_pointers(j_decompress_ptr cinfo)
Definition: jdmainct.c:266
boolean buffer_full
Definition: jdmainct.c:120
JDIMENSION rowgroups_avail
Definition: jdmainct.c:130
struct jpeg_common_struct * j_common_ptr
Definition: jpeglib.h:261
METHODDEF(void)
Definition: jdmainct.c:143
#define MAX_COMPONENTS
Definition: jmorecfg.h:35
#define ERREXIT(cinfo, code)
Definition: jerror.h:205
#define TRUE
Definition: OPC_IceHook.h:13
#define SIZEOF(object)
Definition: jinclude.h:80
boolean need_full_buffer
Definition: jpegint.h:338
int main(int argc, argv)
Definition: ansi2knr.c:320
JDIMENSION rowgroup_ctr
Definition: jcmainct.c:32
start_pass_main(j_decompress_ptr cinfo, J_BUF_MODE pass_mode)
Definition: jdmainct.c:307
#define for
png_uint_32 i
Definition: png.h:2735
jpeg_component_info * compptr
Definition: jdct.h:102
JDIMENSION width_in_blocks
Definition: jpeglib.h:139
my_main_controller * my_main_ptr
Definition: jdmainct.c:134
#define JPOOL_IMAGE
Definition: jpeglib.h:749
JSAMPARRAY buffer[MAX_COMPONENTS]
Definition: jcmainct.c:40
#define CTX_PREPARE_FOR_IMCU
Definition: jdmainct.c:137
#define CTX_POSTPONED_ROW
Definition: jdmainct.c:139
#define LOCAL(type)
Definition: jmorecfg.h:186
process_data_simple_main(j_decompress_ptr cinfo, JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)
Definition: jdmainct.c:345
process_data_context_main(j_decompress_ptr cinfo, JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)
Definition: jdmainct.c:385
#define CTX_PROCESS_IMCU
Definition: jdmainct.c:138
make_funny_pointers(j_decompress_ptr cinfo)
Definition: jdmainct.c:195
#define JPP(arglist)
Definition: jpeglib.h:818
JSAMPARRAY * JSAMPIMAGE
Definition: jpeglib.h:68
png_bytep buf
Definition: png.h:2729
JSAMPROW * JSAMPARRAY
Definition: jpeglib.h:67
typedef int
Definition: png.h:1113
#define GLOBAL(type)
Definition: jmorecfg.h:188
JSAMPIMAGE xbuffer[2]
Definition: jdmainct.c:126
png_infop png_bytep buffer
Definition: png.h:2042
JDIMENSION iMCU_row_ctr
Definition: jdmainct.c:131
J_BUF_MODE
Definition: jpegint.h:16
set_wraparound_pointers(j_decompress_ptr cinfo)
Definition: jdmainct.c:238
jpeg_component_info JCOEFPTR JSAMPARRAY output_buf
Definition: jdct.h:102
process_data_crank_post(j_decompress_ptr cinfo, JSAMPARRAY output_buf, JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)
Definition: jdmainct.c:459
unsigned int JDIMENSION
Definition: jmorecfg.h:171
JDIMENSION downsampled_height
Definition: jpeglib.h:155


openhrp3
Author(s): AIST, General Robotix Inc., Nakamura Lab of Dept. of Mechano Informatics at University of Tokyo
autogenerated on Sat May 8 2021 02:42:39