← Back to branch summary

~cosme/ubuntu/precise/freeimage/freeimage-3.15.1

« back to all changes in this revision

Viewing changes to Source/LibJPEG/jdmerge.c

  • Committer: Stefano Rivera
  • Date: 2010-07-24 15:35:51 UTC
  • mto: This revision was merged to the branch mainline in revision 5.
  • Revision ID: stefanor@ubuntu.com-20100724153551-6s3fth1653huk31a
Tags: upstream-3.13.1
Import upstream version 3.31.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
Source/LibJPEG/jdmerge.c
38
38
 
39
39
#ifdef UPSAMPLE_MERGING_SUPPORTED
40
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
41
 
55
42
/* Private subobject */
56
43
 
240
227
                      JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
241
228
                      JSAMPARRAY output_buf)
242
229
{
243
 
 
244
 
 
245
 
 my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
 
230
  my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
246
231
  register int y, cred, cgreen, cblue;
247
232
  int cb, cr;
248
233
  register JSAMPROW outptr;
299
284
 * Upsample and color convert for the case of 2:1 horizontal and 2:1 vertical.
300
285
 */
301
286
 
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
 
287
METHODDEF(void)
 
288
h2v2_merged_upsample (j_decompress_ptr cinfo,
 
289
                      JSAMPIMAGE input_buf, JDIMENSION in_row_group_ctr,
 
290
                      JSAMPARRAY output_buf)
 
291
{
 
292
  my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
 
293
  register int y, cred, cgreen, cblue;
 
294
  int cb, cr;
 
295
  register JSAMPROW outptr0, outptr1;
 
296
  JSAMPROW inptr00, inptr01, inptr1, inptr2;
 
297
  JDIMENSION col;
 
298
  /* copy these pointers into registers if possible */
 
299
  register JSAMPLE * range_limit = cinfo->sample_range_limit;
 
300
  int * Crrtab = upsample->Cr_r_tab;
 
301
  int * Cbbtab = upsample->Cb_b_tab;
 
302
  INT32 * Crgtab = upsample->Cr_g_tab;
 
303
  INT32 * Cbgtab = upsample->Cb_g_tab;
 
304
  SHIFT_TEMPS
 
305
 
 
306
  inptr00 = input_buf[0][in_row_group_ctr*2];
 
307
  inptr01 = input_buf[0][in_row_group_ctr*2 + 1];
 
308
  inptr1 = input_buf[1][in_row_group_ctr];
 
309
  inptr2 = input_buf[2][in_row_group_ctr];
 
310
  outptr0 = output_buf[0];
 
311
  outptr1 = output_buf[1];
 
312
  /* Loop for each group of output pixels */
 
313
  for (col = cinfo->output_width >> 1; col > 0; col--) {
 
314
    /* Do the chroma part of the calculation */
 
315
    cb = GETJSAMPLE(*inptr1++);
 
316
    cr = GETJSAMPLE(*inptr2++);
 
317
    cred = Crrtab[cr];
 
318
    cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
 
319
    cblue = Cbbtab[cb];
 
320
    /* Fetch 4 Y values and emit 4 pixels */
 
321
    y  = GETJSAMPLE(*inptr00++);
 
322
    outptr0[RGB_RED] =   range_limit[y + cred];
 
323
    outptr0[RGB_GREEN] = range_limit[y + cgreen];
 
324
    outptr0[RGB_BLUE] =  range_limit[y + cblue];
 
325
    outptr0 += RGB_PIXELSIZE;
 
326
    y  = GETJSAMPLE(*inptr00++);
 
327
    outptr0[RGB_RED] =   range_limit[y + cred];
 
328
    outptr0[RGB_GREEN] = range_limit[y + cgreen];
 
329
    outptr0[RGB_BLUE] =  range_limit[y + cblue];
 
330
    outptr0 += RGB_PIXELSIZE;
 
331
    y  = GETJSAMPLE(*inptr01++);
 
332
    outptr1[RGB_RED] =   range_limit[y + cred];
 
333
    outptr1[RGB_GREEN] = range_limit[y + cgreen];
 
334
    outptr1[RGB_BLUE] =  range_limit[y + cblue];
 
335
    outptr1 += RGB_PIXELSIZE;
 
336
    y  = GETJSAMPLE(*inptr01++);
 
337
    outptr1[RGB_RED] =   range_limit[y + cred];
 
338
    outptr1[RGB_GREEN] = range_limit[y + cgreen];
 
339
    outptr1[RGB_BLUE] =  range_limit[y + cblue];
 
340
    outptr1 += RGB_PIXELSIZE;
 
341
  }
 
342
  /* If image width is odd, do the last output column separately */
 
343
  if (cinfo->output_width & 1) {
 
344
    cb = GETJSAMPLE(*inptr1);
 
345
    cr = GETJSAMPLE(*inptr2);
 
346
    cred = Crrtab[cr];
 
347
    cgreen = (int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr], SCALEBITS);
 
348
    cblue = Cbbtab[cb];
 
349
    y  = GETJSAMPLE(*inptr00);
 
350
    outptr0[RGB_RED] =   range_limit[y + cred];
 
351
    outptr0[RGB_GREEN] = range_limit[y + cgreen];
 
352
    outptr0[RGB_BLUE] =  range_limit[y + cblue];
 
353
    y  = GETJSAMPLE(*inptr01);
 
354
    outptr1[RGB_RED] =   range_limit[y + cred];
 
355
    outptr1[RGB_GREEN] = range_limit[y + cgreen];
 
356
    outptr1[RGB_BLUE] =  range_limit[y + cblue];
 
357
  }
 
358
}
983
359
 
984
360
 
985
361
/*