libextractor: swscale_internal.h File Reference

#define BLUE_DITHER "2*8"

Definition at line 114 of file swscale_internal.h.

#define CHR_MMX_FILTER_OFFSET "11*8+4*4*256"

Definition at line 124 of file swscale_internal.h.

Referenced by yuv2yuvX().

#define DSTW_OFFSET "11*8+4*4*256*2"

Definition at line 125 of file swscale_internal.h.

#define ESP_OFFSET "11*8+4*4*256*2+8"

Definition at line 126 of file swscale_internal.h.

Referenced by yuv2packed1(), and yuv2packed2().

#define GREEN_DITHER "1*8"

Definition at line 113 of file swscale_internal.h.

#define isBGR ( x )

Value:

(           \
           (x)==PIX_FMT_RGB32       \
        || (x)==PIX_FMT_BGR24       \
        || (x)==PIX_FMT_BGR565      \
        || (x)==PIX_FMT_BGR555      \
        || (x)==PIX_FMT_BGR8        \
        || (x)==PIX_FMT_BGR4        \
        || (x)==PIX_FMT_BGR4_BYTE   \
        || (x)==PIX_FMT_MONOBLACK   \
    )

Definition at line 233 of file swscale_internal.h.

Referenced by yuv2rgb_c_init_tables().

#define isGray ( x )

Value:

(           \
           (x)==PIX_FMT_GRAY8       \
        || (x)==PIX_FMT_GRAY16BE    \
        || (x)==PIX_FMT_GRAY16LE    \
    )

Definition at line 214 of file swscale_internal.h.

Referenced by hcscale(), and swScale().

#define isGray16 ( x )

Value:

(           \
           (x)==PIX_FMT_GRAY16BE    \
        || (x)==PIX_FMT_GRAY16LE    \
    )

Definition at line 219 of file swscale_internal.h.

#define isPlanarYUV ( x )

Value:

(           \
           (x)==PIX_FMT_YUV410P     \
        || (x)==PIX_FMT_YUV420P     \
        || (x)==PIX_FMT_YUV411P     \
        || (x)==PIX_FMT_YUV422P     \
        || (x)==PIX_FMT_YUV444P     \
        || (x)==PIX_FMT_YUV440P     \
        || (x)==PIX_FMT_NV12        \
        || (x)==PIX_FMT_NV21        \
    )

Definition at line 199 of file swscale_internal.h.

Referenced by swScale().

#define isRGB ( x )

Value:

(           \
           (x)==PIX_FMT_BGR32       \
        || (x)==PIX_FMT_RGB24       \
        || (x)==PIX_FMT_RGB565      \
        || (x)==PIX_FMT_RGB555      \
        || (x)==PIX_FMT_RGB8        \
        || (x)==PIX_FMT_RGB4        \
        || (x)==PIX_FMT_RGB4_BYTE   \
        || (x)==PIX_FMT_MONOBLACK   \
    )

Definition at line 223 of file swscale_internal.h.

#define isYUV ( x )

Value:

(           \
           (x)==PIX_FMT_UYVY422     \
        || (x)==PIX_FMT_YUYV422     \
        || isPlanarYUV(x)           \
    )

Definition at line 209 of file swscale_internal.h.

#define LUM_MMX_FILTER_OFFSET "11*8"

Definition at line 123 of file swscale_internal.h.

Referenced by yuv2yuvX().

#define MAX_FILTER_SIZE 256

Definition at line 32 of file swscale_internal.h.

#define RED_DITHER "0*8"

Definition at line 112 of file swscale_internal.h.

#define U_OFFSET "9*8"

Definition at line 121 of file swscale_internal.h.

#define U_TEMP "11*8+4*4*256*2+24"

Definition at line 128 of file swscale_internal.h.

#define UB_COEFF "5*8"

Definition at line 117 of file swscale_internal.h.

#define UG_COEFF "7*8"

Definition at line 119 of file swscale_internal.h.

#define V_OFFSET "10*8"

Definition at line 122 of file swscale_internal.h.

#define V_TEMP "11*8+4*4*256*2+32"

Definition at line 129 of file swscale_internal.h.

#define VG_COEFF "6*8"

Definition at line 118 of file swscale_internal.h.

#define VOF (VOFW*2)

Definition at line 35 of file swscale_internal.h.

Referenced by hcscale(), and yuv2yuvX().

#define VOFW 8192

Definition at line 34 of file swscale_internal.h.

Referenced by hcscale(), yuv2nv12XinC(), yuv2packed2(), yuv2yuv1(), and yuv2yuvXinC().

#define VR_COEFF "4*8"

Definition at line 116 of file swscale_internal.h.

