各种RGB转YUV的计算

// 按照opencv数据存储格式,函数传参顺序为b、g、r      

void yuv2rgb_pixel(unsigned char b, unsigned char g, unsigned char r, unsigned char &y, unsigned char &u, unsigned char &v)
{
    //rgb转yuv公式,参考资料<a target=_blank href="http://www.cnblogs.com/dwdxdy/p/3713990.html">http://www.cnblogs.com/dwdxdy/p/3713990.html</a>
    y = 0.299 * r + 0.587 * g + 0.114 * b;
    u = -0.1687 * r - 0.3313 * g + 0.5 * b + 128;
    v = 0.5 * r - 0.4187 * g - 0.0813 * b + 128;
}

// rgb24转yuv422                                                        
void yuv2rgb_image(unsigned char *pRgb, unsigned char *pYuv, int width, int height)
{
    //考虑到每两个rgb像素对应一个yuyv组合,因此,width应为2的倍数
    int width1 = width = width / 2 * 2;

    for (int h = 0; h < height; h++)
    {
        unsigned char *ptr1 = pRgb + h * width * 3;
        unsigned char *ptr2 = pYuv + h * width * 2;

        for (int w = 0; w < width1; w += 2)
        {
            unsigned char y1, u1, v1, y2, u2, v2;
            yuv2rgb_pixel(*ptr1, *ptr1, *ptr1, y1, u1, v1);
            yuv2rgb_pixel(*ptr1, *ptr1, *ptr1, y2, u2, v2);
            //u、v分量取平均值
            unsigned char u = (u1 + u2) / 2;
            unsigned char v = (v1 + v2) / 2;
            *ptr2 = y1;
            *ptr2 = u;
            *ptr2 = y2;
            *ptr2 = v;
        }
    }
}

#define GetY(R,G,B) (0.257*(R)+0.504*(G)+0.98*(B)+16)
#define GetU(R,G,B) (0.148*(R)-0.291*(G)+0.439*(B)+128)
#define GetV(R,G,B) (0.439*(R)-0.368*(G)-0.071*(B)+128)

/*******************************************
yuv422Planar format 数据排列:
Y0Y1Y2Y3....
U0U2U4....
V1V3V5....
********************************************/
void  rgb2yuv422Planar(const unsigned char *rgbData, int height, int width, int widthstep, unsigned char*yuvData)
{
    int i, j, temp;
    unsigned char *lineUV = (unsigned char *)malloc(width * sizeof(unsigned char));//偶数下标位存U,奇数下标位存V
    if (NULL == lineUV)
    {
        perror("malloc lineUV memory failed!");
        exit(1);
    }
    memset(lineUV, 0, sizeof(width * sizeof(unsigned char)));
    for (i = 0; i < height; i++)
    {
        for (j = 0; j < width; j++) //y
        {
            unsigned char b = rgbData[i*widthstep + 3 * j];
            unsigned char g = rgbData[i*widthstep + 3 * j + 1];
            unsigned char r = rgbData[i*widthstep + 3 * j + 2];
            unsigned char *y = yuvData + i * width + j;
            temp = (int)GetY(r, g, b);
            *y = (temp < 0) ? 0 : ((temp > 255) ? 255 : temp);
            if (0 == j % 2)
            {
                temp = (int)GetU(r, g, b);
                lineUV[j] = (temp < 0) ? 0 : ((temp > 255) ? 255 : temp);

            }
            else
            {
                temp = (int)GetV(r, g, b);
                lineUV[j] = (temp < 0) ? 0 : ((temp > 255) ? 255 : temp);
            }
        }
        for (j = 0; j < width; j++) //u,v
        {
            if (0 == j % 2) //u
            {
                unsigned char *u = yuvData + height * width + i * width / 2 + j / 2;
                *u = lineUV[j];
            }
            else //v
            {
                unsigned char *v = yuvData + height * width * 3 / 2 + i * width / 2 + (int)(j / 2);
                *v = lineUV[j];
            }
        }
    }

    if (lineUV != NULL)
    {
        free(lineUV);
        lineUV = NULL;
    }


}
int  yuv422Packed2Planar(const unsigned char *packedData, unsigned char *planarData, int heigh, int width)
{
    int index;
    int i = 0;
    int j = 0;
    int k = 0;
    unsigned char *y = planarData;
    unsigned char *u = planarData + heigh * width;
    unsigned char *v = planarData + heigh * width * 3 / 2;
    bool flag = true;
    for (index = 0; index < 2 * width*heigh;)
    {
        y[i++] = packedData[index++];
        if (flag)
        {
            u[j++] = packedData[index++];
            flag = false;
        }
        else
        {
            v[k++] = packedData[index++];
            flag = true;
        }
    }
    if (2 * width*heigh == index && width*heigh == i && width*heigh / 2 == j && j == k)
    {
        return 0;
    }
    else
    {
        return -1;
    }
}

