实验一&实验二

彩色空间转换实验

一、基本原理

1.RGB与YUV

RGB:

存储方式：文件数据按照B,G,R的顺序依次排列，每相邻3个字节保存一个像素的信息。存储顺序为按行从左向右存储。

YUV：

存储方式：以YUV的顺序按行从左向右分别存储，存完整幅图的Y后存U，类推到V。
以4；2:0格式采样。4:2:0格式是指色差信号U，V的取样频率为亮度信号取样频率的四分之一，在水平方向和垂直方向上的取样点数均为Y的一半。

2.YUV与RGB空间的相互转换

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

对于数字信号，为了减少数据量也需要对色差信号进行压缩。压缩过的色差信号用Cb，Cr表示，为了使Y，Cb，Cr的幅度相同，转换公式与上面模拟信号的转换系数略有差异：
Cr=0.713(R−Y)=0.500R−0.4187G−0.0813B
Cb=0.564(B−Y)=−0.1684R−0.3316G+0.500B

为了使得量化后的色差信号幅度没有负值，还要加128的偏置，最终结果为：
Cr=0.500R−0.4187G−0.0813B+128
Cb=−0.1684R−0.3316G+0.500B+128

RGB->YUV

本实验对于色差信号仍以U、V来表示。V对应数字分量的Cr，U对应数字分量的Cb。则RGB转YUV的公式如下 ：

通过矩阵运算可以解得YUV转RGB的公式：

3.码电平分配及数字表达式

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

二、流程及关键代码

(1).RGB to YUV的代码由教师给出，这里不分析

(2).YUV to RGB

１.程序初始化（打开两个文件、定义变量和缓冲区等）

这里定义了存ＹＵＶ整体数据的ｙｕｖｂｕｆｆｅｒ，单独存ｙ／ｕ／ｖ的三个ｂｕｆｆｅｒ，和存输出ＲＧＢ的一个ｂｕｆｆｅｒ　　

    u_int frameWidth = 256;         /* --width=<uint> */
    u_int frameHeight = 256;        /* --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* yuvBuf = 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 */
    yuvFileName = argv[1];
    rgbFileName = argv[2];
    frameWidth = atoi(argv[3]);
    frameHeight = atoi(argv[4]);

    /* 打开ＹＵＶｆｉｌｅ */
    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("cannot find rgb file\n");
        exit(1);
    }
    else
    {
        printf("The output rgb file is %s\n", rgbFileName);
    }

    /* 开辟ＹＵＶ缓冲区 */
    yuvBuf = (u_int8_t*)malloc((frameWidth * frameHeight *3)/2);
    yBuf = (u_int8_t*)malloc(frameWidth * frameHeight);
    uBuf = (u_int8_t*)malloc((frameWidth * frameHeight) / 4);
    vBuf = (u_int8_t*)malloc((frameWidth * frameHeight) / 4);


    /*　开辟ＲＧＢ缓冲区 */
     rgbBuf = (u_int8_t*)malloc(frameWidth * frameHeight * 3);

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

２.读取ＹＵＶ文件，抽取ＹＵＶ数据写入缓冲区

用ｗｈｉｌｅ函数，这里只读取一帧图像

while (fread(yuvBuf, 1, (frameWidth * frameHeight * 3)/2, yuvFile)) 

３.调用ＹＵＶ２ＲＧＢ函数实现ＹＵＶ到ＲＧＢ数据转换

ＹＵＶ２ＲＧＢ的参数分别为图像宽、高、ｙｕｖ缓冲，ｒｇｂ缓冲和ｙ，ｕ，ｖ缓冲

if(YUV2RGB(frameWidth, frameHeight, yuvBuf, rgbBuf, yBuf,uBuf,vBuf,flip))
        {
            printf("error");
            return 0;
        }

