How to convert a YV12 image to BGRA using opencv? - c++

Question

To convert YV12 to BGRA, I do like below:
cv::Mat yuv(height * 3/2, width, CV_8UC1, src);
cv::Mat dst;
cv::cvtColor(yuv, dst, CV_YUV2BGRA_YV12);
That code will work when the "src" is a contiguous buffer.
In case I have a YV12 buffer with its Y, U, V components stored in 3 separate planes and they are not contiguous, how can I do the conversion using cvtColor()?

Answer 1

For using cv::cvtColor, you have to copy the separate components into continuous image buffer as noted by Christoph Rackwitz.
I don't think copying the components is trivial, and I think you deserve an answer.
The continuous YV12 image applies the following structure:
Y (cols x rows) - Top Image.
V (cols/2 x rows/2) - Below Y
U (cols/2 x rows/2) - Below V
We may allocate a continuous buffer, and copy the components to the allocated buffer.
Since OpenCV "hides" the buffer in the data member, I thought it would be simpler to allocate the buffer using new, and create a cv:Mat that "wraps" the buffer.
Example:
unsigned char *YV12 = new unsigned char[cols*rows*3/2]; //Allocate continuous memory buffer for storing YV12 in as single buffer.
cv::Mat inYV12 = cv::Mat(rows*3/2, cols, CV_8UC1, YV12); //cv::Mat wrapper of YV12 buffer.
Defining cv:Mat wrappers to Y, U and V, sharing the continuous buffer:
cv::Mat inY0 = cv::Mat(rows, cols, CV_8UC1, YV12); //Copy Y color channel.
cv::Mat inU0 = cv::Mat(rows/2, cols/2, CV_8UC1, YV12 + cols*rows); //U color channel (after Y).
cv::Mat inV0 = cv::Mat(rows/2, cols/2, CV_8UC1, YV12 + cols*rows + cols*rows/4); //V color channel (after U).
Copy the three separate images to the continuous image:
inY.copyTo(inY0);
inU.copyTo(inU0);
inV.copyTo(inV0);
Complete code sample:
#include "opencv2/opencv.hpp"
int main()
{
const int cols = 192;
const int rows = 108;
//Read Y, U and V into 3 separate buffers for testing.
////////////////////////////////////////////////////////////////////////////
unsigned char *Y = new unsigned char[cols*rows];
unsigned char *U = new unsigned char[cols*rows / 4];
unsigned char *V = new unsigned char[cols*rows / 4];
FILE *f;
f = fopen("test.yv12", "rb"); //Note: In Visual Studio, you may have to use fopen_s or define _CRT_SECURE_NO_WARNINGS
fread(Y, 1, cols*rows, f); //Read Y
fread(U, 1, cols*rows/4, f); //Read U
fread(V, 1, cols*rows/4, f); //Read V
fclose(f);
//Define cv::Mat "wrappers".
cv::Mat inY = cv::Mat(rows, cols, CV_8UC1, Y);
cv::Mat inU = cv::Mat(rows/2, cols/2, CV_8UC1, U);
cv::Mat inV = cv::Mat(rows/2, cols/2, CV_8UC1, V);
////////////////////////////////////////////////////////////////////////////
unsigned char *YV12 = new unsigned char[cols*rows*3/2]; //Allocate continuous memory buffer for storing YV12 in as single buffer.
cv::Mat inYV12 = cv::Mat(rows*3/2, cols, CV_8UC1, YV12); //cv::Mat wrapper of YV12 buffer.
//Define cv::Mat "wrappers" to the continuous memory buffer.
cv::Mat inY0 = cv::Mat(rows, cols, CV_8UC1, YV12); //Copy Y color channel.
cv::Mat inU0 = cv::Mat(rows/2, cols/2, CV_8UC1, YV12 + cols*rows); //U color channel (after Y).
cv::Mat inV0 = cv::Mat(rows/2, cols/2, CV_8UC1, YV12 + cols*rows + cols*rows/4); //V color channel (after U).
//Copy the three separate images to the continuous image.
inY.copyTo(inY0);
inU.copyTo(inU0);
inV.copyTo(inV0);
//Convert YV12 to BGRA:
cv::Mat dstBGRA;
//cv::cvtColor(inYV12, dstBGRA, cv::CV_YUV2BGRA_YV12);
cv::cvtColor(inYV12, dstBGRA, cv::COLOR_YUV2BGRA_YV12);
//Release memory
delete[] Y;
delete[] U;
delete[] V;
delete[] YV12;
cv::imwrite("dstBGRA.png", dstBGRA); //Save output for testing
//Show result (for testing):
cv::imshow("dstBGRA", dstBGRA);
cv::waitKey();
cv::destroyAllWindows();
return 0;
}
Input (converted to continuous grayscale image):
Output: