← Back to branch summary

~medibuntu-maintainers/mplayer/medibuntu.precise

« back to all changes in this revision

Viewing changes to ffmpeg/libpostproc/postprocess_altivec_template.c

  • Committer: Package Import Robot
  • Author(s): Reinhard Tartler
  • Date: 2012-01-12 22:23:28 UTC
  • mfrom: (0.4.7 sid)
  • mto: This revision was merged to the branch mainline in revision 76.
  • Revision ID: package-import@ubuntu.com-20120112222328-8jqdyodym3p84ygu
Tags: 2:1.0~rc4.dfsg1+svn34540-1
* New upstream snapshot
* upload to unstable

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg/libpostproc/postprocess_altivec_template.c
530
530
}
531
531
 
532
532
static inline void dering_altivec(uint8_t src[], int stride, PPContext *c) {
 
533
    const vector signed int vsint32_8 = vec_splat_s32(8);
 
534
    const vector unsigned int vuint32_4 = vec_splat_u32(4);
 
535
    const vector signed char neg1 = vec_splat_s8(-1);
 
536
 
 
537
    const vector unsigned char permA1 = (vector unsigned char)
 
538
        {0x00, 0x01, 0x02, 0x10, 0x11, 0x12, 0x1F, 0x1F,
 
539
         0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F};
 
540
    const vector unsigned char permA2 = (vector unsigned char)
 
541
        {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x10, 0x11,
 
542
         0x12, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F};
 
543
    const vector unsigned char permA1inc = (vector unsigned char)
 
544
        {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00,
 
545
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
546
    const vector unsigned char permA2inc = (vector unsigned char)
 
547
        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01,
 
548
         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
549
    const vector unsigned char magic = (vector unsigned char)
 
550
        {0x01, 0x02, 0x01, 0x02, 0x04, 0x02, 0x01, 0x02,
 
551
         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
552
    const vector unsigned char extractPerm = (vector unsigned char)
 
553
        {0x10, 0x10, 0x10, 0x01, 0x10, 0x10, 0x10, 0x01,
 
554
         0x10, 0x10, 0x10, 0x01, 0x10, 0x10, 0x10, 0x01};
 
555
    const vector unsigned char extractPermInc = (vector unsigned char)
 
556
        {0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
 
557
         0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01};
 
558
    const vector unsigned char identity = vec_lvsl(0,(unsigned char *)0);
 
559
    const vector unsigned char tenRight = (vector unsigned char)
 
560
        {0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
561
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
562
    const vector unsigned char eightLeft = (vector unsigned char)
 
563
        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
564
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08};
 
565
 
533
566
    /*
534
567
    this code makes no assumption on src or stride.
535
568
    One could remove the recomputation of the perm
539
572
    src & stride :-(
540
573
    */
541
574
    uint8_t *srcCopy = src;
542
 
    DECLARE_ALIGNED(16, uint8_t, dt)[16];
 
575
    DECLARE_ALIGNED(16, uint8_t, dt)[16] = { deringThreshold };
543
576
    const vector signed int zero = vec_splat_s32(0);
544
 
    vector unsigned char v_dt;
545
 
    dt[0] = deringThreshold;
546
 
    v_dt = vec_splat(vec_ld(0, dt), 0);
 
577
    vector unsigned char v_dt = vec_splat(vec_ld(0, dt), 0);
547
578
 
548
579
#define LOAD_LINE(i)                                                  \
549
580
    const vector unsigned char perm##i =                              \
565
596
#undef LOAD_LINE
566
597
 
567
598
    vector unsigned char v_avg;
 
599
    DECLARE_ALIGNED(16, signed int, S)[8];
 
600
    DECLARE_ALIGNED(16, int, tQP2)[4] = { c->QP/2 + 1 };
 
601
    vector signed int vQP2 = vec_ld(0, tQP2);
 
602
    vQP2 = vec_splat(vQP2, 0);
 
603
 
568
604
    {
569
605
    const vector unsigned char trunc_perm = (vector unsigned char)
570
606
        {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
575
611
    const vector unsigned char trunc_src78 = vec_perm(src7, src8, trunc_perm);
576
612
 
577
613
#define EXTRACT(op) do {                                                \
578
 
    const vector unsigned char s##op##_1   = vec_##op(trunc_src12, trunc_src34); \
579
 
    const vector unsigned char s##op##_2   = vec_##op(trunc_src56, trunc_src78); \
580
 
    const vector unsigned char s##op##_6   = vec_##op(s##op##_1, s##op##_2);     \
581
 
    const vector unsigned char s##op##_8h  = vec_mergeh(s##op##_6, s##op##_6);   \
582
 
    const vector unsigned char s##op##_8l  = vec_mergel(s##op##_6, s##op##_6);   \
583
 
    const vector unsigned char s##op##_9   = vec_##op(s##op##_8h, s##op##_8l);   \
584
 
    const vector unsigned char s##op##_9h  = vec_mergeh(s##op##_9, s##op##_9);   \
585
 
    const vector unsigned char s##op##_9l  = vec_mergel(s##op##_9, s##op##_9);   \
586
 
    const vector unsigned char s##op##_10  = vec_##op(s##op##_9h, s##op##_9l);   \
587
 
    const vector unsigned char s##op##_10h = vec_mergeh(s##op##_10, s##op##_10); \
588
 
    const vector unsigned char s##op##_10l = vec_mergel(s##op##_10, s##op##_10); \
589
 
    const vector unsigned char s##op##_11  = vec_##op(s##op##_10h, s##op##_10l); \
590
 
    const vector unsigned char s##op##_11h = vec_mergeh(s##op##_11, s##op##_11); \
591
 
    const vector unsigned char s##op##_11l = vec_mergel(s##op##_11, s##op##_11); \
592
 
    v_##op = vec_##op(s##op##_11h, s##op##_11l); } while (0)
 
614
    const vector unsigned char s_1   = vec_##op(trunc_src12, trunc_src34); \
 
615
    const vector unsigned char s_2   = vec_##op(trunc_src56, trunc_src78); \
 
616
    const vector unsigned char s_6   = vec_##op(s_1, s_2);     \
 
617
    const vector unsigned char s_8h  = vec_mergeh(s_6, s_6);   \
 
618
    const vector unsigned char s_8l  = vec_mergel(s_6, s_6);   \
 
619
    const vector unsigned char s_9   = vec_##op(s_8h, s_8l);   \
 
620
    const vector unsigned char s_9h  = vec_mergeh(s_9, s_9);   \
 
621
    const vector unsigned char s_9l  = vec_mergel(s_9, s_9);   \
 
622
    const vector unsigned char s_10  = vec_##op(s_9h, s_9l);   \
 
623
    const vector unsigned char s_10h = vec_mergeh(s_10, s_10); \
 
624
    const vector unsigned char s_10l = vec_mergel(s_10, s_10); \
 
625
    const vector unsigned char s_11  = vec_##op(s_10h, s_10l); \
 
626
    const vector unsigned char s_11h = vec_mergeh(s_11, s_11); \
 
627
    const vector unsigned char s_11l = vec_mergel(s_11, s_11); \
 
628
    v_##op = vec_##op(s_11h, s_11l);                           \
 
629
} while (0)
593
630
 
594
631
    vector unsigned char v_min;
595
632
    vector unsigned char v_max;
603
640
    v_avg = vec_avg(v_min, v_max);
604
641
    }
605
642
 
606
 
    DECLARE_ALIGNED(16, signed int, S)[8];
607
643
    {
608
644
    const vector unsigned short mask1 = (vector unsigned short)
609
645
                                        {0x0001, 0x0002, 0x0004, 0x0008,
615
651
    const vector unsigned int vuint32_16 = vec_sl(vec_splat_u32(1), vec_splat_u32(4));
616
652
    const vector unsigned int vuint32_1 = vec_splat_u32(1);
617
653
 
 
654
    vector signed int sumA2;
 
655
    vector signed int sumB2;
 
656
    vector signed int sum0, sum1, sum2, sum3, sum4;
 
657
    vector signed int sum5, sum6, sum7, sum8, sum9;
 
658
 
618
659
#define COMPARE(i)                                                      \
619
 
    vector signed int sum##i;                                           \
620
660
    do {                                                                \
621
 
        const vector unsigned char cmp##i =                             \
 
661
        const vector unsigned char cmp =                                \
622
662
            (vector unsigned char)vec_cmpgt(src##i, v_avg);             \
623
 
        const vector unsigned short cmpHi##i =                          \
624
 
            (vector unsigned short)vec_mergeh(cmp##i, cmp##i);          \
625
 
        const vector unsigned short cmpLi##i =                          \
626
 
            (vector unsigned short)vec_mergel(cmp##i, cmp##i);          \
627
 
        const vector signed short cmpHf##i =                            \
628
 
            (vector signed short)vec_and(cmpHi##i, mask1);              \
629
 
        const vector signed short cmpLf##i =                            \
630
 
            (vector signed short)vec_and(cmpLi##i, mask2);              \
631
 
        const vector signed int sump##i = vec_sum4s(cmpHf##i, zero);    \
632
 
        const vector signed int sumq##i = vec_sum4s(cmpLf##i, sump##i); \
633
 
        sum##i  = vec_sums(sumq##i, zero); } while (0)
 
663
        const vector unsigned short cmpHi =                             \
 
664
            (vector unsigned short)vec_mergeh(cmp, cmp);                \
 
665
        const vector unsigned short cmpLi =                             \
 
666
            (vector unsigned short)vec_mergel(cmp, cmp);                \
 
667
        const vector signed short cmpHf =                               \
 
668
            (vector signed short)vec_and(cmpHi, mask1);                 \
 
669
        const vector signed short cmpLf =                               \
 
670
            (vector signed short)vec_and(cmpLi, mask2);                 \
 
671
        const vector signed int sump = vec_sum4s(cmpHf, zero);          \
 
672
        const vector signed int sumq = vec_sum4s(cmpLf, sump);          \
 
673
        sum##i  = vec_sums(sumq, zero);                                 \
 
674
    } while (0)
634
675
 
635
676
    COMPARE(0);
636
677
    COMPARE(1);
644
685
    COMPARE(9);
645
686
#undef COMPARE
646
687
 
647
 
    vector signed int sumA2;
648
 
    vector signed int sumB2;
649
688
    {
650
689
    const vector signed int sump02 = vec_mergel(sum0, sum2);
651
690
    const vector signed int sump13 = vec_mergel(sum1, sum3);
699
738
    /* I'm not sure the following is actually faster
700
739
       than straight, unvectorized C code :-( */
701
740
 
702
 
    DECLARE_ALIGNED(16, int, tQP2)[4];
703
 
    tQP2[0]= c->QP/2 + 1;
704
 
    vector signed int vQP2 = vec_ld(0, tQP2);
705
 
    vQP2 = vec_splat(vQP2, 0);
706
 
    const vector signed int vsint32_8 = vec_splat_s32(8);
707
 
    const vector unsigned int vuint32_4 = vec_splat_u32(4);
708
 
 
709
 
    const vector unsigned char permA1 = (vector unsigned char)
710
 
        {0x00, 0x01, 0x02, 0x10, 0x11, 0x12, 0x1F, 0x1F,
711
 
         0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F};
712
 
    const vector unsigned char permA2 = (vector unsigned char)
713
 
        {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x10, 0x11,
714
 
         0x12, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F};
715
 
    const vector unsigned char permA1inc = (vector unsigned char)
716
 
        {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00,
717
 
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
718
 
    const vector unsigned char permA2inc = (vector unsigned char)
719
 
        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01,
720
 
         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
721
 
    const vector unsigned char magic = (vector unsigned char)
722
 
        {0x01, 0x02, 0x01, 0x02, 0x04, 0x02, 0x01, 0x02,
723
 
         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
724
 
    const vector unsigned char extractPerm = (vector unsigned char)
725
 
        {0x10, 0x10, 0x10, 0x01, 0x10, 0x10, 0x10, 0x01,
726
 
         0x10, 0x10, 0x10, 0x01, 0x10, 0x10, 0x10, 0x01};
727
 
    const vector unsigned char extractPermInc = (vector unsigned char)
728
 
        {0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
729
 
         0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01};
730
 
    const vector unsigned char identity = vec_lvsl(0,(unsigned char *)0);
731
 
    const vector unsigned char tenRight = (vector unsigned char)
732
 
        {0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
733
 
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
734
 
    const vector unsigned char eightLeft = (vector unsigned char)
735
 
        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
736
 
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08};
737
 
 
738
 
 
739
 
#define F_INIT(i)                                       \
740
 
    vector unsigned char tenRightM##i = tenRight;       \
741
 
    vector unsigned char permA1M##i = permA1;           \
742
 
    vector unsigned char permA2M##i = permA2;           \
743
 
    vector unsigned char extractPermM##i = extractPerm
 
741
#define F_INIT()                                       \
 
742
    vector unsigned char tenRightM = tenRight;         \
 
743
    vector unsigned char permA1M = permA1;             \
 
744
    vector unsigned char permA2M = permA2;             \
 
745
    vector unsigned char extractPermM = extractPerm
744
746
 
745
747
#define F2(i, j, k, l)                                                  \
746
748
    if (S[i] & (1 << (l+1))) {                                          \
747
 
        const vector unsigned char a_##j##_A##l =                       \
748
 
            vec_perm(src##i, src##j, permA1M##i);                       \
749
 
        const vector unsigned char a_##j##_B##l =                       \
750
 
            vec_perm(a_##j##_A##l, src##k, permA2M##i);                 \
751
 
        const vector signed int a_##j##_sump##l =                       \
752
 
            (vector signed int)vec_msum(a_##j##_B##l, magic,            \
753
 
                                        (vector unsigned int)zero);     \
754
 
        vector signed int F_##j##_##l =                                 \
755
 
            vec_sr(vec_sums(a_##j##_sump##l, vsint32_8), vuint32_4);    \
756
 
        F_##j##_##l = vec_splat(F_##j##_##l, 3);                        \
757
 
        const vector signed int p_##j##_##l =                           \
758
 
            (vector signed int)vec_perm(src##j,                         \
759
 
                                        (vector unsigned char)zero,     \
760
 
                                        extractPermM##i);               \
761
 
        const vector signed int sum_##j##_##l  = vec_add( p_##j##_##l, vQP2);\
762
 
        const vector signed int diff_##j##_##l = vec_sub( p_##j##_##l, vQP2);\
763
 
        vector signed int newpm_##j##_##l;                              \
764
 
        if (vec_all_lt(sum_##j##_##l, F_##j##_##l))                     \
765
 
            newpm_##j##_##l = sum_##j##_##l;                            \
766
 
        else if (vec_all_gt(diff_##j##_##l, F_##j##_##l))               \
767
 
            newpm_##j##_##l = diff_##j##_##l;                           \
768
 
        else newpm_##j##_##l = F_##j##_##l;                             \
769
 
        const vector unsigned char newpm2_##j##_##l =                   \
770
 
            vec_splat((vector unsigned char)newpm_##j##_##l, 15);       \
771
 
        const vector unsigned char mask##j##l = vec_add(identity,       \
772
 
                                                        tenRightM##i);  \
773
 
        src##j = vec_perm(src##j, newpm2_##j##_##l, mask##j##l);        \
 
749
        const vector unsigned char a_A = vec_perm(src##i, src##j, permA1M); \
 
750
        const vector unsigned char a_B = vec_perm(a_A, src##k, permA2M); \
 
751
        const vector signed int a_sump =                                \
 
752
            (vector signed int)vec_msum(a_B, magic, (vector unsigned int)zero);\
 
753
        vector signed int F = vec_sr(vec_sums(a_sump, vsint32_8), vuint32_4); \
 
754
        const vector signed int p =                                     \
 
755
            (vector signed int)vec_perm(src##j, (vector unsigned char)zero, \
 
756
                                        extractPermM);                  \
 
757
        const vector signed int sum  = vec_add(p, vQP2);                \
 
758
        const vector signed int diff = vec_sub(p, vQP2);                \
 
759
        vector signed int newpm;                                        \
 
760
        vector unsigned char newpm2, mask;                              \
 
761
        F = vec_splat(F, 3);                                            \
 
762
        if (vec_all_lt(sum, F))                                         \
 
763
            newpm = sum;                                                \
 
764
        else if (vec_all_gt(diff, F))                                   \
 
765
            newpm = diff;                                               \
 
766
        else newpm = F;                                                 \
 
767
        newpm2 = vec_splat((vector unsigned char)newpm, 15);            \
 
768
        mask = vec_add(identity, tenRightM);                            \
 
769
        src##j = vec_perm(src##j, newpm2, mask);                        \
774
770
    }                                                                   \
775
 
    permA1M##i = vec_add(permA1M##i, permA1inc);                        \
776
 
    permA2M##i = vec_add(permA2M##i, permA2inc);                        \
777
 
    tenRightM##i = vec_sro(tenRightM##i, eightLeft);                    \
778
 
    extractPermM##i = vec_add(extractPermM##i, extractPermInc)
 
771
    permA1M = vec_add(permA1M, permA1inc);                              \
 
772
    permA2M = vec_add(permA2M, permA2inc);                              \
 
773
    tenRightM = vec_sro(tenRightM, eightLeft);                          \
 
774
    extractPermM = vec_add(extractPermM, extractPermInc)
779
775
 
780
 
#define ITER(i, j, k)                           \
781
 
    F_INIT(i);                                  \
 
776
#define ITER(i, j, k) do {                      \
 
777
    F_INIT();                                   \
782
778
    F2(i, j, k, 0);                             \
783
779
    F2(i, j, k, 1);                             \
784
780
    F2(i, j, k, 2);                             \
786
782
    F2(i, j, k, 4);                             \
787
783
    F2(i, j, k, 5);                             \
788
784
    F2(i, j, k, 6);                             \
789
 
    F2(i, j, k, 7)
 
785
    F2(i, j, k, 7);                             \
 
786
} while (0)
790
787
 
791
788
    ITER(0, 1, 2);
792
789
    ITER(1, 2, 3);
797
794
    ITER(6, 7, 8);
798
795
    ITER(7, 8, 9);
799
796
 
800
 
    const vector signed char neg1 = vec_splat_s8(-1);
801
 
 
802
 
#define STORE_LINE(i)                                   \
803
 
    const vector unsigned char permST##i =              \
 
797
#define STORE_LINE(i) do {                              \
 
798
    const vector unsigned char permST =                 \
804
799
        vec_lvsr(i * stride, srcCopy);                  \
805
 
    const vector unsigned char maskST##i =              \
 
800
    const vector unsigned char maskST =                 \
806
801
        vec_perm((vector unsigned char)zero,            \
807
 
                 (vector unsigned char)neg1, permST##i);\
808
 
    src##i = vec_perm(src##i ,src##i, permST##i);       \
809
 
    sA##i= vec_sel(sA##i, src##i, maskST##i);           \
810
 
    sB##i= vec_sel(src##i, sB##i, maskST##i);           \
 
802
                 (vector unsigned char)neg1, permST);   \
 
803
    src##i = vec_perm(src##i ,src##i, permST);          \
 
804
    sA##i= vec_sel(sA##i, src##i, maskST);              \
 
805
    sB##i= vec_sel(src##i, sB##i, maskST);              \
811
806
    vec_st(sA##i, i * stride, srcCopy);                 \
812
 
    vec_st(sB##i, i * stride + 16, srcCopy)
 
807
    vec_st(sB##i, i * stride + 16, srcCopy);            \
 
808
} while (0)
813
809
 
814
810
    STORE_LINE(1);
815
811
    STORE_LINE(2);
832
828
static inline void RENAME(tempNoiseReducer)(uint8_t *src, int stride,
833
829
                                            uint8_t *tempBlurred, uint32_t *tempBlurredPast, int *maxNoise)
834
830
{
 
831
    const vector signed char neg1 = vec_splat_s8(-1);
 
832
    const vector unsigned char permHH = (const vector unsigned char){0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 
833
                                                                     0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F};
 
834
 
835
835
    const vector signed int zero = vec_splat_s32(0);
836
836
    const vector signed short vsint16_1 = vec_splat_s16(1);
837
837
    vector signed int v_dp = zero;
838
838
    vector signed int v_sysdp = zero;
839
839
    int d, sysd, i;
840
840
 
841
 
    tempBlurredPast[127]= maxNoise[0];
842
 
    tempBlurredPast[128]= maxNoise[1];
843
 
    tempBlurredPast[129]= maxNoise[2];
844
 
 
845
841
#define LOAD_LINE(src, i)                                               \
846
842
    register int j##src##i = i * stride;                                \
847
843
    vector unsigned char perm##src##i = vec_lvsl(j##src##i, src);       \
872
868
    LOAD_LINE(tempBlurred, 7);
873
869
#undef LOAD_LINE
874
870
 
875
 
#define ACCUMULATE_DIFFS(i)                                     \
876
 
    vector signed short v_d##i = vec_sub(v_tempBlurredAss##i,   \
877
 
                                         v_srcAss##i);          \
878
 
    v_dp = vec_msums(v_d##i, v_d##i, v_dp);                     \
879
 
    v_sysdp = vec_msums(v_d##i, vsint16_1, v_sysdp)
 
871
#define ACCUMULATE_DIFFS(i) do {                                \
 
872
        vector signed short v_d = vec_sub(v_tempBlurredAss##i,  \
 
873
                                          v_srcAss##i);         \
 
874
        v_dp = vec_msums(v_d, v_d, v_dp);                       \
 
875
        v_sysdp = vec_msums(v_d, vsint16_1, v_sysdp);           \
 
876
    } while (0)
880
877
 
881
878
    ACCUMULATE_DIFFS(0);
882
879
    ACCUMULATE_DIFFS(1);
888
885
    ACCUMULATE_DIFFS(7);
889
886
#undef ACCUMULATE_DIFFS
890
887
 
 
888
    tempBlurredPast[127]= maxNoise[0];
 
889
    tempBlurredPast[128]= maxNoise[1];
 
890
    tempBlurredPast[129]= maxNoise[2];
 
891
 
891
892
    v_dp = vec_sums(v_dp, zero);
892
893
    v_sysdp = vec_sums(v_sysdp, zero);
893
894
 
938
939
            const vector signed short vsint16_4 = vec_splat_s16(4);
939
940
            const vector unsigned short vuint16_3 = vec_splat_u16(3);
940
941
 
941
 
#define OP(i)                                                   \
942
 
            const vector signed short v_temp##i =               \
943
 
                vec_mladd(v_tempBlurredAss##i,                  \
944
 
                          vsint16_7, v_srcAss##i);              \
945
 
            const vector signed short v_temp2##i =              \
946
 
                vec_add(v_temp##i, vsint16_4);                  \
947
 
            v_tempBlurredAss##i = vec_sr(v_temp2##i, vuint16_3)
 
942
#define OP(i) do {                                                      \
 
943
            const vector signed short v_temp =                          \
 
944
                vec_mladd(v_tempBlurredAss##i, vsint16_7, v_srcAss##i); \
 
945
            const vector signed short v_temp2 = vec_add(v_temp, vsint16_4); \
 
946
            v_tempBlurredAss##i = vec_sr(v_temp2, vuint16_3);           \
 
947
        } while (0)
948
948
 
949
949
            OP(0);
950
950
            OP(1);
959
959
            const vector signed short vsint16_3 = vec_splat_s16(3);
960
960
            const vector signed short vsint16_2 = vec_splat_s16(2);
961
961
 
962
 
#define OP(i)                                                   \
963
 
            const vector signed short v_temp##i =               \
964
 
                vec_mladd(v_tempBlurredAss##i,                  \
965
 
                          vsint16_3, v_srcAss##i);              \
966
 
            const vector signed short v_temp2##i =              \
967
 
                vec_add(v_temp##i, vsint16_2);                  \
968
 
            v_tempBlurredAss##i = vec_sr(v_temp2##i, (vector unsigned short)vsint16_2)
 
962
#define OP(i) do {                                              \
 
963
            const vector signed short v_temp =                  \
 
964
                vec_mladd(v_tempBlurredAss##i, vsint16_3, v_srcAss##i); \
 
965
            const vector signed short v_temp2 = vec_add(v_temp, vsint16_2); \
 
966
            v_tempBlurredAss##i =                                       \
 
967
                vec_sr(v_temp2, (vector unsigned short)vsint16_2);      \
 
968
        } while (0)
969
969
 
970
970
            OP(0);
971
971
            OP(1);
979
979
        }
980
980
    }
981
981
 
982
 
    const vector signed char neg1 = vec_splat_s8(-1);
983
 
    const vector unsigned char permHH = (const vector unsigned char){0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
984
 
                                                                     0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F};
985
 
 
986
 
#define PACK_AND_STORE(src, i)                                  \
987
 
    const vector unsigned char perms##src##i =                  \
988
 
        vec_lvsr(i * stride, src);                              \
989
 
    const vector unsigned char vf##src##i =                     \
990
 
        vec_packsu(v_tempBlurredAss##i, (vector signed short)zero); \
991
 
    const vector unsigned char vg##src##i =                     \
992
 
        vec_perm(vf##src##i, v_##src##A##i, permHH);            \
993
 
    const vector unsigned char mask##src##i =                   \
994
 
        vec_perm((vector unsigned char)zero, (vector unsigned char)neg1, perms##src##i); \
995
 
    const vector unsigned char vg2##src##i =                    \
996
 
        vec_perm(vg##src##i, vg##src##i, perms##src##i);        \
997
 
    const vector unsigned char svA##src##i =                    \
998
 
        vec_sel(v_##src##A1##i, vg2##src##i, mask##src##i);     \
999
 
    const vector unsigned char svB##src##i =                    \
1000
 
        vec_sel(vg2##src##i, v_##src##A2##i, mask##src##i);     \
1001
 
    vec_st(svA##src##i, i * stride, src);                       \
1002
 
    vec_st(svB##src##i, i * stride + 16, src)
 
982
#define PACK_AND_STORE(src, i) do {                                      \
 
983
    const vector unsigned char perms = vec_lvsr(i * stride, src);        \
 
984
    const vector unsigned char vf =                                      \
 
985
        vec_packsu(v_tempBlurredAss##1, (vector signed short)zero);     \
 
986
    const vector unsigned char vg = vec_perm(vf, v_##src##A##i, permHH); \
 
987
    const vector unsigned char mask =                                    \
 
988
        vec_perm((vector unsigned char)zero, (vector unsigned char)neg1, perms); \
 
989
    const vector unsigned char vg2 = vec_perm(vg, vg, perms);            \
 
990
    const vector unsigned char svA = vec_sel(v_##src##A1##i, vg2, mask); \
 
991
    const vector unsigned char svB = vec_sel(vg2, v_##src##A2##i, mask); \
 
992
    vec_st(svA, i * stride, src);                                        \
 
993
    vec_st(svB, i * stride + 16, src);                                   \
 
994
} while (0)
1003
995
 
1004
996
    PACK_AND_STORE(src, 0);
1005
997
    PACK_AND_STORE(src, 1);
1127
1119
 
1128
1120
static inline void transpose_8x16_char_fromPackedAlign_altivec(unsigned char* dst, unsigned char* src, int stride) {
1129
1121
    const vector unsigned char zero = vec_splat_u8(0);
 
1122
    const vector signed   char neg1 = vec_splat_s8(-1);
1130
1123
 
1131
1124
#define LOAD_DOUBLE_LINE(i, j)                                  \
1132
1125
    vector unsigned char src##i = vec_ld(i * 16, src);            \
1187
1180
    temp7 = vec_mergel(tempD, tempL);
1188
1181
 
1189
1182
 
1190
 
    const vector signed char neg1 = vec_splat_s8(-1);
1191
 
#define STORE_DOUBLE_LINE(i, j)                                         \
1192
 
    vector unsigned char dstA##i = vec_ld(i * stride, dst);             \
1193
 
    vector unsigned char dstB##i = vec_ld(i * stride + 16, dst);        \
1194
 
    vector unsigned char dstA##j = vec_ld(j * stride, dst);             \
1195
 
    vector unsigned char dstB##j = vec_ld(j * stride+ 16, dst);         \
1196
 
    vector unsigned char align##i = vec_lvsr(i * stride, dst);          \
1197
 
    vector unsigned char align##j = vec_lvsr(j * stride, dst);          \
1198
 
    vector unsigned char mask##i = vec_perm(zero, (vector unsigned char)neg1, align##i); \
1199
 
    vector unsigned char mask##j = vec_perm(zero, (vector unsigned char)neg1, align##j); \
1200
 
    vector unsigned char dstR##i = vec_perm(temp##i, temp##i, align##i);\
1201
 
    vector unsigned char dstR##j = vec_perm(temp##j, temp##j, align##j);\
1202
 
    vector unsigned char dstAF##i = vec_sel(dstA##i, dstR##i, mask##i); \
1203
 
    vector unsigned char dstBF##i = vec_sel(dstR##i, dstB##i, mask##i); \
1204
 
    vector unsigned char dstAF##j = vec_sel(dstA##j, dstR##j, mask##j); \
1205
 
    vector unsigned char dstBF##j = vec_sel(dstR##j, dstB##j, mask##j); \
1206
 
    vec_st(dstAF##i, i * stride, dst);                                  \
1207
 
    vec_st(dstBF##i, i * stride + 16, dst);                             \
1208
 
    vec_st(dstAF##j, j * stride, dst);                                  \
1209
 
    vec_st(dstBF##j, j * stride + 16, dst)
 
1183
#define STORE_DOUBLE_LINE(i, j) do {                                    \
 
1184
    vector unsigned char dstAi = vec_ld(i * stride, dst);               \
 
1185
    vector unsigned char dstBi = vec_ld(i * stride + 16, dst);          \
 
1186
    vector unsigned char dstAj = vec_ld(j * stride, dst);               \
 
1187
    vector unsigned char dstBj = vec_ld(j * stride+ 16, dst);           \
 
1188
    vector unsigned char aligni = vec_lvsr(i * stride, dst);            \
 
1189
    vector unsigned char alignj = vec_lvsr(j * stride, dst);            \
 
1190
    vector unsigned char maski =                                        \
 
1191
        vec_perm(zero, (vector unsigned char)neg1, aligni);             \
 
1192
    vector unsigned char maskj =                                        \
 
1193
        vec_perm(zero, (vector unsigned char)neg1, alignj);             \
 
1194
    vector unsigned char dstRi = vec_perm(temp##i, temp##i, aligni);    \
 
1195
    vector unsigned char dstRj = vec_perm(temp##j, temp##j, alignj);    \
 
1196
    vector unsigned char dstAFi = vec_sel(dstAi, dstRi, maski);         \
 
1197
    vector unsigned char dstBFi = vec_sel(dstRi, dstBi, maski);         \
 
1198
    vector unsigned char dstAFj = vec_sel(dstAj, dstRj, maskj);         \
 
1199
    vector unsigned char dstBFj = vec_sel(dstRj, dstBj, maskj);         \
 
1200
    vec_st(dstAFi, i * stride, dst);                                    \
 
1201
    vec_st(dstBFi, i * stride + 16, dst);                               \
 
1202
    vec_st(dstAFj, j * stride, dst);                                    \
 
1203
    vec_st(dstBFj, j * stride + 16, dst);                               \
 
1204
} while (0)
1210
1205
 
1211
1206
    STORE_DOUBLE_LINE(0,1);
1212
1207
    STORE_DOUBLE_LINE(2,3);