ReactOS  0.4.15-dev-976-g0f66c66
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 
51 typedef 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 */
75 } my_upsampler;
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 
89 LOCAL(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)
103  ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(INT32));
104  upsample->Cb_g_tab = (INT32 *) (*cinfo->mem->alloc_small)
105  ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(INT32));
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 
123 LOCAL(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)
137  ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(INT32));
138  upsample->Cb_g_tab = (INT32 *) (*cinfo->mem->alloc_small)
139  ((j_common_ptr) cinfo, JPOOL_IMAGE, (MAXJSAMPLE+1) * SIZEOF(INT32));
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 
161 METHODDEF(void)
162 start_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 
179 METHODDEF(void)
180 merged_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 
228 METHODDEF(void)
229 merged_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 
261 METHODDEF(void)
262 h2v1_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 
323 METHODDEF(void)
324 h2v2_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 
405 GLOBAL(void)
406 jinit_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)
433  build_bg_ycc_rgb_table(cinfo);
434  else
435  build_ycc_rgb_table(cinfo);
436 }
437 
438 #endif /* UPSAMPLE_MERGING_SUPPORTED */
#define CENTERJSAMPLE
Definition: jmorecfg.h:84
char JSAMPLE
Definition: jmorecfg.h:74
JDIMENSION output_height
Definition: jpeglib.h:508
JSAMPLE FAR * JSAMPROW
Definition: jpeglib.h:75
#define TRUE
Definition: types.h:120
#define SCALEBITS
Definition: jccolor.c:71
struct jpeg_common_struct * j_common_ptr
Definition: jpeglib.h:284
#define GETJSAMPLE(value)
Definition: jmorecfg.h:78
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
JDIMENSION output_width
Definition: jpeglib.h:507
#define MAXJSAMPLE
Definition: jmorecfg.h:83
struct jpeg_upsampler pub
Definition: jdsample.c:35
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * bits
Definition: glext.h:10929
#define SHIFT_TEMPS
Definition: jpegint.h:301
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 SIZEOF(_ar)
Definition: calc.h:97
#define JPOOL_IMAGE
Definition: jpeglib.h:808
#define FALSE
Definition: types.h:117
JDIMENSION rows_to_go
Definition: jdsample.c:50
smooth NULL
Definition: ftsmooth.c:416
#define ONE_HALF
Definition: jccolor.c:73
#define LOCAL(type)
Definition: jmorecfg.h:289
JSAMPLE * sample_range_limit
Definition: jpeglib.h:642
if(!(yy_init))
Definition: macro.lex.yy.c:714
int JSAMPARRAY int int num_rows
Definition: jpegint.h:419
#define for
Definition: utility.h:88
JMETHOD(void, start_pass,(j_decompress_ptr cinfo, boolean is_pre_scan))
JSAMPARRAY * JSAMPIMAGE
Definition: jpeglib.h:77
Definition: inflate.c:139
JSAMPROW * JSAMPARRAY
Definition: jpeglib.h:76
GLenum GLint * range
Definition: glext.h:7539
my_upsampler * my_upsample_ptr
Definition: jdsample.c:62
#define GLOBAL(type)
Definition: jmorecfg.h:291
build_bg_ycc_rgb_table(j_decompress_ptr cinfo)
Definition: jdcolor.c:153
#define METHODDEF(type)
Definition: jmorecfg.h:287
#define FIX(x)
Definition: jccolor.c:74
struct jpeg_upsampler * upsample
Definition: jpeglib.h:686
#define RIGHT_SHIFT(x, shft)
Definition: jpegint.h:302
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
static HMODULE MODULEINFO DWORD cb
Definition: module.c:32
build_ycc_rgb_table(j_decompress_ptr cinfo)
Definition: jdcolor.c:119
jpeg_component_info JCOEFPTR JSAMPARRAY output_buf
Definition: jdct.h:238
unsigned int JDIMENSION
Definition: jmorecfg.h:229
signed int INT32
#define DESCALE(x, n)
Definition: jpegint.h:310
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
Sorry
Definition: jdcolor.c:19
J_COLOR_SPACE jpeg_color_space
Definition: jpeglib.h:471
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31