From 9f6321117565f9e673c8c6dbfb4104c09272704e Mon Sep 17 00:00:00 2001 From: "Ronald S. Bultje" Date: Tue, 14 Jun 2011 15:02:24 -0400 Subject: swscale: split out RGB48 output functions from yuv2packed[12X]_c(). This is part of the Great Evil Plan to simplify swscale. Note that you'll see some code duplication between the output functions for different RGB variants, and even between packed-YUV and RGB variants. This is intentional because it improves readability. --- libswscale/swscale.c | 323 +++++++++++++++++++++++++++++++++++++-------------- 1 file changed, 235 insertions(+), 88 deletions(-) (limited to 'libswscale/swscale.c') diff --git a/libswscale/swscale.c b/libswscale/swscale.c index a09dba037e..07f2145062 100644 --- a/libswscale/swscale.c +++ b/libswscale/swscale.c @@ -408,6 +408,13 @@ static void yuv2nv12X_c(SwsContext *c, const int16_t *lumFilter, } } +#define output_pixel(pos, val) \ + if (target == PIX_FMT_GRAY16BE) { \ + AV_WB16(pos, val); \ + } else { \ + AV_WL16(pos, val); \ + } + static av_always_inline void yuv2gray16_X_c_template(SwsContext *c, const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize, @@ -418,12 +425,6 @@ yuv2gray16_X_c_template(SwsContext *c, const int16_t *lumFilter, { int i; -#define output_pixel(pos, val) \ - if (target == PIX_FMT_GRAY16BE) { \ - AV_WB16(pos, val); \ - } else { \ - AV_WL16(pos, val); \ - } for (i = 0; i < (dstW >> 1); i++) { int j; int Y1 = 1 << 18; @@ -485,10 +486,11 @@ yuv2gray16_1_c_template(SwsContext *c, const uint16_t *buf0, output_pixel(&dest[2 * i2 + 0], Y1); output_pixel(&dest[2 * i2 + 2], Y2); } -#undef output_pixel } -#define YUV2PACKEDWRAPPER(name, ext, fmt) \ +#undef output_pixel + +#define YUV2PACKEDWRAPPER(name, base, ext, fmt) \ static void name ## ext ## _X_c(SwsContext *c, const int16_t *lumFilter, \ const int16_t **lumSrc, int lumFilterSize, \ const int16_t *chrFilter, const int16_t **chrUSrc, \ @@ -496,7 +498,7 @@ static void name ## ext ## _X_c(SwsContext *c, const int16_t *lumFilter, \ const int16_t **alpSrc, uint8_t *dest, int dstW, \ int y) \ { \ - name ## _X_c_template(c, lumFilter, lumSrc, lumFilterSize, \ + name ## base ## _X_c_template(c, lumFilter, lumSrc, lumFilterSize, \ chrFilter, chrUSrc, chrVSrc, chrFilterSize, \ alpSrc, dest, dstW, y, fmt); \ } \ @@ -508,7 +510,7 @@ static void name ## ext ## _2_c(SwsContext *c, const uint16_t *buf0, \ const uint16_t *abuf1, uint8_t *dest, int dstW, \ int yalpha, int uvalpha, int y) \ { \ - name ## _2_c_template(c, buf0, buf1, ubuf0, ubuf1, \ + name ## base ## _2_c_template(c, buf0, buf1, ubuf0, ubuf1, \ vbuf0, vbuf1, abuf0, abuf1, \ dest, dstW, yalpha, uvalpha, y, fmt); \ } \ @@ -520,13 +522,20 @@ static void name ## ext ## _1_c(SwsContext *c, const uint16_t *buf0, \ int uvalpha, enum PixelFormat dstFormat, \ int flags, int y) \ { \ - name ## _1_c_template(c, buf0, ubuf0, ubuf1, vbuf0, \ + name ## base ## _1_c_template(c, buf0, ubuf0, ubuf1, vbuf0, \ vbuf1, abuf0, dest, dstW, uvalpha, \ dstFormat, flags, y, fmt); \ } -YUV2PACKEDWRAPPER(yuv2gray16, LE, PIX_FMT_GRAY16LE); -YUV2PACKEDWRAPPER(yuv2gray16, BE, PIX_FMT_GRAY16BE); +YUV2PACKEDWRAPPER(yuv2gray16,, LE, PIX_FMT_GRAY16LE); +YUV2PACKEDWRAPPER(yuv2gray16,, BE, PIX_FMT_GRAY16BE); + +#define output_pixel(pos, acc) \ + if (target == PIX_FMT_MONOBLACK) { \ + pos = acc; \ + } else { \ + pos = ~acc; \ + } static av_always_inline void yuv2mono_X_c_template(SwsContext *c, const int16_t *lumFilter, @@ -541,12 +550,6 @@ yuv2mono_X_c_template(SwsContext *c, const int16_t *lumFilter, int i; int acc = 0; -#define output_pixel(pos, acc) \ - if (target == PIX_FMT_MONOBLACK) { \ - pos = acc; \ - } else { \ - pos = ~acc; \ - } for (i = 0; i < dstW - 1; i += 2) { int j; int Y1 = 1 << 18; @@ -620,21 +623,12 @@ yuv2mono_1_c_template(SwsContext *c, const uint16_t *buf0, acc += acc + g[(buf0[i + 7] >> 7) + d128[7]]; output_pixel(*dest++, acc); } -#undef output_pixel } -YUV2PACKEDWRAPPER(yuv2mono, white, PIX_FMT_MONOWHITE); -YUV2PACKEDWRAPPER(yuv2mono, black, PIX_FMT_MONOBLACK); +#undef output_pixel -static av_always_inline void -yuv2422_X_c_template(SwsContext *c, const int16_t *lumFilter, - const int16_t **lumSrc, int lumFilterSize, - const int16_t *chrFilter, const int16_t **chrUSrc, - const int16_t **chrVSrc, int chrFilterSize, - const int16_t **alpSrc, uint8_t *dest, int dstW, - int y, enum PixelFormat target) -{ - int i; +YUV2PACKEDWRAPPER(yuv2mono,, white, PIX_FMT_MONOWHITE); +YUV2PACKEDWRAPPER(yuv2mono,, black, PIX_FMT_MONOBLACK); #define output_pixels(pos, Y1, U, Y2, V) \ if (target == PIX_FMT_YUYV422) { \ @@ -649,6 +643,16 @@ yuv2422_X_c_template(SwsContext *c, const int16_t *lumFilter, dest[pos + 3] = Y2; \ } +static av_always_inline void +yuv2422_X_c_template(SwsContext *c, const int16_t *lumFilter, + const int16_t **lumSrc, int lumFilterSize, + const int16_t *chrFilter, const int16_t **chrUSrc, + const int16_t **chrVSrc, int chrFilterSize, + const int16_t **alpSrc, uint8_t *dest, int dstW, + int y, enum PixelFormat target) +{ + int i; + for (i = 0; i < (dstW >> 1); i++) { int j; int Y1 = 1 << 18; @@ -730,11 +734,157 @@ yuv2422_1_c_template(SwsContext *c, const uint16_t *buf0, output_pixels(i * 4, Y1, U, Y2, V); } } +} + #undef output_pixels + +YUV2PACKEDWRAPPER(yuv2, 422, yuyv422, PIX_FMT_YUYV422); +YUV2PACKEDWRAPPER(yuv2, 422, uyvy422, PIX_FMT_UYVY422); + +#define r_b ((target == PIX_FMT_RGB48LE || target == PIX_FMT_RGB48BE) ? r : b) +#define b_r ((target == PIX_FMT_RGB48LE || target == PIX_FMT_RGB48BE) ? b : r) + +static av_always_inline void +yuv2rgb48_X_c_template(SwsContext *c, const int16_t *lumFilter, + const int16_t **lumSrc, int lumFilterSize, + const int16_t *chrFilter, const int16_t **chrUSrc, + const int16_t **chrVSrc, int chrFilterSize, + const int16_t **alpSrc, uint8_t *dest, int dstW, + int y, enum PixelFormat target) +{ + int i; + + for (i = 0; i < (dstW >> 1); i++) { + int j; + int Y1 = 1 << 18; + int Y2 = 1 << 18; + int U = 1 << 18; + int V = 1 << 18; + const uint8_t *r, *g, *b; + + for (j = 0; j < lumFilterSize; j++) { + Y1 += lumSrc[j][i * 2] * lumFilter[j]; + Y2 += lumSrc[j][i * 2 + 1] * lumFilter[j]; + } + for (j = 0; j < chrFilterSize; j++) { + U += chrUSrc[j][i] * chrFilter[j]; + V += chrVSrc[j][i] * chrFilter[j]; + } + Y1 >>= 19; + Y2 >>= 19; + U >>= 19; + V >>= 19; + if ((Y1 | Y2 | U | V) & 0x100) { + Y1 = av_clip_uint8(Y1); + Y2 = av_clip_uint8(Y2); + U = av_clip_uint8(U); + V = av_clip_uint8(V); + } + + /* FIXME fix tables so that clipping is not needed and then use _NOCLIP*/ + r = (const uint8_t *) c->table_rV[V]; + g = (const uint8_t *)(c->table_gU[U] + c->table_gV[V]); + b = (const uint8_t *) c->table_bU[U]; + + dest[ 0] = dest[ 1] = r_b[Y1]; + dest[ 2] = dest[ 3] = g[Y1]; + dest[ 4] = dest[ 5] = b_r[Y1]; + dest[ 6] = dest[ 7] = r_b[Y2]; + dest[ 8] = dest[ 9] = g[Y2]; + dest[10] = dest[11] = b_r[Y2]; + dest += 12; + } +} + +static av_always_inline void +yuv2rgb48_2_c_template(SwsContext *c, const uint16_t *buf0, + const uint16_t *buf1, const uint16_t *ubuf0, + const uint16_t *ubuf1, const uint16_t *vbuf0, + const uint16_t *vbuf1, const uint16_t *abuf0, + const uint16_t *abuf1, uint8_t *dest, int dstW, + int yalpha, int uvalpha, int y, + enum PixelFormat target) +{ + int yalpha1 = 4095 - yalpha; + int uvalpha1 = 4095 - uvalpha; + int i; + + for (i = 0; i < (dstW >> 1); i++) { + int Y1 = (buf0[i * 2] * yalpha1 + buf1[i * 2] * yalpha) >> 19; + int Y2 = (buf0[i * 2 + 1] * yalpha1 + buf1[i * 2 + 1] * yalpha) >> 19; + int U = (ubuf0[i] * uvalpha1 + ubuf1[i] * uvalpha) >> 19; + int V = (vbuf0[i] * uvalpha1 + vbuf1[i] * uvalpha) >> 19; + const uint8_t *r = (const uint8_t *) c->table_rV[V], + *g = (const uint8_t *)(c->table_gU[U] + c->table_gV[V]), + *b = (const uint8_t *) c->table_bU[U]; + + dest[ 0] = dest[ 1] = r_b[Y1]; + dest[ 2] = dest[ 3] = g[Y1]; + dest[ 4] = dest[ 5] = b_r[Y1]; + dest[ 6] = dest[ 7] = r_b[Y2]; + dest[ 8] = dest[ 9] = g[Y2]; + dest[10] = dest[11] = b_r[Y2]; + dest += 12; + } +} + +static av_always_inline void +yuv2rgb48_1_c_template(SwsContext *c, const uint16_t *buf0, + const uint16_t *ubuf0, const uint16_t *ubuf1, + const uint16_t *vbuf0, const uint16_t *vbuf1, + const uint16_t *abuf0, uint8_t *dest, int dstW, + int uvalpha, enum PixelFormat dstFormat, + int flags, int y, enum PixelFormat target) +{ + int i; + + if (uvalpha < 2048) { + for (i = 0; i < (dstW >> 1); i++) { + int Y1 = buf0[i * 2] >> 7; + int Y2 = buf0[i * 2 + 1] >> 7; + int U = ubuf1[i] >> 7; + int V = vbuf1[i] >> 7; + const uint8_t *r = (const uint8_t *) c->table_rV[V], + *g = (const uint8_t *)(c->table_gU[U] + c->table_gV[V]), + *b = (const uint8_t *) c->table_bU[U]; + + dest[ 0] = dest[ 1] = r_b[Y1]; + dest[ 2] = dest[ 3] = g[Y1]; + dest[ 4] = dest[ 5] = b_r[Y1]; + dest[ 6] = dest[ 7] = r_b[Y2]; + dest[ 8] = dest[ 9] = g[Y2]; + dest[10] = dest[11] = b_r[Y2]; + dest += 12; + } + } else { + for (i = 0; i < (dstW >> 1); i++) { + int Y1 = buf0[i * 2] >> 7; + int Y2 = buf0[i * 2 + 1] >> 7; + int U = (ubuf0[i] + ubuf1[i]) >> 8; + int V = (vbuf0[i] + vbuf1[i]) >> 8; + /* FIXME fix tables so that clipping is not needed and then use _NOCLIP*/ + const uint8_t *r = (const uint8_t *) c->table_rV[V], + *g = (const uint8_t *)(c->table_gU[U] + c->table_gV[V]), + *b = (const uint8_t *) c->table_bU[U]; + + dest[ 0] = dest[ 1] = r_b[Y1]; + dest[ 2] = dest[ 3] = g[Y1]; + dest[ 4] = dest[ 5] = b_r[Y1]; + dest[ 6] = dest[ 7] = r_b[Y2]; + dest[ 8] = dest[ 9] = g[Y2]; + dest[10] = dest[11] = b_r[Y2]; + dest += 12; + } + } } -YUV2PACKEDWRAPPER(yuv2422, yuyv, PIX_FMT_YUYV422); -YUV2PACKEDWRAPPER(yuv2422, uyvy, PIX_FMT_UYVY422); +#undef r_b +#undef b_r + +YUV2PACKEDWRAPPER(yuv2, rgb48, rgb48be, PIX_FMT_RGB48BE); +//YUV2PACKEDWRAPPER(yuv2, rgb48, rgb48le, PIX_FMT_RGB48LE); +YUV2PACKEDWRAPPER(yuv2, rgb48, bgr48be, PIX_FMT_BGR48BE); +//YUV2PACKEDWRAPPER(yuv2, rgb48, bgr48le, PIX_FMT_BGR48LE); #define YSCALE_YUV_2_RGBX_C(type,alpha) \ for (i=0; i<(dstW>>1); i++) {\ @@ -876,36 +1026,6 @@ YUV2PACKEDWRAPPER(yuv2422, uyvy, PIX_FMT_UYVY422); #define YSCALE_YUV_2_ANYRGB_C(func)\ switch(c->dstFormat) {\ - case PIX_FMT_RGB48BE:\ - case PIX_FMT_RGB48LE:\ - func(uint8_t,0)\ - ((uint8_t*)dest)[ 0]= r[Y1];\ - ((uint8_t*)dest)[ 1]= r[Y1];\ - ((uint8_t*)dest)[ 2]= g[Y1];\ - ((uint8_t*)dest)[ 3]= g[Y1];\ - ((uint8_t*)dest)[ 4]= b[Y1];\ - ((uint8_t*)dest)[ 5]= b[Y1];\ - ((uint8_t*)dest)[ 6]= r[Y2];\ - ((uint8_t*)dest)[ 7]= r[Y2];\ - ((uint8_t*)dest)[ 8]= g[Y2];\ - ((uint8_t*)dest)[ 9]= g[Y2];\ - ((uint8_t*)dest)[10]= b[Y2];\ - ((uint8_t*)dest)[11]= b[Y2];\ - dest+=12;\ - }\ - break;\ - case PIX_FMT_BGR48BE:\ - case PIX_FMT_BGR48LE:\ - func(uint8_t,0)\ - ((uint8_t*)dest)[ 0] = ((uint8_t*)dest)[ 1] = b[Y1];\ - ((uint8_t*)dest)[ 2] = ((uint8_t*)dest)[ 3] = g[Y1];\ - ((uint8_t*)dest)[ 4] = ((uint8_t*)dest)[ 5] = r[Y1];\ - ((uint8_t*)dest)[ 6] = ((uint8_t*)dest)[ 7] = b[Y2];\ - ((uint8_t*)dest)[ 8] = ((uint8_t*)dest)[ 9] = g[Y2];\ - ((uint8_t*)dest)[10] = ((uint8_t*)dest)[11] = r[Y2];\ - dest+=12;\ - }\ - break;\ case PIX_FMT_RGBA:\ case PIX_FMT_BGRA:\ if (CONFIG_SMALL) {\ @@ -1196,19 +1316,21 @@ static av_always_inline void fillPlane(uint8_t* plane, int stride, } } +#define input_pixel(pos) (isBE(origin) ? AV_RB16(pos) : AV_RL16(pos)) + +#define r ((origin == PIX_FMT_BGR48BE || origin == PIX_FMT_BGR48LE) ? b_r : r_b) +#define b ((origin == PIX_FMT_BGR48BE || origin == PIX_FMT_BGR48LE) ? r_b : b_r) + static av_always_inline void rgb48ToY_c_template(uint8_t *dst, const uint8_t *src, int width, enum PixelFormat origin) { int i; for (i = 0; i < width; i++) { -#define input_pixel(pos) (isBE(origin) ? AV_RB16(pos) : AV_RL16(pos)) - int a = input_pixel(&src[i*6+0]) >> 8; - int g = input_pixel(&src[i*6+2]) >> 8; - int c = input_pixel(&src[i*6+4]) >> 8; + int r_b = input_pixel(&src[i*6+0]) >> 8; + int g = input_pixel(&src[i*6+2]) >> 8; + int b_r = input_pixel(&src[i*6+4]) >> 8; -#define r ((origin == PIX_FMT_BGR48BE || origin == PIX_FMT_BGR48LE) ? c : a) -#define b ((origin == PIX_FMT_BGR48BE || origin == PIX_FMT_BGR48LE) ? a : c) dst[i] = (RY*r + GY*g + BY*b + (33<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT; } } @@ -1221,9 +1343,9 @@ rgb48ToUV_c_template(uint8_t *dstU, uint8_t *dstV, int i; assert(src1==src2); for (i = 0; i < width; i++) { - int a = input_pixel(&src1[6*i + 0]) >> 8; - int g = input_pixel(&src1[6*i + 2]) >> 8; - int c = input_pixel(&src1[6*i + 4]) >> 8; + int r_b = input_pixel(&src1[i*6+0]) >> 8; + int g = input_pixel(&src1[i*6+2]) >> 8; + int b_r = input_pixel(&src1[i*6+4]) >> 8; dstU[i] = (RU*r + GU*g + BU*b + (257<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT; dstV[i] = (RV*r + GV*g + BV*b + (257<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT; @@ -1238,17 +1360,18 @@ rgb48ToUV_half_c_template(uint8_t *dstU, uint8_t *dstV, int i; assert(src1==src2); for (i = 0; i < width; i++) { - int a = (input_pixel(&src1[12*i + 0]) >> 8) + (input_pixel(&src1[12*i + 6]) >> 8); - int g = (input_pixel(&src1[12*i + 2]) >> 8) + (input_pixel(&src1[12*i + 8]) >> 8); - int c = (input_pixel(&src1[12*i + 4]) >> 8) + (input_pixel(&src1[12*i + 10]) >> 8); + int r_b = (input_pixel(&src1[12*i + 0]) >> 8) + (input_pixel(&src1[12*i + 6]) >> 8); + int g = (input_pixel(&src1[12*i + 2]) >> 8) + (input_pixel(&src1[12*i + 8]) >> 8); + int b_r = (input_pixel(&src1[12*i + 4]) >> 8) + (input_pixel(&src1[12*i + 10]) >> 8); dstU[i]= (RU*r + GU*g + BU*b + (257<> (RGB2YUV_SHIFT+1); dstV[i]= (RV*r + GV*g + BV*b + (257<> (RGB2YUV_SHIFT+1); } +} + #undef r #undef b #undef input_pixel -} #define rgb48funcs(pattern, BE_LE, origin) \ static void pattern ## 48 ## BE_LE ## ToY_c(uint8_t *dst, const uint8_t *src, \ @@ -1276,6 +1399,10 @@ rgb48funcs(rgb, BE, PIX_FMT_RGB48BE); rgb48funcs(bgr, LE, PIX_FMT_BGR48LE); rgb48funcs(bgr, BE, PIX_FMT_BGR48BE); +#define input_pixel(i) ((origin == PIX_FMT_RGBA || origin == PIX_FMT_BGRA || \ + origin == PIX_FMT_ARGB || origin == PIX_FMT_ABGR) ? AV_RN32A(&src[(i)*4]) : \ + (isBE(origin) ? AV_RB16(&src[(i)*2]) : AV_RL16(&src[(i)*2]))) + static av_always_inline void rgb16_32ToY_c_template(uint8_t *dst, const uint8_t *src, int width, enum PixelFormat origin, @@ -1288,9 +1415,6 @@ rgb16_32ToY_c_template(uint8_t *dst, const uint8_t *src, int i; for (i = 0; i < width; i++) { -#define input_pixel(i) ((origin == PIX_FMT_RGBA || origin == PIX_FMT_BGRA || \ - origin == PIX_FMT_ARGB || origin == PIX_FMT_ABGR) ? AV_RN32A(&src[(i)*4]) : \ - (isBE(origin) ? AV_RB16(&src[(i)*2]) : AV_RL16(&src[(i)*2]))) int px = input_pixel(i) >> shp; int b = (px & maskb) >> shb; int g = (px & maskg) >> shg; @@ -1356,9 +1480,10 @@ rgb16_32ToUV_half_c_template(uint8_t *dstU, uint8_t *dstV, dstU[i] = (ru * r + gu * g + bu * b + rnd) >> (S + 1); dstV[i] = (rv * r + gv * g + bv * b + rnd) >> (S + 1); } -#undef input_pixel } +#undef input_pixel + #define rgb16_32_wrapper(fmt, name, shr, shg, shb, shp, maskr, \ maskg, maskb, rsh, gsh, bsh, S) \ static void name ## ToY_c(uint8_t *dst, const uint8_t *src, \ @@ -1545,6 +1670,8 @@ static void nv21ToUV_c(uint8_t *dstU, uint8_t *dstV, nvXXtoUV_c(dstV, dstU, src1, width); } +#define input_pixel(pos) (isBE(origin) ? AV_RB16(pos) : AV_RL16(pos)) + // FIXME Maybe dither instead. static av_always_inline void yuv9_OR_10ToUV_c_template(uint8_t *dstU, uint8_t *dstV, @@ -1555,7 +1682,6 @@ yuv9_OR_10ToUV_c_template(uint8_t *dstU, uint8_t *dstV, const uint16_t *srcU = (const uint16_t *) _srcU; const uint16_t *srcV = (const uint16_t *) _srcV; -#define input_pixel(pos) (isBE(origin) ? AV_RB16(pos) : AV_RL16(pos)) for (i = 0; i < width; i++) { dstU[i] = input_pixel(&srcU[i]) >> (depth - 8); dstV[i] = input_pixel(&srcV[i]) >> (depth - 8); @@ -1571,9 +1697,10 @@ yuv9_or_10ToY_c_template(uint8_t *dstY, const uint8_t *_srcY, for (i = 0; i < width; i++) dstY[i] = input_pixel(&srcY[i]) >> (depth - 8); -#undef input_pixel } +#undef input_pixel + #define YUV_NBPS(depth, BE_LE, origin) \ static void BE_LE ## depth ## ToUV_c(uint8_t *dstU, uint8_t *dstV, \ const uint8_t *srcU, const uint8_t *srcV, \ @@ -1855,14 +1982,34 @@ find_c_packed_planar_out_funcs(SwsContext *c, *yuv2packedX = yuv2monoblack_X_c; break; case PIX_FMT_YUYV422: - *yuv2packed1 = yuv2422yuyv_1_c; - *yuv2packed2 = yuv2422yuyv_2_c; - *yuv2packedX = yuv2422yuyv_X_c; + *yuv2packed1 = yuv2yuyv422_1_c; + *yuv2packed2 = yuv2yuyv422_2_c; + *yuv2packedX = yuv2yuyv422_X_c; break; case PIX_FMT_UYVY422: - *yuv2packed1 = yuv2422uyvy_1_c; - *yuv2packed2 = yuv2422uyvy_2_c; - *yuv2packedX = yuv2422uyvy_X_c; + *yuv2packed1 = yuv2uyvy422_1_c; + *yuv2packed2 = yuv2uyvy422_2_c; + *yuv2packedX = yuv2uyvy422_X_c; + break; + case PIX_FMT_RGB48LE: + //*yuv2packed1 = yuv2rgb48le_1_c; + //*yuv2packed2 = yuv2rgb48le_2_c; + //*yuv2packedX = yuv2rgb48le_X_c; + //break; + case PIX_FMT_RGB48BE: + *yuv2packed1 = yuv2rgb48be_1_c; + *yuv2packed2 = yuv2rgb48be_2_c; + *yuv2packedX = yuv2rgb48be_X_c; + break; + case PIX_FMT_BGR48LE: + //*yuv2packed1 = yuv2bgr48le_1_c; + //*yuv2packed2 = yuv2bgr48le_2_c; + //*yuv2packedX = yuv2bgr48le_X_c; + //break; + case PIX_FMT_BGR48BE: + *yuv2packed1 = yuv2bgr48be_1_c; + *yuv2packed2 = yuv2bgr48be_2_c; + *yuv2packedX = yuv2bgr48be_X_c; break; default: *yuv2packed1 = yuv2packed1_c; -- cgit v1.2.3