ReactOS 0.4.15-dev-8349-g6f277e9
jdmerge.c
Go to the documentation of this file.
1/*
2 * jdmerge.c
3 *
4 * Copyright (C) 1994-1996, Thomas G. Lane.
5 * Modified 2013-2019 by Guido Vollbeding.
6 * This file is part of the Independent JPEG Group's software.
7 * For conditions of distribution and use, see the accompanying README file.
8 *
9 * This file contains code for merged upsampling/color conversion.
10 *
11 * This file combines functions from jdsample.c and jdcolor.c;
12 * read those files first to understand what's going on.
13 *
14 * When the chroma components are to be upsampled by simple replication
15 * (ie, box filtering), we can save some work in color conversion by
16 * calculating all the output pixels corresponding to a pair of chroma
17 * samples at one time. In the conversion equations
18 * R = Y + K1 * Cr
19 * G = Y + K2 * Cb + K3 * Cr
20 * B = Y + K4 * Cb
21 * only the Y term varies among the group of pixels corresponding to a pair
22 * of chroma samples, so the rest of the terms can be calculated just once.
23 * At typical sampling ratios, this eliminates half or three-quarters of the
24 * multiplications needed for color conversion.
25 *
26 * This file currently provides implementations for the following cases:
27 * YCC => RGB color conversion only (YCbCr or BG_YCC).
28 * Sampling ratios of 2h1v or 2h2v.
29 * No scaling needed at upsample time.
30 * Corner-aligned (non-CCIR601) sampling alignment.
31 * Other special cases could be added, but in most applications these are
32 * the only common cases. (For uncommon cases we fall back on the more
33 * general code in jdsample.c and jdcolor.c.)
34 */
35
36#define JPEG_INTERNALS
37#include "jinclude.h"
38#include "jpeglib.h"
39
40#ifdef UPSAMPLE_MERGING_SUPPORTED
41
42
43#if RANGE_BITS < 2
44 /* Deliberate syntax err */
45 Sorry, this code requires 2 or more range extension bits.
46#endif
47
48
49/* Private subobject */
50
51typedef struct {
52 struct jpeg_upsampler pub; /* public fields */
53
54 /* Pointer to routine to do actual upsampling/conversion of one row group */
55 JMETHOD(void, upmethod, (j_decompress_ptr cinfo,
56 JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
58
59 /* Private state for YCC->RGB conversion */
60 int * Cr_r_tab; /* => table for Cr to R conversion */
61 int * Cb_b_tab; /* => table for Cb to B conversion */
62 INT32 * Cr_g_tab; /* => table for Cr to G conversion */
63 INT32 * Cb_g_tab; /* => table for Cb to G conversion */
64
65 /* For 2:1 vertical sampling, we produce two output rows at a time.
66 * We need a "spare" row buffer to hold the second output row if the
67 * application provides just a one-row buffer; we also use the spare
68 * to discard the dummy last row if the image height is odd.
69 */
70 JSAMPROW spare_row;
71 boolean spare_full; /* T if spare buffer is occupied */
72
73 JDIMENSION out_row_width; /* samples per output row */
74 JDIMENSION rows_to_go; /* counts rows remaining in image */
76
78
79#define SCALEBITS 16 /* speediest right-shift on some machines */
80#define ONE_HALF ((INT32) 1 << (SCALEBITS-1))
81#define FIX(x) ((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
82
83
84/*
85 * Initialize tables for YCbCr->RGB and BG_YCC->RGB colorspace conversion.
86 * This is taken directly from jdcolor.c; see that file for more info.
87 */
88
89LOCAL(void)
91/* Normal case, sYCC */
92{
93 my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
94 int i;
95 INT32 x;
97
98 upsample->Cr_r_tab = (int *) (*cinfo->mem->alloc_small)
99 ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(int));
100 upsample->Cb_b_tab = (int *) (*cinfo->mem->alloc_small)
101 ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(int));
102 upsample->Cr_g_tab = (INT32 *) (*cinfo->mem->alloc_small)
104 upsample->Cb_g_tab = (INT32 *) (*cinfo->mem->alloc_small)
106
107 for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
108 /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
109 /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */
110 /* Cr=>R value is nearest int to 1.402 * x */
111 upsample->Cr_r_tab[i] = (int) DESCALE(FIX(1.402) * x, SCALEBITS);
112 /* Cb=>B value is nearest int to 1.772 * x */
113 upsample->Cb_b_tab[i] = (int) DESCALE(FIX(1.772) * x, SCALEBITS);
114 /* Cr=>G value is scaled-up -0.714136286 * x */
115 upsample->Cr_g_tab[i] = (- FIX(0.714136286)) * x;
116 /* Cb=>G value is scaled-up -0.344136286 * x */
117 /* We also add in ONE_HALF so that need not do it in inner loop */
118 upsample->Cb_g_tab[i] = (- FIX(0.344136286)) * x + ONE_HALF;
119 }
120}
121
122
123LOCAL(void)
125/* Wide gamut case, bg-sYCC */
126{
127 my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
128 int i;
129 INT32 x;
131
132 upsample->Cr_r_tab = (int *) (*cinfo->mem->alloc_small)
133 ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(int));
134 upsample->Cb_b_tab = (int *) (*cinfo->mem->alloc_small)
135 ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(int));
136 upsample->Cr_g_tab = (INT32 *) (*cinfo->mem->alloc_small)
138 upsample->Cb_g_tab = (INT32 *) (*cinfo->mem->alloc_small)
140
141 for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
142 /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
143 /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */
144 /* Cr=>R value is nearest int to 2.804 * x */
145 upsample->Cr_r_tab[i] = (int) DESCALE(FIX(2.804) * x, SCALEBITS);
146 /* Cb=>B value is nearest int to 3.544 * x */
147 upsample->Cb_b_tab[i] = (int) DESCALE(FIX(3.544) * x, SCALEBITS);
148 /* Cr=>G value is scaled-up -1.428272572 * x */
149 upsample->Cr_g_tab[i] = (- FIX(1.428272572)) * x;
150 /* Cb=>G value is scaled-up -0.688272572 * x */
151 /* We also add in ONE_HALF so that need not do it in inner loop */
152 upsample->Cb_g_tab[i] = (- FIX(0.688272572)) * x + ONE_HALF;
153 }
154}
155
156
157/*
158 * Initialize for an upsampling pass.
159 */
160
161METHODDEF(void)
162start_pass_merged_upsample (j_decompress_ptr cinfo)
163{
164 my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
165
166 /* Mark the spare buffer empty */
167 upsample->spare_full = FALSE;
168 /* Initialize total-height counter for detecting bottom of image */
169 upsample->rows_to_go = cinfo->output_height;
170}
171
172
173/*
174 * Control routine to do upsampling (and color conversion).
175 *
176 * The control routine just handles the row buffering considerations.
177 */
178
179METHODDEF(void)
180merged_2v_upsample (j_decompress_ptr cinfo,
181 JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
182 JDIMENSION in_row_groups_avail,
183 JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
184 JDIMENSION out_rows_avail)
185/* 2:1 vertical sampling case: may need a spare row. */
186{
187 my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
188 JSAMPROW work_ptrs[2];
189 JDIMENSION num_rows; /* number of rows returned to caller */
190
191 if (upsample->spare_full) {
192 /* If we have a spare row saved from a previous cycle, just return it. */
193 jcopy_sample_rows(& upsample->spare_row, 0, output_buf + *out_row_ctr, 0,
194 1, upsample->out_row_width);
195 num_rows = 1;
196 upsample->spare_full = FALSE;
197 } else {
198 /* Figure number of rows to return to caller. */
199 num_rows = 2;
200 /* Not more than the distance to the end of the image. */
201 if (num_rows > upsample->rows_to_go)
202 num_rows = upsample->rows_to_go;
203 /* And not more than what the client can accept: */
204 out_rows_avail -= *out_row_ctr;
205 if (num_rows > out_rows_avail)
206 num_rows = out_rows_avail;
207 /* Create output pointer array for upsampler. */
208 work_ptrs[0] = output_buf[*out_row_ctr];
209 if (num_rows > 1) {
210 work_ptrs[1] = output_buf[*out_row_ctr + 1];
211 } else {
212 work_ptrs[1] = upsample->spare_row;
213 upsample->spare_full = TRUE;
214 }
215 /* Now do the upsampling. */
216 (*upsample->upmethod) (cinfo, input_buf, *in_row_group_ctr, work_ptrs);
217 }
218
219 /* Adjust counts */
220 *out_row_ctr += num_rows;
221 upsample->rows_to_go -= num_rows;
222 /* When the buffer is emptied, declare this input row group consumed */
223 if (! upsample->spare_full)
224 (*in_row_group_ctr)++;
225}
226
227
228METHODDEF(void)
229merged_1v_upsample (j_decompress_ptr cinfo,
230 JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
231 JDIMENSION in_row_groups_avail,
232 JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
233 JDIMENSION out_rows_avail)
234/* 1:1 vertical sampling case: much easier, never need a spare row. */
235{
236 my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
237
238 /* Just do the upsampling. */
239 (*upsample->upmethod) (cinfo, input_buf, *in_row_group_ctr,
240 output_buf + *out_row_ctr);
241 /* Adjust counts */
242 (*out_row_ctr)++;
243 (*in_row_group_ctr)++;
244}
245
246
247/*
248 * These are the routines invoked by the control routines to do
249 * the actual upsampling/conversion. One row group is processed per call.
250 *
251 * Note: since we may be writing directly into application-supplied buffers,
252 * we have to be honest about the output width; we can't assume the buffer
253 * has been rounded up to an even width.
254 */
255
256
257/*
258 * Upsample and color convert for the case of 2:1 horizontal and 1:1 vertical.
259 */
260
261METHODDEF(void)
262h2v1_merged_upsample (j_decompress_ptr cinfo,
263 JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
265{
266 my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
267 register int y, cred, cgreen, cblue;
268 int cb, cr;
269 register JSAMPROW outptr;
270 JSAMPROW inptr0, inptr1, inptr2;
271 JDIMENSION col;
272 /* copy these pointers into registers if possible */
273 register JSAMPLE * range_limit = cinfo->sample_range_limit;
274 int * Crrtab = upsample->Cr_r_tab;
275 int * Cbbtab = upsample->Cb_b_tab;
276 INT32 * Crgtab = upsample->Cr_g_tab;
277 INT32 * Cbgtab = upsample->Cb_g_tab;
279
280 inptr0 = input_buf[0][in_row_group_ctr];
281 inptr1 = input_buf[1][in_row_group_ctr];
282 inptr2 = input_buf[2][in_row_group_ctr];
283 outptr = output_buf[0];
284 /* Loop for each pair of output pixels */
285 for (col = cinfo->output_width >> 1; col > 0; col--) {
286 /* Do the chroma part of the calculation */
287 cb = GETJSAMPLE(*inptr1++);
288 cr = GETJSAMPLE(*inptr2++);
289 cred = Crrtab[cr];
290 cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
291 cblue = Cbbtab[cb];
292 /* Fetch 2 Y values and emit 2 pixels */
293 y = GETJSAMPLE(*inptr0++);
294 outptr[RGB_RED] = range_limit[y + cred];
295 outptr[RGB_GREEN] = range_limit[y + cgreen];
296 outptr[RGB_BLUE] = range_limit[y + cblue];
297 outptr += RGB_PIXELSIZE;
298 y = GETJSAMPLE(*inptr0++);
299 outptr[RGB_RED] = range_limit[y + cred];
300 outptr[RGB_GREEN] = range_limit[y + cgreen];
301 outptr[RGB_BLUE] = range_limit[y + cblue];
302 outptr += RGB_PIXELSIZE;
303 }
304 /* If image width is odd, do the last output column separately */
305 if (cinfo->output_width & 1) {
306 cb = GETJSAMPLE(*inptr1);
307 cr = GETJSAMPLE(*inptr2);
308 cred = Crrtab[cr];
309 cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
310 cblue = Cbbtab[cb];
311 y = GETJSAMPLE(*inptr0);
312 outptr[RGB_RED] = range_limit[y + cred];
313 outptr[RGB_GREEN] = range_limit[y + cgreen];
314 outptr[RGB_BLUE] = range_limit[y + cblue];
315 }
316}
317
318
319/*
320 * Upsample and color convert for the case of 2:1 horizontal and 2:1 vertical.
321 */
322
323METHODDEF(void)
324h2v2_merged_upsample (j_decompress_ptr cinfo,
325 JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
327{
328 my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
329 register int y, cred, cgreen, cblue;
330 int cb, cr;
331 register JSAMPROW outptr0, outptr1;
332 JSAMPROW inptr00, inptr01, inptr1, inptr2;
333 JDIMENSION col;
334 /* copy these pointers into registers if possible */
335 register JSAMPLE * range_limit = cinfo->sample_range_limit;
336 int * Crrtab = upsample->Cr_r_tab;
337 int * Cbbtab = upsample->Cb_b_tab;
338 INT32 * Crgtab = upsample->Cr_g_tab;
339 INT32 * Cbgtab = upsample->Cb_g_tab;
341
342 inptr00 = input_buf[0][in_row_group_ctr*2];
343 inptr01 = input_buf[0][in_row_group_ctr*2 + 1];
344 inptr1 = input_buf[1][in_row_group_ctr];
345 inptr2 = input_buf[2][in_row_group_ctr];
346 outptr0 = output_buf[0];
347 outptr1 = output_buf[1];
348 /* Loop for each group of output pixels */
349 for (col = cinfo->output_width >> 1; col > 0; col--) {
350 /* Do the chroma part of the calculation */
351 cb = GETJSAMPLE(*inptr1++);
352 cr = GETJSAMPLE(*inptr2++);
353 cred = Crrtab[cr];
354 cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
355 cblue = Cbbtab[cb];
356 /* Fetch 4 Y values and emit 4 pixels */
357 y = GETJSAMPLE(*inptr00++);
358 outptr0[RGB_RED] = range_limit[y + cred];
359 outptr0[RGB_GREEN] = range_limit[y + cgreen];
360 outptr0[RGB_BLUE] = range_limit[y + cblue];
361 outptr0 += RGB_PIXELSIZE;
362 y = GETJSAMPLE(*inptr00++);
363 outptr0[RGB_RED] = range_limit[y + cred];
364 outptr0[RGB_GREEN] = range_limit[y + cgreen];
365 outptr0[RGB_BLUE] = range_limit[y + cblue];
366 outptr0 += RGB_PIXELSIZE;
367 y = GETJSAMPLE(*inptr01++);
368 outptr1[RGB_RED] = range_limit[y + cred];
369 outptr1[RGB_GREEN] = range_limit[y + cgreen];
370 outptr1[RGB_BLUE] = range_limit[y + cblue];
371 outptr1 += RGB_PIXELSIZE;
372 y = GETJSAMPLE(*inptr01++);
373 outptr1[RGB_RED] = range_limit[y + cred];
374 outptr1[RGB_GREEN] = range_limit[y + cgreen];
375 outptr1[RGB_BLUE] = range_limit[y + cblue];
376 outptr1 += RGB_PIXELSIZE;
377 }
378 /* If image width is odd, do the last output column separately */
379 if (cinfo->output_width & 1) {
380 cb = GETJSAMPLE(*inptr1);
381 cr = GETJSAMPLE(*inptr2);
382 cred = Crrtab[cr];
383 cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
384 cblue = Cbbtab[cb];
385 y = GETJSAMPLE(*inptr00);
386 outptr0[RGB_RED] = range_limit[y + cred];
387 outptr0[RGB_GREEN] = range_limit[y + cgreen];
388 outptr0[RGB_BLUE] = range_limit[y + cblue];
389 y = GETJSAMPLE(*inptr01);
390 outptr1[RGB_RED] = range_limit[y + cred];
391 outptr1[RGB_GREEN] = range_limit[y + cgreen];
392 outptr1[RGB_BLUE] = range_limit[y + cblue];
393 }
394}
395
396
397/*
398 * Module initialization routine for merged upsampling/color conversion.
399 *
400 * NB: this is called under the conditions determined by use_merged_upsample()
401 * in jdmaster.c. That routine MUST correspond to the actual capabilities
402 * of this module; no safety checks are made here.
403 */
404
405GLOBAL(void)
406jinit_merged_upsampler (j_decompress_ptr cinfo)
407{
408 my_upsample_ptr upsample;
409
410 upsample = (my_upsample_ptr) (*cinfo->mem->alloc_small)
412 cinfo->upsample = &upsample->pub;
413 upsample->pub.start_pass = start_pass_merged_upsample;
414 upsample->pub.need_context_rows = FALSE;
415
416 upsample->out_row_width = cinfo->output_width * cinfo->out_color_components;
417
418 if (cinfo->max_v_samp_factor == 2) {
419 upsample->pub.upsample = merged_2v_upsample;
420 upsample->upmethod = h2v2_merged_upsample;
421 /* Allocate a spare row buffer */
422 upsample->spare_row = (JSAMPROW) (*cinfo->mem->alloc_large)
423 ((j_common_ptr) cinfo, JPOOL_IMAGE,
424 (size_t) upsample->out_row_width * SIZEOF(JSAMPLE));
425 } else {
426 upsample->pub.upsample = merged_1v_upsample;
427 upsample->upmethod = h2v1_merged_upsample;
428 /* No spare row needed */
429 upsample->spare_row = NULL;
430 }
431
432 if (cinfo->jpeg_color_space == JCS_BG_YCC)
434 else
435 build_ycc_rgb_table(cinfo);
436}
437
438#endif /* UPSAMPLE_MERGING_SUPPORTED */
signed int INT32
#define SIZEOF(_ar)
Definition: calc.h:97
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
GLenum GLint * range
Definition: glext.h:7539
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * bits
Definition: glext.h:10929
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define SCALEBITS
Definition: jccolor.c:71
#define FIX(x)
Definition: jccolor.c:74
#define ONE_HALF
Definition: jccolor.c:73
Sorry
Definition: jdcolor.c:19
build_ycc_rgb_table(j_decompress_ptr cinfo)
Definition: jdcolor.c:119
build_bg_ycc_rgb_table(j_decompress_ptr cinfo)
Definition: jdcolor.c:153
jpeg_component_info JCOEFPTR JSAMPARRAY output_buf
Definition: jdct.h:239
my_upsampler * my_upsample_ptr
Definition: jdsample.c:62
unsigned int JDIMENSION
Definition: jmorecfg.h:229
#define MAXJSAMPLE
Definition: jmorecfg.h:83
char JSAMPLE
Definition: jmorecfg.h:74
#define JMETHOD(type, methodname, arglist)
Definition: jmorecfg.h:308
#define LOCAL(type)
Definition: jmorecfg.h:289
#define METHODDEF(type)
Definition: jmorecfg.h:287
#define CENTERJSAMPLE
Definition: jmorecfg.h:84
#define GLOBAL(type)
Definition: jmorecfg.h:291
#define GETJSAMPLE(value)
Definition: jmorecfg.h:78
#define SHIFT_TEMPS
Definition: jpegint.h:301
int JSAMPARRAY int int num_rows
Definition: jpegint.h:421
#define RIGHT_SHIFT(x, shft)
Definition: jpegint.h:302
#define DESCALE(x, n)
Definition: jpegint.h:310
struct jpeg_common_struct * j_common_ptr
Definition: jpeglib.h:284
JSAMPARRAY * JSAMPIMAGE
Definition: jpeglib.h:77
@ JCS_BG_YCC
Definition: jpeglib.h:228
JSAMPROW * JSAMPARRAY
Definition: jpeglib.h:76
JSAMPLE FAR * JSAMPROW
Definition: jpeglib.h:75
#define JPOOL_IMAGE
Definition: jpeglib.h:808
jcopy_sample_rows(JSAMPARRAY input_array, int source_row, JSAMPARRAY output_array, int dest_row, int num_rows, JDIMENSION num_cols)
Definition: jutils.c:177
if(dx< 0)
Definition: linetemp.h:194
#define for
Definition: utility.h:88
static HMODULE MODULEINFO DWORD cb
Definition: module.c:33
Definition: inflate.c:139
JDIMENSION output_height
Definition: jpeglib.h:508
JSAMPLE * sample_range_limit
Definition: jpeglib.h:642
struct jpeg_upsampler * upsample
Definition: jpeglib.h:686
J_COLOR_SPACE jpeg_color_space
Definition: jpeglib.h:471
JDIMENSION output_width
Definition: jpeglib.h:507
JDIMENSION rows_to_go
Definition: jdsample.c:50
struct jpeg_upsampler pub
Definition: jdsample.c:35