Main MRPT website > C++ reference for MRPT 1.5.6
jcsample.cpp
Go to the documentation of this file.
1 /* +---------------------------------------------------------------------------+
2  | Mobile Robot Programming Toolkit (MRPT) |
3  | http://www.mrpt.org/ |
4  | |
5  | Copyright (c) 2005-2017, Individual contributors, see AUTHORS file |
6  | See: http://www.mrpt.org/Authors - All rights reserved. |
7  | Released under BSD License. See details in http://www.mrpt.org/License |
8  +---------------------------------------------------------------------------+ */
9 
10 #define JPEG_INTERNALS
11 #include "jinclude.h"
12 #include "mrpt_jpeglib.h"
13 
14 
15 /* Pointer to routine to downsample a single component */
16 typedef JMETHOD(void, downsample1_ptr,
18  JSAMPARRAY input_data, JSAMPARRAY output_data));
19 
20 /* Private subobject */
21 
22 typedef struct {
23  struct jpeg_downsampler pub; /* public fields */
24 
25  /* Downsampling method pointers, one per component */
26  downsample1_ptr methods[MAX_COMPONENTS];
28 
30 
31 
32 /*
33  * Initialize for a downsampling pass.
34  */
35 
36 METHODDEF(void)
38 {
39  /* no work for now */
40 }
41 
42 
43 /*
44  * Expand a component horizontally from width input_cols to width output_cols,
45  * by duplicating the rightmost samples.
46  */
47 
48 LOCAL(void)
50  JDIMENSION input_cols, JDIMENSION output_cols)
51 {
52  JSAMPROW ptr;
53  JSAMPLE pixval;
54  int count;
55  int row;
56  int numcols = (int) (output_cols - input_cols);
57 
58  if (numcols > 0) {
59  for (row = 0; row < num_rows; row++) {
60  ptr = image_data[row] + input_cols;
61  pixval = ptr[-1]; /* don't need GETJSAMPLE() here */
62  for (count = numcols; count > 0; count--)
63  *ptr++ = pixval;
64  }
65  }
66 }
67 
68 
69 /*
70  * Do downsampling for a whole row group (all components).
71  *
72  * In this version we simply downsample each component independently.
73  */
74 
75 METHODDEF(void)
77  JSAMPIMAGE input_buf, JDIMENSION in_row_index,
78  JSAMPIMAGE output_buf, JDIMENSION out_row_group_index)
79 {
80  my_downsample_ptr downsample = (my_downsample_ptr) cinfo->downsample;
81  int ci;
83  JSAMPARRAY in_ptr, out_ptr;
84 
85  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
86  ci++, compptr++) {
87  in_ptr = input_buf[ci] + in_row_index;
88  out_ptr = output_buf[ci] + (out_row_group_index * compptr->v_samp_factor);
89  (*downsample->methods[ci]) (cinfo, compptr, in_ptr, out_ptr);
90  }
91 }
92 
93 
94 /*
95  * Downsample pixel values of a single component.
96  * One row group is processed per call.
97  * This version handles arbitrary integral sampling ratios, without smoothing.
98  * Note that this version is not actually used for customary sampling ratios.
99  */
100 
101 METHODDEF(void)
103  JSAMPARRAY input_data, JSAMPARRAY output_data)
104 {
105  int inrow, outrow, h_expand, v_expand, numpix, numpix2, h, v;
106  JDIMENSION outcol, outcol_h; /* outcol_h == outcol*h_expand */
107  JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
108  JSAMPROW inptr, outptr;
109  INT32 outvalue;
110 
111  h_expand = cinfo->max_h_samp_factor / compptr->h_samp_factor;
112  v_expand = cinfo->max_v_samp_factor / compptr->v_samp_factor;
113  numpix = h_expand * v_expand;
114  numpix2 = numpix/2;
115 
116  /* Expand input data enough to let all the output samples be generated
117  * by the standard loop. Special-casing padded output would be more
118  * efficient.
119  */
120  expand_right_edge(input_data, cinfo->max_v_samp_factor,
121  cinfo->image_width, output_cols * h_expand);
122 
123  inrow = 0;
124  for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
125  outptr = output_data[outrow];
126  for (outcol = 0, outcol_h = 0; outcol < output_cols;
127  outcol++, outcol_h += h_expand) {
128  outvalue = 0;
129  for (v = 0; v < v_expand; v++) {
130  inptr = input_data[inrow+v] + outcol_h;
131  for (h = 0; h < h_expand; h++) {
132  outvalue += (INT32) GETJSAMPLE(*inptr++);
133  }
134  }
135  *outptr++ = (JSAMPLE) ((outvalue + numpix2) / numpix);
136  }
137  inrow += v_expand;
138  }
139 }
140 
141 
142 /*
143  * Downsample pixel values of a single component.
144  * This version handles the special case of a full-size component,
145  * without smoothing.
146  */
147 
148 METHODDEF(void)
150  JSAMPARRAY input_data, JSAMPARRAY output_data)
151 {
152  /* Copy the data */
153  jcopy_sample_rows(input_data, 0, output_data, 0,
154  cinfo->max_v_samp_factor, cinfo->image_width);
155  /* Edge-expand */
156  expand_right_edge(output_data, cinfo->max_v_samp_factor,
157  cinfo->image_width, compptr->width_in_blocks * DCTSIZE);
158 }
159 
160 
161 /*
162  * Downsample pixel values of a single component.
163  * This version handles the common case of 2:1 horizontal and 1:1 vertical,
164  * without smoothing.
165  *
166  * A note about the "bias" calculations: when rounding fractional values to
167  * integer, we do not want to always round 0.5 up to the next integer.
168  * If we did that, we'd introduce a noticeable bias towards larger values.
169  * Instead, this code is arranged so that 0.5 will be rounded up or down at
170  * alternate pixel locations (a simple ordered dither pattern).
171  */
172 
173 METHODDEF(void)
175  JSAMPARRAY input_data, JSAMPARRAY output_data)
176 {
177  int outrow;
178  JDIMENSION outcol;
179  JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
180  JSAMPROW inptr, outptr;
181  int bias;
182 
183  /* Expand input data enough to let all the output samples be generated
184  * by the standard loop. Special-casing padded output would be more
185  * efficient.
186  */
187  expand_right_edge(input_data, cinfo->max_v_samp_factor,
188  cinfo->image_width, output_cols * 2);
189 
190  for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
191  outptr = output_data[outrow];
192  inptr = input_data[outrow];
193  bias = 0; /* bias = 0,1,0,1,... for successive samples */
194  for (outcol = 0; outcol < output_cols; outcol++) {
195  *outptr++ = (JSAMPLE) ((GETJSAMPLE(*inptr) + GETJSAMPLE(inptr[1])
196  + bias) >> 1);
197  bias ^= 1; /* 0=>1, 1=>0 */
198  inptr += 2;
199  }
200  }
201 }
202 
203 
204 /*
205  * Downsample pixel values of a single component.
206  * This version handles the standard case of 2:1 horizontal and 2:1 vertical,
207  * without smoothing.
208  */
209 
210 METHODDEF(void)
212  JSAMPARRAY input_data, JSAMPARRAY output_data)
213 {
214  int inrow, outrow;
215  JDIMENSION outcol;
216  JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
217  JSAMPROW inptr0, inptr1, outptr;
218  int bias;
219 
220  /* Expand input data enough to let all the output samples be generated
221  * by the standard loop. Special-casing padded output would be more
222  * efficient.
223  */
224  expand_right_edge(input_data, cinfo->max_v_samp_factor,
225  cinfo->image_width, output_cols * 2);
226 
227  inrow = 0;
228  for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
229  outptr = output_data[outrow];
230  inptr0 = input_data[inrow];
231  inptr1 = input_data[inrow+1];
232  bias = 1; /* bias = 1,2,1,2,... for successive samples */
233  for (outcol = 0; outcol < output_cols; outcol++) {
234  *outptr++ = (JSAMPLE) ((GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
235  GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1])
236  + bias) >> 2);
237  bias ^= 3; /* 1=>2, 2=>1 */
238  inptr0 += 2; inptr1 += 2;
239  }
240  inrow += 2;
241  }
242 }
243 
244 
245 #ifdef INPUT_SMOOTHING_SUPPORTED
246 
247 /*
248  * Downsample pixel values of a single component.
249  * This version handles the standard case of 2:1 horizontal and 2:1 vertical,
250  * with smoothing. One row of context is required.
251  */
252 
253 METHODDEF(void)
255  JSAMPARRAY input_data, JSAMPARRAY output_data)
256 {
257  int inrow, outrow;
258  JDIMENSION colctr;
259  JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
260  JSAMPROW inptr0, inptr1, above_ptr, below_ptr, outptr;
261  INT32 membersum, neighsum, memberscale, neighscale;
262 
263  /* Expand input data enough to let all the output samples be generated
264  * by the standard loop. Special-casing padded output would be more
265  * efficient.
266  */
267  expand_right_edge(input_data - 1, cinfo->max_v_samp_factor + 2,
268  cinfo->image_width, output_cols * 2);
269 
270  /* We don't bother to form the individual "smoothed" input pixel values;
271  * we can directly compute the output which is the average of the four
272  * smoothed values. Each of the four member pixels contributes a fraction
273  * (1-8*SF) to its own smoothed image and a fraction SF to each of the three
274  * other smoothed pixels, therefore a total fraction (1-5*SF)/4 to the final
275  * output. The four corner-adjacent neighbor pixels contribute a fraction
276  * SF to just one smoothed pixel, or SF/4 to the final output; while the
277  * eight edge-adjacent neighbors contribute SF to each of two smoothed
278  * pixels, or SF/2 overall. In order to use integer arithmetic, these
279  * factors are scaled by 2^16 = 65536.
280  * Also recall that SF = smoothing_factor / 1024.
281  */
282 
283  memberscale = 16384 - cinfo->smoothing_factor * 80; /* scaled (1-5*SF)/4 */
284  neighscale = cinfo->smoothing_factor * 16; /* scaled SF/4 */
285 
286  inrow = 0;
287  for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
288  outptr = output_data[outrow];
289  inptr0 = input_data[inrow];
290  inptr1 = input_data[inrow+1];
291  above_ptr = input_data[inrow-1];
292  below_ptr = input_data[inrow+2];
293 
294  /* Special case for first column: pretend column -1 is same as column 0 */
295  membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
296  GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
297  neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
298  GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
299  GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[2]) +
300  GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[2]);
301  neighsum += neighsum;
302  neighsum += GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[2]) +
303  GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[2]);
304  membersum = membersum * memberscale + neighsum * neighscale;
305  *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
306  inptr0 += 2; inptr1 += 2; above_ptr += 2; below_ptr += 2;
307 
308  for (colctr = output_cols - 2; colctr > 0; colctr--) {
309  /* sum of pixels directly mapped to this output element */
310  membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
311  GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
312  /* sum of edge-neighbor pixels */
313  neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
314  GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
315  GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[2]) +
316  GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[2]);
317  /* The edge-neighbors count twice as much as corner-neighbors */
318  neighsum += neighsum;
319  /* Add in the corner-neighbors */
320  neighsum += GETJSAMPLE(above_ptr[-1]) + GETJSAMPLE(above_ptr[2]) +
321  GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[2]);
322  /* form final output scaled up by 2^16 */
323  membersum = membersum * memberscale + neighsum * neighscale;
324  /* round, descale and output it */
325  *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
326  inptr0 += 2; inptr1 += 2; above_ptr += 2; below_ptr += 2;
327  }
328 
329  /* Special case for last column */
330  membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
331  GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
332  neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
333  GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
334  GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[1]) +
335  GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[1]);
336  neighsum += neighsum;
337  neighsum += GETJSAMPLE(above_ptr[-1]) + GETJSAMPLE(above_ptr[1]) +
338  GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[1]);
339  membersum = membersum * memberscale + neighsum * neighscale;
340  *outptr = (JSAMPLE) ((membersum + 32768) >> 16);
341 
342  inrow += 2;
343  }
344 }
345 
346 
347 /*
348  * Downsample pixel values of a single component.
349  * This version handles the special case of a full-size component,
350  * with smoothing. One row of context is required.
351  */
352 
353 METHODDEF(void)
355  JSAMPARRAY input_data, JSAMPARRAY output_data)
356 {
357  int outrow;
358  JDIMENSION colctr;
359  JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
360  JSAMPROW inptr, above_ptr, below_ptr, outptr;
361  INT32 membersum, neighsum, memberscale, neighscale;
362  int colsum, lastcolsum, nextcolsum;
363 
364  /* Expand input data enough to let all the output samples be generated
365  * by the standard loop. Special-casing padded output would be more
366  * efficient.
367  */
368  expand_right_edge(input_data - 1, cinfo->max_v_samp_factor + 2,
369  cinfo->image_width, output_cols);
370 
371  /* Each of the eight neighbor pixels contributes a fraction SF to the
372  * smoothed pixel, while the main pixel contributes (1-8*SF). In order
373  * to use integer arithmetic, these factors are multiplied by 2^16 = 65536.
374  * Also recall that SF = smoothing_factor / 1024.
375  */
376 
377  memberscale = 65536L - cinfo->smoothing_factor * 512L; /* scaled 1-8*SF */
378  neighscale = cinfo->smoothing_factor * 64; /* scaled SF */
379 
380  for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
381  outptr = output_data[outrow];
382  inptr = input_data[outrow];
383  above_ptr = input_data[outrow-1];
384  below_ptr = input_data[outrow+1];
385 
386  /* Special case for first column */
387  colsum = GETJSAMPLE(*above_ptr++) + GETJSAMPLE(*below_ptr++) +
388  GETJSAMPLE(*inptr);
389  membersum = GETJSAMPLE(*inptr++);
390  nextcolsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(*below_ptr) +
391  GETJSAMPLE(*inptr);
392  neighsum = colsum + (colsum - membersum) + nextcolsum;
393  membersum = membersum * memberscale + neighsum * neighscale;
394  *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
395  lastcolsum = colsum; colsum = nextcolsum;
396 
397  for (colctr = output_cols - 2; colctr > 0; colctr--) {
398  membersum = GETJSAMPLE(*inptr++);
399  above_ptr++; below_ptr++;
400  nextcolsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(*below_ptr) +
401  GETJSAMPLE(*inptr);
402  neighsum = lastcolsum + (colsum - membersum) + nextcolsum;
403  membersum = membersum * memberscale + neighsum * neighscale;
404  *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
405  lastcolsum = colsum; colsum = nextcolsum;
406  }
407 
408  /* Special case for last column */
409  membersum = GETJSAMPLE(*inptr);
410  neighsum = lastcolsum + (colsum - membersum) + colsum;
411  membersum = membersum * memberscale + neighsum * neighscale;
412  *outptr = (JSAMPLE) ((membersum + 32768) >> 16);
413 
414  }
415 }
416 
417 #endif /* INPUT_SMOOTHING_SUPPORTED */
418 
419 
420 /*
421  * Module initialization routine for downsampling.
422  * Note that we must select a routine for each component.
423  */
424 
425 GLOBAL(void)
427 {
428  my_downsample_ptr downsample;
429  int ci;
431  boolean smoothok = TRUE;
432 
433  downsample = (my_downsample_ptr)
434  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
436  cinfo->downsample = (struct jpeg_downsampler *) downsample;
437  downsample->pub.start_pass = start_pass_downsample;
438  downsample->pub.downsample = sep_downsample;
439  downsample->pub.need_context_rows = FALSE;
440 
441  if (cinfo->CCIR601_sampling)
442  ERREXIT(cinfo, JERR_CCIR601_NOTIMPL);
443 
444  /* Verify we can handle the sampling factors, and set up method pointers */
445  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
446  ci++, compptr++) {
447  if (compptr->h_samp_factor == cinfo->max_h_samp_factor &&
448  compptr->v_samp_factor == cinfo->max_v_samp_factor) {
449 #ifdef INPUT_SMOOTHING_SUPPORTED
450  if (cinfo->smoothing_factor) {
451  downsample->methods[ci] = fullsize_smooth_downsample;
452  downsample->pub.need_context_rows = TRUE;
453  } else
454 #endif
455  downsample->methods[ci] = fullsize_downsample;
456  } else if (compptr->h_samp_factor * 2 == cinfo->max_h_samp_factor &&
457  compptr->v_samp_factor == cinfo->max_v_samp_factor) {
458  smoothok = FALSE;
459  downsample->methods[ci] = h2v1_downsample;
460  } else if (compptr->h_samp_factor * 2 == cinfo->max_h_samp_factor &&
461  compptr->v_samp_factor * 2 == cinfo->max_v_samp_factor) {
462 #ifdef INPUT_SMOOTHING_SUPPORTED
463  if (cinfo->smoothing_factor) {
464  downsample->methods[ci] = h2v2_smooth_downsample;
465  downsample->pub.need_context_rows = TRUE;
466  } else
467 #endif
468  downsample->methods[ci] = h2v2_downsample;
469  } else if ((cinfo->max_h_samp_factor % compptr->h_samp_factor) == 0 &&
470  (cinfo->max_v_samp_factor % compptr->v_samp_factor) == 0) {
471  smoothok = FALSE;
472  downsample->methods[ci] = int_downsample;
473  } else
474  ERREXIT(cinfo, JERR_FRACT_SAMPLE_NOTIMPL);
475  }
476 
477 #ifdef INPUT_SMOOTHING_SUPPORTED
478  if (cinfo->smoothing_factor && !smoothok)
479  TRACEMS(cinfo, 0, JTRC_SMOOTH_NOTIMPL);
480 #endif
481 }
jinit_downsampler(j_compress_ptr cinfo)
Definition: jcsample.cpp:426
const GLdouble * v
Definition: glew.h:1296
start_pass_downsample(j_compress_ptr)
Definition: jcsample.cpp:37
my_downsampler * my_downsample_ptr
Definition: jcsample.cpp:29
char JSAMPLE
Definition: jmorecfg.h:61
GLenum GLenum GLvoid * row
Definition: glew.h:2903
h2v2_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr, JSAMPARRAY input_data, JSAMPARRAY output_data)
Definition: jcsample.cpp:211
#define DCTSIZE
Definition: mrpt_jpeglib.h:38
struct jpeg_common_struct * j_common_ptr
Definition: mrpt_jpeglib.h:258
int_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr, JSAMPARRAY input_data, JSAMPARRAY output_data)
Definition: jcsample.cpp:102
#define MAX_COMPONENTS
Definition: jmorecfg.h:32
#define GETJSAMPLE(value)
Definition: jmorecfg.h:65
#define ERREXIT(cinfo, code)
Definition: jerror.h:199
#define SIZEOF(object)
Definition: jinclude.h:73
JSAMPLE FAR * JSAMPROW
Definition: mrpt_jpeglib.h:63
long INT32
Definition: jmorecfg.h:158
jpeg_component_info * compptr
Definition: jdct.h:97
#define TRACEMS(cinfo, lvl, code)
Definition: jerror.h:246
jcopy_sample_rows(JSAMPARRAY input_array, int source_row, JSAMPARRAY output_array, int dest_row, int num_rows, JDIMENSION num_cols)
Definition: jutils.cpp:107
h2v1_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr, JSAMPARRAY input_data, JSAMPARRAY output_data)
Definition: jcsample.cpp:174
GLfloat bias
Definition: glew.h:6196
JSAMPIMAGE input_buf
Definition: jccoefct.cpp:59
expand_right_edge(JSAMPARRAY image_data, int num_rows, JDIMENSION input_cols, JDIMENSION output_cols)
Definition: jcsample.cpp:49
#define FALSE
Definition: jmorecfg.h:227
#define JPOOL_IMAGE
Definition: mrpt_jpeglib.h:746
#define LOCAL(type)
Definition: jmorecfg.h:183
JSAMPROW * JSAMPARRAY
Definition: mrpt_jpeglib.h:64
typedef int(WINAPI *PFNWGLRELEASEPBUFFERDCARBPROC)(HPBUFFERARB hPbuffer
int JSAMPARRAY int int num_rows
Definition: jpegint.h:370
#define TRUE
Definition: jmorecfg.h:230
sep_downsample(j_compress_ptr cinfo, JSAMPIMAGE input_buf, JDIMENSION in_row_index, JSAMPIMAGE output_buf, JDIMENSION out_row_group_index)
Definition: jcsample.cpp:76
struct jpeg_downsampler pub
Definition: jcsample.cpp:23
JSAMPARRAY * JSAMPIMAGE
Definition: mrpt_jpeglib.h:65
JSAMPIMAGE output_buf
Definition: jdcoefct.cpp:59
#define GLOBAL(type)
Definition: jmorecfg.h:185
#define METHODDEF(type)
Definition: jmorecfg.h:181
downsample1_ptr methods[MAX_COMPONENTS]
Definition: jcsample.cpp:26
fullsize_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr, JSAMPARRAY input_data, JSAMPARRAY output_data)
Definition: jcsample.cpp:149
GLuint GLuint GLsizei count
Definition: glew.h:1167
fullsize_smooth_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr, JSAMPARRAY input_data, JSAMPARRAY output_data)
Definition: jcsample.cpp:354
unsigned int JDIMENSION
Definition: jmorecfg.h:168
boolean need_context_rows
Definition: jpegint.h:95
typedef JMETHOD(void, downsample1_ptr,(j_compress_ptr cinfo, jpeg_component_info *compptr, JSAMPARRAY input_data, JSAMPARRAY output_data))
h2v2_smooth_downsample(j_compress_ptr cinfo, jpeg_component_info *compptr, JSAMPARRAY input_data, JSAMPARRAY output_data)
Definition: jcsample.cpp:254



Page generated by Doxygen 1.8.6 for MRPT 1.5.6 Git: 4c65e84 Tue Apr 24 08:18:17 2018 +0200 at mar abr 24 08:26:17 CEST 2018