具体ＹＵＶ２ＲＧＢ函数写在ｙｕｖ２ｒｇｂ．ｃｐｐ里
这里使用的是四个缓冲区，Ｙ（２５６×２５６），Ｕ（１２８×１２８），Ｖ（１２８×１２８），ｒｇｂ＿ｏｕｔ（３＊２５６＊２５６）
４个基本指针，指向正在操作的行Ｙ，Ｕ，Ｖ，ＯＵＴ
５个移动指针，用于操作当前数据ＰＹ，ＰＹ２，ＰＵ，ＰＶ，ｐＯＵＴ，ｐＯＵＴ２
上采样，可以理解为每一个点恢复成四个点，即使用相同的Ｕ，Ｖ值

/*YUV2RGB函数*/
int YUV2RGB (int x_dim, int y_dim, void *yuvbmp, void *rgb_out0,void *yin,void *uin,void *vin,int flip)
{
    static int init_done = 0;
     /*定义变量*/
    long  size,stride_y,stride_uv,stride_out;

    unsigned char *yuvbmp0,*rgb_out;
    unsigned char *y0,*u0,*v0,*y,*u,*v;
    unsigned char *py,*py2,*pu,*pv,*pout,*pout2;

    yuvbmp0=(unsigned char *)yuvbmp;
    y0=(unsigned char *)yin;
    u0=(unsigned char *)uin;
    v0=(unsigned char *)vin;
    y=(unsigned char *)yin;
    u=(unsigned char *)uin;
    v=(unsigned char *)vin;
    rgb_out=(unsigned char *)rgb_out0;

    /*分别定义y,u,v,RGB缓冲区每行的长度变量*/
    stride_y=x_dim;
    stride_uv=x_dim/2;
    stride_out=x_dim*3;

    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;


  /*将YUVbuffer中数据分散存储到Y0、U0、V0三个缓存区*/
    for(int i1=0;i1<size ;i1++)
    {
        *y0=*yuvbmp0;
        y0++;
        yuvbmp0++;
    }
    for(int i2=0;i2<size/4 ;i2++)
    {
        *u0=*yuvbmp0;
        u0++;
        yuvbmp0++;
    }
    for(int i3=0;i3<size/4 ;i3++)
    {
        *v0=*yuvbmp0;
        v0++;
        yuvbmp0++;
    }

// convert YUV to RGB   上采样 这里不显示flip=0,即RGB按RGB顺序的情况代码
for (int j = 0; j < y_dim; j+=2)//两行一次循环
        {
                py=y;
                py2=y+stride_y;//指向第二行的首位
                pu=u;
                pv=v;
                pout=rgb_out;
                pout2=rgb_out+stride_out;RGB第二行
        for(int i=0;i<x_dim;i+=2)
        {
            for(int k=0;k<2;k++)//计算相邻两个像素点的RGB值（每两个点用一个相同的U、V，每个点有一个对应的Ｙ）
            {
            *pout=(unsigned char)( *py + RGBYUV17718[*pu] + RGBYUV00013[*pv]-226.6286);//B
            *(pout+1)=(unsigned char)( *py + RGBYUV03441[*pu] + RGBYUV07139[*pv]+135.4193);//G
            *(pout+2)=(unsigned char)( *py + RGBYUV14020[*pv]-179.4497);//R
            pout+=3;
            py++;
            }
            for(int k2=0;k2<2;k2++)//第二行同上
            {
            *pout2=(unsigned char)( *py2 + RGBYUV17718[*pu] + RGBYUV00013[*pv]-226.6286);
            *(pout2+1)=(unsigned char)( *py2 + RGBYUV03441[*pu] + RGBYUV07139[*pv]+135.4193);
            *(pout2+2)=(unsigned char)( *py2 + RGBYUV14020[*pv]-179.4497);
            pout2+=3;
            py2++;
            }
            pu++;
            pv++;

        }
        y+=2*stride_y;//指向下两行
        u+=stride_uv;//指向下一行
        v+=stride_uv;//指向下一行
        rgb_out+=2*stride_out;//指向下两行
       }


}
    return 0;

void InitLookupTable()//提前算好公式对应值存在数组里，加快运算速度
{
    int i;

    for (i = 0; i < 256; i++) RGBYUV14020[i] = (float)1.4020 * i;
    for (i = 0; i < 256; i++) RGBYUV03441[i] = (float)-0.3441 * i;
    for (i = 0; i < 256; i++) RGBYUV07139[i] = (float)-0.7139 * i;
    for (i = 0; i < 256; i++) RGBYUV17718[i] = (float)1.7718* i;
    for (i = 0; i < 256; i++) RGBYUV00013[i] = (float)-0.0013 * i;

}

