Mercurial > mplayer.hg
changeset 12698:d2aef091743c
altivec yuv->rgb converter
orginal patch by (Marc Hoffman <mmh at pleasantst dot com>)
critical fixes by (Reza Jelveh <reza.jelveh at tu-harburg dot de>)
known bugs/issues, which should be fixed ASAP by someone who has a ppc:
0..255 vs. 16..235
unneeded recalculation of tables
general cleaup, like removing double initalizing of variables
| author | michael |
|---|---|
| date | Sun, 27 Jun 2004 00:07:15 +0000 |
| parents | 86ca4e017ac8 |
| children | 02efc0619f61 |
| files | postproc/Makefile postproc/cs_test.c postproc/swscale.c postproc/swscale_internal.h postproc/swscale_template.c postproc/yuv2rgb.c postproc/yuv2rgb_altivec.c |
| diffstat | 7 files changed, 878 insertions(+), 2 deletions(-) [+] |
line wrap: on
line diff
--- a/postproc/Makefile Sat Jun 26 16:21:22 2004 +0000 +++ b/postproc/Makefile Sun Jun 27 00:07:15 2004 +0000 @@ -4,8 +4,13 @@ SWSLIB = libswscale.a SWSSRCS=swscale.c rgb2rgb.c yuv2rgb.c + SWSOBJS=$(SWSSRCS:.c=.o) +ifeq ($(TARGET_ALTIVEC),yes) +SWSOBJS += yuv2rgb_altivec.o +endif + CFLAGS = $(OPTFLAGS) $(MLIB_INC) -I. -I.. $(EXTRA_INC) # -I/usr/X11R6/include/ @@ -44,3 +49,4 @@ ifneq ($(wildcard .depend),) include .depend endif +
--- a/postproc/cs_test.c Sat Jun 26 16:21:22 2004 +0000 +++ b/postproc/cs_test.c Sun Jun 27 00:07:15 2004 +0000 @@ -28,6 +28,10 @@ #define srcByte 0x55 #define dstByte 0xBB +#ifdef __APPLE_CC__ +#define memalign(x,y) malloc(y) +#endif + static int get_sws_cpuflags() { return (gCpuCaps.hasMMX ? SWS_CPU_CAPS_MMX : 0) | @@ -281,4 +285,4 @@ printf("%d converters passed, %d converters randomly overwrote memory\n", passedNum, failedNum); return failedNum; -} \ No newline at end of file +}
--- a/postproc/swscale.c Sat Jun 26 16:21:22 2004 +0000 +++ b/postproc/swscale.c Sun Jun 27 00:07:15 2004 +0000 @@ -1726,7 +1726,10 @@ yuv2rgb_c_init_tables(c, inv_table, srcRange, brightness, contrast, saturation); //FIXME factorize - + +#ifdef HAVE_ALTIVEC + yuv2rgb_altivec_init_tables (c, inv_table); +#endif return 0; }
--- a/postproc/swscale_internal.h Sat Jun 26 16:21:22 2004 +0000 +++ b/postproc/swscale_internal.h Sun Jun 27 00:07:15 2004 +0000 @@ -132,6 +132,19 @@ int dstW; int esp; uint64_t vRounder __attribute__((aligned(8))); + +#ifdef HAVE_ALTIVEC + + vector signed short CY; + vector signed short CRV; + vector signed short CBU; + vector signed short CGU; + vector signed short CGV; + vector signed short OY; + vector unsigned short CSHIFT; + +#endif + } SwsContext; //FIXME check init (where 0)
--- a/postproc/swscale_template.c Sat Jun 26 16:21:22 2004 +0000 +++ b/postproc/swscale_template.c Sun Jun 27 00:07:15 2004 +0000 @@ -943,9 +943,15 @@ break; #endif default: +#ifdef HAVE_ALTIVEC + altivec_yuv2packedX (c, lumFilter, lumSrc, lumFilterSize, + chrFilter, chrSrc, chrFilterSize, + dest, dstW, dstY); +#else yuv2packedXinC(c, lumFilter, lumSrc, lumFilterSize, chrFilter, chrSrc, chrFilterSize, dest, dstW, dstY); +#endif break; } }
--- a/postproc/yuv2rgb.c Sat Jun 26 16:21:22 2004 +0000 +++ b/postproc/yuv2rgb.c Sun Jun 27 00:07:15 2004 +0000 @@ -607,6 +607,14 @@ if(t) return t; } #endif +#ifdef HAVE_ALTIVEC + if (c->flags & SWS_CPU_CAPS_ALTIVEC) + { + SwsFunc t = yuv2rgb_init_altivec(c); + if(t) return t; + } +#endif + MSG_WARN("No accelerated colorspace conversion found\n"); switch(c->dstFormat){
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/postproc/yuv2rgb_altivec.c Sun Jun 27 00:07:15 2004 +0000 @@ -0,0 +1,836 @@ +/* + marc.hoffman@analog.com March 8, 2004 + + Altivec Acceleration for Color Space Conversion revision 0.2 + + convert I420 YV12 to RGB in various formats, + it rejects images that are not in 420 formats + it rejects images that don't have widths of multiples of 16 + it rejects images that don't have heights of multiples of 2 + reject defers to C simulation codes. + + lots of optimizations to be done here + + 1. need to fix saturation code, I just couldn't get it to fly with packs and adds. + so we currently use max min to clip + + 2. the inefficient use of chroma loading needs a bit of brushing up + + 3. analysis of pipeline stalls needs to be done, use shark to identify pipeline stalls + + + MODIFIED to calculate coeffs from currently selected color space. + MODIFIED core to be a macro which you spec the output format. + ADDED UYVY conversion which is never called due to some thing in SWSCALE. + CORRECTED algorithim selection to be strict on input formats. + ADDED runtime detection of altivec. + + ADDED altivec_yuv2packedX vertical scl + RGB converter + + March 27,2004 + PERFORMANCE ANALYSIS + + The C version use 25% of the processor or ~250Mips for D1 video rawvideo used as test + The ALTIVEC version uses 10% of the processor or ~100Mips for D1 video same sequence + + 720*480*30 ~10MPS + + so we have roughly 10clocks per pixel this is too high something has to be wrong. + + OPTIMIZED clip codes to utilize vec_max and vec_packs removing the need for vec_min. + + OPTIMIZED DST OUTPUT cache/dma controls. we are pretty much + guaranteed to have the input video frame it was just decompressed so + it probably resides in L1 caches. However we are creating the + output video stream this needs to use the DSTST instruction to + optimize for the cache. We couple this with the fact that we are + not going to be visiting the input buffer again so we mark it Least + Recently Used. This shaves 25% of the processor cycles off. + + Now MEMCPY is the largest mips consumer in the system, probably due + to the inefficient X11 stuff. + + GL libraries seem to be very slow on this machine 1.33Ghz PB running + Jaguar, this is not the case for my 1Ghz PB. I thought it might be + a versioning issues, however i have libGL.1.2.dylib for both + machines. ((We need to figure this out now)) + + GL2 libraries work now with patch for RGB32 + + NOTE quartz vo driver ARGB32_to_RGB24 consumes 30% of the processor + + Integrated luma prescaling adjustment for saturation/contrast/brightness adjustment. + +*/ +#include <stdio.h> +#include <stdlib.h> +#include <inttypes.h> +#include <assert.h> +#include "config.h" +#include "rgb2rgb.h" +#include "swscale.h" +#include "swscale_internal.h" +#include "../mangle.h" +#include "../libvo/img_format.h" //FIXME try to reduce dependency of such stuff + +#undef PROFILE_THE_BEAST +#undef INC_SCALING + +typedef unsigned char ubyte; +typedef signed char sbyte; + + +/* RGB interleaver, 16 planar pels 8-bit samples per channel in + homogeneous vector registers x0,x1,x2 are interleaved with the + following technique: + + o0 = vec_mergeh (x0,x1); + o1 = vec_perm (o0, x2, perm_rgb_0); + o2 = vec_perm (o0, x2, perm_rgb_1); + o3 = vec_mergel (x0,x1); + o4 = vec_perm (o3,o2,perm_rgb_2); + o5 = vec_perm (o3,o2,perm_rgb_3); + + perm_rgb_0: o0(RG).h v1(B) --> o1* + 0 1 2 3 4 + rgbr|gbrg|brgb|rgbr + 0010 0100 1001 0010 + 0102 3145 2673 894A + + perm_rgb_1: o0(RG).h v1(B) --> o2 + 0 1 2 3 4 + gbrg|brgb|bbbb|bbbb + 0100 1001 1111 1111 + B5CD 6EF7 89AB CDEF + + perm_rgb_2: o3(RG).l o2(rgbB.l) --> o4* + 0 1 2 3 4 + gbrg|brgb|rgbr|gbrg + 1111 1111 0010 0100 + 89AB CDEF 0182 3945 + + perm_rgb_2: o3(RG).l o2(rgbB.l) ---> o5* + 0 1 2 3 4 + brgb|rgbr|gbrg|brgb + 1001 0010 0100 1001 + a67b 89cA BdCD eEFf + +*/ +static +const vector unsigned char + perm_rgb_0 = (vector unsigned char)(0x00,0x01,0x10,0x02,0x03,0x11,0x04,0x05, + 0x12,0x06,0x07,0x13,0x08,0x09,0x14,0x0a), + perm_rgb_1 = (vector unsigned char)(0x0b,0x15,0x0c,0x0d,0x16,0x0e,0x0f,0x17, + 0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f), + perm_rgb_2 = (vector unsigned char)(0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17, + 0x00,0x01,0x18,0x02,0x03,0x19,0x04,0x05), + perm_rgb_3 = (vector unsigned char)(0x1a,0x06,0x07,0x1b,0x08,0x09,0x1c,0x0a, + 0x0b,0x1d,0x0c,0x0d,0x1e,0x0e,0x0f,0x1f); + +#define vec_merge3(x2,x1,x0,y0,y1,y2) \ +do { \ + typeof(x0) o0,o2,o3; \ + o0 = vec_mergeh (x0,x1); \ + y0 = vec_perm (o0, x2, perm_rgb_0);\ + o2 = vec_perm (o0, x2, perm_rgb_1);\ + o3 = vec_mergel (x0,x1); \ + y1 = vec_perm (o3,o2,perm_rgb_2); \ + y2 = vec_perm (o3,o2,perm_rgb_3); \ +} while(0) + +#define vec_mstrgb24(x0,x1,x2,ptr) \ +do { \ + typeof(x0) _0,_1,_2; \ + vec_merge3 (x0,x1,x2,_0,_1,_2); \ + vec_st (_0, 0, ptr++); \ + vec_st (_1, 0, ptr++); \ + vec_st (_2, 0, ptr++); \ +} while (0); + +#define vec_mstbgr24(x0,x1,x2,ptr) \ +do { \ + typeof(x0) _0,_1,_2; \ + vec_merge3 (x2,x1,x0,_0,_1,_2); \ + vec_st (_0, 0, ptr++); \ + vec_st (_1, 0, ptr++); \ + vec_st (_2, 0, ptr++); \ +} while (0); + +/* pack the pixels in rgb0 format + msb R + lsb 0 +*/ +#define vec_mstrgb32(T,x0,x1,x2,x3,ptr) \ +do { \ + T _0,_1,_2,_3; \ + _0 = vec_mergeh (x0,x1); \ + _1 = vec_mergeh (x2,x3); \ + _2 = (T)vec_mergeh ((vector unsigned short)_0,(vector unsigned short)_1); \ + _3 = (T)vec_mergel ((vector unsigned short)_0,(vector unsigned short)_1); \ + vec_st (_2, 0*16, (T *)ptr); \ + vec_st (_3, 1*16, (T *)ptr); \ + _0 = vec_mergel (x0,x1); \ + _1 = vec_mergel (x2,x3); \ + _2 = (T)vec_mergeh ((vector unsigned short)_0,(vector unsigned short)_1); \ + _3 = (T)vec_mergel ((vector unsigned short)_0,(vector unsigned short)_1); \ + vec_st (_2, 2*16, (T *)ptr); \ + vec_st (_3, 3*16, (T *)ptr); \ + ptr += 4; \ +} while (0); + +/* + + | 1 0 1.4021 | | Y | + | 1 -0.3441 -0.7142 |x| Cb| + | 1 1.7718 0 | | Cr| + + + Y: [-128 127] + Cb/Cr : [-128 127] + + typical yuv conversion work on Y: 0-255 this version has been optimized for jpeg decode. + +*/ + + + + +#define vec_unh(x) \ + (vector signed short) \ + vec_perm(x,(typeof(x))(0),\ + (vector unsigned char)(0x10,0x00,0x10,0x01,0x10,0x02,0x10,0x03,\ + 0x10,0x04,0x10,0x05,0x10,0x06,0x10,0x07)) +#define vec_unl(x) \ + (vector signed short) \ + vec_perm(x,(typeof(x))(0),\ + (vector unsigned char)(0x10,0x08,0x10,0x09,0x10,0x0A,0x10,0x0B,\ + 0x10,0x0C,0x10,0x0D,0x10,0x0E,0x10,0x0F)) + +#define vec_clip(x) \ + vec_max (vec_min (x, (typeof(x))(255)), (typeof(x))(0)) + +#define vec_packclp_a(x,y) \ + (vector unsigned char)vec_pack (vec_clip (x), vec_clip (y)) + +#define vec_packclp(x,y) \ + (vector unsigned char)vec_packs \ + ((vector unsigned short)vec_max (x,(vector signed short) (0)), \ + (vector unsigned short)vec_max (y,(vector signed short) (0))) + +//#define out_pixels(a,b,c,ptr) vec_mstrgb32(typeof(a),((typeof (a))(0)),a,a,a,ptr) + + +static inline cvtyuvtoRGB (SwsContext *c, + vector signed short Y, vector signed short U, vector signed short V, + vector signed short *R, vector signed short *G, vector signed short *B) +{ + vector signed short vx,ux,uvx; + + Y = vec_mradds (Y, c->CY, c->OY); + + U = vec_sub (U,(vector signed short)(128)); + V = vec_sub (V,(vector signed short)(128)); + + // ux = (CBU*(u<<c->CSHIFT)+0x4000)>>15; + ux = vec_sl (U, c->CSHIFT); + *B = vec_mradds (ux, c->CBU, Y); + + // vx = (CRV*(v<<c->CSHIFT)+0x4000)>>15; + vx = vec_sl (V, c->CSHIFT); + *R = vec_mradds (vx, c->CRV, Y); + + // uvx = ((CGU*u) + (CGV*v))>>15; + uvx = vec_mradds (U, c->CGU, Y); + *G = vec_mradds (V, c->CGV, uvx); +} + + +/* + ------------------------------------------------------------------------------ + CS converters + ------------------------------------------------------------------------------ +*/ + + +#define DEFCSP420_CVT(name,out_pixels) \ +static int altivec_##name (SwsContext *c, \ + unsigned char **in, int *instrides, \ + int srcSliceY, int srcSliceH, \ + unsigned char **oplanes, int *outstrides) \ +{ \ + int w = c->srcW; \ + int h = srcSliceH; \ + int i,j; \ + int instrides_scl[3]; \ + vector unsigned char y0,y1; \ + \ + vector signed char u,v; \ + \ + vector signed short Y0,Y1,Y2,Y3; \ + vector signed short U,V; \ + vector signed short vx,ux,uvx; \ + vector signed short vx0,ux0,uvx0; \ + vector signed short vx1,ux1,uvx1; \ + vector signed short R0,G0,B0; \ + vector signed short R1,G1,B1; \ + vector unsigned char R,G,B; \ + \ + vector unsigned char *uivP, *vivP; \ + vector unsigned char align_perm; \ + \ + vector signed short \ + lCY = c->CY, \ + lOY = c->OY, \ + lCRV = c->CRV, \ + lCBU = c->CBU, \ + lCGU = c->CGU, \ + lCGV = c->CGV; \ + \ + vector unsigned short lCSHIFT = c->CSHIFT; \ + \ + ubyte *y1i = in[0]; \ + ubyte *y2i = in[0]+w; \ + ubyte *ui = in[1]; \ + ubyte *vi = in[2]; \ + \ + vector unsigned char *oute \ + = (vector unsigned char *) \ + (oplanes[0]+srcSliceY*outstrides[0]); \ + vector unsigned char *outo \ + = (vector unsigned char *) \ + (oplanes[0]+srcSliceY*outstrides[0]+outstrides[0]); \ + \ + \ + instrides_scl[0] = instrides[0]; \ + instrides_scl[1] = instrides[1]-w/2; /* the loop moves ui by w/2 */ \ + instrides_scl[2] = instrides[2]-w/2; /* the loop moves vi by w/2 */ \ + \ + \ + for (i=0;i<h/2;i++) { \ + vec_dstst (outo, (0x02000002|(((w*3+32)/32)<<16)), 0); \ + vec_dstst (oute, (0x02000002|(((w*3+32)/32)<<16)), 1); \ + \ + for (j=0;j<w/16;j++) { \ + \ + y0 = vec_ldl (0,y1i); \ + y1 = vec_ldl (0,y2i); \ + uivP = (vector unsigned char *)ui; \ + vivP = (vector unsigned char *)vi; \ + \ + align_perm = vec_lvsl (0, ui); \ + u = (vector signed char)vec_perm (uivP[0], uivP[1], align_perm); \ + \ + align_perm = vec_lvsl (0, vi); \ + v = (vector signed char)vec_perm (vivP[0], vivP[1], align_perm); \ + \ + u = (vector signed char)vec_sub (u, (vector signed char)(128)); \ + v = (vector signed char)vec_sub (v, (vector signed char)(128)); \ + U = vec_unpackh (u); \ + V = vec_unpackh (v); \ + \ + \ + Y0 = vec_unh (y0); \ + Y1 = vec_unl (y0); \ + Y2 = vec_unh (y1); \ + Y3 = vec_unl (y1); \ + \ + Y0 = vec_mradds (Y0, lCY, lOY); \ + Y1 = vec_mradds (Y1, lCY, lOY); \ + Y2 = vec_mradds (Y2, lCY, lOY); \ + Y3 = vec_mradds (Y3, lCY, lOY); \ + \ + /* ux = (CBU*(u<<CSHIFT)+0x4000)>>15 */ \ + ux = vec_sl (U, lCSHIFT); \ + ux = vec_mradds (ux, lCBU, (vector signed short)(0)); \ + ux0 = vec_mergeh (ux,ux); \ + ux1 = vec_mergel (ux,ux); \ + \ + /* vx = (CRV*(v<<CSHIFT)+0x4000)>>15; */ \ + vx = vec_sl (V, lCSHIFT); \ + vx = vec_mradds (vx, lCRV, (vector signed short)(0)); \ + vx0 = vec_mergeh (vx,vx); \ + vx1 = vec_mergel (vx,vx); \ + \ + /* uvx = ((CGU*u) + (CGV*v))>>15 */ \ + uvx = vec_mradds (U, lCGU, (vector signed short)(0)); \ + uvx = vec_mradds (V, lCGV, uvx); \ + uvx0 = vec_mergeh (uvx,uvx); \ + uvx1 = vec_mergel (uvx,uvx); \ + \ + R0 = vec_add (Y0,vx0); \ + G0 = vec_add (Y0,uvx0); \ + B0 = vec_add (Y0,ux0); \ + R1 = vec_add (Y1,vx1); \ + G1 = vec_add (Y1,uvx1); \ + B1 = vec_add (Y1,ux1); \ + \ + R = vec_packclp (R0,R1); \ + G = vec_packclp (G0,G1); \ + B = vec_packclp (B0,B1); \ + \ + out_pixels(R,G,B,oute); \ + \ + R0 = vec_add (Y2,vx0); \ + G0 = vec_add (Y2,uvx0); \ + B0 = vec_add (Y2,ux0); \ + R1 = vec_add (Y3,vx1); \ + G1 = vec_add (Y3,uvx1); \ + B1 = vec_add (Y3,ux1); \ + R = vec_packclp (R0,R1); \ + G = vec_packclp (G0,G1); \ + B = vec_packclp (B0,B1); \ + \ + \ + out_pixels(R,G,B,outo); \ + \ + y1i += 16; \ + y2i += 16; \ + ui += 8; \ + vi += 8; \ + \ + } \ + \ + outo += (outstrides[0])>>4; \ + oute += (outstrides[0])>>4; \ + \ + ui += instrides_scl[1]; \ + vi += instrides_scl[2]; \ + y1i += instrides_scl[0]; \ + y2i += instrides_scl[0]; \ + } \ + return srcSliceH; \ +} + + +#define out_abgr(a,b,c,ptr) vec_mstrgb32(typeof(a),((typeof (a))(0)),c,b,a,ptr) +#define out_bgra(a,b,c,ptr) vec_mstrgb32(typeof(a),c,b,a,((typeof (a))(0)),ptr) +#define out_rgba(a,b,c,ptr) vec_mstrgb32(typeof(a),a,b,c,((typeof (a))(0)),ptr) +#define out_argb(a,b,c,ptr) vec_mstrgb32(typeof(a),((typeof (a))(0)),a,b,c,ptr) +#define out_rgb24(a,b,c,ptr) vec_mstrgb24(a,b,c,ptr) +#define out_bgr24(a,b,c,ptr) vec_mstrgb24(c,b,a,ptr) + +DEFCSP420_CVT (yuv2_abgr32, out_abgr) +DEFCSP420_CVT (yuv2_bgra32, out_argb) +DEFCSP420_CVT (yuv2_rgba32, out_rgba) +DEFCSP420_CVT (yuv2_argb32, out_argb) +DEFCSP420_CVT (yuv2_rgb24, out_rgb24) +DEFCSP420_CVT (yuv2_bgr24, out_bgr24) + + +// uyvy|uyvy|uyvy|uyvy +// 0123 4567 89ab cdef +static +const vector unsigned char + demux_u = (vector unsigned char)(0x10,0x00,0x10,0x00, + 0x10,0x04,0x10,0x04, + 0x10,0x08,0x10,0x08, + 0x10,0x0c,0x10,0x0c), + demux_v = (vector unsigned char)(0x10,0x02,0x10,0x02, + 0x10,0x06,0x10,0x06, + 0x10,0x0A,0x10,0x0A, + 0x10,0x0E,0x10,0x0E), + demux_y = (vector unsigned char)(0x10,0x01,0x10,0x03, + 0x10,0x05,0x10,0x07, + 0x10,0x09,0x10,0x0B, + 0x10,0x0D,0x10,0x0F); + +/* + this is so I can play live CCIR raw video +*/ +static int altivec_uyvy_rgb32 (SwsContext *c, + unsigned char **in, int *instrides, + int srcSliceY, int srcSliceH, + unsigned char **oplanes, int *outstrides) +{ + int w = c->srcW; + int h = srcSliceH; + int i,j; + vector unsigned char uyvy; + vector signed short Y,U,V; + vector signed short vx,ux,uvx; + vector signed short R0,G0,B0,R1,G1,B1; + vector unsigned char R,G,B; + vector unsigned char *out; + ubyte *img; + + img = in[0]; + out = (vector unsigned char *)(oplanes[0]+srcSliceY*outstrides[0]); + + for (i=0;i<h;i++) { + for (j=0;j<w/16;j++) { + uyvy = vec_ld (0, img); + U = (vector signed short) + vec_perm (uyvy, (vector unsigned char)(0), demux_u); + + V = (vector signed short) + vec_perm (uyvy, (vector unsigned char)(0), demux_v); + + Y = (vector signed short) + vec_perm (uyvy, (vector unsigned char)(0), demux_y); + + cvtyuvtoRGB (c, Y,U,V,&R0,&G0,&B0); + + uyvy = vec_ld (16, img); + U = (vector signed short) + vec_perm (uyvy, (vector unsigned char)(0), demux_u); + + V = (vector signed short) + vec_perm (uyvy, (vector unsigned char)(0), demux_v); + + Y = (vector signed short) + vec_perm (uyvy, (vector unsigned char)(0), demux_y); + + cvtyuvtoRGB (c, Y,U,V,&R1,&G1,&B1); + + R = vec_packclp (R0,R1); + G = vec_packclp (G0,G1); + B = vec_packclp (B0,B1); + + // vec_mstbgr24 (R,G,B, out); + out_rgba (R,G,B,out); + + img += 32; + } + } +} + + + +/* Ok currently the acceleration routine only supports + inputs of widths a multiple of 16 + and heights a multiple 2 + + So we just fall back to the C codes for this. +*/ +SwsFunc yuv2rgb_init_altivec (SwsContext *c) +{ + if (!(c->flags & SWS_CPU_CAPS_ALTIVEC)) + return NULL; + + /* + and this seems not to matter too much I tried a bunch of + videos with abnormal widths and mplayer crashes else where. + mplayer -vo x11 -rawvideo on:w=350:h=240 raw-350x240.eyuv + boom with X11 bad match. + + */ + if ((c->srcW & 0xf) != 0) return NULL; + + switch (c->srcFormat) { + case IMGFMT_YVU9: + case IMGFMT_IF09: + case IMGFMT_YV12: + case IMGFMT_I420: + case IMGFMT_IYUV: + case IMGFMT_CLPL: + case IMGFMT_Y800: + case IMGFMT_Y8: + case IMGFMT_NV12: + case IMGFMT_NV21: + if ((c->srcH & 0x1) != 0) + return NULL; + + switch(c->dstFormat){ + case IMGFMT_RGB24: + MSG_WARN("ALTIVEC: Color Space RGB24\n"); + return altivec_yuv2_rgb24; + case IMGFMT_BGR24: + MSG_WARN("ALTIVEC: Color Space BGR24\n"); + return altivec_yuv2_bgr24; + case IMGFMT_RGB32: + MSG_WARN("ALTIVEC: Color Space ARGB32\n"); + return altivec_yuv2_argb32; + case IMGFMT_BGR32: + MSG_WARN("ALTIVEC: Color Space BGRA32\n"); + // return profile_altivec_bgra32; + + return altivec_yuv2_bgra32; + default: return NULL; + } + break; + + case IMGFMT_UYVY: + switch(c->dstFormat){ + case IMGFMT_RGB32: + MSG_WARN("ALTIVEC: Color Space UYVY -> RGB32\n"); + return altivec_uyvy_rgb32; + case IMGFMT_RGB24: + case IMGFMT_BGR32: + + default: return NULL; + } + break; + + } + return NULL; +} + + +int yuv2rgb_altivec_init_tables (SwsContext *c, const int inv_table[4]) +{ + + vector signed short + CY = (vector signed short)(0x7fff), + CRV = (vector signed short)(22972), + CBU = (vector signed short)(29029), + CGU = (vector signed short)(-11276), + CGV = (vector signed short)(-23400), + OY; + + vector unsigned short CSHIFT = (vector unsigned short)(1); + + vector signed short Y0; + int brightness = c->brightness, contrast = c->contrast, saturation = c->saturation; + int64_t crv __attribute__ ((aligned(16))); + int64_t cbu __attribute__ ((aligned(16))); + int64_t cgu __attribute__ ((aligned(16))); + int64_t cgv __attribute__ ((aligned(16))); + short tmp __attribute__ ((aligned(16))); + + int64_t cy = (1<<16)-1; + int64_t oy = 0; + + if ((c->flags & SWS_CPU_CAPS_ALTIVEC) == 0) + return; + + crv = inv_table[0]; + cbu = inv_table[1]; + cgu = inv_table[2]; + cgv = inv_table[3]; + +#if 0 + printf ("crv: %hvx\n", CRV); + printf ("cbu: %hvx\n", CBU); + printf ("cgv: %hvx\n", CGV); + printf ("cgu: %hvx\n", CGU); + + printf ("contrast: %d, brightness: %d, saturation: %d\n", contrast, brightness, saturation); + + printf("%lld %lld %lld %lld %lld\n", cy, crv, cbu, cgu, cgv); +#endif + + cy = (cy *contrast )>>17; + crv= (crv*contrast * saturation)>>32; + cbu= (cbu*contrast * saturation)>>32; + cgu= (cgu*contrast * saturation)>>32; + cgv= (cgv*contrast * saturation)>>32; + + oy -= 256*brightness; + + + //printf("%llx %llx %llx %llx %llx\n", cy, crv, cbu, cgu, cgv); + + // vector signed short CBU,CRV,CGU,CGY,CY; + tmp = cy; + CY = vec_lde (0, &tmp); + CY = vec_splat (CY, 0); + + tmp = oy; + OY = vec_lde (0, &tmp); + OY = vec_splat (OY, 0); + + tmp = crv>>3; + CRV = vec_lde (0, &tmp); + CRV = vec_splat (CRV, 0); + tmp = cbu>>3; + CBU = vec_lde (0, &tmp); + CBU = vec_splat (CBU, 0); + + tmp = -(cgu>>1); + CGU = vec_lde (0, &tmp); + CGU = vec_splat (CGU, 0); + tmp = -(cgv>>1); + CGV = vec_lde (0, &tmp); + CGV = vec_splat (CGV, 0); + + CSHIFT = (vector unsigned short)(2); +#if 1 + c->CSHIFT = CSHIFT; + c->CY = CY; + c->OY = OY; + c->CRV = CRV; + c->CBU = CBU; + c->CGU = CGU; + c->CGV = CGV; +#endif +#if 1 + printf ("cy: %hvx\n", CY); + printf ("oy: %hvx\n", OY); + printf ("crv: %hvx\n", CRV); + printf ("cbu: %hvx\n", CBU); + printf ("cgv: %hvx\n", CGV); + printf ("cgu: %hvx\n", CGU); +#endif +} + + +void +altivec_yuv2packedX (SwsContext *c, + int16_t *lumFilter, int16_t **lumSrc, int lumFilterSize, + int16_t *chrFilter, int16_t **chrSrc, int chrFilterSize, + uint8_t *dest, int dstW, int dstY) +{ + int i,j; + short tmp __attribute__((aligned (16))); + short *p; + short *f; + vector signed short X,X0,X1,Y0,U0,V0,Y1,U1,V1,U,V; + vector signed short R0,G0,B0,R1,G1,B1; + + vector unsigned char R,G,B,pels[3]; + vector unsigned char *out,*nout; + vector signed short RND = (vector signed short)(1<<3); + vector unsigned short SCL = (vector unsigned short)(4); + unsigned long scratch[16] __attribute__ ((aligned (16))); + + vector signed short *vYCoeffsBank, *vCCoeffsBank; + + vector signed short *YCoeffs, *CCoeffs; + + vYCoeffsBank = malloc (sizeof (vector signed short)*lumFilterSize*dstW); + vCCoeffsBank = malloc (sizeof (vector signed short)*chrFilterSize*dstW); + + for (i=0;i<lumFilterSize*dstW;i++) { + tmp = c->vLumFilter[i]; + p = &vYCoeffsBank[i]; + for (j=0;j<8;j++) + p[j] = tmp; + } + + for (i=0;i<chrFilterSize*dstW;i++) { + tmp = c->vChrFilter[i]; + p = &vCCoeffsBank[i]; + for (j=0;j<8;j++) + p[j] = tmp; + } + + YCoeffs = vYCoeffsBank+dstY*lumFilterSize; + CCoeffs = vCCoeffsBank+dstY*chrFilterSize; + + out = (vector unsigned char *)dest; + + for(i=0; i<dstW; i+=16){ + Y0 = RND; + Y1 = RND; + /* extract 16 coeffs from lumSrc */ + for(j=0; j<lumFilterSize; j++) { + X0 = vec_ld (0, &lumSrc[j][i]); + X1 = vec_ld (16, &lumSrc[j][i]); + Y0 = vec_mradds (X0, YCoeffs[j], Y0); + Y1 = vec_mradds (X1, YCoeffs[j], Y1); + } + + U = RND; + V = RND; + /* extract 8 coeffs from U,V */ + for(j=0; j<chrFilterSize; j++) { + X = vec_ld (0, &chrSrc[j][i/2]); + U = vec_mradds (X, CCoeffs[j], U); + X = vec_ld (0, &chrSrc[j][i/2+2048]); + V = vec_mradds (X, CCoeffs[j], V); + } + + /* scale and clip signals */ + Y0 = vec_sra (Y0, SCL); + Y1 = vec_sra (Y1, SCL); + U = vec_sra (U, SCL); + V = vec_sra (V, SCL); + + Y0 = vec_clip (Y0); + Y1 = vec_clip (Y1); + U = vec_clip (U); + V = vec_clip (V); + + /* now we have + Y0= y0 y1 y2 y3 y4 y5 y6 y7 Y1= y8 y9 y10 y11 y12 y13 y14 y15 + U= u0 u1 u2 u3 u4 u5 u6 u7 V= v0 v1 v2 v3 v4 v5 v6 v7 + + Y0= y0 y1 y2 y3 y4 y5 y6 y7 Y1= y8 y9 y10 y11 y12 y13 y14 y15 + U0= u0 u0 u1 u1 u2 u2 u3 u3 U1= u4 u4 u5 u5 u6 u6 u7 u7 + V0= v0 v0 v1 v1 v2 v2 v3 v3 V1= v4 v4 v5 v5 v6 v6 v7 v7 + */ + + U0 = vec_mergeh (U,U); + V0 = vec_mergeh (V,V); + + U1 = vec_mergel (U,U); + V1 = vec_mergel (V,V); + + cvtyuvtoRGB (c, Y0,U0,V0,&R0,&G0,&B0); + cvtyuvtoRGB (c, Y1,U1,V1,&R1,&G1,&B1); + + R = vec_packclp (R0,R1); + G = vec_packclp (G0,G1); + B = vec_packclp (B0,B1); + + out_rgba (R,G,B,out); + } + + if (i < dstW) { + i -= 16; + + Y0 = RND; + Y1 = RND; + /* extract 16 coeffs from lumSrc */ + for(j=0; j<lumFilterSize; j++) { + X0 = vec_ld (0, &lumSrc[j][i]); + X1 = vec_ld (16, &lumSrc[j][i]); + Y0 = vec_mradds (X0, YCoeffs[j], Y0); + Y1 = vec_mradds (X1, YCoeffs[j], Y1); + } + + U = RND; + V = RND; + /* extract 8 coeffs from U,V */ + for(j=0; j<chrFilterSize; j++) { + X = vec_ld (0, &chrSrc[j][i/2]); + U = vec_mradds (X, CCoeffs[j], U); + X = vec_ld (0, &chrSrc[j][i/2+2048]); + V = vec_mradds (X, CCoeffs[j], V); + } + + /* scale and clip signals */ + Y0 = vec_sra (Y0, SCL); + Y1 = vec_sra (Y1, SCL); + U = vec_sra (U, SCL); + V = vec_sra (V, SCL); + + Y0 = vec_clip (Y0); + Y1 = vec_clip (Y1); + U = vec_clip (U); + V = vec_clip (V); + + /* now we have + Y0= y0 y1 y2 y3 y4 y5 y6 y7 Y1= y8 y9 y10 y11 y12 y13 y14 y15 + U= u0 u1 u2 u3 u4 u5 u6 u7 V= v0 v1 v2 v3 v4 v5 v6 v7 + + Y0= y0 y1 y2 y3 y4 y5 y6 y7 Y1= y8 y9 y10 y11 y12 y13 y14 y15 + U0= u0 u0 u1 u1 u2 u2 u3 u3 U1= u4 u4 u5 u5 u6 u6 u7 u7 + V0= v0 v0 v1 v1 v2 v2 v3 v3 V1= v4 v4 v5 v5 v6 v6 v7 v7 + */ + + U0 = vec_mergeh (U,U); + V0 = vec_mergeh (V,V); + + U1 = vec_mergel (U,U); + V1 = vec_mergel (V,V); + + cvtyuvtoRGB (c, Y0,U0,V0,&R0,&G0,&B0); + cvtyuvtoRGB (c, Y1,U1,V1,&R1,&G1,&B1); + + R = vec_packclp (R0,R1); + G = vec_packclp (G0,G1); + B = vec_packclp (B0,B1); + + nout = (vector unsigned char *)scratch; + out_rgba (R,G,B,nout); + + memcpy (&((uint32_t*)dest)[i], scratch, (dstW-i)/4); + } + + if (vYCoeffsBank) free (vYCoeffsBank); + if (vCCoeffsBank) free (vCCoeffsBank); + +} + +