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

实验原理

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文件。

代码分析
rgb2yuv.h代码

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

void InitLookupTable();

rgb2yuv.cpp代码

#include "stdlib.h"
    #include "rgb2yuv.h"

    static float RGBYUV02990[256], RGBYUV05870[256], RGBYUV01140[256];
    static float RGBYUV01684[256], RGBYUV03316[256];
    static float RGBYUV04187[256], RGBYUV00813[256];


    int RGB2YUV (int x_dim, int y_dim, void *bmp, void *y_out, void *u_out, void *v_out, int flip)
    {
        static int init_done = 0;

        long i, j, size;
        unsigned char *r, *g, *b;
        unsigned char *y, *u, *v;
        unsigned char *pu1, *pu2, *pv1, *pv2, *psu, *psv;
        unsigned char *y_buffer, *u_buffer, *v_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;

        // allocate memory
        y_buffer = (unsigned char *)y_out;
        sub_u_buf = (unsigned char *)u_out;
        sub_v_buf = (unsigned char *)v_out;
        u_buffer = (unsigned char *)malloc(size * sizeof(unsigned char));
        v_buffer = (unsigned char *)malloc(size * sizeof(unsigned char));
        if (!(u_buffer && v_buffer))
        {
            if (u_buffer) free(u_buffer);
            if (v_buffer) free(v_buffer);
            return 2;
        }

        b = (unsigned char *)bmp;
        y = y_buffer;
        u = u_buffer;
        v = v_buffer;

        // convert RGB to YUV
        if (!flip) {
            for (j = 0; j < y_dim; j ++)
            {
                y = y_buffer + (y_dim - j - 1) * x_dim;
                u = u_buffer + (y_dim - j - 1) * x_dim;
                v = v_buffer + (y_dim - j - 1) * x_dim;

                for (i = 0; i < x_dim; i ++) {
                    g = b + 1;
                    r = b + 2;
                    *y = (unsigned char)(  RGBYUV02990[*r] + RGBYUV05870[*g] + RGBYUV01140[*b]);
                    *u = (unsigned char)(- RGBYUV01684[*r] - RGBYUV03316[*g] + (*b)/2          + 128);
                    *v = (unsigned char)(  (*r)/2          - RGBYUV04187[*g] - RGBYUV00813[*b] + 128);
                    b += 3;
                    y ++;
                    u ++;
                    v ++;
                }
            }
        } else {
            for (i = 0; i < size; i++)
            {
                g = b + 1;
                r = b + 2;
                *y = (unsigned char)(  RGBYUV02990[*r] + RGBYUV05870[*g] + RGBYUV01140[*b]);
                *u = (unsigned char)(- RGBYUV01684[*r] - RGBYUV03316[*g] + (*b)/2          + 128);
                *v = (unsigned char)(  (*r)/2          - RGBYUV04187[*g] - RGBYUV00813[*b] + 128);
                b += 3;
                y ++;
                u ++;
                v ++;
            }
        }

        // subsample UV
        for (j = 0; j < y_dim/2; j ++)
        {
            psu = sub_u_buf + j * x_dim / 2;
            psv = sub_v_buf + j * x_dim / 2;
            pu1 = u_buffer + 2 * j * x_dim;
            pu2 = u_buffer + (2 * j + 1) * x_dim;
            pv1 = v_buffer + 2 * j * x_dim;
            pv2 = v_buffer + (2 * j + 1) * x_dim;
            for (i = 0; i < x_dim/2; i ++)
            {
                *psu = (*pu1 + *(pu1+1) + *pu2 + *(pu2+1)) / 4;
                *psv = (*pv1 + *(pv1+1) + *pv2 + *(pv2+1)) / 4;
                psu ++;
                psv ++;
                pu1 += 2;
                pu2 += 2;
                pv1 += 2;
                pv2 += 2;
            }
        }

        free(u_buffer);
        free(v_buffer);

        return 0;
    }


    void InitLookupTable()
    {
        int i;

        for (i = 0; i < 256; i++) RGBYUV02990[i] = (float)0.2990 * i;
        for (i = 0; i < 256; i++) RGBYUV05870[i] = (float)0.5870 * i;
        for (i = 0; i < 256; i++) RGBYUV01140[i] = (float)0.1140 * i;
        for (i = 0; i < 256; i++) RGBYUV01684[i] = (float)0.1684 * i;
        for (i = 0; i < 256; i++) RGBYUV03316[i] = (float)0.3316 * i;
        for (i = 0; i < 256; i++) RGBYUV04187[i] = (float)0.4187 * i;
        for (i = 0; i < 256; i++) RGBYUV00813[i] = (float)0.0813 * i;
    }