４.写入ＲＧＢ文件，关闭文件，释放缓冲区等

/*将缓存好的ＲＧＢ　ｂｕｆｆｅｒ数据限制在０～２５５之间*/
for (i = 0; i < frameWidth*frameHeight*3; i++)
        {
            if (rgbBuf[i] < 16) rgbBuf[i] = 16;
            if (rgbBuf[i] > 235) rgbBuf[i] = 235;
        }


        fwrite(rgbBuf, 1, frameWidth * frameHeight*3, rgbFile);


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

/* 释放缓冲区，关闭文件 */
    free(rgbBuf);
    free(yBuf);
    free(uBuf);
    free(vBuf);
    free(yuvBuf);

    fclose(rgbFile);
    fclose(yuvFile);

    return(0);

以上代码未做溢出处理，得到图像有噪点，因为强制用（unsigned char )会导致有些溢出部分直接把剩下地位赋值给图像，出现噪点。可以将计算结果存在double型缓存区里，再赋值给rgbbuffer.

double *rgb_out = (double*)malloc(x_dim * y_dim * 3);//开辟double缓存区暂存计算结果防止溢出
for (int i = 0; i < 3 * size;i++)
        {
            if (*rgb_outtem < 0)
                *rgb_outtem = 0;
            if (*rgb_outtem > 255)
                *rgb_outtem = 255;
            *rgb_out00 =(unsigned char) *rgb_outtem;
            rgb_out00++;
            rgb_outtem++;

        }

四、结果及结论

结论：

1.RGB转YUV图像时四点取一点，YUV图像转RGB图像时由于上采样，一点扩四点，使得得到的RGB图像和原来略显不同。
2.注意计算时溢出问题，不然可能会有较大噪点，如下图

3.注意堆栈指针操作，直接用堆指针加减操作容易出错

图像文件的读写和转换实验

实验原理

1．BMP文件的组成结构
BMP（全称 Bitmap）是 Windows 操作系统中的标准图像文件格式，可以分成两类：设备
相关位图（DDB）和设备无关位图（DIB），使用非常广。它采用位映射存储格式，除了图像
深度可选以外，在绝大多数应用中不采用其他任何压缩，因此，BMP 文件所占用的空间很大。
BMP 文件的图像深度可选 lbit、4bit、8bit、16bit 及 24bit。BMP 文件存储数据时，图像的扫
描方式是按从左到右、从下到上的顺序。由于 BMP 文件格式是 Windows 环境中交换与图有
关的数据的一种标准，因此在 Windows 环境中运行的图形图像软件都支持 BMP 图像格式。
典型的 BMP 图像文件由四部分组成：
（1）位图头文件数据结构，它包含 BMP 图像文件的类型、显示内容等信息；
（2）位图信息数据结构，它包含有 BMP 图像的宽、高、压缩方法，以及定义颜色等信
息；
（3）调色板，这个部分是可选的，有些位图需要调色板，有些位图，比如真彩色图（24位的 BMP）就不需要调色板；
（4）位图数据，这部分的内容根据 BMP 位图使用的位数不同而不同，在 24 位图中直接使用 RGB，而其他的小于 24 位的使用调色板中颜色索引值。
相应的数据结构可表示如下:
位图文件头主要包括：

typedef struct tagBITMAPFILEHEADER { 
 2
WORD bfType; /* 说明文件的类型 */ 
DWORD bfSize; /* 说明文件的大小，用字节为单位 */ 
WORD bfReserved1; /* 保留，设置为 0 */ 
WORD bfReserved2; /* 保留，设置为 0 */ 
DWORD bfOffBits; /* 说明从 BITMAPFILEHEADER 结构开始到实际的图像数 据之间的字节偏移量 */ 
} BITMAPFILEHEADER; 

(2) 位图信息头主要包括：

