RGB YUV420 相互转换

如果用ffmpeg的话就不要用下面的函数了,效率实在是太.......

直接用ffmpeg的sws_scale 很快的

#define min3v(v1, v2, v3) ((v1)>(v2)? ((v2)>(v3)?(v3):(v2)):((v1)>(v3)?(v3):(v2)))
#define max3v(v1, v2, v3) ((v1)<(v2)? ((v2)<(v3)?(v3):(v2)):((v1)<(v3)?(v3):(v1)))
typedef struct
{
BYTE red; // [0,255]
BYTE green; // [0,255]
BYTE blue; // [0,255]

}COLOR_RGB;

typedef struct
{
float hue; // [0,360]
float saturation; // [0,100]
float luminance; // [0,100]
}COLOR_HSL;

// Converts RGB to HSL

static void RGBtoHSL(/*[in]*/const COLOR_RGB *rgb, /*[out]*/COLOR_HSL *hsl)
{
float h=0, s=0, l=0;
// normalizes red-green-blue values
float r = rgb->red/255.f;
float g = rgb->green/255.f;
float b = rgb->blue/255.f;
float maxVal = max3v(r, g, b);
float minVal = min3v(r, g, b);


// hue

if(maxVal == minVal)
{
h = 0; // undefined
}

else if(maxVal==r && g>=b)
{
h = 60.0f*(g-b)/(maxVal-minVal);
}

else if(maxVal==r && g<b)
{
h = 60.0f*(g-b)/(maxVal-minVal) + 360.0f;
}

else if(maxVal==g)
{
h = 60.0f*(b-r)/(maxVal-minVal) + 120.0f;
}
else if(maxVal==b)
{
h = 60.0f*(r-g)/(maxVal-minVal) + 240.0f;
}

// luminance

l = (maxVal+minVal)/2.0f;
// saturation

if(l == 0 || maxVal == minVal)
{
s = 0;
}

else if(0<l && l<=0.5f)
{
s = (maxVal-minVal)/(maxVal+minVal);
}
else if(l>0.5f)
{
s = (maxVal-minVal)/(2 - (maxVal+minVal)); //(maxVal-minVal > 0)?
}
hsl->hue = (h>360)? 360 : ((h<0)?0:h);
hsl->saturation = ((s>1)? 1 : ((s<0)?0:s))*100;
hsl->luminance = ((l>1)? 1 : ((l<0)?0:l))*100;
}
// Converts HSL to RGB

static void HSLtoRGB(const COLOR_HSL *hsl, COLOR_RGB *rgb)
{
float h = hsl->hue; // h must be [0, 360]
float s = hsl->saturation/100.f; // s must be [0, 1]
float l = hsl->luminance/100.f; // l must be [0, 1]
float R, G, B;

if(hsl->saturation == 0)
{
// achromatic color (gray scale)
R = G = B = l*255.f;
}
else
{
float q = (l<0.5f)?(l * (1.0f+s)):(l+s - (l*s));
float p = (2.0f * l) - q;
float Hk = h/360.0f;
float T[3];
T[0] = Hk + 0.3333333f; // Tr 0.3333333f=1.0/3.0
T[1] = Hk; // Tb
T[2] = Hk - 0.3333333f; // Tg

for(int i=0; i<3; i++)
{
if(T[i] < 0) T[i] += 1.0f;
if(T[i] > 1) T[i] -= 1.0f;

if((T[i]*6) < 1)
{
T[i] = p + ((q-p)*6.0f*T[i]);
}
else if((T[i]*2.0f) < 1) //(1.0/6.0)<=T[i] && T[i]<0.5
{
T[i] = q;
}
else if((T[i]*3.0f) < 2) // 0.5<=T[i] && T[i]<(2.0/3.0)
{
T[i] = p + (q-p) * ((2.0f/3.0f) - T[i]) * 6.0f;
}
else T[i] = p;
}
R = T[0]*255.0f;
G = T[1]*255.0f;
B = T[2]*255.0f;

}
rgb->red = (BYTE)((R>255)? 255 : ((R<0)?0 : R));
rgb->green = (BYTE)((G>255)? 255 : ((G<0)?0 : G));
rgb->blue = (BYTE)((B>255)? 255 : ((B<0)?0 : B));

}