#define VROUNDER_OFFSET "11*8+4*4*256*2+16"

Definition at line 127 of file swscale_internal.h.

#define Y_COEFF "3*8"

Definition at line 115 of file swscale_internal.h.

#define Y_OFFSET "8*8"

Definition at line 120 of file swscale_internal.h.

typedef int(*) SwsFunc(struct SwsContext *context, uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])

Definition at line 37 of file swscale_internal.h.

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
	)

Definition at line 792 of file yuv2rgb_altivec.c.

References __attribute__(), av_log(), AV_LOG_ERROR, B, B0, B1, c, cvtyuvtoRGB(), G, out_abgr, out_argb, out_bgr24, out_bgra, out_rgb24, out_rgba, PIX_FMT_ABGR, PIX_FMT_ARGB, PIX_FMT_BGR24, PIX_FMT_BGRA, PIX_FMT_RGB24, PIX_FMT_RGBA, R, R0, R1, sws_format_name(), V, vec_clip_s16, and vec_packclp.

Referenced by yuv2packedX().

00796 {
00797     int i,j;
00798     vector signed short X,X0,X1,Y0,U0,V0,Y1,U1,V1,U,V;
00799     vector signed short R0,G0,B0,R1,G1,B1;
00800 
00801     vector unsigned char R,G,B;
00802     vector unsigned char *out,*nout;
00803 
00804     vector signed short   RND = vec_splat_s16(1<<3);
00805     vector unsigned short SCL = vec_splat_u16(4);
00806     unsigned long scratch[16] __attribute__ ((aligned (16)));
00807 
00808     vector signed short *YCoeffs, *CCoeffs;
00809 
00810     YCoeffs = c->vYCoeffsBank+dstY*lumFilterSize;
00811     CCoeffs = c->vCCoeffsBank+dstY*chrFilterSize;
00812 
00813     out = (vector unsigned char *)dest;
00814 
00815     for (i=0; i<dstW; i+=16){
00816         Y0 = RND;
00817         Y1 = RND;
00818         /* extract 16 coeffs from lumSrc */
00819         for (j=0; j<lumFilterSize; j++) {
00820             X0 = vec_ld (0,  &lumSrc[j][i]);
00821             X1 = vec_ld (16, &lumSrc[j][i]);
00822             Y0 = vec_mradds (X0, YCoeffs[j], Y0);
00823             Y1 = vec_mradds (X1, YCoeffs[j], Y1);
00824         }
00825 
00826         U = RND;
00827         V = RND;
00828         /* extract 8 coeffs from U,V */
00829         for (j=0; j<chrFilterSize; j++) {
00830             X  = vec_ld (0, &chrSrc[j][i/2]);
00831             U  = vec_mradds (X, CCoeffs[j], U);
00832             X  = vec_ld (0, &chrSrc[j][i/2+2048]);
00833             V  = vec_mradds (X, CCoeffs[j], V);
00834         }
00835 
00836         /* scale and clip signals */
00837         Y0 = vec_sra (Y0, SCL);
00838         Y1 = vec_sra (Y1, SCL);
00839         U  = vec_sra (U,  SCL);
00840         V  = vec_sra (V,  SCL);
00841 
00842         Y0 = vec_clip_s16 (Y0);
00843         Y1 = vec_clip_s16 (Y1);
00844         U  = vec_clip_s16 (U);
00845         V  = vec_clip_s16 (V);
00846 
00847         /* now we have
00848           Y0= y0 y1 y2 y3 y4 y5 y6 y7     Y1= y8 y9 y10 y11 y12 y13 y14 y15
00849           U= u0 u1 u2 u3 u4 u5 u6 u7      V= v0 v1 v2 v3 v4 v5 v6 v7
00850 
00851           Y0= y0 y1 y2 y3 y4 y5 y6 y7    Y1= y8 y9 y10 y11 y12 y13 y14 y15
00852           U0= u0 u0 u1 u1 u2 u2 u3 u3    U1= u4 u4 u5 u5 u6 u6 u7 u7
00853           V0= v0 v0 v1 v1 v2 v2 v3 v3    V1= v4 v4 v5 v5 v6 v6 v7 v7
00854         */
00855 
00856         U0 = vec_mergeh (U,U);
00857         V0 = vec_mergeh (V,V);
00858 
00859         U1 = vec_mergel (U,U);
00860         V1 = vec_mergel (V,V);
00861 
00862         cvtyuvtoRGB (c, Y0,U0,V0,&R0,&G0,&B0);
00863         cvtyuvtoRGB (c, Y1,U1,V1,&R1,&G1,&B1);
00864 
00865         R  = vec_packclp (R0,R1);
00866         G  = vec_packclp (G0,G1);
00867         B  = vec_packclp (B0,B1);
00868 
00869         switch(c->dstFormat) {
00870             case PIX_FMT_ABGR:  out_abgr  (R,G,B,out); break;
00871             case PIX_FMT_BGRA:  out_bgra  (R,G,B,out); break;
00872             case PIX_FMT_RGBA:  out_rgba  (R,G,B,out); break;
00873             case PIX_FMT_ARGB:  out_argb  (R,G,B,out); break;
00874             case PIX_FMT_RGB24: out_rgb24 (R,G,B,out); break;
00875             case PIX_FMT_BGR24: out_bgr24 (R,G,B,out); break;
00876             default:
00877             {
00878                 /* If this is reached, the caller should have called yuv2packedXinC
00879                    instead. */
00880                 static int printed_error_message;
00881                 if (!printed_error_message) {
00882                     av_log(c, AV_LOG_ERROR, "altivec_yuv2packedX doesn't support %s output\n",
00883                            sws_format_name(c->dstFormat));
00884                     printed_error_message=1;
00885                 }
00886                 return;
00887             }
00888         }
00889     }
00890 
00891     if (i < dstW) {
00892         i -= 16;
00893 
00894         Y0 = RND;
00895         Y1 = RND;
00896         /* extract 16 coeffs from lumSrc */
00897         for (j=0; j<lumFilterSize; j++) {
00898             X0 = vec_ld (0,  &lumSrc[j][i]);
00899             X1 = vec_ld (16, &lumSrc[j][i]);
00900             Y0 = vec_mradds (X0, YCoeffs[j], Y0);
00901             Y1 = vec_mradds (X1, YCoeffs[j], Y1);
00902         }
00903 
00904         U = RND;
00905         V = RND;
00906         /* extract 8 coeffs from U,V */
00907         for (j=0; j<chrFilterSize; j++) {
00908             X  = vec_ld (0, &chrSrc[j][i/2]);
00909             U  = vec_mradds (X, CCoeffs[j], U);
00910             X  = vec_ld (0, &chrSrc[j][i/2+2048]);
00911             V  = vec_mradds (X, CCoeffs[j], V);
00912         }
00913 
00914         /* scale and clip signals */
00915         Y0 = vec_sra (Y0, SCL);
00916         Y1 = vec_sra (Y1, SCL);
00917         U  = vec_sra (U,  SCL);
00918         V  = vec_sra (V,  SCL);
00919 
00920         Y0 = vec_clip_s16 (Y0);
00921         Y1 = vec_clip_s16 (Y1);
00922         U  = vec_clip_s16 (U);
00923         V  = vec_clip_s16 (V);
00924 
00925         /* now we have
00926            Y0= y0 y1 y2 y3 y4 y5 y6 y7     Y1= y8 y9 y10 y11 y12 y13 y14 y15
00927            U = u0 u1 u2 u3 u4 u5 u6 u7     V = v0 v1 v2 v3 v4 v5 v6 v7
00928 
00929            Y0= y0 y1 y2 y3 y4 y5 y6 y7    Y1= y8 y9 y10 y11 y12 y13 y14 y15
00930            U0= u0 u0 u1 u1 u2 u2 u3 u3    U1= u4 u4 u5 u5 u6 u6 u7 u7
00931            V0= v0 v0 v1 v1 v2 v2 v3 v3    V1= v4 v4 v5 v5 v6 v6 v7 v7
00932         */
00933 
00934         U0 = vec_mergeh (U,U);
00935         V0 = vec_mergeh (V,V);
00936 
00937         U1 = vec_mergel (U,U);
00938         V1 = vec_mergel (V,V);
00939 
00940         cvtyuvtoRGB (c, Y0,U0,V0,&R0,&G0,&B0);
00941         cvtyuvtoRGB (c, Y1,U1,V1,&R1,&G1,&B1);
00942 
00943         R  = vec_packclp (R0,R1);
00944         G  = vec_packclp (G0,G1);
00945         B  = vec_packclp (B0,B1);
00946 
00947         nout = (vector unsigned char *)scratch;
00948         switch(c->dstFormat) {
00949             case PIX_FMT_ABGR:  out_abgr  (R,G,B,nout); break;
00950             case PIX_FMT_BGRA:  out_bgra  (R,G,B,nout); break;
00951             case PIX_FMT_RGBA:  out_rgba  (R,G,B,nout); break;
00952             case PIX_FMT_ARGB:  out_argb  (R,G,B,nout); break;
00953             case PIX_FMT_RGB24: out_rgb24 (R,G,B,nout); break;
00954             case PIX_FMT_BGR24: out_bgr24 (R,G,B,nout); break;
00955             default:
00956                 /* Unreachable, I think. */
00957                 av_log(c, AV_LOG_ERROR, "altivec_yuv2packedX doesn't support %s output\n",
00958                        sws_format_name(c->dstFormat));
00959                 return;
00960         }
00961 
00962         memcpy (&((uint32_t*)dest)[i], scratch, (dstW-i)/4);
00963     }
00964 
00965 }

