YUV2RGB

彩色空间转换----YUV2RGB

1．彩色空间转换的基本思想及转换公式

（1）YUV与RGB空间的相互转换

              由电视原理可知，亮度和色差信号的构成如下：
      Y＝0.2990R+0.5870G+0.1140B
      R-Y＝0.7010R-0.5870G-0.1140B
      B-Y＝-0.2990R-0.5870G+0.8860B

             为了使色差信号的动态范围控制在0.5之间，需要进行归一化，对色差信号引入压缩系数。归一化后的色差信号为：

      U＝-0.1684R-0.3316G+0.5B
      V＝0.5R-0.4187G-0.0813B
      由RGB转YUV的公式可推出YUV转RGB的公式如下，
       R = Y + 1.4075(V - 128)
       G = Y -  0.3455(U - 128) - 0.7169(V - 128)
       B = Y + 1.779(U - 128)

（2） 码电平分配及数字表达式 

        亮电平信号量化后码电平分配在对分量信号进行8比特均匀量化时，共分为256个等间隔的量化级。为了防止信号变动造成过载，在256级上端留20级，下端留16级作为信号超越动态范围的保护带。
      色差信号量化后码电平分配色差信号经过归一化处理后，动态范围为-0.5－0.5，让色差零电平对应码电平128，色差信号总共占225个量化级。在256级上端留15级，下端留16级作为信号超越动态范围的保护带。故在YUV转RGB时，UV分量需要先减去128。

（3）色度格式

         4:2:0格式是指色差信号U，V的取样频率为亮度信号取样频率的四分之一，在水平方向和垂直方向上的取样点数均为Y的一半，故UV分量分别所占的空间为Y的1/4。

（4）存储的排列方式

      在4:2:0 的色度格式下,

     RGB文件的排列顺序为

          b1g1r1, b2g2r2,b3g3r3,b4g4r4,......

     YUV文件的排列顺序为

         Y1，Y2，Y3，Y4，Y5，Y6，Y7，Y8，.........

         U1，U2，U3，U4，.......
         V1，V2，V3，V4，........

 2.  实验流程 

      （1） 程序初始化

               打开两个文件test.tuv和test.rgb；

               定义变量包括指向输入输出文件的文件指针、图片的宽和高等；

               开辟4个缓冲区；

    （2） 读取YUV文件，抽取YUV数据分别写入缓冲区y_buf、u_buf、v_buf；

    （3） 调用YUV2RGB的函数实现YUV到RGB数据的转换,并将数据写入缓冲区rgb_buf；

    （4） 将rgb_buf中的数据写入RGB文件；

    （5） 程序收尾工作（关闭文件，释放缓冲区）；

    （6） 将得到的rgb文件通过rgb2yuv程序得到新的yuv文件，用yuvplayer打开，与原始的yuv文件进行对比。

 3.  关键代码分析

    yuv2rgb.h

#ifndef YUV2RGB_H_
#define YUV2RGB_H_

int YUV2RGB (int x_dim, int y_dim,void *y_in, void *u_in, void *v_in,void *bmp, int flip);
          
void InitLookupTable();
#endif

  main.cpp

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

/* 为防止不同计算机软件对int分配字节的不同，这里做统一的定义*/
#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 = 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 */

//argv[0]是当前执行的exe文件名,其中包含该文件的路径名
yuvFileName = argv[1];
rgbFileName = argv[2];


frameWidth = atoi(argv[3]);/* 这里由于argv[3]和argv[4]中的数据以字符串类型存储，需要引用atoi函数，将字符串强制转换为整型 */
frameHeight = atoi(argv[4]);

/*int main(int argc, char** argv) 调用：命令名 参数1  参数2 ......参数n; argc= n+1;
       argv[0]自动指向当前执行的程序的全路径名 */
/* 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);
}

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

/* get the input 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);
/* get an output buffer for a frame */
rgbBuf = (u_int8_t*)malloc(frameWidth * frameHeight * 3);


if (rgbBuf == NULL || yBuf == NULL || uBuf == NULL || vBuf == NULL)
{
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, yBuf, uBuf, vBuf, rgbBuf, flip))
{
printf("error");
return 0;
}
fwrite(rgbBuf, 1, frameWidth * frameHeight*3, rgbFile);

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.cpp

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

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