#define SCALEBITS 8
#define ONE_HALF (1 << (SCALEBITS - 1))
#define FIX(x) ((int) ((x) * (1L<<SCALEBITS) + 0.5))
typedef unsigned char uint8_t;
void rgb24_to_yuv420p(uint8_t *lum, uint8_t *cb, uint8_t *cr, uint8_t *src, int width, int height)
{
int wrap, wrap3, x, y;
int r, g, b, r1, g1, b1;
uint8_t *p;
wrap = width;
wrap3 = width * 3;
p = src;
for (y = 0; y < height; y += 2)
{
for (x = 0; x < width; x += 2)
{
r = p[0];
g = p[1];
b = p[2];
r1 = r;
g1 = g;
b1 = b;
lum[0] = (FIX(0.29900) * r + FIX(0.58700) * g +FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;
r = p[3];
g = p[4];
b = p[5];
r1 += r;
g1 += g;
b1 += b;
lum[1] = (FIX(0.29900) * r + FIX(0.58700) * g +FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;
p += wrap3;
lum += wrap;
r = p[0];
g = p[1];
b = p[2];
r1 += r;
g1 += g;
b1 += b;
lum[0] = (FIX(0.29900) * r + FIX(0.58700) * g +FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;
r = p[3];
g = p[4];
b = p[5];
r1 += r;
g1 += g;
b1 += b;
lum[1] = (FIX(0.29900) * r + FIX(0.58700) * g +FIX(0.11400) * b + ONE_HALF) >> SCALEBITS;

cb[0] = (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +
FIX(0.50000) * b1 + 4 * ONE_HALF - 1) >> (SCALEBITS + 2)) + 128);
cr[0] = (((FIX(0.50000) * r1 - FIX(0.41869) * g1 -
FIX(0.08131) * b1 + 4 * ONE_HALF - 1) >> (SCALEBITS + 2)) + 128);
cb++;
cr++;
p += -wrap3+2 * 3;
lum += -wrap + 2;
}
p += wrap3;
lum += wrap;
}
}

inline byte ADJUST(double tmp)
{
return (byte)((tmp >= 0 && tmp <= 255)?tmp:(tmp < 0 ? 0 : 255));
}

void YUV420P_TO_RGB24(unsigned char* yuv_src,unsigned char* rgb_dst,int nWidth,int nHeight)
{
unsigned char tmpbuf[CAM_WIDTH*CAM_HEIGHT*3];
byte Y,U,V,R,G,B;
byte* y_planar,*u_planar,*v_planar;
int C,D,E;
int rgb_width , u_width;
rgb_width = nWidth * 3;
u_width = (nWidth >> 1);
int ypSize = nWidth * nHeight;
int upSize = (ypSize>>2);
int offSet = 0;

y_planar = yuv_src;
u_planar = yuv_src + ypSize;
v_planar = u_planar + upSize;

/*
int ns_r[256],ns_g[256],ns_b[256];
memset(ns_r,0,sizeof(ns_r));
memset(ns_g,0,sizeof(ns_r));
memset(ns_b,0,sizeof(ns_r));

double ps_r[256],ps_g[256],ps_b[256];
double temp_r[256],temp_g[256],temp_b[256];
*/

for(int i = 0; i < nHeight; i++)
{
for(int j = 0; j < nWidth; j ++)
{
// Get the Y value from the y planar
Y = *(y_planar + nWidth * i + j);
// Get the V value from the u planar
offSet = (i>>1) * (u_width) + (j>>1);
V = *(u_planar + offSet);
// Get the U value from the v planar
U = *(v_planar + offSet);

// Cacular the R,G,B values
/*R = ADJUST((Y + (1.4075 * (V - 128))));
G = ADJUST((Y - (0.3455 * (U - 128) - 0.7169 * (V - 128))));
B = ADJUST((Y + (1.7790 * (U - 128))));*/

// The following formulas are from MicroSoft' MSDN
// the result is better than the former
//
C = Y - 16;
D = U - 128;
E = V - 128;

R = ADJUST(( 298 * C + 409 * E + 128) >> 8);
G = ADJUST(( 298 * C - 100 * D - 208 * E + 128) >> 8);
B = ADJUST(( 298 * C + 516 * D + 128) >> 8);
R = ((R - 128) * .6 + 128 )>255?255:(R - 128) * .6 + 128;
G = ((G - 128) * .6 + 128 )>255?255:(G - 128) * .6 + 128;
B = ((B - 128) * .6 + 128 )>255?255:(B - 128) * .6 + 128;
//COLOR_RGB rgb={R,G,B};
//COLOR_HSL hsl;
//RGBtoHSL((const COLOR_RGB *)&rgb,&hsl);
//hsl.saturation =hsl.saturation>90?100:hsl.saturation+10;
//hsl.luminance=hsl.luminance>90?100:hsl.luminance+10;
//HSLtoRGB((const COLOR_HSL *)&hsl,&rgb);
// Set the values

//ns_r为R分量的统计记数
// ns_r[R]++;
//ns_g为G分量的统计记数
// ns_g[G]++;
//ns_b为B分量的统计记数
// ns_b[B]++;
offSet = rgb_width * i + j * 3;
//tmpbuf[offSet] = R;
//tmpbuf[offSet + 1] = G;
//tmpbuf[offSet + 2] = B;

rgb_dst[offSet] = B;
rgb_dst[offSet + 1] = G;
rgb_dst[offSet + 2] = R;
}
}
/*
for(i=0;i<256;i++) //计算R、G、B三分量的直方图分布
{
//ps_r[i]为R分量中i灰度级出现的概率
ps_r[i]=ns_r[i]/((nWidth*nHeight)/1.0f);
//ps_b[i]为G分量中i灰度级出现的概率
ps_g[i]=ns_g[i]/((nWidth*nHeight)/1.0f);
//ps_b[i]为B分量中i灰度级出现的概率
ps_b[i]=ns_b[i]/((nWidth*nHeight)/1.0f);
}
for(i=0;i<256;i++)
{
//计算累计直方图分布
temp_r[i]=(i>0?temp_r[i-1]:0)+ps_r[i];
temp_g[i]=(i>0?temp_g[i-1]:0)+ps_g[i];
temp_b[i]=(i>0?temp_b[i-1]:0)+ps_b[i];
//累计分布取整，ns_r[]、ns_g[]、ns_b[]保存有计算出来的灰度映射关系
ns_r[i]=(int)(255.0f*temp_r[i]+0.5f);
ns_g[i]=(int)(255.0f*temp_g[i]+0.5f);
ns_b[i]=(int)(255.0f*temp_b[i]+0.5f);
}
for(i = 0; i < nHeight; i++)
{
for(int j = 0; j < nWidth; j ++)
{
offSet = rgb_width * i + j * 3;
rgb_dst[offSet]=ns_r[tmpbuf[offSet]] ;
rgb_dst[offSet+ 1]=ns_r[tmpbuf[offSet + 1] ];
rgb_dst[offSet+ 2]=ns_r[tmpbuf[offSet + 2]];
}
}
*/
}