const DECLARE_ALIGNED	(	8	,
		uint64_t	,
		ff_dither8	[2]
	)

const DECLARE_ALIGNED	(	8	,
		uint64_t	,
		ff_dither4	[2]
	)

static int fmt_depth ( int fmt ) [inline, static]

Definition at line 244 of file swscale_internal.h.

References PIX_FMT_ABGR, PIX_FMT_ARGB, PIX_FMT_BGR24, PIX_FMT_BGR4, PIX_FMT_BGR4_BYTE, PIX_FMT_BGR555, PIX_FMT_BGR565, PIX_FMT_BGR8, PIX_FMT_BGRA, PIX_FMT_GRAY16BE, PIX_FMT_GRAY16LE, PIX_FMT_MONOBLACK, PIX_FMT_RGB24, PIX_FMT_RGB4, PIX_FMT_RGB4_BYTE, PIX_FMT_RGB555, PIX_FMT_RGB565, PIX_FMT_RGB8, and PIX_FMT_RGBA.

Referenced by yuv2rgb_c_init_tables().

00245 {
00246     switch(fmt) {
00247         case PIX_FMT_BGRA:
00248         case PIX_FMT_ABGR:
00249         case PIX_FMT_RGBA:
00250         case PIX_FMT_ARGB:
00251             return 32;
00252         case PIX_FMT_BGR24:
00253         case PIX_FMT_RGB24:
00254             return 24;
00255         case PIX_FMT_BGR565:
00256         case PIX_FMT_RGB565:
00257         case PIX_FMT_GRAY16BE:
00258         case PIX_FMT_GRAY16LE:
00259             return 16;
00260         case PIX_FMT_BGR555:
00261         case PIX_FMT_RGB555:
00262             return 15;
00263         case PIX_FMT_BGR8:
00264         case PIX_FMT_RGB8:
00265             return 8;
00266         case PIX_FMT_BGR4:
00267         case PIX_FMT_RGB4:
00268         case PIX_FMT_BGR4_BYTE:
00269         case PIX_FMT_RGB4_BYTE:
00270             return 4;
00271         case PIX_FMT_MONOBLACK:
00272             return 1;
00273         default:
00274             return 0;
00275     }
00276 }