typedef struct tagBITMAPINFOHEADER { 
DWORD biSize; /* 说明结构体所需字节数 */ 
LONG biWidth; /* 以像素为单位说明图像的宽度 */ 
LONG biHeight; /* 以像素为单位说明图像的高速 */ 
WORD biPlanes; /* 说明位面数，必须为 1 */ 
WORD biBitCount; /* 说明位数/像素，1、2、4、8、24 */ 
DWORD biCompression; /* 说明图像是否压缩及压缩类型 BI_RGB，BI_RLE8，BI_RLE4， BI_BITFIELDS */ 
DWORD biSizeImage; /* 以字节为单位说明图像大小，必须是 4 的整数倍*/ 
LONG biXPelsPerMeter; /*目标设备的水平分辨率，像素/米 */ LONG biYPelsPerMeter; /*目标设备的垂直分辨率，像素/米 */ DWORD biClrUsed; /* 说明图像实际用到的颜色数，如果为 0，则颜色数为 2 的 biBitCount 次方 */ 
DWORD biClrImportant; /*说明对图像显示有重要影响的颜色索引的数目，如果是 0，表 示都重要。*/ 
} BITMAPINFOHEADER; 

(3) 调色板实际上是一个数组，它所包含的元素与位图所具有的颜色数相同，决定于biClrUsed 和 biBitCount 字段。数组中每个元素的类型是一个 RGBQUAD 结构。真彩色无调色板部分。

typedef struct tagRGBQUAD { 
BYTE rgbBlue; /*指定蓝色分量*/ 
BYTE rgbGreen; /*指定绿色分量*/ 
BYTE rgbRed; /*指定红色分量*/ 
BYTE rgbReserved; /*保留，指定为 0*/ 
} RGBQUAD; 

(4) 紧跟在调色板之后的是图像数据字节阵列。对于用到调色板的位图，图像数据就是该像素颜色在调色板中的索引值（逻辑色）。对于真彩色图，图像数据就是实际的 R、G、B值。图像的每一扫描行由表示图像像素的连续的字节组成，每一行的字节数取决于图像的颜色数目和用像素表示的图像宽度。规定每一扫描行的字节数必须是 4 的整倍数，也就是DWORD 对齐的。扫描行是由底向上存储的，这就是说，阵列中的第一个字节表示位图左下角的像素，而最后一个字节表示位图右上角的像素。
2．字节序
不同的计算机系统采用不同的字节序存储数据，同样一个 4 字节的 32 位整数，在内存中存储的方式不同。字节序分为小尾字节序(Little Endian)和大尾字节序(Big Endian)。Intel 处理
器大多数使用小尾字节序，Motorola 处理器大多数使用大尾(Big Endian)字节序。
小尾就是低位字节排放在内存的低端，高位字节排放在内存的高端，即所谓的“低位在前，高位在后”。大尾就是高位字节排放在内存的低端，低位字节排放在内存的高端，即所谓的“高位在前，低位在后”。 TCP/IP 各层协议将字节序定义为大尾，因此 TCP/IP 协议中使用的字节序通常称之为网络字节序。
在实现 BMP 文件头信息的写入时，需要注意整数保存时的字节序。例如：文件大小是以Intel 序保存的。在编程前先用二进制打开方式观察 BMP 文件各个部分的数据存储格式。

实验流程

读取BMP文件信息，获得R、G、B值，将R、G、B值顺序调整，转换为Y、U、V值，将Y、U、V值写入新文件。

代码分析

参数：pic1.bmp 80 pic2.bmp 70 pic3.bmp 60 out.yuv
main.cpp代码

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <Windows.h>
#include <math.h>
#include "bmp2yuv.h"
#define u_int8_t    unsigned __int8
#define u_int       unsigned __int32
#define u_int32_t   unsigned __int32

BITMAPFILEHEADER File_header;
BITMAPINFOHEADER Info_header;

