X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libswscale%2Fppc%2Fswscale_altivec.c;h=1630355f51c6b55cf7c4b25a967ee2f9586ad6d4;hb=f4df5039a791a56de85c64e6b9e4448a221b5c40;hp=2fb2337769939b54184bf913872fb9ce33a3cdba;hpb=41cd5af3250ef976f0a48adeb6dbccc9b2683e58;p=ffmpeg diff --git a/libswscale/ppc/swscale_altivec.c b/libswscale/ppc/swscale_altivec.c index 2fb23377699..1630355f51c 100644 --- a/libswscale/ppc/swscale_altivec.c +++ b/libswscale/ppc/swscale_altivec.c @@ -32,34 +32,27 @@ #include "libavutil/ppc/util_altivec.h" #if HAVE_ALTIVEC +#if HAVE_BIGENDIAN #define vzero vec_splat_s32(0) -#if HAVE_BIGENDIAN #define GET_LS(a,b,c,s) {\ vector signed short l2 = vec_ld(((b) << 1) + 16, s);\ ls = vec_perm(a, l2, c);\ a = l2;\ } -#else -#define GET_LS(a,b,c,s) {\ - ls = a;\ - a = vec_vsx_ld(((b) << 1) + 16, s);\ - } -#endif #define yuv2planeX_8(d1, d2, l1, src, x, perm, filter) do {\ vector signed short ls;\ + vector signed int vf1, vf2, i1, i2;\ GET_LS(l1, x, perm, src);\ - vector signed int i1 = vec_mule(filter, ls);\ - vector signed int i2 = vec_mulo(filter, ls);\ - vector signed int vf1, vf2;\ + i1 = vec_mule(filter, ls);\ + i2 = vec_mulo(filter, ls);\ vf1 = vec_mergeh(i1, i2);\ vf2 = vec_mergel(i1, i2);\ d1 = vec_add(d1, vf1);\ d2 = vec_add(d2, vf2);\ } while (0) -#if HAVE_BIGENDIAN #define LOAD_FILTER(vf,f) {\ vector unsigned char perm0 = vec_lvsl(joffset, f);\ vf = vec_ld(joffset, f);\ @@ -69,89 +62,7 @@ p = vec_lvsl(xoffset, s);\ ll1 = vec_ld(xoffset, s);\ } -#else -#define LOAD_FILTER(vf,f) {\ - vf = vec_vsx_ld(joffset, f);\ -} -#define LOAD_L1(ll1,s,p){\ - ll1 = vec_vsx_ld(xoffset, s);\ -} -#endif - -static void yuv2planeX_16_altivec(const int16_t *filter, int filterSize, - const int16_t **src, uint8_t *dest, - const uint8_t *dither, int offset, int x) -{ - register int i, j; - LOCAL_ALIGNED(16, int, val, [16]); - vector signed int vo1, vo2, vo3, vo4; - vector unsigned short vs1, vs2; - vector unsigned char vf; - vector unsigned int altivec_vectorShiftInt19 = - vec_add(vec_splat_u32(10), vec_splat_u32(9)); - - for (i = 0; i < 16; i++) - val[i] = dither[(x + i + offset) & 7] << 12; - - vo1 = vec_ld(0, val); - vo2 = vec_ld(16, val); - vo3 = vec_ld(32, val); - vo4 = vec_ld(48, val); - - for (j = 0; j < filterSize; j++) { - unsigned int joffset=j<<1; - unsigned int xoffset=x<<1; - vector unsigned char perm; - vector signed short l1,vLumFilter; - LOAD_FILTER(vLumFilter,filter); - vLumFilter = vec_splat(vLumFilter, 0); - LOAD_L1(l1,src[j],perm); - yuv2planeX_8(vo1, vo2, l1, src[j], x, perm, vLumFilter); - yuv2planeX_8(vo3, vo4, l1, src[j], x + 8, perm, vLumFilter); - } - - vo1 = vec_sra(vo1, altivec_vectorShiftInt19); - vo2 = vec_sra(vo2, altivec_vectorShiftInt19); - vo3 = vec_sra(vo3, altivec_vectorShiftInt19); - vo4 = vec_sra(vo4, altivec_vectorShiftInt19); - vs1 = vec_packsu(vo1, vo2); - vs2 = vec_packsu(vo3, vo4); - vf = vec_packsu(vs1, vs2); - VEC_ST(vf, 0, dest); -} - -static inline void yuv2planeX_u(const int16_t *filter, int filterSize, - const int16_t **src, uint8_t *dest, int dstW, - const uint8_t *dither, int offset, int x) -{ - int i, j; - - for (i = x; i < dstW; i++) { - int t = dither[(i + offset) & 7] << 12; - for (j = 0; j < filterSize; j++) - t += src[j][i] * filter[j]; - dest[i] = av_clip_uint8(t >> 19); - } -} - -static void yuv2planeX_altivec(const int16_t *filter, int filterSize, - const int16_t **src, uint8_t *dest, int dstW, - const uint8_t *dither, int offset) -{ - int dst_u = -(uintptr_t)dest & 15; - int i; - - yuv2planeX_u(filter, filterSize, src, dest, dst_u, dither, offset, 0); - - for (i = dst_u; i < dstW - 15; i += 16) - yuv2planeX_16_altivec(filter, filterSize, src, dest + i, dither, - offset, i); - - yuv2planeX_u(filter, filterSize, src, dest, dstW, dither, offset, i); -} - -#if HAVE_BIGENDIAN // The 3 above is 2 (filterSize == 4) + 1 (sizeof(short) == 2). // The neat trick: We only care for half the elements, @@ -187,143 +98,141 @@ static void yuv2planeX_altivec(const int16_t *filter, int filterSize, vf1 = vec_ld((a * 2 * filterSize) + (b * 2) + 16 + off, f);\ vf = vec_perm(vf0, vf1, per);\ } -#else /* else of #if HAVE_BIGENDIAN */ -#define GET_VF4(a, vf, f) {\ - vf = (vector signed short)vec_vsx_ld(a << 3, f);\ - vf = vec_mergeh(vf, (vector signed short)vzero);\ + +#define FUNC(name) name ## _altivec +#include "swscale_ppc_template.c" +#undef FUNC + +#undef vzero + +#endif /* HAVE_BIGENDIAN */ + +#define output_pixel(pos, val, bias, signedness) \ + if (big_endian) { \ + AV_WB16(pos, bias + av_clip_ ## signedness ## 16(val >> shift)); \ + } else { \ + AV_WL16(pos, bias + av_clip_ ## signedness ## 16(val >> shift)); \ + } + +static void +yuv2plane1_float_u(const int32_t *src, float *dest, int dstW, int start) +{ + static const int big_endian = HAVE_BIGENDIAN; + static const int shift = 3; + static const float float_mult = 1.0f / 65535.0f; + int i, val; + uint16_t val_uint; + + for (i = start; i < dstW; ++i){ + val = src[i] + (1 << (shift - 1)); + output_pixel(&val_uint, val, 0, uint); + dest[i] = float_mult * (float)val_uint; + } } -#define FIRST_LOAD(sv, pos, s, per) {} -#define UPDATE_PTR(s0, d0, s1, d1) {} -#define LOAD_SRCV(pos, a, s, per, v0, v1, vf) {\ - vf = vec_vsx_ld(pos + a, s);\ + +static void +yuv2plane1_float_bswap_u(const int32_t *src, uint32_t *dest, int dstW, int start) +{ + static const int big_endian = HAVE_BIGENDIAN; + static const int shift = 3; + static const float float_mult = 1.0f / 65535.0f; + int i, val; + uint16_t val_uint; + + for (i = start; i < dstW; ++i){ + val = src[i] + (1 << (shift - 1)); + output_pixel(&val_uint, val, 0, uint); + dest[i] = av_bswap32(av_float2int(float_mult * (float)val_uint)); + } } -#define LOAD_SRCV8(pos, a, s, per, v0, v1, vf) LOAD_SRCV(pos, a, s, per, v0, v1, vf) -#define GET_VFD(a, b, f, vf0, vf1, per, vf, off) {\ - vf = vec_vsx_ld((a * 2 * filterSize) + (b * 2) + off, f);\ + +static void yuv2plane1_float_altivec(const int32_t *src, float *dest, int dstW) +{ + const int dst_u = -(uintptr_t)dest & 3; + const int shift = 3; + const int add = (1 << (shift - 1)); + const int clip = (1 << 16) - 1; + const float fmult = 1.0f / 65535.0f; + const vec_u32 vadd = (vec_u32) {add, add, add, add}; + const vec_u32 vshift = (vec_u32) vec_splat_u32(shift); + const vec_u32 vlargest = (vec_u32) {clip, clip, clip, clip}; + const vec_f vmul = (vec_f) {fmult, fmult, fmult, fmult}; + const vec_f vzero = (vec_f) {0, 0, 0, 0}; + vec_u32 v; + vec_f vd; + int i; + + yuv2plane1_float_u(src, dest, dst_u, 0); + + for (i = dst_u; i < dstW - 3; i += 4) { + v = vec_ld(0, (const uint32_t *) &src[i]); + v = vec_add(v, vadd); + v = vec_sr(v, vshift); + v = vec_min(v, vlargest); + + vd = vec_ctf(v, 0); + vd = vec_madd(vd, vmul, vzero); + + vec_st(vd, 0, &dest[i]); + } + + yuv2plane1_float_u(src, dest, dstW, i); } -#endif /* end of #if HAVE_BIGENDIAN */ -static void hScale_altivec_real(SwsContext *c, int16_t *dst, int dstW, - const uint8_t *src, const int16_t *filter, - const int32_t *filterPos, int filterSize) +static void yuv2plane1_float_bswap_altivec(const int32_t *src, uint32_t *dest, int dstW) { - register int i; - LOCAL_ALIGNED(16, int, tempo, [4]); - - if (filterSize % 4) { - for (i = 0; i < dstW; i++) { - register int j; - register int srcPos = filterPos[i]; - register int val = 0; - for (j = 0; j < filterSize; j++) - val += ((int)src[srcPos + j]) * filter[filterSize * i + j]; - dst[i] = FFMIN(val >> 7, (1 << 15) - 1); - } - } else - switch (filterSize) { - case 4: - for (i = 0; i < dstW; i++) { - register int srcPos = filterPos[i]; - - vector unsigned char src_vF = unaligned_load(srcPos, src); - vector signed short src_v, filter_v; - vector signed int val_vEven, val_s; - src_v = // vec_unpackh sign-extends... - (vector signed short)(VEC_MERGEH((vector unsigned char)vzero, src_vF)); - // now put our elements in the even slots - src_v = vec_mergeh(src_v, (vector signed short)vzero); - GET_VF4(i, filter_v, filter); - val_vEven = vec_mule(src_v, filter_v); - val_s = vec_sums(val_vEven, vzero); - vec_st(val_s, 0, tempo); - dst[i] = FFMIN(tempo[3] >> 7, (1 << 15) - 1); - } - break; - case 8: - for (i = 0; i < dstW; i++) { - register int srcPos = filterPos[i]; - vector unsigned char src_vF, src_v0, src_v1; - vector unsigned char permS; - vector signed short src_v, filter_v; - vector signed int val_v, val_s; - FIRST_LOAD(src_v0, srcPos, src, permS); - LOAD_SRCV8(srcPos, 0, src, permS, src_v0, src_v1, src_vF); - src_v = // vec_unpackh sign-extends... - (vector signed short)(VEC_MERGEH((vector unsigned char)vzero, src_vF)); - filter_v = vec_ld(i << 4, filter); - val_v = vec_msums(src_v, filter_v, (vector signed int)vzero); - val_s = vec_sums(val_v, vzero); - vec_st(val_s, 0, tempo); - dst[i] = FFMIN(tempo[3] >> 7, (1 << 15) - 1); - } - break; - - case 16: - for (i = 0; i < dstW; i++) { - register int srcPos = filterPos[i]; - - vector unsigned char src_vF = unaligned_load(srcPos, src); - vector signed short src_vA = // vec_unpackh sign-extends... - (vector signed short)(VEC_MERGEH((vector unsigned char)vzero, src_vF)); - vector signed short src_vB = // vec_unpackh sign-extends... - (vector signed short)(VEC_MERGEL((vector unsigned char)vzero, src_vF)); - vector signed short filter_v0 = vec_ld(i << 5, filter); - vector signed short filter_v1 = vec_ld((i << 5) + 16, filter); - - vector signed int val_acc = vec_msums(src_vA, filter_v0, (vector signed int)vzero); - vector signed int val_v = vec_msums(src_vB, filter_v1, val_acc); - - vector signed int val_s = vec_sums(val_v, vzero); - - VEC_ST(val_s, 0, tempo); - dst[i] = FFMIN(tempo[3] >> 7, (1 << 15) - 1); - } - break; - - default: - for (i = 0; i < dstW; i++) { - register int j, offset = i * 2 * filterSize; - register int srcPos = filterPos[i]; - - vector signed int val_s, val_v = (vector signed int)vzero; - vector signed short filter_v0R; - vector unsigned char permF, src_v0, permS; - FIRST_LOAD(filter_v0R, offset, filter, permF); - FIRST_LOAD(src_v0, srcPos, src, permS); - - for (j = 0; j < filterSize - 15; j += 16) { - vector unsigned char src_v1, src_vF; - vector signed short filter_v1R, filter_v2R, filter_v0, filter_v1; - LOAD_SRCV(srcPos, j, src, permS, src_v0, src_v1, src_vF); - vector signed short src_vA = // vec_unpackh sign-extends... - (vector signed short)(VEC_MERGEH((vector unsigned char)vzero, src_vF)); - vector signed short src_vB = // vec_unpackh sign-extends... - (vector signed short)(VEC_MERGEL((vector unsigned char)vzero, src_vF)); - GET_VFD(i, j, filter, filter_v0R, filter_v1R, permF, filter_v0, 0); - GET_VFD(i, j, filter, filter_v1R, filter_v2R, permF, filter_v1, 16); - - vector signed int val_acc = vec_msums(src_vA, filter_v0, val_v); - val_v = vec_msums(src_vB, filter_v1, val_acc); - UPDATE_PTR(filter_v2R, filter_v0R, src_v1, src_v0); - } - - if (j < filterSize - 7) { - // loading src_v0 is useless, it's already done above - vector unsigned char src_v1, src_vF; - vector signed short src_v, filter_v1R, filter_v; - LOAD_SRCV8(srcPos, j, src, permS, src_v0, src_v1, src_vF); - src_v = // vec_unpackh sign-extends... - (vector signed short)(VEC_MERGEH((vector unsigned char)vzero, src_vF)); - GET_VFD(i, j, filter, filter_v0R, filter_v1R, permF, filter_v, 0); - val_v = vec_msums(src_v, filter_v, val_v); - } - val_s = vec_sums(val_v, vzero); - - VEC_ST(val_s, 0, tempo); - dst[i] = FFMIN(tempo[3] >> 7, (1 << 15) - 1); - } - } + const int dst_u = -(uintptr_t)dest & 3; + const int shift = 3; + const int add = (1 << (shift - 1)); + const int clip = (1 << 16) - 1; + const float fmult = 1.0f / 65535.0f; + const vec_u32 vadd = (vec_u32) {add, add, add, add}; + const vec_u32 vshift = (vec_u32) vec_splat_u32(shift); + const vec_u32 vlargest = (vec_u32) {clip, clip, clip, clip}; + const vec_f vmul = (vec_f) {fmult, fmult, fmult, fmult}; + const vec_f vzero = (vec_f) {0, 0, 0, 0}; + const vec_u32 vswapbig = (vec_u32) {16, 16, 16, 16}; + const vec_u16 vswapsmall = vec_splat_u16(8); + vec_u32 v; + vec_f vd; + int i; + + yuv2plane1_float_bswap_u(src, dest, dst_u, 0); + + for (i = dst_u; i < dstW - 3; i += 4) { + v = vec_ld(0, (const uint32_t *) &src[i]); + v = vec_add(v, vadd); + v = vec_sr(v, vshift); + v = vec_min(v, vlargest); + + vd = vec_ctf(v, 0); + vd = vec_madd(vd, vmul, vzero); + + vd = (vec_f) vec_rl((vec_u32) vd, vswapbig); + vd = (vec_f) vec_rl((vec_u16) vd, vswapsmall); + + vec_st(vd, 0, (float *) &dest[i]); + } + + yuv2plane1_float_bswap_u(src, dest, dstW, i); } + +#define yuv2plane1_float(template, dest_type, BE_LE) \ +static void yuv2plane1_float ## BE_LE ## _altivec(const int16_t *src, uint8_t *dest, \ + int dstW, \ + const uint8_t *dither, int offset) \ +{ \ + template((const int32_t *)src, (dest_type *)dest, dstW); \ +} + +#if HAVE_BIGENDIAN +yuv2plane1_float(yuv2plane1_float_altivec, float, BE) +yuv2plane1_float(yuv2plane1_float_bswap_altivec, uint32_t, LE) +#else +yuv2plane1_float(yuv2plane1_float_altivec, float, LE) +yuv2plane1_float(yuv2plane1_float_bswap_altivec, uint32_t, BE) +#endif + #endif /* HAVE_ALTIVEC */ av_cold void ff_sws_init_swscale_ppc(SwsContext *c) @@ -334,15 +243,22 @@ av_cold void ff_sws_init_swscale_ppc(SwsContext *c) if (!(av_get_cpu_flags() & AV_CPU_FLAG_ALTIVEC)) return; +#if HAVE_BIGENDIAN if (c->srcBpc == 8 && c->dstBpc <= 14) { - c->hyScale = c->hcScale = hScale_altivec_real; + c->hyScale = c->hcScale = hScale_real_altivec; } - if (!is16BPS(dstFormat) && !isNBPS(dstFormat) && - dstFormat != AV_PIX_FMT_NV12 && dstFormat != AV_PIX_FMT_NV21 && + if (!is16BPS(dstFormat) && !isNBPS(dstFormat) && !isSemiPlanarYUV(dstFormat) && dstFormat != AV_PIX_FMT_GRAYF32BE && dstFormat != AV_PIX_FMT_GRAYF32LE && !c->needAlpha) { c->yuv2planeX = yuv2planeX_altivec; } +#endif + + if (dstFormat == AV_PIX_FMT_GRAYF32BE) { + c->yuv2plane1 = yuv2plane1_floatBE_altivec; + } else if (dstFormat == AV_PIX_FMT_GRAYF32LE) { + c->yuv2plane1 = yuv2plane1_floatLE_altivec; + } /* The following list of supported dstFormat values should * match what's found in the body of ff_yuv2packedX_altivec() */ @@ -369,4 +285,6 @@ av_cold void ff_sws_init_swscale_ppc(SwsContext *c) } } #endif /* HAVE_ALTIVEC */ + + ff_sws_init_swscale_vsx(c); }