数据压缩原理 实验报告一 彩色空间转换

实验原理

YUV与RGB转换公式

由电视原理可知，RGB信号转换为YUV信号的公式为

Y=  0.2990R + 0.5870G + 0.1140B
U= -0.1684R - 0.3316G + 0.5B
V=     0.5R - 0.4187G - 0.0813B

YUV信号转换为RGB信号的公式为

R= Y + 1.4075(V−128)
G= Y − 0.3455(U−128) − 0.7169(V−128)
B= Y + 1.779 (U−128 

YUV与RGB存储方式

YUV存储方式是将一帧图像的Y、U、V数据分开来存，先存所有的Y数据，再存所有的U数据，再存所有的V数据。

RGB存储方式是将一帧图像按像素点存储，先存第一个像素点的B、G、R数据，再存第二个点的B、G、R数据。

YUV与RGB所需存储空间

当YUV色度格式为4：4：4时，每一个像素点有一个Y一个U一个V，所需存储空间为height*width*3；

当YUV色度格式为4：2：0时，每一个像素点有一个Y，四个像素点共用一个U一个V，所需存储空间为height*width*1.5；

RGB格式每一个像素点有一个R一个G一个B，所需存储空间为height*width*3。

实验流程

打开RGB文件，先将RGB信号转换为4：4：4色度格式的YUV信号，再将4：4：4色度格式的YUV信号转换为4：2：0色度格式的YUV信号，最后写入YUV文件。

代码分析

yuv2rgb.h代码

#ifndef YUV2RGB_H_
#define YUV2RGB_H_

int YUV2RGB (int x_dim, int y_dim, void *bmp, void *y_out, void *u_out, void *v_out, int flip);

void InitLookupTable();

#endif

yuv2rgb.cpp代码

/*
    总步骤：先将4:2:0格式的YUV转成4:4:4格式的YUV 再把YUV转成RGB
*/

#include "stdlib.h"
#include "yuv2rgb.h"

static float YUVRGB14075[256], YUVRGB03455[256], YUVRGB07169[256], YUVRGB17790[256];

/*
    R=Y+1.4075(V−128)
    G=Y−0.3455(U−128)−0.7169(V−128)
    B=Y+1.779(U−128)
    定义静态全局变量，计算所有可能出现的值
 */

int YUV2RGB (int x_dim, int y_dim, void *rgb_out, void *y_in, void *u_in, void *v_in, int flip)
{
    static int init_done = 0;

    long i, j, size;
    unsigned char *r, *g, *b;                                   //建RGB指针
    unsigned char *y, *u, *v;                                   //建YUV指针
    float rr, gg, bb;                                           //因为RGB可能会溢出 所以建立RGB中转变量
    unsigned char *pu, *pv, *psu1, *psu2, *psv1, *psv2;         //建把YUV转成4:4:4格式的指针
    unsigned char *y_buffer, *u_buffer, *v_buffer, *rgb_buffer;
    unsigned char *sub_u_buf, *sub_v_buf;

    if (init_done == 0)
    {
        InitLookupTable();
        init_done = 1;
    }

    // check to see if x_dim and y_dim are divisible by 2
    if ((x_dim % 2) || (y_dim % 2)) return 1;                   //检查图像宽高是否是偶数
    size = x_dim * y_dim;                                       //尺寸=宽×高

    y_buffer  = (unsigned char *)y_in;                          //输入YUV是4:2:0格式
    u_buffer  = (unsigned char *)u_in;
    v_buffer  = (unsigned char *)v_in;
    sub_u_buf = (unsigned char *)malloc(x_dim * y_dim);         //这两个buf用于转4:4;4格式
    sub_v_buf = (unsigned char *)malloc(x_dim * y_dim);

    b = (unsigned char *)rgb_out;
    y = y_buffer;
    u = sub_u_buf;
    v = sub_v_buf;

    for (j = 0; j < y_dim/2; j ++)                              //第j行 第i列
    {
        pu = u_buffer + j*x_dim/2;                              //pu是4:2:0格式的u
        psu1 = sub_u_buf + 2*j*x_dim;                           //psu1和psu2是4:4:4格式的u
        psu2 = sub_u_buf + (2*j+1)*x_dim;

        pv = v_buffer + j*x_dim/2;
        psv1 = sub_v_buf + 2*j*x_dim;
        psv2 = sub_v_buf + (2*j+1)*x_dim;

        for (i = 0; i < x_dim/2; i ++)
        {
            *psu1 = *(psu1+1) = *psu2 = *(psu2+1) = *pu;        //把4:2:0格式转成4:4:4格式
            *psv1 = *(psv1+1) = *psv2 = *(psv2+1) = *pv;

            pu ++;
            psu1 +=2;
            psu2 +=2;
            pv ++;
            psv1 +=2;
            psv2 +=2;
        }
    }

    // convert RGB to YUV
    if (!flip)                                                  //YUV2RGB 倒序 flip0是倒序 flip1是正序
    {
        for (j = 0; j < y_dim; j ++)                            //把YUV(4:4:4格式)转成RGB
        {
            for (i = 0; i < x_dim; i ++) 
            {
                g = b + 1;
                r = b + 2;
                rr = *y + YUVRGB14075[*v];                      //按公式把YUV转成RGB
                gg = *y - YUVRGB03455[*u] - YUVRGB07169[*v];
                bb = *y + YUVRGB17790[*u];
                //R= Y + 1.4075(V−128)
                //G= Y − 0.3455(U−128) − 0.7169(V−128)
                //B= Y + 1.779 (U−128)
                *r = (unsigned char)(rr<0 ? 0 : rr>255 ? 255 : rr); //防止变换后色彩溢出0~255
                *g = (unsigned char)(gg<0 ? 0 : gg>255 ? 255 : gg); //如果变换后小于0 则取0 大于255 则取255
                *b = (unsigned char)(bb<0 ? 0 : bb>255 ? 255 : bb); //否则取变换后的值
                b += 3;
                y ++;
                u ++;
                v ++;
            }
        }
    }
    //else的情况此处不需要 省略

    if(sub_u_buf!=NULL)                                         //关不需要的buffer
        free(sub_u_buf);
    if(sub_v_buf!=NULL) 
        free(sub_v_buf);

    return 0;
}

void InitLookupTable()                                          //提前计算所有可能的值
{
    int i;
    for (i = 0; i < 256; i++) YUVRGB14075[i] = (float)1.4075 * (i-128);
    for (i = 0; i < 256; i++) YUVRGB03455[i] = (float)0.3455 * (i-128);
    for (i = 0; i < 256; i++) YUVRGB07169[i] = (float)0.7169 * (i-128);
    for (i = 0; i < 256; i++) YUVRGB17790[i] = (float)1.7790 * (i-128);
}

main.cpp代码

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include "yuv2rgb.h"

#define u_int8_t    unsigned __int8
#define u_int       unsigned __int32
#define u_int32_t   unsigned __int32
#define FALSE       false
#define TRUE        true

int main(int argc, char** argv)
{
    /* variables controlable from command line */
    u_int frameWidth = 352;         /* --width=<uint> */
    u_int frameHeight = 240;        /* --height=<uint> */
    bool flip = FALSE;
    unsigned int i;

    /* internal variables */
    char* rgbFileName = NULL;                               //定义文件名
    char* yuvFileName = NULL;
    FILE* rgbFile = NULL;                                   //定义文件指针
    FILE* yuvFile = NULL;
    u_int8_t* rgbBuf = NULL;                                //定义RGB、Y、U、V buffer
    u_int8_t* yBuf = NULL;
    u_int8_t* uBuf = NULL;
    u_int8_t* vBuf = NULL;
    u_int32_t videoFramesWritten = 0;

    /* begin process command line */
    /* point to the specified file names */
    yuvFileName = argv[1];                                  //取YUV文件名
    rgbFileName = argv[2];                                  //取RGB文件名
    frameWidth = atoi(argv[3]);                             //取宽
    frameHeight = atoi(argv[4]);                            //取高

    /* open the YUV file */
    yuvFile = fopen(yuvFileName, "rb");                     //打开YUV文件
    if (yuvFile == NULL)                                    //判断能否打开文件
    {
        printf("cannot find yuv file\n");
        exit(1);
    }
    else
    {
        printf("The input yuv file is %s\n", rgbFileName);
    }
    /* open the RGB file */
    rgbFile = fopen(rgbFileName, "wb");                     //打开已有或新建RGB文件
    if (rgbFile == NULL)                                    //判断能否打开文件
    {
        printf("cannot find rgb file\n");
        exit(1);
    }
    else
    {
        printf("The output rgb file is %s\n", yuvFileName);
    }

    /* get the output buffers for a frame */
    yBuf = (u_int8_t*)malloc(frameWidth * frameHeight);             //赋YUV buffer
    uBuf = (u_int8_t*)malloc((frameWidth * frameHeight) / 4);
    vBuf = (u_int8_t*)malloc((frameWidth * frameHeight) / 4);
    /* get an input buffer for a frame */
    rgbBuf = (u_int8_t*)malloc(frameWidth * frameHeight * 3);       //赋RGB buffer

    if (rgbBuf == NULL || yBuf == NULL || uBuf == NULL || vBuf == NULL)     //判断buffer是否建好
    {
        printf("no enought memory\n");
        exit(1);
    }

    while(fread(yBuf,1,frameWidth*frameHeight,yuvFile)
        &&fread(uBuf,1,frameWidth*frameHeight/4,yuvFile)
        &&fread(vBuf,1,frameWidth*frameHeight/4,yuvFile)) 
    {
        if(YUV2RGB(frameWidth, frameHeight, rgbBuf, yBuf, uBuf, vBuf, flip))
        {
            printf("error");
            return 0;
        }
        fwrite(rgbBuf, 1, frameWidth * frameHeight * 3, rgbFile);   //写RGB文件
        printf("\r...%d", ++videoFramesWritten);
    }

    printf("\n%u %ux%u video frames written\n", 
        videoFramesWritten, frameWidth, frameHeight);

    /* cleanup */

    if(rgbFile!=NULL)                                               //关文件 关buffer
        fclose(rgbFile);
    if(yuvFile!=NULL)   
        fclose(yuvFile);

    if(rgbBuf!=NULL) 
        free(rgbBuf);
    if(yBuf!=NULL)   
        free(yBuf);
    if(uBuf!=NULL)   
        free(uBuf);
    if(vBuf!=NULL)   
        free(vBuf);
    system("pause");
    return(0);
}

实验结果与总结

把实验得到的RGB文件输入RGB to YUV文件后打开新得到的文件，与最开始变换的文件做比较，几乎没有误差。

但是实验过程中

rr = *y + YUVRGB14075[*v];
gg = *y - YUVRGB03455[*u] - YUVRGB07169[*v];
bb = *y + YUVRGB17790[*u];
*r = (unsigned char)(rr<0 ? 0 : rr>255 ? 255 : rr);
*g = (unsigned char)(gg<0 ? 0 : gg>255 ? 255 : gg);
*b = (unsigned char)(bb<0 ? 0 : bb>255 ? 255 : bb);

这一段代码若写为

rr = (unsigned char)(*y + YUVRGB14075[*v]);
gg = (unsigned char)(*y - YUVRGB03455[*u] - YUVRGB07169[*v]);
bb = (unsigned char)(*y + YUVRGB17790[*u]);
*r = (rr<0 ? 0 : rr>255 ? 255 : rr);
*g = (gg<0 ? 0 : gg>255 ? 255 : gg);
*b = (bb<0 ? 0 : bb>255 ? 255 : bb);

则图像会出现明显的红点