前言

本专栏将不间断更新有关C++音视频开发的内容，其中有初级章、中级章与高级章的内容，包括但不限于音视频基础、FFmpeg实战、QT、流媒体客户端、流媒体服务器、WebRTC实战、Android NDK等等。是博主花了将近5000元购买的课程中的知识点，其中也掺杂着一些我的个人理解，希望能帮助大家和我一起入门音视频开发。

视频基础知识

1.RGB

1.1RGB的排列

我们前面已经讲过了RGB色彩表示，这里我们重点讲解RGB的排列。

通常图像像素是按照RGB顺序进行排列的，但有些图像处理要转换成其他排列顺序，比如我们经常使用的OpenCv就经常转换为BGR的排列方式。

为什么需要转换为BGR这样子的排列呢？这其实是算法上的问题：

OpenCV在1999年由Intel建立，当时主流的摄像头制造商和软件供应商提供的摄像头采集的图像的通道排列顺序为BGR，另外对于图片，位图BMP是最简单的，也是Windows显示图片的基本格式，其文件扩展名为*.BMP。在Windows下，任何格式的图片文件（包括视频播放）都要转化为位图才能显示出来，各种格式的图片文件也都是在位图格式的基础上采用不同的压缩算法生成的，值得注意的是位图BMP的格式就是BGR。正是基于BGR在当时被广泛使用，于是早期OpenCV开发者就选择BGR颜色格式，这也就成为了一种规范一直用到现在。

上图是关于各种类型色彩通道的信息表示，根据以往的知识来分析十分的简单，在此处就不多费口舌了。

2.YUV

2.1 YUV概念

▲ 与我们熟知的RGB类似，YUV也是一种颜色编码方式，但是它是指：亮度参量（Y:Luminance或Luma）和色度参量（UV：Chrominace或Chroma）分开进行表示的像素编码格式。

▲ 将Y与UV分开的好处是什么呢？这样子做可以避免互相干扰，而且没有UV信息一样可以显示完整的图像，因而解决了彩色电视与黑白电视的兼容问题；还可以降低色彩的采样率而不会对图像质量有太多的影响，降低了视屏信号传输时对频宽（带宽）的要求。

总结：为什么使用YUV? 显示器从黑白显示器演变过来的,为了和以前格式兼容以及YUV存储的数据比RGB要少很多。

▲ YUV是一种比较笼统的说法，针对它的具体排列方式，可以分为很多种具体的格式：

- 打包（packed）格式：将每个像素点Y、U、V分量交叉排列并以像素点为单元连续存放在同一数组中，通常几个相邻的像素点组成一个宏像素（macro-pixel）

- 平面（planar）格式：使用三个数组分开连续的存放Y、U、V三个分量，即Y、U、V分别存放在各自的数组中。

2.2 YUV采样表示法

▲ YUV采用A:B:C表示法来描述Y,U,V采样频率比例，下图中黑点表示采样像素点Y分量，空心圆表示采样像素点的UV分量。主要分为YUV 4:4:4 、YUV 4:2:2、YUV 4:2:0，这几种常用的类型。

★ 4:4:4 表示色度频道没有下采样，即一个Y分量对应着一个U分量和一个V分量。

★ 4:2:2 表示2:1的水平下采样，没有垂直下采样，即每两个Y分量共用一个U分量和一个V分量。

★ 4:2:0 表示2:1的水平下采样，2:1的垂直下采样，即每四个Y分量公用一个U分量和一个V分量。（应用最广泛的格式，播放器必须支持）

重要：4：2：0并不意味着只有Y、Cb两个分量，而没有Cr分量。它实际指的是每行扫描线来说，只有一种色度分量，它以2：1的抽样率存储。相邻的扫描行存储不同的色度分量，也就是说，如果一行是4：2：0的话，下一行就是4：0：2，再下一行是4：2：0…以此类推

2.3 YUV数据存储

▲ 下面每一个分量数据存储在一个char（或byte）中为例描述YUV的数据存储方式。

（1）- 4:4:4 格式

（2）- 4:2:2 格式

（3）- 4:2:0 格式

2.3.1——4:4:4格式

2.3.2 ——4:2:2格式

2.3.3——4:2:0格式（应用最广泛的格式，播放器必须支持）

3、RGB与YUV的转换

RGB与YUV关系：RGB用于屏幕图像的展示，YUV用于采集与编码。

3、1 YUV转RGB：

公式：

代码：