int main(int argc, char** argv)
{   
    bool flip = FALSE;                                      //BMP文件倒序存的所以要做倒序
    char* bmpFileName = NULL;                               //文件名
    char* yuvFileName = NULL;
    FILE* bmpFile = NULL;                                   //文件指针
    FILE* yuvFile = NULL;
    u_int8_t* rgbBuf = NULL;                                //buffer
    u_int8_t* yBuf = NULL;
    u_int8_t* uBuf = NULL;
    u_int8_t* vBuf = NULL;
    u_int32_t videoFramesWritten = 0;
    u_int frameWidth, frameHeight;                          //图像宽高
    int i=0,j=0;

   /***********打开YUV文件***********/
    yuvFileName = argv[argc-1];                             //取YUV文件名
    yuvFile = fopen(yuvFileName, "ab");                     //打开已有或新建YUV文件
    if (yuvFile == NULL)
    {
        printf("cannot find yuv file\n");
        exit(1);
    }
    else
    {
        printf("The output yuv file is %s\n", yuvFileName);
    }
    /***********循环读BMP文件并写入YUV文件***********/
    for (i = 0; i < argc/2-1; i++)                          //循环(argc/2-1)次
    {
        videoFramesWritten = 0;
        /***********打开BMP文件***********/
        bmpFileName = argv[2*i+1];                          //取BMP文件名
        bmpFile = fopen(bmpFileName, "rb");                 //读取BMP文件
        if (bmpFile == NULL)
        {
            printf("cannot find bmp file\n");
            exit(1);
        }
        else
        {
            printf("The input bmp file is %s\n", bmpFileName);
        }

        /***********read BMP fileheader & infoheader***********/
        if (fread(&File_header, sizeof(BITMAPFILEHEADER), 1, bmpFile) != 1)
        {
            printf("read file header error!");
            exit(0);
        }
        if (File_header.bfType != 0x4D42)
        {
            printf("Not bmp file!");
            exit(0);
        }
        else
        {
            printf("this is a bmp file.\n", File_header.bfType);
        }
        if (fread(&Info_header, sizeof(BITMAPINFOHEADER), 1, bmpFile) != 1)
        {
            printf("read info header error!");
            exit(0);
        }
        /***********end read header***********/

        frameWidth = Info_header.biWidth;               //宽
        frameHeight = Info_header.biHeight;             //高
        printf("width=%d  height=%d\n", frameWidth, frameHeight);

        /***********开BUFFER***********/
        rgbBuf = (unsigned char *)malloc(sizeof(unsigned char)*frameHeight*frameWidth * 3);
        yBuf = (unsigned char*)malloc(sizeof(unsigned char)*frameHeight*frameWidth);
        uBuf = (unsigned char*)malloc(sizeof(unsigned char)*frameHeight*frameWidth/4);
        vBuf = (unsigned char*)malloc(sizeof(unsigned char)*frameHeight*frameWidth/4);
        if (rgbBuf == NULL || yBuf == NULL || uBuf == NULL || vBuf == NULL)     //判断buffer是否建好
        {
            printf("no enought memory\n");
            exit(1);
        }

        ReadRGB(rgbBuf, bmpFile, File_header,Info_header);

        if (RGB2YUV(frameWidth, frameHeight, rgbBuf, yBuf, uBuf, vBuf, flip))
        {
            printf("error");
            return 0;
        }

        /**********带上这一段有bug*********
        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;
        }
        ***********************************/

        /**********按参数写YUV文件**********/
        for (j = 0; j <atoi(argv[2*i+2]);j++)
        {
            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%ux%u video frames written\n", frameWidth, frameHeight);

        printf("\n\n");
        if (rgbBuf != NULL) 
            free(rgbBuf);
        if (yBuf != NULL) 
            free(yBuf);
        if (uBuf != NULL) 
            free(uBuf);
        if (vBuf != NULL) 
            free(vBuf);
        if (bmpFile != NULL) 
            fclose(bmpFile);
    }
    if (yuvFile != NULL) 
        fclose(yuvFile);

    system("pause");
    return 0;
}

bmp2yuv.cpp代码

#include<Windows.h>
#include<stdio.h>
#include<math.h>
#include"bmp2yuv.h"

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

/***********调色板***********/
bool MakePalette(FILE * pFile, BITMAPFILEHEADER &file_h, BITMAPINFOHEADER & info_h, RGBQUAD *pRGB_out)
{
    if ((file_h.bfOffBits - sizeof(BITMAPFILEHEADER) - info_h.biSize) == sizeof(RGBQUAD)*pow((float)2, info_h.biBitCount))
    {
        fseek(pFile, sizeof(BITMAPFILEHEADER) + info_h.biSize, 0);
        fread(pRGB_out, sizeof(RGBQUAD), (unsigned int)pow((float)2, info_h.biBitCount), pFile);
        return true;
    }
    else
        return false;
}

/***********读取BMP图像数据***********/
void ReadRGB(unsigned char * rgbbuf, FILE *bmpfile, BITMAPFILEHEADER &file_h ,BITMAPINFOHEADER & info_h )
{
    u_int Width=0, Height=0;
    int k=0;
    unsigned char *bmpBuf=NULL;
    unsigned char *rgb=NULL;
    unsigned char mask=0;
    int difference = 0;
    rgb = rgbbuf;

/*每一扫描行的字节数必须是4的整数倍，与DWORD对齐
  若扫描行字节数不为4的整数倍，要补零为4的整数倍
  difference用来计算实际字节数和用于图像信息存储的字节数之差*/

    if (((info_h.biWidth*info_h.biBitCount/8)%4) == 0)
        Width = info_h.biWidth*info_h.biBitCount/8;
    else
        Width = (info_h.biWidth*info_h.biBitCount+31)/32*4;

    if ((info_h.biHeight % 2) == 0)
        Height= info_h.biHeight;
    else
        Height = info_h.biHeight + 1;

    difference = Width-info_h.biWidth*info_h.biBitCount/8 ;

    bmpBuf = (unsigned char *)malloc(sizeof(unsigned char)*Height*Width);

    RGBQUAD *pRGB = (RGBQUAD *)malloc(sizeof(RGBQUAD)*(unsigned int)pow((float)2, info_h.biBitCount));

    if (!MakePalette(bmpfile, file_h, info_h, pRGB))
    {
        printf("No palette!\n");                    //没有调色板
    }

    fread(bmpBuf, 1, Height*Width, bmpfile);

    if (info_h.biBitCount == 24)
    {
        for (k=0; k<Height*Width; k++)
        {
        /***********补零***********/
            if (difference != 0)
            {
                if (difference == 1)
                {
                    if ((k+1)%Width == 0)
                        continue;
                }
                else if (difference == 2)
                {
                    if ((k+1)%Width == 0 || (k+2)%Width == 0)
                        continue;
                }
                else
                {
                    if ((k+1)%Width == 0 || (k+2)%Width == 0 || (k+3)%Width == 0)
                        continue;
                }
            }
            *rgb = *(bmpBuf+k);
            rgb++;
        }
    }
    if(pRGB!=NULL) 
        free(pRGB);
    if(bmpBuf != NULL)
        free(bmpBuf);
}

/***********把所读取的BMP数据的RGB信息转换为YUV数据***********/
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;                               //建rgb指针
    unsigned char *y, *u, *v;                               //建yuv指针
    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;                                   //尺寸=宽×高

    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(x_dim * y_dim);
    v_buffer  = (unsigned char *)malloc(x_dim * y_dim);

    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;

    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 ++;
        }
    }

    for (j = 0; j < y_dim/2; j ++)
    {
        psu = sub_u_buf + j * x_dim / 2;
        pu1 = u_buffer + 2 * j * x_dim;
        pu2 = u_buffer + (2 * j + 1) * x_dim;

        psv = sub_v_buf + j * x_dim / 2;
        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;
}

bmp2yuv.h代码

#ifndef BMP2YUV_H_
#define BMP2YUV_H_

void ReadRGB(unsigned char * rgbbuf, FILE *bmpfile, BITMAPFILEHEADER &file_h ,BITMAPINFOHEADER & info_h );

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

void InitLookupTable();

#endif

实验结果与总结

运行结果如图：

bitCount	原BMP图像	生成YUV序列中的一帧
24bit
8bit
4bit
1bit