main.cpp代码

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

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

/*
 * rgb2yuv
 * required arg1 should be the input RAW RGB24 file
 * required arg2 should be the output RAW YUV12 file
 */ 
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 = TRUE;               /* --flip */
    unsigned int i;

    /* internal variables */
    char* rgbFileName = NULL;
    char* yuvFileName = NULL;
    FILE* rgbFile = NULL;
    FILE* yuvFile = NULL;
    u_int8_t* rgbBuf = NULL;
    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 */
    rgbFileName = argv[1];
    yuvFileName = argv[2];

    frameWidth = atoi(argv[3]);
    frameHeight = atoi(argv[4]);



    /* open the RGB file */
    rgbFile = fopen(rgbFileName, "rb+");
    if (rgbFile == NULL)
    {
        printf("cannot find rgb file\n");
        exit(1);
    }
    else
    {
        printf("The input rgb file is %s\n", rgbFileName);
    }

    /* open the RAW file */
    yuvFile = fopen(yuvFileName, "wb+");
    if (yuvFile == NULL)
    {
        printf("cannot find yuv file\n");
        exit(1);
    }
    else
    {
        printf("The output yuv file is %s\n", yuvFileName);
    }

    /* get an input buffer for a frame */
    rgbBuf = (u_int8_t*)malloc(frameWidth * frameHeight * 3);

    /* get the output buffers for a frame */
    yBuf = (u_int8_t*)malloc(frameWidth * frameHeight);
    uBuf = (u_int8_t*)malloc((frameWidth * frameHeight) / 4);
    vBuf = (u_int8_t*)malloc((frameWidth * frameHeight) / 4);

    if (rgbBuf == NULL || yBuf == NULL || uBuf == NULL || vBuf == NULL)
    {
        printf("no enought memory\n");
        exit(1);
    }

    while (fread(rgbBuf, 1, frameWidth * frameHeight * 3, rgbFile)) 
    {
        if(RGB2YUV(frameWidth, frameHeight, rgbBuf, yBuf, uBuf, vBuf, flip))
        {
            printf("error");
            return 0;
                    }

        for (i = 0; i < frameWidth*frameHeight; i++)
        {
            if (yBuf[i] < 16) yBuf[i] = 16;
            if (yBuf[i] > 235) yBuf[i] = 235;
        }

        for (i = 0; i < frameWidth*frameHeight/4; i++)
        {
            if (uBuf[i] < 16) uBuf[i] = 16;
            if (uBuf[i] > 240) uBuf[i] = 240;

            if (vBuf[i] < 16) vBuf[i] = 16;
            if (vBuf[i] > 240) vBuf[i] = 240;
        }

        fwrite(yBuf, 1, frameWidth * frameHeight, yuvFile);
        fwrite(uBuf, 1, (frameWidth * frameHeight) / 4, yuvFile);
        fwrite(vBuf, 1, (frameWidth * frameHeight) / 4, yuvFile);

        printf("\r...%d", ++videoFramesWritten);
    }

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

    /* cleanup */
    free(rgbBuf);
    free(yBuf);
    free(uBuf);
    free(vBuf);
    fclose(rgbFile);
    fclose(yuvFile);

    return(0);
}

yuv2rgb.h代码

#ifndef YUV2RGB_H_
#define YUV2RGB_H_
#endif

int YUV2RGB(int x_dim, int y_dim, void *y_int, void *u_int, void *v_int, void *out_rgb, int flip);

void InitLookupTable();

yuv2rgb.cpp代码

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


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