const char* sws_format_name ( int format )

void yuv2rgb_altivec_init_tables	(	SwsContext *	c,
		const int	inv_table[4],
		int	brightness,
		int	contrast,
		int	saturation
	)

Definition at line 756 of file yuv2rgb_altivec.c.

References __attribute__(), c, and printf.

00757 {
00758     union {
00759         signed short tmp[8] __attribute__ ((aligned(16)));
00760         vector signed short vec;
00761     } buf;
00762 
00763     buf.tmp[0] =  ((0xffffLL) * contrast>>8)>>9;                        //cy
00764     buf.tmp[1] =  -256*brightness;                                      //oy
00765     buf.tmp[2] =  (inv_table[0]>>3) *(contrast>>16)*(saturation>>16);   //crv
00766     buf.tmp[3] =  (inv_table[1]>>3) *(contrast>>16)*(saturation>>16);   //cbu
00767     buf.tmp[4] = -((inv_table[2]>>1)*(contrast>>16)*(saturation>>16));  //cgu
00768     buf.tmp[5] = -((inv_table[3]>>1)*(contrast>>16)*(saturation>>16));  //cgv
00769 
00770 
00771     c->CSHIFT = (vector unsigned short)vec_splat_u16(2);
00772     c->CY   = vec_splat ((vector signed short)buf.vec, 0);
00773     c->OY   = vec_splat ((vector signed short)buf.vec, 1);
00774     c->CRV  = vec_splat ((vector signed short)buf.vec, 2);
00775     c->CBU  = vec_splat ((vector signed short)buf.vec, 3);
00776     c->CGU  = vec_splat ((vector signed short)buf.vec, 4);
00777     c->CGV  = vec_splat ((vector signed short)buf.vec, 5);
00778 #if 0
00779     {
00780     int i;
00781     char *v[6]={"cy","oy","crv","cbu","cgu","cgv"};
00782     for (i=0; i<6; i++)
00783         printf("%s %d ", v[i],buf.tmp[i] );
00784         printf("\n");
00785     }
00786 #endif
00787     return;
00788 }

