Ticket #113: idct_add_altivec.diff

libavcodec/ppc/h264_altivec.c

@@ -404 +404 @@
- * IDCT transform:
- ****************************************************************************/
-
+#define VEC_1D_DCT(vb0,vb1,vb2,vb3,va0,va1,va2,va3)              \
+   /* 1st stage */                                               \
+   vz0 = vec_add(vb0,vb2);       /* temp[0] = Y[0] + Y[2] */     \
+   vz1 = vec_sub(vb0,vb2);       /* temp[1] = Y[0] - Y[2] */     \
+   vz2 = vec_sra(vb1,vec_splat_u16(1));                          \
+   vz2 = vec_sub(vz2,vb3);       /* temp[2] = Y[1].1/2 - Y[3] */ \
+   vz3 = vec_sra(vb3,vec_splat_u16(1));                          \
+   vz3 = vec_add(vb1,vz3);       /* temp[3] = Y[1] + Y[3].1/2 */ \
+   /* 2nd stage: output */                                       \
+   va0 = vec_add(vz0,vz3);       /* x[0] = temp[0] + temp[3] */  \
+   va1 = vec_add(vz1,vz2);       /* x[1] = temp[1] + temp[2] */  \
+   va2 = vec_sub(vz1,vz2);       /* x[2] = temp[1] - temp[2] */  \
+   va3 = vec_sub(vz0,vz3)        /* x[3] = temp[0] - temp[3] */
+
+#define VEC_TRANSPOSE_4(a0,a1,a2,a3,b0,b1,b2,b3) \
+    b0 = vec_mergeh( a0, a0 ); \
+    b1 = vec_mergeh( a1, a0 ); \
+    b2 = vec_mergeh( a2, a0 ); \
+    b3 = vec_mergeh( a3, a0 ); \
+    a0 = vec_mergeh( b0, b2 ); \
+    a1 = vec_mergel( b0, b2 ); \
+    a2 = vec_mergeh( b1, b3 ); \
+    a3 = vec_mergel( b1, b3 ); \
+    b0 = vec_mergeh( a0, a2 ); \
+    b1 = vec_mergel( a0, a2 ); \
+    b2 = vec_mergeh( a1, a3 ); \
+    b3 = vec_mergel( a1, a3 )
+
+#define VEC_LOAD_UNALIGNED_U8_ADD_S16_STORE_U8(p,mask,va,perm)\
+    vdst_orig = vec_ld(0,p);                                  \
+    vdst = vec_perm(vdst_orig, (vec_u8_t)vzero, mask);        \
+    vdst_ss = (vec_s16_t) vec_mergeh((vec_u8_t)vzero, vdst);  \
+    va = vec_add(va,vdst_ss);                                 \
+    va_u8 = vec_packsu(va,(vec_s16_t) vzero);                 \
+    vfdst = vec_perm(vdst_orig, va_u8, perm);                 \
+    vec_st(vfdst, 0, dst);
+
+#define VEC_LOAD_U8_ADD_S16_STORE_U8(p,va,perm)               \
+    vdst = vec_ld(0, p);                                      \
+    vdst_ss = (vec_s16_t)vec_mergeh((vec_u8_t)vzero, vdst);   \
+    va = vec_add(va,vdst_ss);                                 \
+    va_u8 = vec_packsu(va,(vec_s16_t) vzero);                 \
+    vfdst = vec_perm(vdst, va_u8, perm);                      \
+    vec_st(vfdst, 0, dst);
+
+static void ff_h264_idct_add_altivec(uint8_t *dst, DCTELEM *block, int stride)
+{
+    vec_s16_t va0, va1, va2, va3;
+    vec_s16_t vz0, vz1, vz2, vz3;
+    vec_s16_t vtmp0, vtmp1, vtmp2, vtmp3;
+    vec_u8_t va_u8;
+    vec_s16_t vdst_ss;
+    vec_u8_t vmaskl;
+    vec_s16_t vload1, vload2, vload3;
+    const vec_u16_t v6us = vec_splat_u16(6);
+    const vec_s32_t vzero = vec_splat_s32(0);
+    const int block_stride = 8;
+    vec_u8_t dstperm;
+    vec_u8_t vdst, vdst_orig, vfdst;
+
+    block[0] += 32;  /* add 32 as a DC-level for rounding */
+
+    vload1 = vec_ld(0,block);
+    vload2 = vec_ld(16,block);
+    vload3 = (vec_s16_t) vzero;
+    vmaskl = vec_lvsl(block_stride,block);
+    va0 = vload1;
+    va1 = vec_perm(vload1,vload2,vmaskl);
+    va2 = vload2;
+    va3 = vec_perm(vload2,vload3,vmaskl);
+
+//    VEC_TRANSPOSE_4(va0,va1,va2,va3,vtmp0,vtmp1,vtmp2,vtmp3);
+    vtmp0 = va0;
+    vtmp1 = va1;
+    vtmp2 = va2;
+    vtmp3 = va3;
+    VEC_1D_DCT(vtmp0,vtmp1,vtmp2,vtmp3,va0,va1,va2,va3);
+    VEC_TRANSPOSE_4(va0,va1,va2,va3,vtmp0,vtmp1,vtmp2,vtmp3);
+    VEC_1D_DCT(vtmp0,vtmp1,vtmp2,vtmp3,va0,va1,va2,va3);
+
+    va0 = vec_sra(va0,v6us);
+    va1 = vec_sra(va1,v6us);
+    va2 = vec_sra(va2,v6us);
+    va3 = vec_sra(va3,v6us);
+
+    if ((unsigned long)dst & 0xF){
+        vec_u8_t vdst_mask;
+        switch ((unsigned long)dst & 0xF){
+        case 0:
+            dstperm = (vec_u8_t)AVV(0x10, 0x11, 0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
+                                    0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F);
+            break;
+        case 4:
+            dstperm = (vec_u8_t)AVV(0x00, 0x01, 0x02, 0x03, 0x10, 0x11, 0x12, 0x13,
+                                    0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F);
+            break;
+        case 8:
+            dstperm = (vec_u8_t)AVV(0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+                                    0x10, 0x11, 0x12, 0x13, 0x0C, 0x0D, 0x0E, 0x0F);
+            break;
+        case 12:
+            dstperm = (vec_u8_t)AVV(0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+                                    0x08, 0x09, 0x0A, 0x0B, 0x10, 0x11, 0x12, 0x13);
+            break;
+        default:
+            dstperm = (vec_u8_t)AVV(0x10, 0x11, 0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
+                                    0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F);
+            break;
+        }
+
+        vdst_mask = vec_lvsl(0, dst);
+
+        VEC_LOAD_UNALIGNED_U8_ADD_S16_STORE_U8(dst,vdst_mask,va0,dstperm);
+        dst += stride;
+        VEC_LOAD_UNALIGNED_U8_ADD_S16_STORE_U8(dst,vdst_mask,va1,dstperm);
+        dst += stride;
+        VEC_LOAD_UNALIGNED_U8_ADD_S16_STORE_U8(dst,vdst_mask,va2,dstperm);
+        dst += stride;
+        VEC_LOAD_UNALIGNED_U8_ADD_S16_STORE_U8(dst,vdst_mask,va3,dstperm);
+    }
+    else{
+        dstperm = (vec_u8_t)AVV(0x10, 0x11, 0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
+                                0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F);
+        VEC_LOAD_U8_ADD_S16_STORE_U8(dst,va0,dstperm);
+        dst += stride;
+        VEC_LOAD_U8_ADD_S16_STORE_U8(dst,va1,dstperm);
+        dst += stride;
+        VEC_LOAD_U8_ADD_S16_STORE_U8(dst,va2,dstperm);
+        dst += stride;
+        VEC_LOAD_U8_ADD_S16_STORE_U8(dst,va3,dstperm);
+    }
+}
+
+static void ff_h264_idct_add_altivec_mat(uint8_t *dst, DCTELEM *block, int stride)
+{
+    vec_s16_t va0, va1, va2, va3;
+    vec_s32_t va0_sw, va1_sw, va2_sw, va3_sw;
+    vec_s16_t vz0, vz1;
+    vec_u8_t va_u8;
+    vec_s16_t vdst_ss;
+    vec_s16_t vload1, vload2;
+    const vec_u16_t v8us = vec_splat_u16(8);
+    const vec_s32_t vzero = vec_splat_s32(0);
+    vec_u8_t dstperm;
+    vec_u8_t vdst, vdst_orig, vfdst;
+    vec_s16_t vy0_a, vy0_b,vy1_a, vy1_b;
+    vec_s32_t vz0_a, vz0_b, vz1_a, vz1_b;
+    vec_s32_t v32_sw = (vec_s32_t) AVV(128, 128, 128, 128);  /* 1<<(shift-1) */
+
+    vec_u8_t vperm1 = (vec_u8_t) AVV(0x00,0x01,0x02,0x03,0x08,0x09,0x0A,0x0B,0x04,0x05,0x06,0x07,0x0C,0x0D,0x0E,0x0F);
+    vec_u8_t vperm2 = (vec_u8_t) AVV(0x04,0x05,0x06,0x07,0x0C,0x0D,0x0E,0x0F,0x00,0x01,0x02,0x03,0x08,0x09,0x0A,0x0B);
+
+    vec_s16_t vm0 = (vec_s16_t) AVV( 2,  2,  2,  2,   -2, -2, -2, -2);
+    /* 2*(a00, a10, a00, a10, a21, a31, a21, a31) */
+    vec_s16_t vm1 = (vec_s16_t) AVV( 2,  1,  2,  1,    2,  1,  2,  1);
+    /* 2*(a20, a30, a20, a30, a01, a11, a01, a11) */
+    vec_s16_t vm2 = (vec_s16_t) AVV( 2, -1,  2, -1,    2, -1,  2, -1);
+    /* 2*(a02, a12, a02, a12, a23, a33, a23, a33) */
+    vec_s16_t vm3 = (vec_s16_t) AVV(-2,  1, -2,  1,    2, -2,  2, -2);
+    /* 2*(a22, a32, a22, a32, a03, a13, a03, a13) */
+
+    vec_s16_t vn0 = vec_splat_s16(2);
+    /* 2*(b00, b01, b00, b01, b00, b01, b00, b01) */
+    vec_s16_t vn1 = (vec_s16_t) AVV( 2,  1,  2,  1,    2,  1,  2,  1);
+    /* 2*(b02, b03, b02, b03, b02, b03, b02, b03) */
+    vec_s16_t vn2 = (vec_s16_t) AVV( 2,  1,  2,  1,    2,  1,  2,  1);
+    /* 2*(b10, b11, b10, b11, b10, b11, b10, b11) */
+    vec_s16_t vn3 = (vec_s16_t) AVV(-2,- 2, -2, -2,   -2, -2, -2, -2);
+    /* 2*(b12, b13, b12, b13, b12, b13, b12, b13) */
+    vec_s16_t vn4 = (vec_s16_t) AVV( 2, -1,  2, -1,    2, -1,  2, -1);
+    /* 2*(b20, b21, b20, b21, b20, b21, b20, b21) */
+    vec_s16_t vn5 = (vec_s16_t) AVV(-2,  2, -2,  2,   -2,  2, -2,  2);
+    /* 2*(b22, b32, b22, b32, b22, b32, b22, b32) */
+    vec_s16_t vn6 = (vec_s16_t) AVV( 2, -2,  2, -2,    2, -2,  2, -2);
+    /* 2*(b30, b31, b30, b31, b30, b31, b30, b31) */
+    vec_s16_t vn7 = (vec_s16_t) AVV( 2, -1,  2, -1,    2, -1,  2, -1);
+    /* 2*(b32, b33, b32, b33, b32, b33, b32, b33) */
+
+    vload1 = vec_ld(0,block);
+    vload2 = vec_ld(16,block);
+
+    vy0_a = vec_perm(vload1,vload2,vperm1);
+    vy0_b = vec_perm(vload1,vload2,vperm2);
+    vy1_a = vec_perm(vload2,vload1,vperm1);
+    vy1_b = vec_perm(vload2,vload1,vperm2);
+
+    vz0_a = vec_msum(vy0_a,vm0,vzero);
+    vz0_a = vec_msum(vy0_b,vm1,vz0_a);  /* z00, z10, z01, z11 */
+    vz0_b = vec_msum(vy0_a,vm2,vzero);
+    vz0_b = vec_msum(vy0_b,vm3,vz0_b);  /* z02, z12, z03, z13 */
+    vz0 = vec_pack(vz0_a, vz0_b);       /* z00, z10, z01, z11 z02, z12, z03, z13 */
+
+    vz1_a = vec_msum(vy1_a,vm0,vzero);
+    vz1_a = vec_msum(vy1_b,vm1,vz1_a);  /* z20, z30, z21, z31 */
+    vz1_b = vec_msum(vy1_a,vm2,vzero);
+    vz1_b = vec_msum(vy1_b,vm3,vz1_b);  /* z22, z32, z23, z33 */
+    vz1 = vec_pack(vz1_a, vz1_b);       /* z20, z30, z21, z31 z22, z32, z23, z33 */
+
+    va0_sw = vec_msum(vz0,vn0,v32_sw);
+    va0_sw = vec_msum(vz1,vn1,va0_sw);  /* x00, x01, x02, x03 */
+    va1_sw = vec_msum(vz0,vn2,v32_sw);
+    va1_sw = vec_msum(vz1,vn3,va1_sw);  /* x10, x11, x12, x13 */
+    va2_sw = vec_msum(vz0,vn4,v32_sw);
+    va2_sw = vec_msum(vz1,vn5,va2_sw);  /* x20, x21, x22, x23 */
+    va3_sw = vec_msum(vz0,vn6,v32_sw);
+    va3_sw = vec_msum(vz1,vn7,va3_sw);  /* x30, x31, x32, x33 */
+
+    va0 = vec_pack(va0_sw,vzero);       /* x00, x01, x02, x03, 00, 00, 00, 00 */
+    va1 = vec_pack(va1_sw,vzero);       /* x10, x11, x12, x13, 00, 00, 00, 00 */
+    va2 = vec_pack(va2_sw,vzero);       /* x20, x21, x22, x23, 00, 00, 00, 00 */
+    va3 = vec_pack(va3_sw,vzero);       /* x30, x31, x32, x33, 00, 00, 00, 00 */
+
+    va0 = vec_sra(va0,v8us);  /* 6 from the rounding shift +2 for matrix scaling */
+    va1 = vec_sra(va1,v8us);
+    va2 = vec_sra(va2,v8us);
+    va3 = vec_sra(va3,v8us);
+
+    if ((unsigned long)dst & 0xF){
+        vec_u8_t vdst_mask;
+        switch ((unsigned long)dst & 0xF){
+        case 0:
+            dstperm = (vec_u8_t)AVV(0x10, 0x11, 0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
+                                    0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F);
+            break;
+        case 4:
+            dstperm = (vec_u8_t)AVV(0x00, 0x01, 0x02, 0x03, 0x10, 0x11, 0x12, 0x13,
+                                    0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F);
+            break;
+        case 8:
+            dstperm = (vec_u8_t)AVV(0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+                                    0x10, 0x11, 0x12, 0x13, 0x0C, 0x0D, 0x0E, 0x0F);
+            break;
+        case 12:
+            dstperm = (vec_u8_t)AVV(0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+                                    0x08, 0x09, 0x0A, 0x0B, 0x10, 0x11, 0x12, 0x13);
+            break;
+        default:
+            dstperm = (vec_u8_t)AVV(0x10, 0x11, 0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
+                                    0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F);
+            break;
+        }
+
+        vdst_mask = vec_lvsl(0, dst);
+
+        VEC_LOAD_UNALIGNED_U8_ADD_S16_STORE_U8(dst,vdst_mask,va0,dstperm);
+        dst += stride;
+        VEC_LOAD_UNALIGNED_U8_ADD_S16_STORE_U8(dst,vdst_mask,va1,dstperm);
+        dst += stride;
+        VEC_LOAD_UNALIGNED_U8_ADD_S16_STORE_U8(dst,vdst_mask,va2,dstperm);
+        dst += stride;
+        VEC_LOAD_UNALIGNED_U8_ADD_S16_STORE_U8(dst,vdst_mask,va3,dstperm);
+    }
+    else{
+        dstperm = (vec_u8_t)AVV(0x10, 0x11, 0x12, 0x13, 0x04, 0x05, 0x06, 0x07,
+                                0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F);
+
+        VEC_LOAD_U8_ADD_S16_STORE_U8(dst,va0,dstperm);
+        dst += stride;
+        VEC_LOAD_U8_ADD_S16_STORE_U8(dst,va1,dstperm);
+        dst += stride;
+        VEC_LOAD_U8_ADD_S16_STORE_U8(dst,va2,dstperm);
+        dst += stride;
+        VEC_LOAD_U8_ADD_S16_STORE_U8(dst,va3,dstperm);
+    }
+}
+
-#define IDCT8_1D_ALTIVEC(s0, s1, s2, s3, s4, s5, s6, s7,  d0, d1, d2, d3, d4, d5, d6, d7) {\
-    /*        a0  = SRC(0) + SRC(4); */ \
-    vec_s16_t a0v = vec_add(s0, s4);    \
@@ -531 +797 @@
-    c->put_h264_chroma_pixels_tab[0] = put_h264_chroma_mc8_altivec;
-    c->put_no_rnd_h264_chroma_pixels_tab[0] = put_no_rnd_h264_chroma_mc8_altivec;
-    c->avg_h264_chroma_pixels_tab[0] = avg_h264_chroma_mc8_altivec;
+    c->h264_idct_add = ff_h264_idct_add_altivec;
+//    c->h264_idct_add = ff_h264_idct_add_altivec_mat;
-    c->h264_idct8_add = ff_h264_idct8_add_altivec;
-
-#define dspfunc(PFX, IDX, NUM) \