/*******************************
yuv422Packed format 数据排列:
Y0U0Y1V1Y2U2Y3V3.....
................
*******************************/
void  rgb2yuv422Packed(const unsigned char *rgbData, int height, int width, int widthstep, unsigned char *yuvData)
{
    int i, j, temp;
    int index = 0;

    for (i = 0; i < height; i++)
    {
        bool bsetU = true;
        for (j = 0; j < width; j++)
        {
            unsigned char r = rgbData[i*widthstep + 3 * j];
            unsigned char g = rgbData[i*widthstep + 3 * j + 1];
            unsigned char b = rgbData[i*widthstep + 3 * j + 2];
            temp = (int)GetY(r, g, b);
            yuvData[index++] = (temp < 0) ? 0 : ((temp > 255) ? 255 : temp);
            if (bsetU) //
            {
                temp = (int)GetU(r, g, b);
                yuvData[index++] = (temp < 0) ? 0 : ((temp > 255) ? 255 : temp);
                bsetU = false;
            }
            else
            {
                temp = (int)GetV(r, g, b);
                yuvData[index++] = (temp < 0) ? 0 : ((temp > 255) ? 255 : temp);
                bsetU = true;
            }
        }
    }

}


//************************************
// Method:    rgb24_to_yuv420p
// FullName:  rgb24_to_yuv420p
// Access:    public 
// Returns:   int            返回值为0表示成功,否则失败
// Qualifier:                将RGB24格式图像转化为YUV420P格式,并进行相应的缩放
// Parameter: void * src    输入缓冲
// Parameter: int srcW        源宽
// Parameter: int srcH        源高
// Parameter: int srcSz        输入RGB图像数据大小=srcW*srcH*3
// Parameter: void * dst    输出缓冲
// Parameter: int dstW        目标宽
// Parameter: int dstH        目标高
// Parameter: int dstSz        输出的YUV图像数据大小=dstW*dstH*1.5
//************************************
int rgb24_to_yuv420p(void* src, int srcW, int srcH, int srcSz, void* dst, int dstW, int dstH, int dstSz)
{
    if (!src || !dst || srcSz <= 0 || srcW <= 0 || srcH <= 0 || dstSz <= 0 || dstW <= 0 || dstH <= 0)
    {
        return -1;
    }
    if (srcSz != srcW * srcH * 3 || dstSz != dstW * dstH*1.5)
    {
        return -1;
    }
    auto* ctxt = sws_getContext(srcW, srcH, AV_PIX_FMT_BGR24, dstW, dstH, AV_PIX_FMT_YUV420P, 0, 0, 0, 0);
    const int srcStride[1] = { 3 * srcW };
    const int dstStride[4] = { dstW, dstW / 2, dstW / 2, 0 };
    uint8_t * dstEx[4] = { 0 };
    dstEx[0] = (uint8_t *)dst;
    dstEx[1] = dstEx[0] + dstW * dstH;
    dstEx[2] = dstEx[1] + dstW * dstH / 4;
    sws_scale(ctxt, (const uint8_t * const *)&src, srcStride, 0, srcH, dstEx, dstStride);
    sws_freeContext(ctxt);
    return 0;
}