int YUV2RGB(int x_dim, int y_dim, void *y_int, void *u_int, void *v_int, void *out_rgb, int flip)
{
    static int init_done = 0;
    long i, j, size;   //define buffer
    float r_tmp, b_tmp, g_tmp;
    unsigned char *y, *u, *v;
    unsigned char *r,*g,*b;
    unsigned char *y_buffer, *v_buffer, *u_buffer;
    if (init_done == 0)
    {
        InitLookupTable();
        init_done = 1;
    }
    if ((x_dim % 2) || (y_dim % 2)) return 1;
    size = x_dim * y_dim;

    y_buffer = (unsigned char *)y_int;
    u_buffer = (unsigned char *)u_int;
    v_buffer = (unsigned char *)v_int;
    y = y_buffer;
    v = v_buffer;
    u = u_buffer;
    b = (unsigned char *)out_rgb;
    if (!flip)
    {

    }
    else
    {
        for (j = 0; j < y_dim; j++)
        {
            for (i = 0; i < x_dim; i++)
            {
                g = b + 1;
                r = b + 2;
                r_tmp = ((*y) + YUVRGB14075[*v]);
                g_tmp = ((*y) - YUVRGB07169[*v] - YUVRGB03455[*u]);
                b_tmp = ((*y) + YUVRGB1779[*u]);
                *r = (unsigned char)(r_tmp<0 ? 0 : r_tmp>255 ? 255 : r_tmp);
                *g = (unsigned char)(g_tmp<0 ? 0 : g_tmp>255 ? 255 : g_tmp);
                *b = (unsigned char)(b_tmp<0 ? 0 : b_tmp>255 ? 255 : b_tmp);
                b += 3;
                y++;
                u = u_buffer + (j / 2)*x_dim/2 + i / 2;
                v = v_buffer + (j / 2)*x_dim/2 + i / 2;
            }
        }
    }

    return 0;
}


void InitLookupTable()
{
    int i;
    for (i = 0; i < 256; i++)YUVRGB14075[i] = (float)1.14075*(i-128);
    for (i = 0; i < 256; i++)YUVRGB07169[i] = (float)0.7169*(i-128);
    for (i = 0; i < 256; i++)YUVRGB03455[i] = (float)0.3455*(i-128);
    for (i = 0; i < 256; i++)YUVRGB1779[i] = (float)1.779*(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)
{
    u_int frameWidth = 352;
    u_int frameHeight = 240;
    bool flip = TRUE;
    unsigned int i;

    FILE* yuvFile = NULL;
    FILE* rgbFile = NULL;
    char* rgbFileName = NULL;
    char* yuvFileName = NULL;
    u_int8_t* rgbBuf = NULL;
    u_int8_t* yBuf = NULL;
    u_int8_t* uBuf = NULL;
    u_int8_t* vBuf = NULL;
    u_int32_t videoFramesWritten = 0;

    yuvFileName = argv[1];
    rgbFileName = argv[2];
    frameWidth = atoi(argv[3]);
    frameHeight = atoi(argv[4]);


    /* open the YUV file */
    yuvFile = fopen(yuvFileName, "rb+");
    if (yuvFile == NULL)
    {
        printf("cannot find yuv file\n");
        /*exit(1);*/
    }
    else
    {
        printf("The input yuv file is %s\n", yuvFileName);
    }

    rgbFile = fopen(rgbFileName, "wb+");
    if (rgbFile == NULL)
    {
        printf("can't find rgb file\n");
        exit(1);
    }
    else
    {
        printf("The output file is %s\n", rgbFileName);
    }
    /* get an input buffer */
    yBuf = (u_int8_t*)malloc(frameWidth * frameHeight);
    uBuf = (u_int8_t*)malloc((frameWidth * frameHeight) / 4);
    vBuf = (u_int8_t*)malloc((frameWidth * frameHeight) / 4);
    /* get an output buffer */
    rgbBuf = (u_int8_t*)malloc(frameWidth * frameHeight * 3);

    if (rgbBuf == NULL || yBuf == NULL || uBuf == NULL || vBuf == NULL)
    {
        printf("no enought memory\n");
        exit(1);
    }
    /*   yuv2rgb*/
    fread(yBuf, 1, frameWidth * frameHeight, yuvFile);
    fread(uBuf, 1, frameWidth * frameHeight / 4, yuvFile);
    fread(vBuf, 1, frameWidth * frameHeight / 4, yuvFile);
    //DAI TIANXIE
    if (YUV2RGB(frameWidth, frameHeight, yBuf, uBuf, vBuf, rgbBuf, flip))
    {
        printf("error");
        return 0;
    }
    if (fwrite(rgbBuf, 1, frameWidth *frameHeight * 3, rgbFile))
        printf("\n%u %ux%u video frames written\n",
        ++videoFramesWritten, frameWidth, frameHeight);
    /* cleanup */
    if (rgbBuf)
        free(rgbBuf);
    if (yBuf)
        free(yBuf);
    if (uBuf)
        free(uBuf);
    if (vBuf)
        free(vBuf);
    if (rgbFile)
        fclose(rgbFile);
    if (yuvFile)
        fclose(yuvFile);

    return(0);
}

实验结果与总结

把输出得到的RGB文件输入RGB2YUV文件进行转换后打开输出的YUV文件并与第一次输出的YUV文件作对比，发现几乎没有不同。