int yuv2rgb_c_init_tables	(	SwsContext *	c,
		const int	inv_table[4],
		int	fullRange,
		int	brightness,
		int	contrast,
		int	saturation
	)

Definition at line 676 of file yuv2rgb.c.

References av_free(), av_log(), AV_LOG_ERROR, av_malloc(), c, div_round(), fmt_depth(), isBGR, and NULL.

00677 {
00678     const int isRgb = isBGR(c->dstFormat);
00679     const int bpp = fmt_depth(c->dstFormat);
00680     int i;
00681     uint8_t table_Y[1024];
00682     uint32_t *table_32 = 0;
00683     uint16_t *table_16 = 0;
00684     uint8_t *table_8 = 0;
00685     uint8_t *table_332 = 0;
00686     uint8_t *table_121 = 0;
00687     uint8_t *table_1 = 0;
00688     int entry_size = 0;
00689     void *table_r = 0, *table_g = 0, *table_b = 0;
00690     void *table_start;
00691 
00692     int64_t crv =  inv_table[0];
00693     int64_t cbu =  inv_table[1];
00694     int64_t cgu = -inv_table[2];
00695     int64_t cgv = -inv_table[3];
00696     int64_t cy  = 1<<16;
00697     int64_t oy  = 0;
00698 
00699 //printf("%lld %lld %lld %lld %lld\n", cy, crv, cbu, cgu, cgv);
00700     if (!fullRange){
00701         cy= (cy*255) / 219;
00702         oy= 16<<16;
00703     }else{
00704         crv= (crv*224) / 255;
00705         cbu= (cbu*224) / 255;
00706         cgu= (cgu*224) / 255;
00707         cgv= (cgv*224) / 255;
00708     }
00709 
00710     cy = (cy *contrast             )>>16;
00711     crv= (crv*contrast * saturation)>>32;
00712     cbu= (cbu*contrast * saturation)>>32;
00713     cgu= (cgu*contrast * saturation)>>32;
00714     cgv= (cgv*contrast * saturation)>>32;
00715 //printf("%lld %lld %lld %lld %lld\n", cy, crv, cbu, cgu, cgv);
00716     oy -= 256*brightness;
00717 
00718     for (i = 0; i < 1024; i++) {
00719         int j;
00720 
00721         j= (cy*(((i - 384)<<16) - oy) + (1<<31))>>32;
00722         j = (j < 0) ? 0 : ((j > 255) ? 255 : j);
00723         table_Y[i] = j;
00724     }
00725 
00726     switch (bpp) {
00727     case 32:
00728         table_start= table_32 = av_malloc ((197 + 2*682 + 256 + 132) * sizeof (uint32_t));
00729 
00730         entry_size = sizeof (uint32_t);
00731         table_r = table_32 + 197;
00732         table_b = table_32 + 197 + 685;
00733         table_g = table_32 + 197 + 2*682;
00734 
00735         for (i = -197; i < 256+197; i++)
00736             ((uint32_t *)table_r)[i] = table_Y[i+384] << (isRgb ? 16 : 0);
00737         for (i = -132; i < 256+132; i++)
00738             ((uint32_t *)table_g)[i] = table_Y[i+384] << 8;
00739         for (i = -232; i < 256+232; i++)
00740             ((uint32_t *)table_b)[i] = table_Y[i+384] << (isRgb ? 0 : 16);
00741         break;
00742 
00743     case 24:
00744         table_start= table_8 = av_malloc ((256 + 2*232) * sizeof (uint8_t));
00745 
00746         entry_size = sizeof (uint8_t);
00747         table_r = table_g = table_b = table_8 + 232;
00748 
00749         for (i = -232; i < 256+232; i++)
00750             ((uint8_t * )table_b)[i] = table_Y[i+384];
00751         break;
00752 
00753     case 15:
00754     case 16:
00755         table_start= table_16 = av_malloc ((197 + 2*682 + 256 + 132) * sizeof (uint16_t));
00756 
00757         entry_size = sizeof (uint16_t);
00758         table_r = table_16 + 197;
00759         table_b = table_16 + 197 + 685;
00760         table_g = table_16 + 197 + 2*682;
00761 
00762         for (i = -197; i < 256+197; i++) {
00763             int j = table_Y[i+384] >> 3;
00764 
00765             if (isRgb)
00766                 j <<= ((bpp==16) ? 11 : 10);
00767 
00768             ((uint16_t *)table_r)[i] = j;
00769         }
00770         for (i = -132; i < 256+132; i++) {
00771             int j = table_Y[i+384] >> ((bpp==16) ? 2 : 3);
00772 
00773             ((uint16_t *)table_g)[i] = j << 5;
00774         }
00775         for (i = -232; i < 256+232; i++) {
00776             int j = table_Y[i+384] >> 3;
00777 
00778             if (!isRgb)
00779                 j <<= ((bpp==16) ? 11 : 10);
00780 
00781             ((uint16_t *)table_b)[i] = j;
00782         }
00783         break;
00784 
00785     case 8:
00786         table_start= table_332 = av_malloc ((197 + 2*682 + 256 + 132) * sizeof (uint8_t));
00787 
00788         entry_size = sizeof (uint8_t);
00789         table_r = table_332 + 197;
00790         table_b = table_332 + 197 + 685;
00791         table_g = table_332 + 197 + 2*682;
00792 
00793         for (i = -197; i < 256+197; i++) {
00794             int j = (table_Y[i+384 - 16] + 18)/36;
00795 
00796             if (isRgb)
00797                 j <<= 5;
00798 
00799             ((uint8_t *)table_r)[i] = j;
00800         }
00801         for (i = -132; i < 256+132; i++) {
00802             int j = (table_Y[i+384 - 16] + 18)/36;
00803 
00804             if (!isRgb)
00805                 j <<= 1;
00806 
00807             ((uint8_t *)table_g)[i] = j << 2;
00808         }
00809         for (i = -232; i < 256+232; i++) {
00810             int j = (table_Y[i+384 - 37] + 43)/85;
00811 
00812             if (!isRgb)
00813                 j <<= 6;
00814 
00815             ((uint8_t *)table_b)[i] = j;
00816         }
00817         break;
00818     case 4:
00819     case 4|128:
00820         table_start= table_121 = av_malloc ((197 + 2*682 + 256 + 132) * sizeof (uint8_t));
00821 
00822         entry_size = sizeof (uint8_t);
00823         table_r = table_121 + 197;
00824         table_b = table_121 + 197 + 685;
00825         table_g = table_121 + 197 + 2*682;
00826 
00827         for (i = -197; i < 256+197; i++) {
00828             int j = table_Y[i+384 - 110] >> 7;
00829 
00830             if (isRgb)
00831                 j <<= 3;
00832 
00833             ((uint8_t *)table_r)[i] = j;
00834         }
00835         for (i = -132; i < 256+132; i++) {
00836             int j = (table_Y[i+384 - 37]+ 43)/85;
00837 
00838             ((uint8_t *)table_g)[i] = j << 1;
00839         }
00840         for (i = -232; i < 256+232; i++) {
00841             int j =table_Y[i+384 - 110] >> 7;
00842 
00843             if (!isRgb)
00844                 j <<= 3;
00845 
00846             ((uint8_t *)table_b)[i] = j;
00847         }
00848         break;
00849 
00850     case 1:
00851         table_start= table_1 = av_malloc (256*2 * sizeof (uint8_t));
00852 
00853         entry_size = sizeof (uint8_t);
00854         table_g = table_1;
00855         table_r = table_b = NULL;
00856 
00857         for (i = 0; i < 256+256; i++) {
00858             int j = table_Y[i + 384 - 110]>>7;
00859 
00860             ((uint8_t *)table_g)[i] = j;
00861         }
00862         break;
00863 
00864     default:
00865         table_start= NULL;
00866         av_log(c, AV_LOG_ERROR, "%ibpp not supported by yuv2rgb\n", bpp);
00867         //free mem?
00868         return -1;
00869     }
00870 
00871     for (i = 0; i < 256; i++) {
00872         c->table_rV[i] = (uint8_t *)table_r + entry_size * div_round (crv * (i-128), 76309);
00873         c->table_gU[i] = (uint8_t *)table_g + entry_size * div_round (cgu * (i-128), 76309);
00874         c->table_gV[i] = entry_size * div_round (cgv * (i-128), 76309);
00875         c->table_bU[i] = (uint8_t *)table_b + entry_size * div_round (cbu * (i-128), 76309);
00876     }
00877 
00878     av_free(c->yuvTable);
00879     c->yuvTable= table_start;
00880     return 0;
00881 }