#include <iostream>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>
using namespace cv;
cv::Mat RGB2YUV(cv::Mat src, bool accelerate = false){
  CV_Assert(src.channels() == 3);
  cv::Mat dst(src.size(), CV_32FC3);  //这里最好要用浮点型,避免丧失精度
  cv::Vec3b rgb;
  int r = src.rows;
  int c = src.cols;
  for (int i = 0; i < r; ++i){
  for (int j = 0; j < c; ++j){
    rgb = src.at<cv::Vec3b>(i, j);
    int B = rgb[0]; int G = rgb[1]; int R = rgb[2];
    if (accelerate == false){
    dst.at<Vec3f>(i, j)[0] = R*0.299 + G*0.587 + B*0.114; //Y
    dst.at<Vec3f>(i, j)[1] = -0.169*R - 0.331*G + 0.500*B + 128; //U
    dst.at<Vec3f>(i, j)[2] = 0.500*R - 0.419*G - 0.081*B + 128;  //V
    }
    else{
    dst.at<Vec3f>(i, j)[0] = ((R << 6) + (R << 3) + (R << 2) + R + (G << 7) + (G << 4) + (G << 2) + (G << 1) + (B << 4) + (B << 3) + (B << 2) + B) >> 8; //Y
    dst.at<Vec3f>(i, j)[1] = (-((R << 5) + (R << 3) + (R << 1)+ R) - ((G << 6) + (G << 4) + (G << 2)+G) + (B << 7) + 32768) >> 8; //U
    dst.at<Vec3f>(i, j)[2] = ((R << 7) - ((G << 6) + (G << 5) + (G << 3) + (G << 3) + G) - ((B << 4) + (B << 2) + B) + 32768 )>> 8; //V
    }
  }
  }
  dst.convertTo(dst, CV_8UC3);
  return dst;
}
cv::Mat YUV2RGB(cv::Mat src, bool accelerate = false){
  CV_Assert(src.channels() == 3);
  cv::Mat dst(src.size(), CV_32FC3); //这里一定要用浮点型,避免丧失精度
  cv::Vec3b yuv;
  int r = src.rows;
  int c = src.cols;
  for (int i = 0; i < r; ++i){
  for (int j = 0; j < c; ++j){
    yuv = src.at<cv::Vec3b>(i, j);
    int Y = yuv[0]; int U = yuv[1]; int V = yuv[2];
    U = U - 128;
    V = V - 128;
    if (accelerate == false){
    dst.at<Vec3f>(i, j)[0] = Y + 1.770*U;//B
    dst.at<Vec3f>(i, j)[1] = Y - 0.343*U - 0.714*V;//G
    dst.at<Vec3f>(i, j)[2] = Y + 1.403*V;//R
    }
    else{
    dst.at<Vec3f>(i, j)[0] = Y + U + ((U * 198) >> 8);
    dst.at<Vec3f>(i, j)[1] = Y -((U * 88) >> 8) - ((V * 183)>>8);
    dst.at<Vec3f>(i, j)[2] = Y + V + ( (V * 103) >> 8);
    }
  }
  }
  dst.convertTo(dst, CV_8UC3);
  return dst;
}
int main(){
  cv::Mat src = cv::imread("I:\\Learning-and-Practice\\2019Change\\Image process algorithm\\Img\\4.JPG");
  if (src.empty()){
  return -1;
  }
  cv::Mat dst, dst1, dst2;
  opencv自带/
  double t2 = (double)cv::getTickCount(); //测时间
  cv::cvtColor(src, dst1, CV_RGB2YUV); //RGB2YUV
  t2 = (double)cv::getTickCount() - t2;
  double time2 = (t2 *1000.) / ((double)cv::getTickFrequency());
  std::cout << "Opencv_RGB2YUV=" << time2 << " ms. " << std::endl << std::endl;
  //RGB2YUV//
  double t1 = (double)cv::getTickCount(); //测时间
  dst = RGB2YUV(src,true); //RGB2YUV
  dst2 = YUV2RGB(dst,true); //YUV2BGR
  t1 = (double)cv::getTickCount() - t1;
  double time1 = (t1 *1000.) / ((double)cv::getTickFrequency());
  std::cout << "My_RGB2YUV=" << time1 << " ms. " << std::endl << std::endl;
  cv::namedWindow("src", CV_WINDOW_NORMAL);
  imshow("src", src);
  cv::namedWindow("My_RGB2YUV", CV_WINDOW_NORMAL);
  imshow("My_RGB2YUV", dst);
  cv::namedWindow("My_YUV2RGB", CV_WINDOW_NORMAL);
  imshow("My_YUV2RGB", dst2);
  cv::namedWindow("Opencv_RGB2YUV", CV_WINDOW_NORMAL);
  imshow("Opencv_RGB2YUV", dst1);
  cv::waitKey(0);
  return 0;
}

3、2 RGB24转YUV420P

公式：

