• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • Examples
  • File List
  • Globals

libavcodec/ppc/vp8dsp_altivec.c

Go to the documentation of this file.
00001 
00023 #include "libavutil/cpu.h"
00024 #include "libavcodec/vp8dsp.h"
00025 #include "dsputil_altivec.h"
00026 #include "types_altivec.h"
00027 #include "util_altivec.h"
00028 
00029 #define REPT4(...) { __VA_ARGS__, __VA_ARGS__, __VA_ARGS__, __VA_ARGS__ }
00030 
00031 // h subpel filter uses msum to multiply+add 4 pixel taps at once
00032 static const vec_s8 h_subpel_filters_inner[7] =
00033 {
00034     REPT4( -6, 123,  12,  -1),
00035     REPT4(-11, 108,  36,  -8),
00036     REPT4( -9,  93,  50,  -6),
00037     REPT4(-16,  77,  77, -16),
00038     REPT4( -6,  50,  93,  -9),
00039     REPT4( -8,  36, 108, -11),
00040     REPT4( -1,  12, 123,  -6),
00041 };
00042 
00043 // for 6tap filters, these are the outer two taps
00044 // The zeros mask off pixels 4-7 when filtering 0-3
00045 // and vice-versa
00046 static const vec_s8 h_subpel_filters_outer[3] =
00047 {
00048     REPT4(0, 0, 2, 1),
00049     REPT4(0, 0, 3, 3),
00050     REPT4(0, 0, 1, 2),
00051 };
00052 
00053 #define LOAD_H_SUBPEL_FILTER(i) \
00054     vec_s8 filter_inner  = h_subpel_filters_inner[i]; \
00055     vec_s8 filter_outerh = h_subpel_filters_outer[(i)>>1]; \
00056     vec_s8 filter_outerl = vec_sld(filter_outerh, filter_outerh, 2)
00057 
00058 #define FILTER_H(dstv, off) \
00059     a = vec_ld((off)-is6tap-1,    src); \
00060     b = vec_ld((off)-is6tap-1+15, src); \
00061 \
00062     pixh  = vec_perm(a, b, permh##off); \
00063     pixl  = vec_perm(a, b, perml##off); \
00064     filth = vec_msum(filter_inner, pixh, c64); \
00065     filtl = vec_msum(filter_inner, pixl, c64); \
00066 \
00067     if (is6tap) { \
00068         outer = vec_perm(a, b, perm_6tap##off); \
00069         filth = vec_msum(filter_outerh, outer, filth); \
00070         filtl = vec_msum(filter_outerl, outer, filtl); \
00071     } \
00072     if (w == 4) \
00073         filtl = filth; /* discard pixels 4-7 */ \
00074     dstv = vec_packs(filth, filtl); \
00075     dstv = vec_sra(dstv, c7)
00076 
00077 static av_always_inline
00078 void put_vp8_epel_h_altivec_core(uint8_t *dst, int dst_stride,
00079                                  uint8_t *src, int src_stride,
00080                                  int h, int mx, int w, int is6tap)
00081 {
00082     LOAD_H_SUBPEL_FILTER(mx-1);
00083     vec_u8 align_vec0, align_vec8, permh0, permh8, filt;
00084     vec_u8 perm_6tap0, perm_6tap8, perml0, perml8;
00085     vec_u8 a, b, pixh, pixl, outer;
00086     vec_s16 f16h, f16l;
00087     vec_s32 filth, filtl;
00088 
00089     vec_u8 perm_inner6 = { 1,2,3,4, 2,3,4,5, 3,4,5,6, 4,5,6,7 };
00090     vec_u8 perm_inner4 = { 0,1,2,3, 1,2,3,4, 2,3,4,5, 3,4,5,6 };
00091     vec_u8 perm_inner  = is6tap ? perm_inner6 : perm_inner4;
00092     vec_u8 perm_outer = { 4,9, 0,5, 5,10, 1,6, 6,11, 2,7, 7,12, 3,8 };
00093     vec_s32 c64 = vec_sl(vec_splat_s32(1), vec_splat_u32(6));
00094     vec_u16 c7  = vec_splat_u16(7);
00095 
00096     align_vec0 = vec_lvsl( -is6tap-1, src);
00097     align_vec8 = vec_lvsl(8-is6tap-1, src);
00098 
00099     permh0     = vec_perm(align_vec0, align_vec0, perm_inner);
00100     permh8     = vec_perm(align_vec8, align_vec8, perm_inner);
00101     perm_inner = vec_add(perm_inner, vec_splat_u8(4));
00102     perml0     = vec_perm(align_vec0, align_vec0, perm_inner);
00103     perml8     = vec_perm(align_vec8, align_vec8, perm_inner);
00104     perm_6tap0 = vec_perm(align_vec0, align_vec0, perm_outer);
00105     perm_6tap8 = vec_perm(align_vec8, align_vec8, perm_outer);
00106 
00107     while (h --> 0) {
00108         FILTER_H(f16h, 0);
00109 
00110         if (w == 16) {
00111             FILTER_H(f16l, 8);
00112             filt = vec_packsu(f16h, f16l);
00113             vec_st(filt, 0, dst);
00114         } else {
00115             filt = vec_packsu(f16h, f16h);
00116             vec_ste((vec_u32)filt, 0, (uint32_t*)dst);
00117             if (w == 8)
00118                 vec_ste((vec_u32)filt, 4, (uint32_t*)dst);
00119         }
00120         src += src_stride;
00121         dst += dst_stride;
00122     }
00123 }
00124 
00125 // v subpel filter does a simple vertical multiply + add
00126 static const vec_u8 v_subpel_filters[7] =
00127 {
00128     { 0,   6, 123,  12,   1,   0 },
00129     { 2,  11, 108,  36,   8,   1 },
00130     { 0,   9,  93,  50,   6,   0 },
00131     { 3,  16,  77,  77,  16,   3 },
00132     { 0,   6,  50,  93,   9,   0 },
00133     { 1,   8,  36, 108,  11,   2 },
00134     { 0,   1,  12, 123,   6,   0 },
00135 };
00136 
00137 #define LOAD_V_SUBPEL_FILTER(i) \
00138     vec_u8 subpel_filter = v_subpel_filters[i]; \
00139     vec_u8 f0 = vec_splat(subpel_filter, 0); \
00140     vec_u8 f1 = vec_splat(subpel_filter, 1); \
00141     vec_u8 f2 = vec_splat(subpel_filter, 2); \
00142     vec_u8 f3 = vec_splat(subpel_filter, 3); \
00143     vec_u8 f4 = vec_splat(subpel_filter, 4); \
00144     vec_u8 f5 = vec_splat(subpel_filter, 5)
00145 
00146 #define FILTER_V(dstv, vec_mul) \
00147     s1f = (vec_s16)vec_mul(s1, f1); \
00148     s2f = (vec_s16)vec_mul(s2, f2); \
00149     s3f = (vec_s16)vec_mul(s3, f3); \
00150     s4f = (vec_s16)vec_mul(s4, f4); \
00151     s2f = vec_subs(s2f, s1f); \
00152     s3f = vec_subs(s3f, s4f); \
00153     if (is6tap) { \
00154         s0f = (vec_s16)vec_mul(s0, f0); \
00155         s5f = (vec_s16)vec_mul(s5, f5); \
00156         s2f = vec_adds(s2f, s0f); \
00157         s3f = vec_adds(s3f, s5f); \
00158     } \
00159     dstv = vec_adds(s2f, s3f); \
00160     dstv = vec_adds(dstv, c64); \
00161     dstv = vec_sra(dstv, c7)
00162 
00163 static av_always_inline
00164 void put_vp8_epel_v_altivec_core(uint8_t *dst, int dst_stride,
00165                                  uint8_t *src, int src_stride,
00166                                  int h, int my, int w, int is6tap)
00167 {
00168     LOAD_V_SUBPEL_FILTER(my-1);
00169     vec_u8 s0, s1, s2, s3, s4, s5, filt, align_vech, perm_vec, align_vecl;
00170     vec_s16 s0f, s1f, s2f, s3f, s4f, s5f, f16h, f16l;
00171     vec_s16 c64 = vec_sl(vec_splat_s16(1), vec_splat_u16(6));
00172     vec_u16 c7  = vec_splat_u16(7);
00173 
00174     // we want pixels 0-7 to be in the even positions and 8-15 in the odd,
00175     // so combine this permute with the alignment permute vector
00176     align_vech = vec_lvsl(0, src);
00177     align_vecl = vec_sld(align_vech, align_vech, 8);
00178     if (w ==16)
00179         perm_vec = vec_mergeh(align_vech, align_vecl);
00180     else
00181         perm_vec = vec_mergeh(align_vech, align_vech);
00182 
00183     if (is6tap)
00184         s0 = load_with_perm_vec(-2*src_stride, src, perm_vec);
00185     s1 = load_with_perm_vec(-1*src_stride, src, perm_vec);
00186     s2 = load_with_perm_vec( 0*src_stride, src, perm_vec);
00187     s3 = load_with_perm_vec( 1*src_stride, src, perm_vec);
00188     if (is6tap)
00189         s4 = load_with_perm_vec( 2*src_stride, src, perm_vec);
00190 
00191     src += (2+is6tap)*src_stride;
00192 
00193     while (h --> 0) {
00194         if (is6tap)
00195             s5 = load_with_perm_vec(0, src, perm_vec);
00196         else
00197             s4 = load_with_perm_vec(0, src, perm_vec);
00198 
00199         FILTER_V(f16h, vec_mule);
00200 
00201         if (w == 16) {
00202             FILTER_V(f16l, vec_mulo);
00203             filt = vec_packsu(f16h, f16l);
00204             vec_st(filt, 0, dst);
00205         } else {
00206             filt = vec_packsu(f16h, f16h);
00207             if (w == 4)
00208                 filt = (vec_u8)vec_splat((vec_u32)filt, 0);
00209             else
00210                 vec_ste((vec_u32)filt, 4, (uint32_t*)dst);
00211             vec_ste((vec_u32)filt, 0, (uint32_t*)dst);
00212         }
00213 
00214         if (is6tap)
00215             s0 = s1;
00216         s1 = s2;
00217         s2 = s3;
00218         s3 = s4;
00219         if (is6tap)
00220             s4 = s5;
00221 
00222         dst += dst_stride;
00223         src += src_stride;
00224     }
00225 }
00226 
00227 #define EPEL_FUNCS(WIDTH, TAPS) \
00228 static av_noinline \
00229 void put_vp8_epel ## WIDTH ## _h ## TAPS ## _altivec(uint8_t *dst, int dst_stride, uint8_t *src, int src_stride, int h, int mx, int my) \
00230 { \
00231     put_vp8_epel_h_altivec_core(dst, dst_stride, src, src_stride, h, mx, WIDTH, TAPS == 6); \
00232 } \
00233 \
00234 static av_noinline \
00235 void put_vp8_epel ## WIDTH ## _v ## TAPS ## _altivec(uint8_t *dst, int dst_stride, uint8_t *src, int src_stride, int h, int mx, int my) \
00236 { \
00237     put_vp8_epel_v_altivec_core(dst, dst_stride, src, src_stride, h, my, WIDTH, TAPS == 6); \
00238 }
00239 
00240 #define EPEL_HV(WIDTH, HTAPS, VTAPS) \
00241 static void put_vp8_epel ## WIDTH ## _h ## HTAPS ## v ## VTAPS ## _altivec(uint8_t *dst, int stride, uint8_t *src, int s, int h, int mx, int my) \
00242 { \
00243     DECLARE_ALIGNED(16, uint8_t, tmp)[(2*WIDTH+5)*16]; \
00244     if (VTAPS == 6) { \
00245         put_vp8_epel ## WIDTH ## _h ## HTAPS ## _altivec(tmp, 16,     src-2*stride, stride, h+5, mx, my); \
00246         put_vp8_epel ## WIDTH ## _v ## VTAPS ## _altivec(dst, stride, tmp+2*16,     16,     h,   mx, my); \
00247     } else { \
00248         put_vp8_epel ## WIDTH ## _h ## HTAPS ## _altivec(tmp, 16,     src-stride, stride, h+4, mx, my); \
00249         put_vp8_epel ## WIDTH ## _v ## VTAPS ## _altivec(dst, stride, tmp+16,     16,     h,   mx, my); \
00250     } \
00251 }
00252 
00253 EPEL_FUNCS(16,6)
00254 EPEL_FUNCS(8, 6)
00255 EPEL_FUNCS(8, 4)
00256 EPEL_FUNCS(4, 6)
00257 EPEL_FUNCS(4, 4)
00258 
00259 EPEL_HV(16, 6,6)
00260 EPEL_HV(8,  6,6)
00261 EPEL_HV(8,  4,6)
00262 EPEL_HV(8,  6,4)
00263 EPEL_HV(8,  4,4)
00264 EPEL_HV(4,  6,6)
00265 EPEL_HV(4,  4,6)
00266 EPEL_HV(4,  6,4)
00267 EPEL_HV(4,  4,4)
00268 
00269 static void put_vp8_pixels16_altivec(uint8_t *dst, int stride, uint8_t *src, int s, int h, int mx, int my)
00270 {
00271     put_pixels16_altivec(dst, src, stride, h);
00272 }
00273 
00274 av_cold void ff_vp8dsp_init_altivec(VP8DSPContext *c)
00275 {
00276     if (!(av_get_cpu_flags() & AV_CPU_FLAG_ALTIVEC))
00277         return;
00278 
00279     c->put_vp8_epel_pixels_tab[0][0][0] = put_vp8_pixels16_altivec;
00280     c->put_vp8_epel_pixels_tab[0][0][2] = put_vp8_epel16_h6_altivec;
00281     c->put_vp8_epel_pixels_tab[0][2][0] = put_vp8_epel16_v6_altivec;
00282     c->put_vp8_epel_pixels_tab[0][2][2] = put_vp8_epel16_h6v6_altivec;
00283 
00284     c->put_vp8_epel_pixels_tab[1][0][2] = put_vp8_epel8_h6_altivec;
00285     c->put_vp8_epel_pixels_tab[1][2][0] = put_vp8_epel8_v6_altivec;
00286     c->put_vp8_epel_pixels_tab[1][0][1] = put_vp8_epel8_h4_altivec;
00287     c->put_vp8_epel_pixels_tab[1][1][0] = put_vp8_epel8_v4_altivec;
00288 
00289     c->put_vp8_epel_pixels_tab[1][2][2] = put_vp8_epel8_h6v6_altivec;
00290     c->put_vp8_epel_pixels_tab[1][1][1] = put_vp8_epel8_h4v4_altivec;
00291     c->put_vp8_epel_pixels_tab[1][1][2] = put_vp8_epel8_h6v4_altivec;
00292     c->put_vp8_epel_pixels_tab[1][2][1] = put_vp8_epel8_h4v6_altivec;
00293 
00294     c->put_vp8_epel_pixels_tab[2][0][2] = put_vp8_epel4_h6_altivec;
00295     c->put_vp8_epel_pixels_tab[2][2][0] = put_vp8_epel4_v6_altivec;
00296     c->put_vp8_epel_pixels_tab[2][0][1] = put_vp8_epel4_h4_altivec;
00297     c->put_vp8_epel_pixels_tab[2][1][0] = put_vp8_epel4_v4_altivec;
00298 
00299     c->put_vp8_epel_pixels_tab[2][2][2] = put_vp8_epel4_h6v6_altivec;
00300     c->put_vp8_epel_pixels_tab[2][1][1] = put_vp8_epel4_h4v4_altivec;
00301     c->put_vp8_epel_pixels_tab[2][1][2] = put_vp8_epel4_h6v4_altivec;
00302     c->put_vp8_epel_pixels_tab[2][2][1] = put_vp8_epel4_h4v6_altivec;
00303 }

Generated on Wed Apr 11 2012 07:31:34 for FFmpeg by  doxygen 1.7.1