Line data Source code
1 : /*
2 : * jdmerge.c
3 : *
4 : * This file was part of the Independent JPEG Group's software:
5 : * Copyright (C) 1994-1996, Thomas G. Lane.
6 : * libjpeg-turbo Modifications:
7 : * Copyright 2009 Pierre Ossman <ossman@cendio.se> for Cendio AB
8 : * Copyright (C) 2009, 2011, 2014-2015, D. R. Commander.
9 : * Copyright (C) 2013, Linaro Limited.
10 : * For conditions of distribution and use, see the accompanying README.ijg
11 : * file.
12 : *
13 : * This file contains code for merged upsampling/color conversion.
14 : *
15 : * This file combines functions from jdsample.c and jdcolor.c;
16 : * read those files first to understand what's going on.
17 : *
18 : * When the chroma components are to be upsampled by simple replication
19 : * (ie, box filtering), we can save some work in color conversion by
20 : * calculating all the output pixels corresponding to a pair of chroma
21 : * samples at one time. In the conversion equations
22 : * R = Y + K1 * Cr
23 : * G = Y + K2 * Cb + K3 * Cr
24 : * B = Y + K4 * Cb
25 : * only the Y term varies among the group of pixels corresponding to a pair
26 : * of chroma samples, so the rest of the terms can be calculated just once.
27 : * At typical sampling ratios, this eliminates half or three-quarters of the
28 : * multiplications needed for color conversion.
29 : *
30 : * This file currently provides implementations for the following cases:
31 : * YCbCr => RGB color conversion only.
32 : * Sampling ratios of 2h1v or 2h2v.
33 : * No scaling needed at upsample time.
34 : * Corner-aligned (non-CCIR601) sampling alignment.
35 : * Other special cases could be added, but in most applications these are
36 : * the only common cases. (For uncommon cases we fall back on the more
37 : * general code in jdsample.c and jdcolor.c.)
38 : */
39 :
40 : #define JPEG_INTERNALS
41 : #include "jinclude.h"
42 : #include "jpeglib.h"
43 : #include "jsimd.h"
44 : #include "jconfigint.h"
45 :
46 : #ifdef UPSAMPLE_MERGING_SUPPORTED
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 : void (*upmethod) (j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
56 : JDIMENSION in_row_group_ctr, JSAMPARRAY output_buf);
57 :
58 : /* Private state for YCC->RGB conversion */
59 : int *Cr_r_tab; /* => table for Cr to R conversion */
60 : int *Cb_b_tab; /* => table for Cb to B conversion */
61 : JLONG *Cr_g_tab; /* => table for Cr to G conversion */
62 : JLONG *Cb_g_tab; /* => table for Cb to G conversion */
63 :
64 : /* For 2:1 vertical sampling, we produce two output rows at a time.
65 : * We need a "spare" row buffer to hold the second output row if the
66 : * application provides just a one-row buffer; we also use the spare
67 : * to discard the dummy last row if the image height is odd.
68 : */
69 : JSAMPROW spare_row;
70 : boolean spare_full; /* T if spare buffer is occupied */
71 :
72 : JDIMENSION out_row_width; /* samples per output row */
73 : JDIMENSION rows_to_go; /* counts rows remaining in image */
74 : } my_upsampler;
75 :
76 : typedef my_upsampler *my_upsample_ptr;
77 :
78 : #define SCALEBITS 16 /* speediest right-shift on some machines */
79 : #define ONE_HALF ((JLONG) 1 << (SCALEBITS-1))
80 : #define FIX(x) ((JLONG) ((x) * (1L<<SCALEBITS) + 0.5))
81 :
82 :
83 : /* Include inline routines for colorspace extensions */
84 :
85 : #include "jdmrgext.c"
86 : #undef RGB_RED
87 : #undef RGB_GREEN
88 : #undef RGB_BLUE
89 : #undef RGB_PIXELSIZE
90 :
91 : #define RGB_RED EXT_RGB_RED
92 : #define RGB_GREEN EXT_RGB_GREEN
93 : #define RGB_BLUE EXT_RGB_BLUE
94 : #define RGB_PIXELSIZE EXT_RGB_PIXELSIZE
95 : #define h2v1_merged_upsample_internal extrgb_h2v1_merged_upsample_internal
96 : #define h2v2_merged_upsample_internal extrgb_h2v2_merged_upsample_internal
97 : #include "jdmrgext.c"
98 : #undef RGB_RED
99 : #undef RGB_GREEN
100 : #undef RGB_BLUE
101 : #undef RGB_PIXELSIZE
102 : #undef h2v1_merged_upsample_internal
103 : #undef h2v2_merged_upsample_internal
104 :
105 : #define RGB_RED EXT_RGBX_RED
106 : #define RGB_GREEN EXT_RGBX_GREEN
107 : #define RGB_BLUE EXT_RGBX_BLUE
108 : #define RGB_ALPHA 3
109 : #define RGB_PIXELSIZE EXT_RGBX_PIXELSIZE
110 : #define h2v1_merged_upsample_internal extrgbx_h2v1_merged_upsample_internal
111 : #define h2v2_merged_upsample_internal extrgbx_h2v2_merged_upsample_internal
112 : #include "jdmrgext.c"
113 : #undef RGB_RED
114 : #undef RGB_GREEN
115 : #undef RGB_BLUE
116 : #undef RGB_ALPHA
117 : #undef RGB_PIXELSIZE
118 : #undef h2v1_merged_upsample_internal
119 : #undef h2v2_merged_upsample_internal
120 :
121 : #define RGB_RED EXT_BGR_RED
122 : #define RGB_GREEN EXT_BGR_GREEN
123 : #define RGB_BLUE EXT_BGR_BLUE
124 : #define RGB_PIXELSIZE EXT_BGR_PIXELSIZE
125 : #define h2v1_merged_upsample_internal extbgr_h2v1_merged_upsample_internal
126 : #define h2v2_merged_upsample_internal extbgr_h2v2_merged_upsample_internal
127 : #include "jdmrgext.c"
128 : #undef RGB_RED
129 : #undef RGB_GREEN
130 : #undef RGB_BLUE
131 : #undef RGB_PIXELSIZE
132 : #undef h2v1_merged_upsample_internal
133 : #undef h2v2_merged_upsample_internal
134 :
135 : #define RGB_RED EXT_BGRX_RED
136 : #define RGB_GREEN EXT_BGRX_GREEN
137 : #define RGB_BLUE EXT_BGRX_BLUE
138 : #define RGB_ALPHA 3
139 : #define RGB_PIXELSIZE EXT_BGRX_PIXELSIZE
140 : #define h2v1_merged_upsample_internal extbgrx_h2v1_merged_upsample_internal
141 : #define h2v2_merged_upsample_internal extbgrx_h2v2_merged_upsample_internal
142 : #include "jdmrgext.c"
143 : #undef RGB_RED
144 : #undef RGB_GREEN
145 : #undef RGB_BLUE
146 : #undef RGB_ALPHA
147 : #undef RGB_PIXELSIZE
148 : #undef h2v1_merged_upsample_internal
149 : #undef h2v2_merged_upsample_internal
150 :
151 : #define RGB_RED EXT_XBGR_RED
152 : #define RGB_GREEN EXT_XBGR_GREEN
153 : #define RGB_BLUE EXT_XBGR_BLUE
154 : #define RGB_ALPHA 0
155 : #define RGB_PIXELSIZE EXT_XBGR_PIXELSIZE
156 : #define h2v1_merged_upsample_internal extxbgr_h2v1_merged_upsample_internal
157 : #define h2v2_merged_upsample_internal extxbgr_h2v2_merged_upsample_internal
158 : #include "jdmrgext.c"
159 : #undef RGB_RED
160 : #undef RGB_GREEN
161 : #undef RGB_BLUE
162 : #undef RGB_ALPHA
163 : #undef RGB_PIXELSIZE
164 : #undef h2v1_merged_upsample_internal
165 : #undef h2v2_merged_upsample_internal
166 :
167 : #define RGB_RED EXT_XRGB_RED
168 : #define RGB_GREEN EXT_XRGB_GREEN
169 : #define RGB_BLUE EXT_XRGB_BLUE
170 : #define RGB_ALPHA 0
171 : #define RGB_PIXELSIZE EXT_XRGB_PIXELSIZE
172 : #define h2v1_merged_upsample_internal extxrgb_h2v1_merged_upsample_internal
173 : #define h2v2_merged_upsample_internal extxrgb_h2v2_merged_upsample_internal
174 : #include "jdmrgext.c"
175 : #undef RGB_RED
176 : #undef RGB_GREEN
177 : #undef RGB_BLUE
178 : #undef RGB_ALPHA
179 : #undef RGB_PIXELSIZE
180 : #undef h2v1_merged_upsample_internal
181 : #undef h2v2_merged_upsample_internal
182 :
183 :
184 : /*
185 : * Initialize tables for YCC->RGB colorspace conversion.
186 : * This is taken directly from jdcolor.c; see that file for more info.
187 : */
188 :
189 : LOCAL(void)
190 0 : build_ycc_rgb_table (j_decompress_ptr cinfo)
191 : {
192 0 : my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
193 : int i;
194 : JLONG x;
195 : SHIFT_TEMPS
196 :
197 0 : upsample->Cr_r_tab = (int *)
198 0 : (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
199 : (MAXJSAMPLE+1) * sizeof(int));
200 0 : upsample->Cb_b_tab = (int *)
201 0 : (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
202 : (MAXJSAMPLE+1) * sizeof(int));
203 0 : upsample->Cr_g_tab = (JLONG *)
204 0 : (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
205 : (MAXJSAMPLE+1) * sizeof(JLONG));
206 0 : upsample->Cb_g_tab = (JLONG *)
207 0 : (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
208 : (MAXJSAMPLE+1) * sizeof(JLONG));
209 :
210 0 : for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
211 : /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
212 : /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */
213 : /* Cr=>R value is nearest int to 1.40200 * x */
214 0 : upsample->Cr_r_tab[i] = (int)
215 0 : RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS);
216 : /* Cb=>B value is nearest int to 1.77200 * x */
217 0 : upsample->Cb_b_tab[i] = (int)
218 0 : RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS);
219 : /* Cr=>G value is scaled-up -0.71414 * x */
220 0 : upsample->Cr_g_tab[i] = (- FIX(0.71414)) * x;
221 : /* Cb=>G value is scaled-up -0.34414 * x */
222 : /* We also add in ONE_HALF so that need not do it in inner loop */
223 0 : upsample->Cb_g_tab[i] = (- FIX(0.34414)) * x + ONE_HALF;
224 : }
225 0 : }
226 :
227 :
228 : /*
229 : * Initialize for an upsampling pass.
230 : */
231 :
232 : METHODDEF(void)
233 0 : start_pass_merged_upsample (j_decompress_ptr cinfo)
234 : {
235 0 : my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
236 :
237 : /* Mark the spare buffer empty */
238 0 : upsample->spare_full = FALSE;
239 : /* Initialize total-height counter for detecting bottom of image */
240 0 : upsample->rows_to_go = cinfo->output_height;
241 0 : }
242 :
243 :
244 : /*
245 : * Control routine to do upsampling (and color conversion).
246 : *
247 : * The control routine just handles the row buffering considerations.
248 : */
249 :
250 : METHODDEF(void)
251 0 : merged_2v_upsample (j_decompress_ptr cinfo,
252 : JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
253 : JDIMENSION in_row_groups_avail,
254 : JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
255 : JDIMENSION out_rows_avail)
256 : /* 2:1 vertical sampling case: may need a spare row. */
257 : {
258 0 : my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
259 : JSAMPROW work_ptrs[2];
260 : JDIMENSION num_rows; /* number of rows returned to caller */
261 :
262 0 : if (upsample->spare_full) {
263 : /* If we have a spare row saved from a previous cycle, just return it. */
264 0 : JDIMENSION size = upsample->out_row_width;
265 0 : if (cinfo->out_color_space == JCS_RGB565)
266 0 : size = cinfo->output_width * 2;
267 0 : jcopy_sample_rows(& upsample->spare_row, 0, output_buf + *out_row_ctr, 0,
268 : 1, size);
269 0 : num_rows = 1;
270 0 : upsample->spare_full = FALSE;
271 : } else {
272 : /* Figure number of rows to return to caller. */
273 0 : num_rows = 2;
274 : /* Not more than the distance to the end of the image. */
275 0 : if (num_rows > upsample->rows_to_go)
276 0 : num_rows = upsample->rows_to_go;
277 : /* And not more than what the client can accept: */
278 0 : out_rows_avail -= *out_row_ctr;
279 0 : if (num_rows > out_rows_avail)
280 0 : num_rows = out_rows_avail;
281 : /* Create output pointer array for upsampler. */
282 0 : work_ptrs[0] = output_buf[*out_row_ctr];
283 0 : if (num_rows > 1) {
284 0 : work_ptrs[1] = output_buf[*out_row_ctr + 1];
285 : } else {
286 0 : work_ptrs[1] = upsample->spare_row;
287 0 : upsample->spare_full = TRUE;
288 : }
289 : /* Now do the upsampling. */
290 0 : (*upsample->upmethod) (cinfo, input_buf, *in_row_group_ctr, work_ptrs);
291 : }
292 :
293 : /* Adjust counts */
294 0 : *out_row_ctr += num_rows;
295 0 : upsample->rows_to_go -= num_rows;
296 : /* When the buffer is emptied, declare this input row group consumed */
297 0 : if (! upsample->spare_full)
298 0 : (*in_row_group_ctr)++;
299 0 : }
300 :
301 :
302 : METHODDEF(void)
303 0 : merged_1v_upsample (j_decompress_ptr cinfo,
304 : JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
305 : JDIMENSION in_row_groups_avail,
306 : JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
307 : JDIMENSION out_rows_avail)
308 : /* 1:1 vertical sampling case: much easier, never need a spare row. */
309 : {
310 0 : my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
311 :
312 : /* Just do the upsampling. */
313 0 : (*upsample->upmethod) (cinfo, input_buf, *in_row_group_ctr,
314 0 : output_buf + *out_row_ctr);
315 : /* Adjust counts */
316 0 : (*out_row_ctr)++;
317 0 : (*in_row_group_ctr)++;
318 0 : }
319 :
320 :
321 : /*
322 : * These are the routines invoked by the control routines to do
323 : * the actual upsampling/conversion. One row group is processed per call.
324 : *
325 : * Note: since we may be writing directly into application-supplied buffers,
326 : * we have to be honest about the output width; we can't assume the buffer
327 : * has been rounded up to an even width.
328 : */
329 :
330 :
331 : /*
332 : * Upsample and color convert for the case of 2:1 horizontal and 1:1 vertical.
333 : */
334 :
335 : METHODDEF(void)
336 0 : h2v1_merged_upsample (j_decompress_ptr cinfo,
337 : JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
338 : JSAMPARRAY output_buf)
339 : {
340 0 : switch (cinfo->out_color_space) {
341 : case JCS_EXT_RGB:
342 0 : extrgb_h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
343 : output_buf);
344 0 : break;
345 : case JCS_EXT_RGBX:
346 : case JCS_EXT_RGBA:
347 0 : extrgbx_h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
348 : output_buf);
349 0 : break;
350 : case JCS_EXT_BGR:
351 0 : extbgr_h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
352 : output_buf);
353 0 : break;
354 : case JCS_EXT_BGRX:
355 : case JCS_EXT_BGRA:
356 0 : extbgrx_h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
357 : output_buf);
358 0 : break;
359 : case JCS_EXT_XBGR:
360 : case JCS_EXT_ABGR:
361 0 : extxbgr_h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
362 : output_buf);
363 0 : break;
364 : case JCS_EXT_XRGB:
365 : case JCS_EXT_ARGB:
366 0 : extxrgb_h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
367 : output_buf);
368 0 : break;
369 : default:
370 0 : h2v1_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
371 : output_buf);
372 0 : break;
373 : }
374 0 : }
375 :
376 :
377 : /*
378 : * Upsample and color convert for the case of 2:1 horizontal and 2:1 vertical.
379 : */
380 :
381 : METHODDEF(void)
382 0 : h2v2_merged_upsample (j_decompress_ptr cinfo,
383 : JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
384 : JSAMPARRAY output_buf)
385 : {
386 0 : switch (cinfo->out_color_space) {
387 : case JCS_EXT_RGB:
388 0 : extrgb_h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
389 : output_buf);
390 0 : break;
391 : case JCS_EXT_RGBX:
392 : case JCS_EXT_RGBA:
393 0 : extrgbx_h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
394 : output_buf);
395 0 : break;
396 : case JCS_EXT_BGR:
397 0 : extbgr_h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
398 : output_buf);
399 0 : break;
400 : case JCS_EXT_BGRX:
401 : case JCS_EXT_BGRA:
402 0 : extbgrx_h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
403 : output_buf);
404 0 : break;
405 : case JCS_EXT_XBGR:
406 : case JCS_EXT_ABGR:
407 0 : extxbgr_h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
408 : output_buf);
409 0 : break;
410 : case JCS_EXT_XRGB:
411 : case JCS_EXT_ARGB:
412 0 : extxrgb_h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
413 : output_buf);
414 0 : break;
415 : default:
416 0 : h2v2_merged_upsample_internal(cinfo, input_buf, in_row_group_ctr,
417 : output_buf);
418 0 : break;
419 : }
420 0 : }
421 :
422 :
423 : /*
424 : * RGB565 conversion
425 : */
426 :
427 : #define PACK_SHORT_565_LE(r, g, b) ((((r) << 8) & 0xF800) | \
428 : (((g) << 3) & 0x7E0) | ((b) >> 3))
429 : #define PACK_SHORT_565_BE(r, g, b) (((r) & 0xF8) | ((g) >> 5) | \
430 : (((g) << 11) & 0xE000) | \
431 : (((b) << 5) & 0x1F00))
432 :
433 : #define PACK_TWO_PIXELS_LE(l, r) ((r << 16) | l)
434 : #define PACK_TWO_PIXELS_BE(l, r) ((l << 16) | r)
435 :
436 : #define PACK_NEED_ALIGNMENT(ptr) (((size_t)(ptr)) & 3)
437 :
438 : #define WRITE_TWO_PIXELS_LE(addr, pixels) { \
439 : ((INT16*)(addr))[0] = (INT16)(pixels); \
440 : ((INT16*)(addr))[1] = (INT16)((pixels) >> 16); \
441 : }
442 : #define WRITE_TWO_PIXELS_BE(addr, pixels) { \
443 : ((INT16*)(addr))[1] = (INT16)(pixels); \
444 : ((INT16*)(addr))[0] = (INT16)((pixels) >> 16); \
445 : }
446 :
447 : #define DITHER_565_R(r, dither) ((r) + ((dither) & 0xFF))
448 : #define DITHER_565_G(g, dither) ((g) + (((dither) & 0xFF) >> 1))
449 : #define DITHER_565_B(b, dither) ((b) + ((dither) & 0xFF))
450 :
451 :
452 : /* Declarations for ordered dithering
453 : *
454 : * We use a 4x4 ordered dither array packed into 32 bits. This array is
455 : * sufficent for dithering RGB888 to RGB565.
456 : */
457 :
458 : #define DITHER_MASK 0x3
459 : #define DITHER_ROTATE(x) ((((x) & 0xFF) << 24) | (((x) >> 8) & 0x00FFFFFF))
460 : static const JLONG dither_matrix[4] = {
461 : 0x0008020A,
462 : 0x0C040E06,
463 : 0x030B0109,
464 : 0x0F070D05
465 : };
466 :
467 :
468 : /* Include inline routines for RGB565 conversion */
469 :
470 : #define PACK_SHORT_565 PACK_SHORT_565_LE
471 : #define PACK_TWO_PIXELS PACK_TWO_PIXELS_LE
472 : #define WRITE_TWO_PIXELS WRITE_TWO_PIXELS_LE
473 : #define h2v1_merged_upsample_565_internal h2v1_merged_upsample_565_le
474 : #define h2v1_merged_upsample_565D_internal h2v1_merged_upsample_565D_le
475 : #define h2v2_merged_upsample_565_internal h2v2_merged_upsample_565_le
476 : #define h2v2_merged_upsample_565D_internal h2v2_merged_upsample_565D_le
477 : #include "jdmrg565.c"
478 : #undef PACK_SHORT_565
479 : #undef PACK_TWO_PIXELS
480 : #undef WRITE_TWO_PIXELS
481 : #undef h2v1_merged_upsample_565_internal
482 : #undef h2v1_merged_upsample_565D_internal
483 : #undef h2v2_merged_upsample_565_internal
484 : #undef h2v2_merged_upsample_565D_internal
485 :
486 : #define PACK_SHORT_565 PACK_SHORT_565_BE
487 : #define PACK_TWO_PIXELS PACK_TWO_PIXELS_BE
488 : #define WRITE_TWO_PIXELS WRITE_TWO_PIXELS_BE
489 : #define h2v1_merged_upsample_565_internal h2v1_merged_upsample_565_be
490 : #define h2v1_merged_upsample_565D_internal h2v1_merged_upsample_565D_be
491 : #define h2v2_merged_upsample_565_internal h2v2_merged_upsample_565_be
492 : #define h2v2_merged_upsample_565D_internal h2v2_merged_upsample_565D_be
493 : #include "jdmrg565.c"
494 : #undef PACK_SHORT_565
495 : #undef PACK_TWO_PIXELS
496 : #undef WRITE_TWO_PIXELS
497 : #undef h2v1_merged_upsample_565_internal
498 : #undef h2v1_merged_upsample_565D_internal
499 : #undef h2v2_merged_upsample_565_internal
500 : #undef h2v2_merged_upsample_565D_internal
501 :
502 :
503 0 : static INLINE boolean is_big_endian(void)
504 : {
505 0 : int test_value = 1;
506 0 : if(*(char *)&test_value != 1)
507 0 : return TRUE;
508 0 : return FALSE;
509 : }
510 :
511 :
512 : METHODDEF(void)
513 0 : h2v1_merged_upsample_565 (j_decompress_ptr cinfo,
514 : JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
515 : JSAMPARRAY output_buf)
516 : {
517 0 : if (is_big_endian())
518 0 : h2v1_merged_upsample_565_be(cinfo, input_buf, in_row_group_ctr,
519 : output_buf);
520 : else
521 0 : h2v1_merged_upsample_565_le(cinfo, input_buf, in_row_group_ctr,
522 : output_buf);
523 0 : }
524 :
525 :
526 : METHODDEF(void)
527 0 : h2v1_merged_upsample_565D (j_decompress_ptr cinfo,
528 : JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
529 : JSAMPARRAY output_buf)
530 : {
531 0 : if (is_big_endian())
532 0 : h2v1_merged_upsample_565D_be(cinfo, input_buf, in_row_group_ctr,
533 : output_buf);
534 : else
535 0 : h2v1_merged_upsample_565D_le(cinfo, input_buf, in_row_group_ctr,
536 : output_buf);
537 0 : }
538 :
539 :
540 : METHODDEF(void)
541 0 : h2v2_merged_upsample_565 (j_decompress_ptr cinfo,
542 : JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
543 : JSAMPARRAY output_buf)
544 : {
545 0 : if (is_big_endian())
546 0 : h2v2_merged_upsample_565_be(cinfo, input_buf, in_row_group_ctr,
547 : output_buf);
548 : else
549 0 : h2v2_merged_upsample_565_le(cinfo, input_buf, in_row_group_ctr,
550 : output_buf);
551 0 : }
552 :
553 :
554 : METHODDEF(void)
555 0 : h2v2_merged_upsample_565D (j_decompress_ptr cinfo,
556 : JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
557 : JSAMPARRAY output_buf)
558 : {
559 0 : if (is_big_endian())
560 0 : h2v2_merged_upsample_565D_be(cinfo, input_buf, in_row_group_ctr,
561 : output_buf);
562 : else
563 0 : h2v2_merged_upsample_565D_le(cinfo, input_buf, in_row_group_ctr,
564 : output_buf);
565 0 : }
566 :
567 :
568 : /*
569 : * Module initialization routine for merged upsampling/color conversion.
570 : *
571 : * NB: this is called under the conditions determined by use_merged_upsample()
572 : * in jdmaster.c. That routine MUST correspond to the actual capabilities
573 : * of this module; no safety checks are made here.
574 : */
575 :
576 : GLOBAL(void)
577 0 : jinit_merged_upsampler (j_decompress_ptr cinfo)
578 : {
579 : my_upsample_ptr upsample;
580 :
581 0 : upsample = (my_upsample_ptr)
582 0 : (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
583 : sizeof(my_upsampler));
584 0 : cinfo->upsample = (struct jpeg_upsampler *) upsample;
585 0 : upsample->pub.start_pass = start_pass_merged_upsample;
586 0 : upsample->pub.need_context_rows = FALSE;
587 :
588 0 : upsample->out_row_width = cinfo->output_width * cinfo->out_color_components;
589 :
590 0 : if (cinfo->max_v_samp_factor == 2) {
591 0 : upsample->pub.upsample = merged_2v_upsample;
592 0 : if (jsimd_can_h2v2_merged_upsample())
593 0 : upsample->upmethod = jsimd_h2v2_merged_upsample;
594 : else
595 0 : upsample->upmethod = h2v2_merged_upsample;
596 0 : if (cinfo->out_color_space == JCS_RGB565) {
597 0 : if (cinfo->dither_mode != JDITHER_NONE) {
598 0 : upsample->upmethod = h2v2_merged_upsample_565D;
599 : } else {
600 0 : upsample->upmethod = h2v2_merged_upsample_565;
601 : }
602 : }
603 : /* Allocate a spare row buffer */
604 0 : upsample->spare_row = (JSAMPROW)
605 0 : (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
606 0 : (size_t) (upsample->out_row_width * sizeof(JSAMPLE)));
607 : } else {
608 0 : upsample->pub.upsample = merged_1v_upsample;
609 0 : if (jsimd_can_h2v1_merged_upsample())
610 0 : upsample->upmethod = jsimd_h2v1_merged_upsample;
611 : else
612 0 : upsample->upmethod = h2v1_merged_upsample;
613 0 : if (cinfo->out_color_space == JCS_RGB565) {
614 0 : if (cinfo->dither_mode != JDITHER_NONE) {
615 0 : upsample->upmethod = h2v1_merged_upsample_565D;
616 : } else {
617 0 : upsample->upmethod = h2v1_merged_upsample_565;
618 : }
619 : }
620 : /* No spare row needed */
621 0 : upsample->spare_row = NULL;
622 : }
623 :
624 0 : build_ycc_rgb_table(cinfo);
625 0 : }
626 :
627 : #endif /* UPSAMPLE_MERGING_SUPPORTED */
|