SwsFunc yuv2rgb_get_func_ptr ( SwsContext * c )

Definition at line 596 of file yuv2rgb.c.

References av_log(), AV_LOG_WARNING, ff_bfin_yuv2rgb_get_func_ptr(), NULL, PIX_FMT_BGR24, PIX_FMT_BGR32, PIX_FMT_BGR4, PIX_FMT_BGR4_BYTE, PIX_FMT_BGR555, PIX_FMT_BGR565, PIX_FMT_BGR8, PIX_FMT_MONOBLACK, PIX_FMT_RGB24, PIX_FMT_RGB32, PIX_FMT_RGB4, PIX_FMT_RGB4_BYTE, PIX_FMT_RGB555, PIX_FMT_RGB565, PIX_FMT_RGB8, SWS_CPU_CAPS_ALTIVEC, SWS_CPU_CAPS_BFIN, SWS_CPU_CAPS_MMX, SWS_CPU_CAPS_MMX2, t, yuv2rgb_init_altivec(), yuv2rgb_init_mlib(), and yuv2rgb_init_vis().

00597 {
00598 #if defined(HAVE_MMX2) || defined(HAVE_MMX)
00599     if (c->flags & SWS_CPU_CAPS_MMX2){
00600         switch(c->dstFormat){
00601         case PIX_FMT_RGB32:  return yuv420_rgb32_MMX2;
00602         case PIX_FMT_BGR24:  return yuv420_rgb24_MMX2;
00603         case PIX_FMT_BGR565: return yuv420_rgb16_MMX2;
00604         case PIX_FMT_BGR555: return yuv420_rgb15_MMX2;
00605         }
00606     }
00607     if (c->flags & SWS_CPU_CAPS_MMX){
00608         switch(c->dstFormat){
00609         case PIX_FMT_RGB32:  return yuv420_rgb32_MMX;
00610         case PIX_FMT_BGR24:  return yuv420_rgb24_MMX;
00611         case PIX_FMT_BGR565: return yuv420_rgb16_MMX;
00612         case PIX_FMT_BGR555: return yuv420_rgb15_MMX;
00613         }
00614     }
00615 #endif
00616 #ifdef HAVE_VIS
00617     {
00618         SwsFunc t= yuv2rgb_init_vis(c);
00619         if (t) return t;
00620     }
00621 #endif
00622 #ifdef CONFIG_MLIB
00623     {
00624         SwsFunc t= yuv2rgb_init_mlib(c);
00625         if (t) return t;
00626     }
00627 #endif
00628 #ifdef HAVE_ALTIVEC
00629     if (c->flags & SWS_CPU_CAPS_ALTIVEC)
00630     {
00631         SwsFunc t = yuv2rgb_init_altivec(c);
00632         if (t) return t;
00633     }
00634 #endif
00635 
00636 #ifdef ARCH_BFIN
00637     if (c->flags & SWS_CPU_CAPS_BFIN)
00638     {
00639         SwsFunc t = ff_bfin_yuv2rgb_get_func_ptr (c);
00640         if (t) return t;
00641     }
00642 #endif
00643 
00644     av_log(c, AV_LOG_WARNING, "No accelerated colorspace conversion found.\n");
00645 
00646     switch(c->dstFormat){
00647     case PIX_FMT_BGR32:
00648     case PIX_FMT_RGB32: return yuv2rgb_c_32;
00649     case PIX_FMT_RGB24: return yuv2rgb_c_24_rgb;
00650     case PIX_FMT_BGR24: return yuv2rgb_c_24_bgr;
00651     case PIX_FMT_RGB565:
00652     case PIX_FMT_BGR565:
00653     case PIX_FMT_RGB555:
00654     case PIX_FMT_BGR555: return yuv2rgb_c_16;
00655     case PIX_FMT_RGB8:
00656     case PIX_FMT_BGR8:  return yuv2rgb_c_8_ordered_dither;
00657     case PIX_FMT_RGB4:
00658     case PIX_FMT_BGR4:  return yuv2rgb_c_4_ordered_dither;
00659     case PIX_FMT_RGB4_BYTE:
00660     case PIX_FMT_BGR4_BYTE:  return yuv2rgb_c_4b_ordered_dither;
00661     case PIX_FMT_MONOBLACK:  return yuv2rgb_c_1_ordered_dither;
00662     default:
00663         assert(0);
00664     }
00665     return NULL;
00666 }

