在使用一些图像处理SDK时，我们常常会遇到一些图像格式的限制，比如我们从相机流中获取了RGB数据，但是在用某些SDK时却发现SDK不能直接支持该类数据，我们可能需要进行进一步的转换才能调用SDK。因此为了方便广大开发者，本文提供了一些常见的图像转换方法。
先介绍下转换中可能用到的一些函数：其中包括RGB和YUV的互换函数，源于网上流传较多的一些公式，以及经常重复用到的对齐函数
// RGB、YUV互换
int rgbToY(int r, int g, int b) {
return (((66 * r + 129 * g + 25 * b + 128) >> 8) + 16);
}
int rgbToU(int r, int g, int b) {
return (((-38 * r - 74 * g + 112 * b + 128) >> 8) + 128);
}
int rgbToV(int r, int g, int b) {
return (((112 * r - 94 * g - 18 * b + 128) >> 8) + 128);
}
int yuvToR(int y, int u, int v) {
int r = y + ((360 * (v - 128)) >> 8);
return r > 0xFF ? 0xFF : (r < 0 ? 0 : r);
}
int yuvToG(int y, int u, int v) {
int g = y - (((88 * (u - 128) + 184 * (v - 128))) >> 8);
return g > 0xFF ? 0xFF : (g < 0 ? 0 : g);
}
int yuvToB(int y, int u, int v) {
int b = y + ((455 * (u - 128)) >> 8);
return b > 0xFF ? 0xFF : (b < 0 ? 0 : b);
}
1. RGBA32转换为BGR24
举个例子，对于4x2的图片，RGBA32格式内容为：
R1 G1 B1 A1 R2 G2 B2 A2 R3 G3 B3 A3 R4 G4 B4 A4
R5 G5 B5 A5 R6 G6 B6 A6 R7 G7 B7 A7 R8 G8 B8 A8
那么若需要转化为BGR24，内容将变成：
B1 G1 R1 B2 G2 R2 B3 G3 R3 B4 G4 R4
B5 G5 R5 B6 G6 R6 B7 G7 R7 B8 G8 R8
BGR24内容为3个byte一组，RGBA32内容为4个byte一组。因此，对于第一组RGBA32(R1 G1 B1 A1)和第一组BGR24(B1 G1 R1)，其对应关系为：
bgr24[0] = Rgba32[2];
bgr24[1] = Rgba32[1];
bgr24[2] = Rgba32[0];
对应的转换代码：
void rgba32ToBgr24(char *rgba32, char *bgr24, int rgbaLength) {
int groupNum = rgbaLength / 4;
for (int i = 0; i < groupNum; i++) {
*(bgr24) = *(rgba32 + 2);
*(bgr24 + 1) = *(rgba32 + 1);
*(bgr24 + 2) = *rgba32;
bgr24 += 3;
rgba32 += 4;
}
}
2.BGR24转换为NV21
BGR24的每一组 B G R 数据对应了一个像素点，而NV21是一种YUV数据，YUV数据的每个Y会和对应的U和V组成一个像素点，NV21的共用关系是每4个Y（例如下标为：0,1,width,width+1的四个Y）会共用一组U和V（对应下标：U:width x height + 1,V:width x height）。所以对于Y而言，需要计算每一组BGR对应的Y值；但是对于NV21的U和V而言，U和V的大小都是各只有Y的一半，所以我们可以在宽度下标和高度下标都为偶数时计算一组U和V。
void bgr24ToNv21(char *bgr24, char *nv21, int width, int height) {
int yIndex = 0;
int uvIndex = width * height;
int bgrIndex = 0;
int nv21EndPos = width * height * 3 / 2 - 2;
for (int j = 0; j < height; ++j) {
for (int i = 0; i < width; ++i) {
int b = bgr24[bgrIndex++];
int g = bgr24[bgrIndex++];
int r = bgr24[bgrIndex++];
int y = rgbToY(r, g, b);
nv21[yIndex++] = static_cast<char>((y));
if ((j & 1) == 0 && (bgrIndex & 0b100) == 0 && uvIndex < nv21EndPos) {
int u = rgbToU(r, g, b);
int v = rgbToV(r, g, b);
nv21[uvIndex++] = static_cast<char>((v));
nv21[uvIndex++] = static_cast<char>((u));
}
}
}
}
3. NV21转换为BGR24
这是上一个介绍的逆过程，在BGR24转换为NV21时，宽度下标和高度下标都为偶数才进行计算U和V；那么若要将NV21转换为BGR24，则我们需要对每组U和V进行一次复用。
void nv21ToBgr24(char *nv21, char *bgr24, int width, int height) {
int bgrLineSize = width * 3;
//偶数行的bgr数据下标
int evenLineBgrIndex = 0;
//奇数行的bgr数据下标
int oddLineBgrIndex = bgrLineSize;
//当前一行y数据最左边的下标
int yLineStart = 0;
//uv数据的下标
int uvIndex = width * height;
//由于NV21的共用关系，每2行做一次转换
for (int i = 0; i < height; i += 2) {
for (int widthOffset = 0; widthOffset < width; widthOffset += 2) {
char v = nv21[uvIndex];
char u = nv21[uvIndex + 1];
char yEven1 = nv21[yLineStart + widthOffset];
char yEven2 = nv21[yLineStart + widthOffset + 1];
char yOdd1 = nv21[yLineStart + width + widthOffset];
char yOdd2 = nv21[yLineStart + width + widthOffset + 1];
//偶数行YUV转RGB
bgr24[evenLineBgrIndex++] = (char) (yuvToB(yEven1, u, v));
bgr24[evenLineBgrIndex++] = (char) (yuvToG(yEven1, u, v));
bgr24[evenLineBgrIndex++] = (char) (yuvToR(yEven1, u, v));
bgr24[evenLineBgrIndex++] = (char) (yuvToB(yEven2, u, v));
bgr24[evenLineBgrIndex++] = (char) (yuvToG(yEven2, u, v));
bgr24[evenLineBgrIndex++] = (char) (yuvToR(yEven2, u, v));
//奇数行YUV转RGB
bgr24[oddLineBgrIndex++] = (char) (yuvToB(yOdd1, u, v));
bgr24[oddLineBgrIndex++] = (char) (yuvToG(yOdd1, u, v));
bgr24[oddLineBgrIndex++] = (char) (yuvToR(yOdd1, u, v));
bgr24[oddLineBgrIndex++] = (char) (yuvToB(yOdd2, u, v));
bgr24[oddLineBgrIndex++] = (char) (yuvToG(yOdd2, u, v));
bgr24[oddLineBgrIndex++] = (char) (yuvToR(yOdd2, u, v));
uvIndex += 2;
}
evenLineBgrIndex += bgrLineSize;
oddLineBgrIndex += bgrLineSize;
//y增2行
yLineStart += (width << 1);
}
}
4. NV12和NV21的互换
NV21和NV12只是U与V的数据位置不同，只需要替换U和V的位置即可。因此，将NV21转换为NV12的代码同样适用于NV12转换为NV21。可参考如下代码：
void nv21ToNv12(char *nv21, char *nv12, int width, int height) {
int ySize = width * height;
int totalSize = width * height * 3 / 2;
//复制Y
memcpy(nv12, nv21, ySize);
//UV互换
for (int uvIndex = ySize; uvIndex < totalSize; uvIndex += 2) {
*(nv12 + uvIndex) = *(nv21 + uvIndex + 1);
*(nv12 + uvIndex + 1) = *(nv21 + uvIndex);
}
}
5. NV21转YV12
NV21转化为YV12的过程主要是将其UV数据的交叉排序修改为连续排序。可参考如下代码：
void nv21ToYv12(char *nv21, char *yv12, int width, int height) {
int ySize = width * height;
int totalSize = width * height * 3 / 2;
int i420UIndex = ySize;
int i420VIndex = ySize * 5 / 4;
//复制y
memcpy(yv12, nv21, ySize);
//复制uv
for (int uvIndex = ySize; uvIndex < totalSize; uvIndex += 2) {
*(yv12 + i420UIndex++) = *(nv21 + uvIndex);
*(yv12 + i420VIndex++) = *(nv21 + uvIndex + 1);
}
}
6. YUYV转NV12
在YUYV格式中，两个Y共用一组U和V，而NV12是四个Y共用一组U和V，因此，这是一个YUV422转YUV420的过程，需要舍弃一半的U和V，需要注意的是，每一组YUYV是2个像素。可参考如下代码：
void yuyvToNv12(char *yuyv, char *nv12, int width, int height) {
int ySize = width * height;
int lineDataSize = width * 2;
char *nv12UV = nv12 + ySize;
for (int i = 0; i < height; i++, yuyv += lineDataSize) {
if ((i & 1) == 0) {
for (int lineOffset = 0; lineOffset < lineDataSize; lineOffset += 4) {
//拷贝Y
*nv12++ = *(yuyv + lineOffset);
*nv12++ = *(yuyv + lineOffset + 2);
//拷贝UV
int uOffset = lineOffset + 1;
int vOffset = lineOffset + 3;
*nv12UV++ = ((*(yuyv + uOffset)) >> 1) +
((*(yuyv + uOffset + lineDataSize)) >> 1);
*nv12UV++ = ((*(yuyv + vOffset)) >> 1) +
((*(yuyv + vOffset + lineDataSize)) >> 1);
}
} else {
for (int lineOffset = 0; lineOffset < lineDataSize; lineOffset += 4) {
//拷贝Y
*nv12++ = *(yuyv + lineOffset);
*nv12++ = *(yuyv + lineOffset + 2);
}
}
}
}
7. I420和YV12的互换
I420和YV12只是U与V的数据位置不同，因此，I420转换为YV12的代码同样适用于YV12转换为I420。可参考如下代码：
void i420ToYv12(char *i420, char *yv12, int width, int height) {
int ySize = width * height;
int uSize = ySize / 4;
int vSize = uSize;
//复制Y
memcpy(yv12, i420, ySize);
//UV互换
memcpy(yv12 + ySize + uSize, i420 + ySize, uSize);
memcpy(yv12 + ySize, i420 + ySize + vSize, vSize);
}
8. I420转换为YUYV
I420和YUYV相比，I420的U和V只有YUYV的一半，这是一个YUV420转YUV422的过程，缺损的数据只能通过复用U和V弥补。
void i420ToYuyv(char *i420, char *yuyv, int width, int height) {
int yuyvLineSize = width * 2;
int i420YIndex = 0;
int i420UIndex = width * height;
int i420VIndex = width * height * 5 / 4;
int yuyvLineStart = 0;
for (int i = 0; i < height; i += 2) {
for (int lineOffset = 0; lineOffset < yuyvLineSize; lineOffset += 4) {
char u = *(i420 + i420UIndex++);
char v = *(i420 + i420VIndex++);
//偶数行数据赋值
int yuyvOffset = yuyvLineStart + lineOffset;
*(yuyv + yuyvOffset) = *(i420 + i420YIndex);
*(yuyv + yuyvOffset + 1) = u;
*(yuyv + yuyvOffset + 2) = *(i420 + i420YIndex + 1);
*(yuyv + yuyvOffset + 3) = v;
//奇数行数据赋值
int yuyvNextLineOffset = yuyvLineStart + yuyvLineSize + lineOffset;
*(yuyv + yuyvNextLineOffset) = *(i420 + i420YIndex + width);
*(yuyv + yuyvNextLineOffset + 1) = u;
*(yuyv + yuyvNextLineOffset + 2) = *(i420 + i420YIndex + width + 1);
*(yuyv + yuyvNextLineOffset + 3) = v;
i420YIndex += 2;
}
i420YIndex += width;
yuyvLineStart += (width << 2);
}
}
9. I420转换为NV12
I420转换为NV12就是把各自连续的U和V修改为交叉存储，示例代码如下
void i420ToNv12(char *i420, char *nv12, int width, int height) {
int ySize = width * height;
int totalSize = width * height * 3 / 2;
int i420UIndex = ySize;
int i420VIndex = ySize * 5 / 4;
//复制y
memcpy(nv12, i420, ySize);
//复制uv
for (int uvIndex = ySize; uvIndex < totalSize; uvIndex += 2) {
*(nv12 + uvIndex) = *(i420 + i420UIndex++);
*(nv12 + uvIndex + 1) = *(i420 + i420VIndex++);
}
}
10. I420转换为NV21
I420转换为NV12就是把各自连续的U和V修改为交叉存储，并且替换U和V的位置。示例代码如下
void i420ToNv21(char *i420, char *nv21, int width, int height) {
int ySize = width * height;
int totalSize = width * height * 3 / 2;
int i420UIndex = ySize;
int i420VIndex = ySize * 5 / 4;
//复制y
memcpy(nv21, i420, ySize);
//复制uv
for (int uvIndex = ySize; uvIndex < totalSize; uvIndex += 2) {
*(nv21 + uvIndex + 1) = *(i420 + i420UIndex++);
*(nv21 + uvIndex) = *(i420 + i420VIndex++);
}
}
网友评论