#include <iostream>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>
using namespace cv;
cv::Mat RGB2YUV(cv::Mat src, bool accelerate = false){
  CV_Assert(src.channels() == 3);
  cv::Mat dst(src.size(), CV_32FC3);  //这里最好要用浮点型,避免丧失精度
  cv::Vec3b rgb;
  int r = src.rows;
  int c = src.cols;
  for (int i = 0; i < r; ++i){
  for (int j = 0; j < c; ++j){
    rgb = src.at<cv::Vec3b>(i, j);
    int B = rgb[0]; int G = rgb[1]; int R = rgb[2];
    if (accelerate == false){
    dst.at<Vec3f>(i, j)[0] = R*0.299 + G*0.587 + B*0.114; //Y
    dst.at<Vec3f>(i, j)[1] = -0.169*R - 0.331*G + 0.500*B + 128; //U
    dst.at<Vec3f>(i, j)[2] = 0.500*R - 0.419*G - 0.081*B + 128;  //V
    }
    else{
    dst.at<Vec3f>(i, j)[0] = ((R << 6) + (R << 3) + (R << 2) + R + (G << 7) + (G << 4) + (G << 2) + (G << 1) + (B << 4) + (B << 3) + (B << 2) + B) >> 8; //Y
    dst.at<Vec3f>(i, j)[1] = (-((R << 5) + (R << 3) + (R << 1)+ R) - ((G << 6) + (G << 4) + (G << 2)+G) + (B << 7) + 32768) >> 8; //U
    dst.at<Vec3f>(i, j)[2] = ((R << 7) - ((G << 6) + (G << 5) + (G << 3) + (G << 3) + G) - ((B << 4) + (B << 2) + B) + 32768 )>> 8; //V
    }
  }
  }
  dst.convertTo(dst, CV_8UC3);
  return dst;
}
cv::Mat YUV2RGB(cv::Mat src, bool accelerate = false){
  CV_Assert(src.channels() == 3);
  cv::Mat dst(src.size(), CV_32FC3); //这里一定要用浮点型,避免丧失精度
  cv::Vec3b yuv;
  int r = src.rows;
  int c = src.cols;
  for (int i = 0; i < r; ++i){
  for (int j = 0; j < c; ++j){
    yuv = src.at<cv::Vec3b>(i, j);
    int Y = yuv[0]; int U = yuv[1]; int V = yuv[2];
    U = U - 128;
    V = V - 128;
    if (accelerate == false){
    dst.at<Vec3f>(i, j)[0] = Y + 1.770*U;//B
    dst.at<Vec3f>(i, j)[1] = Y - 0.343*U - 0.714*V;//G
    dst.at<Vec3f>(i, j)[2] = Y + 1.403*V;//R
    }
    else{
    dst.at<Vec3f>(i, j)[0] = Y + U + ((U * 198) >> 8);
    dst.at<Vec3f>(i, j)[1] = Y -((U * 88) >> 8) - ((V * 183)>>8);
    dst.at<Vec3f>(i, j)[2] = Y + V + ( (V * 103) >> 8);
    }
  }
  }
  dst.convertTo(dst, CV_8UC3);
  return dst;
}
int main(){
  cv::Mat src = cv::imread("I:\\Learning-and-Practice\\2019Change\\Image process algorithm\\Img\\4.JPG");
  if (src.empty()){
  return -1;
  }
  cv::Mat dst, dst1, dst2;
  opencv自带/
  double t2 = (double)cv::getTickCount(); //测时间
  cv::cvtColor(src, dst1, CV_RGB2YUV); //RGB2YUV
  t2 = (double)cv::getTickCount() - t2;
  double time2 = (t2 *1000.) / ((double)cv::getTickFrequency());
  std::cout << "Opencv_RGB2YUV=" << time2 << " ms. " << std::endl << std::endl;
  //RGB2YUV//
  double t1 = (double)cv::getTickCount(); //测时间
  dst = RGB2YUV(src,true); //RGB2YUV
  dst2 = YUV2RGB(dst,true); //YUV2BGR
  t1 = (double)cv::getTickCount() - t1;
  double time1 = (t1 *1000.) / ((double)cv::getTickFrequency());
  std::cout << "My_RGB2YUV=" << time1 << " ms. " << std::endl << std::endl;
  cv::namedWindow("src", CV_WINDOW_NORMAL);
  imshow("src", src);
  cv::namedWindow("My_RGB2YUV", CV_WINDOW_NORMAL);
  imshow("My_RGB2YUV", dst);
  cv::namedWindow("My_YUV2RGB", CV_WINDOW_NORMAL);
  imshow("My_YUV2RGB", dst2);
  cv::namedWindow("Opencv_RGB2YUV", CV_WINDOW_NORMAL);
  imshow("Opencv_RGB2YUV", dst1);
  cv::waitKey(0);
  return 0;
}

【C++音视频开发】视频篇 | RGB与YUV

前言