实验一&实验二

彩色空间转换实验

一、基本原理

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
1.程序初始化(打开两个文件、定义变量和缓冲区等)

这里定义了存YUV整体数据的yuvbuffer,单独存y/u/v的三个buffer,和存输出RGB的一个buffer  

    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 */
    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 */
        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);
    }

    /* 开辟YUV缓冲区 */
    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);


    /* 开辟RGB缓冲区 */
     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);
    }
2.读取YUV文件,抽取YUV数据写入缓冲区

用while函数,这里只读取一帧图像

while (fread(yuvBuf, 1, (frameWidth * frameHeight * 3)/2, yuvFile)) 
3.调用YUV2RGB函数实现YUV到RGB数据转换

YUV2RGB的参数分别为图像宽、高、yuv缓冲,rgb缓冲和y,u,v缓冲

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

具体YUV2RGB函数写在yuv2rgb.cpp里
这里使用的是四个缓冲区,Y(256×256),U(128×128),V(128×128),rgb_out(3*256*256)
4个基本指针,指向正在操作的行Y,U,V,OUT
5个移动指针,用于操作当前数据PY,PY2,PU,PV,pOUT,pOUT2
上采样,可以理解为每一个点恢复成四个点,即使用相同的U,V值

/*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,每个点有一个对应的Y)
            {
            *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;

}
4.写入RGB文件,关闭文件,释放缓冲区等
/*将缓存好的RGB buffer数据限制在0~255之间*/
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这里写图片描述$1
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值