SwsFunc yuv2rgb_init_altivec ( SwsContext * c )

Definition at line 696 of file yuv2rgb_altivec.c.

References altivec_uyvy_rgb32(), av_log(), AV_LOG_WARNING, c, NULL, PIX_FMT_ABGR, PIX_FMT_ARGB, PIX_FMT_BGR24, PIX_FMT_BGR32, PIX_FMT_BGRA, PIX_FMT_GRAY8, PIX_FMT_NV12, PIX_FMT_NV21, PIX_FMT_RGB24, PIX_FMT_RGBA, PIX_FMT_UYVY422, PIX_FMT_YUV410P, PIX_FMT_YUV420P, and SWS_CPU_CAPS_ALTIVEC.

Referenced by yuv2rgb_get_func_ptr().

00697 {
00698     if (!(c->flags & SWS_CPU_CAPS_ALTIVEC))
00699         return NULL;
00700 
00701     /*
00702       and this seems not to matter too much I tried a bunch of
00703       videos with abnormal widths and MPlayer crashes elsewhere.
00704       mplayer -vo x11 -rawvideo on:w=350:h=240 raw-350x240.eyuv
00705       boom with X11 bad match.
00706 
00707     */
00708     if ((c->srcW & 0xf) != 0)    return NULL;
00709 
00710     switch (c->srcFormat) {
00711     case PIX_FMT_YUV410P:
00712     case PIX_FMT_YUV420P:
00713     /*case IMGFMT_CLPL:        ??? */
00714     case PIX_FMT_GRAY8:
00715     case PIX_FMT_NV12:
00716     case PIX_FMT_NV21:
00717         if ((c->srcH & 0x1) != 0)
00718             return NULL;
00719 
00720         switch(c->dstFormat){
00721         case PIX_FMT_RGB24:
00722             av_log(c, AV_LOG_WARNING, "ALTIVEC: Color Space RGB24\n");
00723             return altivec_yuv2_rgb24;
00724         case PIX_FMT_BGR24:
00725             av_log(c, AV_LOG_WARNING, "ALTIVEC: Color Space BGR24\n");
00726             return altivec_yuv2_bgr24;
00727         case PIX_FMT_ARGB:
00728             av_log(c, AV_LOG_WARNING, "ALTIVEC: Color Space ARGB\n");
00729             return altivec_yuv2_argb;
00730         case PIX_FMT_ABGR:
00731             av_log(c, AV_LOG_WARNING, "ALTIVEC: Color Space ABGR\n");
00732             return altivec_yuv2_abgr;
00733         case PIX_FMT_RGBA:
00734             av_log(c, AV_LOG_WARNING, "ALTIVEC: Color Space RGBA\n");
00735             return altivec_yuv2_rgba;
00736         case PIX_FMT_BGRA:
00737             av_log(c, AV_LOG_WARNING, "ALTIVEC: Color Space BGRA\n");
00738             return altivec_yuv2_bgra;
00739         default: return NULL;
00740         }
00741         break;
00742 
00743     case PIX_FMT_UYVY422:
00744         switch(c->dstFormat){
00745         case PIX_FMT_BGR32:
00746             av_log(c, AV_LOG_WARNING, "ALTIVEC: Color Space UYVY -> RGB32\n");
00747             return altivec_uyvy_rgb32;
00748         default: return NULL;
00749         }
00750         break;
00751 
00752     }
00753     return NULL;
00754 }