int YUV2RGB (int x_dim, int y_dim,void *y_in, void *u_in, void *v_in,void *bmp, 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;
float psr,psg,psb;

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;
sub_u_buf = (unsigned char *)u_in;
sub_v_buf = (unsigned char *)v_in;
u_buffer = (unsigned char *)malloc(size * sizeof(unsigned char));
v_buffer = (unsigned char *)malloc(size * sizeof(unsigned char));
//将U, V扩充之后，U,V所占的空间大小与Y相同

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;

// exspand UV
for (j = 0; j < y_dim/2; j ++)
{
psu = sub_u_buf + j * x_dim / 2;//sub_u_buf是指向输入u_in的指针，psu指向输入的每一行
psv = sub_v_buf + j * x_dim / 2;
pu1 = u_buffer + 2 * j * x_dim;// pu1指向u_buffer的奇数行
pu2 = u_buffer + (2 * j + 1) * x_dim;//pu2指向u_buffer的偶数行
pv1 = v_buffer + 2 * j * x_dim;
pv2 = v_buffer + (2 * j + 1) * x_dim;
for (i = 0; i < x_dim/2; i ++)
{
*pu1 = *psu ;
*(pu1+1) = *psu;
*pu2 = *psu ;
*(pu2+1) = *psu;//将输入的一个像素的U以田字格形式赋给输出中的4个像素点

*pv1 = *psv ;
*(pv1+1) = *psv;
*pv2 = *psv ;
*(pv2+1) = *psv;
            
psu ++;
psv ++;
pu1 += 2;
pu2 += 2;
pv1 += 2;
pv2 += 2;
}
}

    // convert YUV to RGB
for (j = 0; j < size; j++)
{
g = b + 1;
r = b + 2;
psr = *y+YUVRGB14075[*v];
if(psr > 255)
psr = 255;
if(psr <0)
psr = 0;
*r = (unsigned char)psr;
psg = *y-YUVRGB034455[*u]-YUVRGB07169[*v];
if(psg > 255)
psg = 255;
if(psg <0)
psg = 0;
*g = (unsigned char)psg;
psb = *y+YUVRGB1779[*u];
if(psb > 255)
psb = 255;
if(psb <0)
psb = 0;
*b = (unsigned char)psb;
b += 3;
y ++;
u ++;
v ++;
}
/*unsigned char 的数据范围是0--255，如果公式右边的计算结果越界，产生的图片就会发生错误。
         在这里设置了三个中间变量,先对公式的结果进行判断，再进行数据赋值*/

free(u_buffer);
free(v_buffer);
//每一个malloc对应一个free
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++) YUVRGB034455[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++) YUVRGB1779[i]      = (float)1.779 *  (i-128);
}
//部分查找表法，将公式简化,提高运行效率

 4.  实验结果及分析

       problem：

     在设置中间变量判断公式计算结果在0到255之前，公式计算的结果产生越界，文件显示如下，产生很多红色小块

       

     

            改进上述问题之后，这里选取了3份图片为例，左图为原始的YUV文件，右图为经过yuv->rgb->yuv两重变换之后得到的YUV文件，经对比变换之后的图片与原文件视觉上没有太大差别。

  example1 

    example2

   example3   

    example4   

5.结论

         通过实验结果的分析可知，程序可成功将yuv文件转换为rgb文件，并且变换前后在视觉上没有太大差异。

6.总结

 （1）  掌握文件的打开、关闭、读写和定位；

  （2） 设置可执行文件的命令参数和工作目录 

               打开项目属性--->配置属性---->调试----->命令行参数依次为：参数1 参数2 参数3 参数4 ...... ,                      

        该实验中，工作目录必须填写输入文件test1.yuv所在的地址，否则无法打开文件,参数3和4也要与yuv文件的宽和高相匹配；

       

(3)学会建立动态数组以及指针的运用，包括头文件<malloc.h>的设置，空间的申请malloc()，赋值和空间回收free();

(4)学会使用部分查找表法，提高运行效率；

(5)每种数据类型都有数据范围，要避免越界；

(6)程序调试，逻辑错误的查找。