unsigned char clip_value(unsigned char x, unsigned char min_val, unsigned char  max_val) {
    if (x > max_val) {
        return max_val;
    }
    else if (x < min_val) {
        return min_val;
    }
    else {
        return x;
    }
}

//RGB to YUV420
bool RGB24_TO_YUV420(unsigned char *RgbBuf, int w, int h, unsigned char *yuvBuf)
{
    unsigned char*ptrY, *ptrU, *ptrV, *ptrRGB;
    memset(yuvBuf, 0, w*h * 3 / 2);
    ptrY = yuvBuf;
    ptrU = yuvBuf + w * h;
    ptrV = ptrU + (w*h * 1 / 4);
    unsigned char y, u, v, r, g, b;
    for (int j = 0; j < h; j++) {
        ptrRGB = RgbBuf + w * j * 3;
        for (int i = 0; i < w; i++) {

            r = *(ptrRGB++);
            g = *(ptrRGB++);
            b = *(ptrRGB++);
            y = (unsigned char)((66 * r + 129 * g + 25 * b + 128) >> 8) + 16;
            u = (unsigned char)((-38 * r - 74 * g + 112 * b + 128) >> 8) + 128;
            v = (unsigned char)((112 * r - 94 * g - 18 * b + 128) >> 8) + 128;
            *(ptrY++) = clip_value(y, 0, 255);
            if (j % 2 == 0 && i % 2 == 0) {
                *(ptrU++) = clip_value(u, 0, 255);
            }
            else {
                if (i % 2 == 0) {
                    *(ptrV++) = clip_value(v, 0, 255);
                }
            }
        }
    }
    return true;
}

在网上搜集的,方便以后,说不定以后用的上

发布了2 篇原创文章 · 获赞 5 · 访问量 1585
展开阅读全文

yuvrgb视频格式

05-23

#define asm __asm typedef unsigned char TUInt8; // [0..255] typedef unsigned long TUInt32; struct TARGB32 // 32 bit color { TUInt8 b,g,r,a; // a is alpha }; struct TPicRegion // 一块颜色数据区的描述,便于参数传递 { TARGB32 * pdata; // 颜色数据首地址 long byte_width; // 一行数据的物理宽度(字节宽度); // abs(byte_width)有可能大于等于width*sizeof(TARGB32); long width; // 像素宽度 long height; // 像素高度 }; // 那么访问一个点的函数可以写为: __forceinline TARGB32 & Pixels( const TPicRegion & pic, const long x, const long y) { return ( (TARGB32 * )((TUInt8 * )pic.pdata + pic.byte_width * y) )[x]; } // 颜色饱和函数 __forceinline long border_color( long color) { if (color > 255 ) return 255 ; else if (color < 0 ) return 0 ; else return color; } __forceinline TARGB32 YUVToRGB32_float( const TUInt8 Y, const TUInt8 U, const TUInt8 V) { TARGB32 result; result.b= border_color( 1.164383 * (Y - 16) + 2.017232*(U - 128) ); result.g= border_color( 1.164383 * (Y - 16) - 0.391762*(U - 128) - 0.812968*(V - 128) ); result.r= border_color( 1.164383 * (Y - 16) + 1.596027*(V - 128) ); result.a = 255 ; return result; } void DECODE_YUYV_Float( const TUInt8 * pYUYV, const TPicRegion & DstPic) { assert((DstPic.width & 1 ) == 0 ); TARGB32 * pDstLine = DstPic.pdata; for ( long y = 0 ;y < DstPic.height; ++ y) { for ( long x = 0 ;x < DstPic.width;x += 2 ) { pDstLine[x + 0 ] = YUVToRGB32_float(pYUYV[ 0 ],pYUYV[ 1 ],pYUYV[ 3 ]); pDstLine[x + 1 ] = YUVToRGB32_float(pYUYV[ 2 ],pYUYV[ 1 ],pYUYV[ 3 ]); pYUYV += 4 ; } ((TUInt8 *& )pDstLine) += DstPic.byte_width; } } 哪位大神帮忙写个 main()函数 让我看看具体输出是啥样的 问答

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览