const AVClass sws_context_class

Definition at line 59 of file swscale_avoption.c.

swscale_internal.h File Reference

Data Structures

Defines

Typedefs

Functions

Variables

Define Documentation

Typedef Documentation

Function Documentation

Variable Documentation


Data Structures
struct	SwsContext
Defines
#define	MAX_FILTER_SIZE 256
#define	VOFW 8192
#define	VOF (VOFW*2)
#define	RED_DITHER "0*8"
#define	GREEN_DITHER "1*8"
#define	BLUE_DITHER "2*8"
#define	Y_COEFF "3*8"
#define	VR_COEFF "4*8"
#define	UB_COEFF "5*8"
#define	VG_COEFF "6*8"
#define	UG_COEFF "7*8"
#define	Y_OFFSET "8*8"
#define	U_OFFSET "9*8"
#define	V_OFFSET "10*8"
#define	LUM_MMX_FILTER_OFFSET "11*8"
#define	CHR_MMX_FILTER_OFFSET "118+44*256"
#define	DSTW_OFFSET "118+442562"
#define	ESP_OFFSET "118+442562+8"
#define	VROUNDER_OFFSET "118+442562+16"
#define	U_TEMP "118+442562+24"
#define	V_TEMP "118+442562+32"
#define	isPlanarYUV(x)
#define	isYUV(x)
#define	isGray(x)
#define	isGray16(x)
#define	isRGB(x)
#define	isBGR(x)
Typedefs
typedef int(*)	SwsFunc (struct SwsContext context, uint8_t src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
Functions
SwsFunc	yuv2rgb_get_func_ptr (SwsContext *c)
int	yuv2rgb_c_init_tables (SwsContext *c, const int inv_table[4], int fullRange, int brightness, int contrast, int saturation)
void	yuv2rgb_altivec_init_tables (SwsContext *c, const int inv_table[4], int brightness, int contrast, int saturation)
SwsFunc	yuv2rgb_init_altivec (SwsContext *c)
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)
const char *	sws_format_name (int format)
static int	fmt_depth (int fmt)
const	DECLARE_ALIGNED (8, uint64_t, ff_dither4[2])
const	DECLARE_ALIGNED (8, uint64_t, ff_dither8[2])
Variables
const AVClass	sws_context_class