?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixing comments to match reality. No bug.
[mozilla-central.git] / jpeg / jdmerge.c
blob3239ddbde82ddbd89bec4268eeeb6572c8e44e1a
1 /*
2 * jdmerge.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 code for merged upsampling/color conversion.
9 *
10 * This file combines functions from jdsample.c and jdcolor.c;
11 * read those files first to understand what's going on.
12 *
13 * When the chroma components are to be upsampled by simple replication
14 * (ie, box filtering), we can save some work in color conversion by
15 * calculating all the output pixels corresponding to a pair of chroma
16 * samples at one time. In the conversion equations
17 * R = Y + K1 * Cr
18 * G = Y + K2 * Cb + K3 * Cr
19 * B = Y + K4 * Cb
20 * only the Y term varies among the group of pixels corresponding to a pair
21 * of chroma samples, so the rest of the terms can be calculated just once.
22 * At typical sampling ratios, this eliminates half or three-quarters of the
23 * multiplications needed for color conversion.
24 *
25 * This file currently provides implementations for the following cases:
26 * YCbCr => RGB color conversion only.
27 * Sampling ratios of 2h1v or 2h2v.
28 * No scaling needed at upsample time.
29 * Corner-aligned (non-CCIR601) sampling alignment.
30 * Other special cases could be added, but in most applications these are
31 * the only common cases. (For uncommon cases we fall back on the more
32 * general code in jdsample.c and jdcolor.c.)
33 */
34
35 #define JPEG_INTERNALS
36 #include "jinclude.h"
37 #include "jpeglib.h"
38
39 #ifdef UPSAMPLE_MERGING_SUPPORTED
40
41 #ifdef HAVE_MMX_INTEL_MNEMONICS
42 __int64 const1 = 0x59BA0000D24B59BA; // Cr_r Cr_b Cr_g Cr_r
43 __int64 const2 = 0x00007168E9FA0000; // Cb-r Cb_b Cb_g Cb_r
44 __int64 const5 = 0x0000D24B59BA0000; // Cr_b Cr_g Cr_r Cr_b
45 __int64 const6 = 0x7168E9FA00007168; // Cb_b Cb_g Cb_r Cb_b
46
47 // constants for factors (One_Half/fix(x)) << 2
48
49 __int64 const05 = 0x0001000000000001; // Cr_r Cr_b Cr_g Cr_r
50 __int64 const15 = 0x00000001FFFA0000; // Cb-r Cb_b Cb_g Cb_r
51 __int64 const45 = 0x0000000000010000; // Cr_b Cr_g Cr_r Cr_b
52 __int64 const55 = 0x0001FFFA00000001; // Cb_b Cb_g Cb_r Cb_b
53 #endif
54
55 /* Private subobject */
56
57 typedef struct {
58 struct jpeg_upsampler pub; /* public fields */
59
60 /* Pointer to routine to do actual upsampling/conversion of one row group */
61 JMETHOD(void, upmethod, (j_decompress_ptr cinfo,
62 JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
63 JSAMPARRAY output_buf));
64
65 /* Private state for YCC->RGB conversion */
66 int * Cr_r_tab; /* => table for Cr to R conversion */
67 int * Cb_b_tab; /* => table for Cb to B conversion */
68 INT32 * Cr_g_tab; /* => table for Cr to G conversion */
69 INT32 * Cb_g_tab; /* => table for Cb to G conversion */
70
71 /* For 2:1 vertical sampling, we produce two output rows at a time.
72 * We need a "spare" row buffer to hold the second output row if the
73 * application provides just a one-row buffer; we also use the spare
74 * to discard the dummy last row if the image height is odd.
75 */
76 JSAMPROW spare_row;
77 boolean spare_full; /* T if spare buffer is occupied */
78
79 JDIMENSION out_row_width; /* samples per output row */
80 JDIMENSION rows_to_go; /* counts rows remaining in image */
81 } my_upsampler;
82
83 typedef my_upsampler * my_upsample_ptr;
84
85 #define SCALEBITS 16 /* speediest right-shift on some machines */
86 #define ONE_HALF ((INT32) 1 << (SCALEBITS-1))
87 #define FIX(x) ((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
88
89
90 /*
91 * Initialize tables for YCC->RGB colorspace conversion.
92 * This is taken directly from jdcolor.c; see that file for more info.
93 */
94
95 LOCAL(void)
96 build_ycc_rgb_table (j_decompress_ptr cinfo)
97 {
98 my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
99 int i;
100 INT32 x;
101 SHIFT_TEMPS
102
103 upsample->Cr_r_tab = (int *)
104 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
105 (MAXJSAMPLE+1) * SIZEOF(int));
106 upsample->Cb_b_tab = (int *)
107 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
108 (MAXJSAMPLE+1) * SIZEOF(int));
109 upsample->Cr_g_tab = (INT32 *)
110 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
111 (MAXJSAMPLE+1) * SIZEOF(INT32));
112 upsample->Cb_g_tab = (INT32 *)
113 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
114 (MAXJSAMPLE+1) * SIZEOF(INT32));
115
116 for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
117 /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
118 /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */
119 /* Cr=>R value is nearest int to 1.40200 * x */
120 upsample->Cr_r_tab[i] = (int)
121 RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS);
122 /* Cb=>B value is nearest int to 1.77200 * x */
123 upsample->Cb_b_tab[i] = (int)
124 RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS);
125 /* Cr=>G value is scaled-up -0.71414 * x */
126 upsample->Cr_g_tab[i] = (- FIX(0.71414)) * x;
127 /* Cb=>G value is scaled-up -0.34414 * x */
128 /* We also add in ONE_HALF so that need not do it in inner loop */
129 upsample->Cb_g_tab[i] = (- FIX(0.34414)) * x + ONE_HALF;
130 }
131 }
132
133
134 /*
135 * Initialize for an upsampling pass.
136 */
137
138 METHODDEF(void)
139 start_pass_merged_upsample (j_decompress_ptr cinfo)
140 {
141 my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
142
143 /* Mark the spare buffer empty */
144 upsample->spare_full = FALSE;
145 /* Initialize total-height counter for detecting bottom of image */
146 upsample->rows_to_go = cinfo->output_height;
147 }
148
149
150 /*
151 * Control routine to do upsampling (and color conversion).
152 *
153 * The control routine just handles the row buffering considerations.
154 */
155
156 METHODDEF(void)
157 merged_2v_upsample (j_decompress_ptr cinfo,
158 JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
159 JDIMENSION in_row_groups_avail,
160 JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
161 JDIMENSION out_rows_avail)
162 /* 2:1 vertical sampling case: may need a spare row. */
163 {
164 my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
165 JSAMPROW work_ptrs[2];
166 JDIMENSION num_rows; /* number of rows returned to caller */
167
168 if (upsample->spare_full) {
169 /* If we have a spare row saved from a previous cycle, just return it. */
170 jcopy_sample_rows(& upsample->spare_row, 0, output_buf + *out_row_ctr, 0,
171 1, upsample->out_row_width);
172 num_rows = 1;
173 upsample->spare_full = FALSE;
174 } else {
175 /* Figure number of rows to return to caller. */
176 num_rows = 2;
177 /* Not more than the distance to the end of the image. */
178 if (num_rows > upsample->rows_to_go)
179 num_rows = upsample->rows_to_go;
180 /* And not more than what the client can accept: */
181 out_rows_avail -= *out_row_ctr;
182 if (num_rows > out_rows_avail)
183 num_rows = out_rows_avail;
184 /* Create output pointer array for upsampler. */
185 work_ptrs[0] = output_buf[*out_row_ctr];
186 if (num_rows > 1) {
187 work_ptrs[1] = output_buf[*out_row_ctr + 1];
188 } else {
189 work_ptrs[1] = upsample->spare_row;
190 upsample->spare_full = TRUE;
191 }
192 /* Now do the upsampling. */
193 (*upsample->upmethod) (cinfo, input_buf, *in_row_group_ctr, work_ptrs);
194 }
195
196 /* Adjust counts */
197 *out_row_ctr += num_rows;
198 upsample->rows_to_go -= num_rows;
199 /* When the buffer is emptied, declare this input row group consumed */
200 if (! upsample->spare_full)
201 (*in_row_group_ctr)++;
202 }
203
204
205 METHODDEF(void)
206 merged_1v_upsample (j_decompress_ptr cinfo,
207 JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
208 JDIMENSION in_row_groups_avail,
209 JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
210 JDIMENSION out_rows_avail)
211 /* 1:1 vertical sampling case: much easier, never need a spare row. */
212 {
213 my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
214
215 /* Just do the upsampling. */
216 (*upsample->upmethod) (cinfo, input_buf, *in_row_group_ctr,
217 output_buf + *out_row_ctr);
218 /* Adjust counts */
219 (*out_row_ctr)++;
220 (*in_row_group_ctr)++;
221 }
222
223
224 /*
225 * These are the routines invoked by the control routines to do
226 * the actual upsampling/conversion. One row group is processed per call.
227 *
228 * Note: since we may be writing directly into application-supplied buffers,
229 * we have to be honest about the output width; we can't assume the buffer
230 * has been rounded up to an even width.
231 */
232
233
234 /*
235 * Upsample and color convert for the case of 2:1 horizontal and 1:1 vertical.
236 */
237
238 METHODDEF(void)
239 h2v1_merged_upsample (j_decompress_ptr cinfo,
240 JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
241 JSAMPARRAY output_buf)
242 {
243
244
245 my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
246 register int y, cred, cgreen, cblue;
247 int cb, cr;
248 register JSAMPROW outptr;
249 JSAMPROW inptr0, inptr1, inptr2;
250 JDIMENSION col;
251 /* copy these pointers into registers if possible */
252 register JSAMPLE * range_limit = cinfo->sample_range_limit;
253 int * Crrtab = upsample->Cr_r_tab;
254 int * Cbbtab = upsample->Cb_b_tab;
255 INT32 * Crgtab = upsample->Cr_g_tab;
256 INT32 * Cbgtab = upsample->Cb_g_tab;
257 SHIFT_TEMPS
258
259 inptr0 = input_buf[0][in_row_group_ctr];
260 inptr1 = input_buf[1][in_row_group_ctr];
261 inptr2 = input_buf[2][in_row_group_ctr];
262 outptr = output_buf[0];
263 /* Loop for each pair of output pixels */
264 for (col = cinfo->output_width >> 1; col > 0; col--) {
265 /* Do the chroma part of the calculation */
266 cb = GETJSAMPLE(*inptr1++);
267 cr = GETJSAMPLE(*inptr2++);
268 cred = Crrtab[cr];
269 cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
270 cblue = Cbbtab[cb];
271 /* Fetch 2 Y values and emit 2 pixels */
272 y = GETJSAMPLE(*inptr0++);
273 outptr[RGB_RED] = range_limit[y + cred];
274 outptr[RGB_GREEN] = range_limit[y + cgreen];
275 outptr[RGB_BLUE] = range_limit[y + cblue];
276 outptr += RGB_PIXELSIZE;
277 y = GETJSAMPLE(*inptr0++);
278 outptr[RGB_RED] = range_limit[y + cred];
279 outptr[RGB_GREEN] = range_limit[y + cgreen];
280 outptr[RGB_BLUE] = range_limit[y + cblue];
281 outptr += RGB_PIXELSIZE;
282 }
283 /* If image width is odd, do the last output column separately */
284 if (cinfo->output_width & 1) {
285 cb = GETJSAMPLE(*inptr1);
286 cr = GETJSAMPLE(*inptr2);
287 cred = Crrtab[cr];
288 cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
289 cblue = Cbbtab[cb];
290 y = GETJSAMPLE(*inptr0);
291 outptr[RGB_RED] = range_limit[y + cred];
292 outptr[RGB_GREEN] = range_limit[y + cgreen];
293 outptr[RGB_BLUE] = range_limit[y + cblue];
294 }
295 }
296
297
298 /*
299 * Upsample and color convert for the case of 2:1 horizontal and 2:1 vertical.
300 */
301
302 #ifdef HAVE_MMX_INTEL_MNEMONICS
303 __inline METHODDEF(void)
304 h2v2_merged_upsample_orig (j_decompress_ptr cinfo,
305 JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
306 JSAMPARRAY output_buf);
307 __inline METHODDEF(void)
308 h2v2_merged_upsample_mmx (j_decompress_ptr cinfo,
309 JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
310 JSAMPARRAY output_buf);
311 #endif
312
313 METHODDEF(void)
314 h2v2_merged_upsample (j_decompress_ptr cinfo,
315 JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
316 JSAMPARRAY output_buf);
317
318 #ifdef HAVE_MMX_INTEL_MNEMONICS
319 METHODDEF(void)
320 h2v2_merged_upsample (j_decompress_ptr cinfo,
321 JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
322 JSAMPARRAY output_buf)
323 {
324 if (MMXAvailable && (cinfo->image_width >= 8))
325 h2v2_merged_upsample_mmx (cinfo, input_buf, in_row_group_ctr, output_buf);
326 else
327 h2v2_merged_upsample_orig (cinfo, input_buf, in_row_group_ctr, output_buf);
328
329 }
330
331 __inline METHODDEF(void)
332 h2v2_merged_upsample_orig (j_decompress_ptr cinfo,
333 JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
334 JSAMPARRAY output_buf)
335 {
336
337 my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
338 register int y, cred, cgreen, cblue;
339 int cb, cr;
340 register JSAMPROW outptr0, outptr1;
341 JSAMPROW inptr00, inptr01, inptr1, inptr2;
342 JDIMENSION col;
343 /* copy these pointers into registers if possible */
344 register JSAMPLE * range_limit = cinfo->sample_range_limit;
345 int * Crrtab = upsample->Cr_r_tab;
346 int * Cbbtab = upsample->Cb_b_tab;
347 INT32 * Crgtab = upsample->Cr_g_tab;
348 INT32 * Cbgtab = upsample->Cb_g_tab;
349 SHIFT_TEMPS
350
351 inptr00 = input_buf[0][in_row_group_ctr*2];
352 inptr01 = input_buf[0][in_row_group_ctr*2 + 1];
353 inptr1 = input_buf[1][in_row_group_ctr];
354 inptr2 = input_buf[2][in_row_group_ctr];
355 outptr0 = output_buf[0];
356 outptr1 = output_buf[1];
357 /* Loop for each group of output pixels */
358 for (col = cinfo->output_width >> 1; col > 0; col--) {
359 /* Do the chroma part of the calculation */
360 cb = GETJSAMPLE(*inptr1++);
361 cr = GETJSAMPLE(*inptr2++);
362 cred = Crrtab[cr];
363 cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
364 cblue = Cbbtab[cb];
365 /* Fetch 4 Y values and emit 4 pixels */
366 y = GETJSAMPLE(*inptr00++);
367 outptr0[RGB_RED] = range_limit[y + cred];
368 outptr0[RGB_GREEN] = range_limit[y + cgreen];
369 outptr0[RGB_BLUE] = range_limit[y + cblue];
370 outptr0 += RGB_PIXELSIZE;
371 y = GETJSAMPLE(*inptr00++);
372 outptr0[RGB_RED] = range_limit[y + cred];
373 outptr0[RGB_GREEN] = range_limit[y + cgreen];
374 outptr0[RGB_BLUE] = range_limit[y + cblue];
375 outptr0 += RGB_PIXELSIZE;
376 y = GETJSAMPLE(*inptr01++);
377 outptr1[RGB_RED] = range_limit[y + cred];
378 outptr1[RGB_GREEN] = range_limit[y + cgreen];
379 outptr1[RGB_BLUE] = range_limit[y + cblue];
380 outptr1 += RGB_PIXELSIZE;
381 y = GETJSAMPLE(*inptr01++);
382 outptr1[RGB_RED] = range_limit[y + cred];
383 outptr1[RGB_GREEN] = range_limit[y + cgreen];
384 outptr1[RGB_BLUE] = range_limit[y + cblue];
385 outptr1 += RGB_PIXELSIZE;
386 }
387 /* If image width is odd, do the last output column separately */
388 if (cinfo->output_width & 1) {
389 cb = GETJSAMPLE(*inptr1);
390 cr = GETJSAMPLE(*inptr2);
391 cred = Crrtab[cr];
392 cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
393 cblue = Cbbtab[cb];
394 y = GETJSAMPLE(*inptr00);
395 outptr0[RGB_RED] = range_limit[y + cred];
396 outptr0[RGB_GREEN] = range_limit[y + cgreen];
397 outptr0[RGB_BLUE] = range_limit[y + cblue];
398 y = GETJSAMPLE(*inptr01);
399 outptr1[RGB_RED] = range_limit[y + cred];
400 outptr1[RGB_GREEN] = range_limit[y + cgreen];
401 outptr1[RGB_BLUE] = range_limit[y + cblue];
402 }
403 }
404
405 /*
406 * Upsample and color convert for the case of 2:1 horizontal and 2:1 vertical.
407 */
408 __inline METHODDEF(void)
409 h2v2_merged_upsample_mmx (j_decompress_ptr cinfo,
410 JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
411 JSAMPARRAY output_buf)
412 {
413 // added for MMX
414 __int64 const128 = 0x0080008000800080;
415 __int64 empty = 0x0000000000000000;
416 __int64 davemask = 0x0000FFFFFFFF0000;
417 ////////////////////////////////
418
419 my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
420 register int y, cred, cgreen, cblue;
421 int cb, cr;
422 register JSAMPROW outptr0, outptr1;
423 JSAMPROW inptr00, inptr01, inptr1, inptr2;
424 JDIMENSION col;
425 /* copy these pointers into registers if possible */
426 register JSAMPLE * range_limit = cinfo->sample_range_limit;
427 int * Crrtab = upsample->Cr_r_tab;
428 int * Cbbtab = upsample->Cb_b_tab;
429 INT32 * Crgtab = upsample->Cr_g_tab;
430 INT32 * Cbgtab = upsample->Cb_g_tab;
431 SHIFT_TEMPS
432
433
434 // Added for MMX
435 register int width = cinfo->image_width;
436 int cols = cinfo->output_width;
437 int cols_asm = (cols >> 3);
438 int diff = cols - (cols_asm<<3);
439 int cols_asm_copy = cols_asm;
440
441 ///////////////////////////////////////
442
443 inptr00 = input_buf[0][in_row_group_ctr*2];
444 inptr01 = input_buf[0][in_row_group_ctr*2 + 1];
445 inptr1 = input_buf[1][in_row_group_ctr];
446 inptr2 = input_buf[2][in_row_group_ctr];
447 outptr0 = output_buf[0];
448 outptr1 = output_buf[1];
449 /* Loop for each group of output pixels */
450
451
452 _asm
453 {
454 mov esi, inptr00
455
456 mov eax, inptr01
457
458 mov ebx, inptr2
459
460 mov ecx, inptr1
461
462 mov edi, outptr0
463
464 mov edx, outptr1
465
466 do_next16:
467
468 movd mm0, [ebx] ; Cr7 Cr6.....Cr1 Cr0
469
470 pxor mm6, mm6
471
472 punpcklbw mm0, mm0 ; Cr3 Cr3 Cr2 Cr2 Cr1 Cr1 Cr0 Cr0
473
474 movq mm7, const128
475
476 punpcklwd mm0, mm0 ; Cr1 Cr1 Cr1 Cr1 Cr0 Cr0 Cr0 Cr0
477
478 movq mm4, mm0
479
480 punpcklbw mm0, mm6 ; Cr0 Cr0 Cr0 Cr0
481
482 psubsw mm0, mm7 ; Cr0 - 128:Cr0-128:Cr0-128:Cr0 -128
483
484 movd mm1, [ecx] ; Cb7 Cb6...... Cb1 Cb0
485
486 psllw mm0, 2 ; left shift by 2 bits
487
488 punpcklbw mm1, mm1 ; Cb3 Cb3 Cb2 Cb2 Cb1 Cb1 Cb0 Cb0
489
490 paddsw mm0, const05 ; add (one_half/fix(x)) << 2
491
492 punpcklwd mm1, mm1 ; Cb1 Cb1 Cb1 Cb1 Cb0 Cb0 Cb0 Cb0
493
494 movq mm5, mm1
495
496 pmulhw mm0, const1 ; multiply by (fix(x) >> 1)
497
498 punpcklbw mm1, mm6 ; Cb0 Cb0 Cb0 Cb0
499
500 punpckhbw mm4, mm6 ; Cr1 Cr1 Cr1 Cr1
501
502 psubsw mm1, mm7 ; Cb0 - 128:Cb0-128:Cb0-128:Cb0 -128
503
504 punpckhbw mm5, mm6 ; Cb1 Cb1 Cb1 Cb1
505
506 psllw mm1, 2 ; left shift by 2 bits
507
508 paddsw mm1, const15 ; add (one_half/fix(x)) << 2
509
510 psubsw mm4, mm7 ; Cr1 - 128:Cr1-128:Cr1-128:Cr1 -128
511
512 psubsw mm5, mm7 ; Cb1 - 128:Cb1-128:Cb1-128:Cb1 -128
513
514 pmulhw mm1, const2 ; multiply by (fix(x) >> 1)
515
516 psllw mm4, 2 ; left shift by 2 bits
517
518 psllw mm5, 2 ; left shift by 2 bits
519
520 paddsw mm4, const45 ; add (one_half/fix(x)) << 2
521
522 movd mm7, [esi] ; Y13 Y12 Y9 Y8 Y5 Y4 Y1 Y0
523
524 pmulhw mm4, const5 ; multiply by (fix(x) >> 1)
525
526 movq mm6, mm7
527
528 punpcklbw mm7, mm7 ; Y5 Y5 Y4 Y4 Y1 Y1 Y0 Y0
529
530 paddsw mm5, const55 ; add (one_half/fix(x)) << 2
531
532 paddsw mm0, mm1 ; cred0 cbl0 cgr0 cred0
533
534 movq mm1, mm7
535
536 pmulhw mm5, const6 ; multiply by (fix(x) >> 1)
537
538 movq mm2, mm0 ; cred0 cbl0 cgr0 cred0
539
540 punpcklwd mm7, mm6 ; Y5 Y4 Y1 Y1 Y1 Y0 Y0 Y0
541
542 pand mm2, davemask ; 0 cbl0 cgr0 0
543
544 psrlq mm1, 16 ; 0 0 Y5 Y5 Y4 Y4 Y1 Y1
545
546 psrlq mm2, 16 ; 0 0 cbl0 cgr0
547
548 punpcklbw mm7, empty ; Y1 Y0 Y0 Y0
549
550 paddsw mm4, mm5 ; cbl1 cgr1 cred1 cbl1
551
552 movq mm3, mm4 ; cbl1 cgr1 cred1 cbl1
553
554 pand mm3, davemask ; 0 cgr1 cred1 0
555
556 paddsw mm7, mm0 ; r1 b0 g0 r0
557
558 psllq mm3, 16 ; cgr1 cred1 0 0
559
560 movq mm6, mm1 ; 0 0 Y5 Y5 Y4 Y4 Y1 Y1
561
562 por mm2, mm3 ; cgr1 cred1 cbl0 cgr0
563
564 punpcklbw mm6, empty ; Y4 Y4 Y1 Y1
565
566 movd mm3, [eax] ; Y15 Y14 Y11 Y10 Y7 Y6 Y3 Y2
567
568 paddsw mm6, mm2 ; g4 r4 b1 g1
569
570 packuswb mm7, mm6 ; g4 r4 b1 g1 r1 b0 g0 r0
571
572 movq mm6, mm3 ; Y15 Y14 Y11 Y10 Y7 Y6 Y3 Y2
573
574 punpcklbw mm3, mm3 ; Y7 Y7 Y6 Y6 Y3 Y3 Y2 Y2
575
576 movq [edi], mm7 ; move to memory g4 r4 b1 g1 r1 b0 g0 r0
577
578 movq mm5, mm3 ; Y7 Y7 Y6 Y6 Y3 Y3 Y2 Y2
579
580 punpcklwd mm3, mm6 ; X X X X Y3 Y2 Y2 Y2
581
582 punpcklbw mm3, empty ; Y3 Y2 Y2 Y2
583
584 psrlq mm5, 16 ; 0 0 Y7 Y7 Y6 Y6 Y3 Y3
585
586 paddsw mm3, mm0 ; r3 b2 g2 r2
587
588 movq mm6, mm5 ; 0 0 Y7 Y7 Y6 Y6 Y3 Y3
589
590 movq mm0, mm1 ; 0 0 Y5 Y5 Y4 Y4 Y1 Y1
591
592 punpckldq mm6, mm6 ; X X X X Y6 Y6 Y3 Y3
593
594 punpcklbw mm6, empty ; Y6 Y6 Y3 Y3
595
596 psrlq mm1, 24 ; 0 0 0 0 0 Y5 Y5 Y4
597
598 paddsw mm6, mm2 ; g6 r6 b3 g3
599
600 packuswb mm3, mm6 ; g6 r6 b3 g3 r3 b2 g2 r2
601
602 movq mm2, mm5 ; 0 0 Y7 Y7 Y6 Y6 Y3 Y3
603
604 psrlq mm0, 32 ; 0 0 0 0 0 0 Y5 Y5
605
606 movq [edx], mm3 ; move to memory g6 r6 b3 g3 r3 b2 g2 r2
607
608 punpcklwd mm1, mm0 ; X X X X Y5 Y5 Y5 Y4
609
610 psrlq mm5, 24 ; 0 0 0 0 0 Y7 Y7 Y6
611
612 movd mm0, [ebx] ; Cr9 Cr8.....Cr3 Cr2
613
614 psrlq mm2, 32 ; 0 0 0 0 0 0 Y7 Y7
615
616 psrlq mm0, 16
617
618 punpcklbw mm1, empty ; Y5 Y5 Y5 Y4
619
620 punpcklwd mm5, mm2 ; X X X X Y7 Y7 Y7 Y6
621
622 paddsw mm1, mm4 ; b5 g5 r5 b4
623
624 punpcklbw mm5, empty ; Y7 Y7 Y7 Y6
625
626 pxor mm6, mm6 ; clear mm6 registr
627
628 punpcklbw mm0, mm0 ; X X X X Cr3 Cr3 Cr2 Cr2
629
630 paddsw mm5, mm4 ; b7 g7 r7 b6
631
632 punpcklwd mm0, mm0 ; Cr3 Cr3 Cr3 Cr3 Cr2 Cr2 Cr2 Cr2
633
634 movq mm4, mm0
635
636 movd mm3, [ecx] ; Cb9 Cb8...... Cb3 Cb2
637
638 punpcklbw mm0, mm6 ; Cr2 Cr2 Cr2 Cr2
639
640 psrlq mm3, 16
641
642 psubsw mm0, const128 ; Cr2 - 128:Cr2-128:Cr2-128:Cr2 -128
643
644 punpcklbw mm3, mm3 ; X X X X Cb3 Cb3 Cb2 Cb2
645
646 psllw mm0, 2 ; left shift by 2 bits
647
648 paddsw mm0, const05 ; add (one_half/fix(x)) << 2
649
650 punpcklwd mm3, mm3 ; Cb3 Cb3 Cb3 Cb3 Cb2 Cb2 Cb2 Cb2
651
652 movq mm7, mm3
653
654 pmulhw mm0, const1 ; multiply by (fix(x) >> 1)
655
656 punpcklbw mm3, mm6 ; Cb2 Cb2 Cb2 Cb2
657
658 psubsw mm3, const128 ; Cb0 - 128:Cb0-128:Cb0-128:Cb0 -128
659
660 punpckhbw mm4, mm6 ; Cr3 Cr3 Cr3 Cr3
661
662 psllw mm3, 2 ; left shift by 2 bits
663
664 paddsw mm3, const15 ; add (one_half/fix(x)) << 2
665
666 punpckhbw mm7, mm6 ; Cb3 Cb3 Cb3 Cb3
667
668 pmulhw mm3, const2 ; multiply by (fix(x) >> 1)
669
670 psubsw mm7, const128 ; Cb3 - 128:Cb3-128:Cb3-128:Cb3 -128
671
672 paddsw mm0, mm3 ; cred2 cbl2 cgr2 cred2
673
674 psllw mm7, 2 ; left shift by 2 bits
675
676 psubsw mm4, const128 ; Cr3 - 128:Cr3-128:Cr3-128:Cr3 -128
677
678 movd mm3, [esi+4] ; Y21 Y20 Y17 Y16 Y13 Y12 Y9 Y8
679
680 psllw mm4, 2 ; left shift by 2 bits
681
682 paddsw mm7, const55 ; add (one_half/fix(x)) << 2
683
684 movq mm6, mm3 ; Y21 Y20 Y17 Y16 Y13 Y12 Y9 Y8
685
686 movq mm2, mm0
687
688 pand mm2, davemask
689
690 punpcklbw mm3, mm3 ; Y13 Y13 Y12 Y12 Y9 Y9 Y8 Y8
691
692 psrlq mm2, 16
693
694 paddsw mm4, const45 ; add (one_half/fix(x)) << 2
695
696 punpcklwd mm3, mm6 ; X X X X Y9 Y8 Y8 Y8
697
698 pmulhw mm4, const5 ; multiply by (fix(x) >> 1)
699
700 pmulhw mm7, const6 ; multiply by (fix(x) >> 1)
701
702 punpcklbw mm3, empty ; Y9 Y8 Y8 Y8
703
704 paddsw mm4, mm7 ; cbl3 cgr3 cred3 cbl3
705
706 paddsw mm3, mm0 ; r9 b8 g8 r8
707
708 movq mm7, mm4
709
710 packuswb mm1, mm3 ; r9 b8 g8 r8 b5 g5 r5 b4
711
712 movd mm3, [eax+4] ; Y23 Y22 Y19 Y18 Y15 Y14 Y11 Y10
713
714 pand mm7, davemask
715
716 psrlq mm6, 8 ; 0 Y21 Y20 Y17 Y16 Y13 Y12 Y9
717
718 psllq mm7, 16
719
720 movq [edi+8], mm1 ; move to memory r9 b8 g8 r8 b5 g5 r5 b4
721
722 por mm2, mm7
723
724 movq mm7, mm3 ; Y23 Y22 Y19 Y18 Y15 Y14 Y11 Y10
725
726 punpcklbw mm3, mm3 ; X X X X Y11 Y11 Y10 Y10
727
728 pxor mm1, mm1
729
730 punpcklwd mm3, mm7 ; X X X X Y11 Y10 Y10 Y10
731
732 punpcklbw mm3, mm1 ; Y11 Y10 Y10 Y10
733
734 psrlq mm7, 8 ; 0 Y23 Y22 Y19 Y18 Y15 Y14 Y11
735
736 paddsw mm3, mm0 ; r11 b10 g10 r10
737
738 movq mm0, mm7 ; 0 Y23 Y22 Y19 Y18 Y15 Y14 Y11
739
740 packuswb mm5, mm3 ; r11 b10 g10 r10 b7 g7 r7 b6
741
742 punpcklbw mm7, mm7 ; X X X X Y14 Y14 Y11 Y11
743
744 movq [edx+8], mm5 ; move to memory r11 b10 g10 r10 b7 g7 r7 b6
745
746 movq mm3, mm6 ; 0 Y21 Y20 Y17 Y16 Y13 Y12 Y9
747
748 punpcklbw mm6, mm6 ; X X X X Y12 Y12 Y9 Y9
749
750 punpcklbw mm7, mm1 ; Y14 Y14 Y11 Y11
751
752 punpcklbw mm6, mm1 ; Y12 Y12 Y9 Y9
753
754 paddsw mm7, mm2 ; g14 r14 b11 g11
755
756 paddsw mm6, mm2 ; g12 r12 b9 g9
757
758 psrlq mm3, 8 ; 0 0 Y21 Y20 Y17 Y16 Y13 Y12
759
760 movq mm1, mm3 ; 0 0 Y21 Y20 Y17 Y16 Y13 Y12
761
762 punpcklbw mm3, mm3 ; X X X X Y13 Y13 Y12 Y12
763
764 add esi, 8
765
766 psrlq mm3, 16 ; X X X X X X Y13 Y13 modified on 09/24
767
768 punpcklwd mm1, mm3 ; X X X X Y13 Y13 Y13 Y12
769
770 add eax, 8
771
772 psrlq mm0, 8 ; 0 0 Y23 Y22 Y19 Y18 Y15 Y14
773
774 punpcklbw mm1, empty ; Y13 Y13 Y13 Y12
775
776 movq mm5, mm0 ; 0 0 Y23 Y22 Y19 Y18 Y15 Y14
777
778 punpcklbw mm0, mm0 ; X X X X Y15 Y15 Y14 Y14
779
780 paddsw mm1, mm4 ; b13 g13 r13 b12
781
782 psrlq mm0, 16 ; X X X X X X Y15 Y15
783
784 add edi, 24
785
786 punpcklwd mm5, mm0 ; X X X X Y15 Y15 Y15 Y14
787
788 packuswb mm6, mm1 ; b13 g13 r13 b12 g12 r12 b9 g9
789
790 add edx, 24
791
792 punpcklbw mm5, empty ; Y15 Y15 Y15 Y14
793
794 add ebx, 4
795
796 paddsw mm5, mm4 ; b15 g15 r15 b14
797
798 movq [edi-8], mm6 ; move to memory b13 g13 r13 b12 g12 r12 b9 g9
799
800 packuswb mm7, mm5 ; b15 g15 r15 b14 g14 r14 b11 g11
801
802 add ecx, 4
803
804 movq [edx-8], mm7 ; move to memory b15 g15 r15 b14 g14 r14 b11 g11
805
806 dec cols_asm
807
808 jnz do_next16
809
810 EMMS
811
812 }
813
814
815 inptr1 += (cols_asm_copy<<2);
816
817 inptr2 += (cols_asm_copy<<2);
818
819 inptr00 += (cols_asm_copy<<3);
820
821 inptr01 += (cols_asm_copy<<3);
822
823 outptr0 += cols_asm_copy*24;
824
825 outptr1 += cols_asm_copy*24;
826
827 //for (col = cinfo->output_width >> 1; col > 0; col--) {
828 /* Do the chroma part of the calculation */
829 /*cb = GETJSAMPLE(*inptr1++);
830 cr = GETJSAMPLE(*inptr2++);
831 cred = Crrtab[cr];
832 cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
833 cblue = Cbbtab[cb];*/
834 /* Fetch 4 Y values and emit 4 pixels */
835 /*y = GETJSAMPLE(*inptr00++);
836 outptr0[RGB_RED] = range_limit[y + cred];
837 outptr0[RGB_GREEN] = range_limit[y + cgreen];
838 outptr0[RGB_BLUE] = range_limit[y + cblue];
839 outptr0 += RGB_PIXELSIZE;
840 y = GETJSAMPLE(*inptr00++);
841 outptr0[RGB_RED] = range_limit[y + cred];
842 outptr0[RGB_GREEN] = range_limit[y + cgreen];
843 outptr0[RGB_BLUE] = range_limit[y + cblue];
844 outptr0 += RGB_PIXELSIZE;
845 y = GETJSAMPLE(*inptr01++);
846 outptr1[RGB_RED] = range_limit[y + cred];
847 outptr1[RGB_GREEN] = range_limit[y + cgreen];
848 outptr1[RGB_BLUE] = range_limit[y + cblue];
849 outptr1 += RGB_PIXELSIZE;
850 y = GETJSAMPLE(*inptr01++);
851 outptr1[RGB_RED] = range_limit[y + cred];
852 outptr1[RGB_GREEN] = range_limit[y + cgreen];
853 outptr1[RGB_BLUE] = range_limit[y + cblue];
854 outptr1 += RGB_PIXELSIZE;
855 } */
856
857
858 for (col = diff >> 1; col > 0; col--) {
859 /* Do the chroma part of the calculation */
860 cb = GETJSAMPLE(*inptr1++);
861 cr = GETJSAMPLE(*inptr2++);
862 cred = Crrtab[cr];
863 cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
864 cblue = Cbbtab[cb];
865 /* Fetch 4 Y values and emit 4 pixels */
866 y = GETJSAMPLE(*inptr00++);
867 outptr0[RGB_RED] = range_limit[y + cred];
868 outptr0[RGB_GREEN] = range_limit[y + cgreen];
869 outptr0[RGB_BLUE] = range_limit[y + cblue];
870 outptr0 += RGB_PIXELSIZE;
871 y = GETJSAMPLE(*inptr00++);
872 outptr0[RGB_RED] = range_limit[y + cred];
873 outptr0[RGB_GREEN] = range_limit[y + cgreen];
874 outptr0[RGB_BLUE] = range_limit[y + cblue];
875 outptr0 += RGB_PIXELSIZE;
876 y = GETJSAMPLE(*inptr01++);
877 outptr1[RGB_RED] = range_limit[y + cred];
878 outptr1[RGB_GREEN] = range_limit[y + cgreen];
879 outptr1[RGB_BLUE] = range_limit[y + cblue];
880 outptr1 += RGB_PIXELSIZE;
881 y = GETJSAMPLE(*inptr01++);
882 outptr1[RGB_RED] = range_limit[y + cred];
883 outptr1[RGB_GREEN] = range_limit[y + cgreen];
884 outptr1[RGB_BLUE] = range_limit[y + cblue];
885 outptr1 += RGB_PIXELSIZE;
886 }
887
888
889 /* If image width is odd, do the last output column separately */
890 //if (cinfo->output_width & 1) {
891 if (diff & 1) {
892 cb = GETJSAMPLE(*inptr1);
893 cr = GETJSAMPLE(*inptr2);
894 cred = Crrtab[cr];
895 cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
896 cblue = Cbbtab[cb];
897 y = GETJSAMPLE(*inptr00);
898 outptr0[RGB_RED] = range_limit[y + cred];
899 outptr0[RGB_GREEN] = range_limit[y + cgreen];
900 outptr0[RGB_BLUE] = range_limit[y + cblue];
901 y = GETJSAMPLE(*inptr01);
902 outptr1[RGB_RED] = range_limit[y + cred];
903 outptr1[RGB_GREEN] = range_limit[y + cgreen];
904 outptr1[RGB_BLUE] = range_limit[y + cblue];
905 }
906 }
907 #else
908
909
910 METHODDEF(void)
911 h2v2_merged_upsample (j_decompress_ptr cinfo,
912 JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
913 JSAMPARRAY output_buf)
914 {
915 my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
916 register int y, cred, cgreen, cblue;
917 int cb, cr;
918 register JSAMPROW outptr0, outptr1;
919 JSAMPROW inptr00, inptr01, inptr1, inptr2;
920 JDIMENSION col;
921 /* copy these pointers into registers if possible */
922 register JSAMPLE * range_limit = cinfo->sample_range_limit;
923 int * Crrtab = upsample->Cr_r_tab;
924 int * Cbbtab = upsample->Cb_b_tab;
925 INT32 * Crgtab = upsample->Cr_g_tab;
926 INT32 * Cbgtab = upsample->Cb_g_tab;
927 SHIFT_TEMPS
928
929 inptr00 = input_buf[0][in_row_group_ctr*2];
930 inptr01 = input_buf[0][in_row_group_ctr*2 + 1];
931 inptr1 = input_buf[1][in_row_group_ctr];
932 inptr2 = input_buf[2][in_row_group_ctr];
933 outptr0 = output_buf[0];
934 outptr1 = output_buf[1];
935 /* Loop for each group of output pixels */
936 for (col = cinfo->output_width >> 1; col > 0; col--) {
937 /* Do the chroma part of the calculation */
938 cb = GETJSAMPLE(*inptr1++);
939 cr = GETJSAMPLE(*inptr2++);
940 cred = Crrtab[cr];
941 cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
942 cblue = Cbbtab[cb];
943 /* Fetch 4 Y values and emit 4 pixels */
944 y = GETJSAMPLE(*inptr00++);
945 outptr0[RGB_RED] = range_limit[y + cred];
946 outptr0[RGB_GREEN] = range_limit[y + cgreen];
947 outptr0[RGB_BLUE] = range_limit[y + cblue];
948 outptr0 += RGB_PIXELSIZE;
949 y = GETJSAMPLE(*inptr00++);
950 outptr0[RGB_RED] = range_limit[y + cred];
951 outptr0[RGB_GREEN] = range_limit[y + cgreen];
952 outptr0[RGB_BLUE] = range_limit[y + cblue];
953 outptr0 += RGB_PIXELSIZE;
954 y = GETJSAMPLE(*inptr01++);
955 outptr1[RGB_RED] = range_limit[y + cred];
956 outptr1[RGB_GREEN] = range_limit[y + cgreen];
957 outptr1[RGB_BLUE] = range_limit[y + cblue];
958 outptr1 += RGB_PIXELSIZE;
959 y = GETJSAMPLE(*inptr01++);
960 outptr1[RGB_RED] = range_limit[y + cred];
961 outptr1[RGB_GREEN] = range_limit[y + cgreen];
962 outptr1[RGB_BLUE] = range_limit[y + cblue];
963 outptr1 += RGB_PIXELSIZE;
964 }
965 /* If image width is odd, do the last output column separately */
966 if (cinfo->output_width & 1) {
967 cb = GETJSAMPLE(*inptr1);
968 cr = GETJSAMPLE(*inptr2);
969 cred = Crrtab[cr];
970 cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
971 cblue = Cbbtab[cb];
972 y = GETJSAMPLE(*inptr00);
973 outptr0[RGB_RED] = range_limit[y + cred];
974 outptr0[RGB_GREEN] = range_limit[y + cgreen];
975 outptr0[RGB_BLUE] = range_limit[y + cblue];
976 y = GETJSAMPLE(*inptr01);
977 outptr1[RGB_RED] = range_limit[y + cred];
978 outptr1[RGB_GREEN] = range_limit[y + cgreen];
979 outptr1[RGB_BLUE] = range_limit[y + cblue];
980 }
981 }
982 #endif
983
984
985 /*
986 * Module initialization routine for merged upsampling/color conversion.
987 *
988 * NB: this is called under the conditions determined by use_merged_upsample()
989 * in jdmaster.c. That routine MUST correspond to the actual capabilities
990 * of this module; no safety checks are made here.
991 */
992
993 GLOBAL(void)
994 jinit_merged_upsampler (j_decompress_ptr cinfo)
995 {
996 my_upsample_ptr upsample;
997
998 upsample = (my_upsample_ptr)
999 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
1000 SIZEOF(my_upsampler));
1001 cinfo->upsample = (struct jpeg_upsampler *) upsample;
1002 upsample->pub.start_pass = start_pass_merged_upsample;
1003 upsample->pub.need_context_rows = FALSE;
1004
1005 upsample->out_row_width = cinfo->output_width * cinfo->out_color_components;
1006
1007 if (cinfo->max_v_samp_factor == 2) {
1008 upsample->pub.upsample = merged_2v_upsample;
1009 upsample->upmethod = h2v2_merged_upsample;
1010 /* Allocate a spare row buffer */
1011 upsample->spare_row = (JSAMPROW)
1012 (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
1013 (size_t) (upsample->out_row_width * SIZEOF(JSAMPLE)));
1014 } else {
1015 upsample->pub.upsample = merged_1v_upsample;
1016 upsample->upmethod = h2v1_merged_upsample;
1017 /* No spare row needed */
1018 upsample->spare_row = NULL;
1019 }
1020
1021 build_ycc_rgb_table(cinfo);
1022 }
1023
1024 #endif /* UPSAMPLE_MERGING_SUPPORTED */
git mirror of mozilla-central