如何转换RGB – > YUV – > RGB（双向）

我想要一对转换算法，一个从RGB到YUV，另一个从YUV到RGB，它们是彼此相反的。 也就是说，往返转换应保持值不变。 （如果您愿意，将YUV替换为Y’UV，YUV，YCbCr，YPbPr。）

这样的事情存在吗？ 如果是这样，它是什么？

发布的解决方案（ 如何在C / C ++中执行RGB-> YUV转换？ ， http：//www.fourcc.org/fccyvrgb.php,http ： //en.wikipedia.org/wiki/YUV ）只是反转（当省略钳位到[0,255]时，两个3×3矩阵是反转的）。 但是省略这种钳位可以产生负亮度等问题，这会对YUV空间中的图像处理造成严重破坏。 保持钳位使转换非线性，这使得定义逆变得棘手。

是的，存在可逆转换。

equasys GmbH发布了从RGB到YUV，YCbCr和YPbPr的可逆转换，以及每种情况适合的解释，这种钳位的真正含义以及与参考的链接。 （就像一个好的答案。）

对于我自己的应用程序（jpg图像，而不是模拟电压）YCbCr是合适的，所以我为这两个转换编写了代码。 实际上，对于许多图像而言，在256中，相反的值相差不到1个部分; 并且前后图像在视觉上无法区分。

PIL的色彩空间转换YCbCr – > RGB因提及equasys的网页而受到赞誉。

其他答案，可能会令人怀疑地提高equasys的精确度和简洁性：

RGB到YUV再返回

在维基百科上有一个很好的关于YUV主题的图表，它描述了YUV420p的布局。 但是，如果你像我一样，你想要NV21，有时称为YUV420sp，它将V和U组件交错在一个平面上，所以在这种情况下，这个图表是错误的，但它让你对它的工作原理有直觉。

此格式（NV21）是Android相机预览的标准图片格式。 YUV 4：2：0平面图像，具有8位Y样本，接着是具有8位2×2子采样色度样本的交织V / U平面。

因此，我看到的很多代码只是在不考虑Endianess的情况下从字面上开始编码。 此外，它们倾向于仅支持YUV到RGB并且仅支持一种或两种格式。 然而，我想要一些更值得信赖的东西，结果发现从Android源代码库获取的C ++代码就可以了。 它几乎是直接的C ++，应该可以在任何项目中轻松使用。

JNI / C ++代码，它采用RGB565图像并将其转换为NV21

在这种情况下，从Java开始，但很容易用C或C ++传入包含RGB565图像的字节数组并输出NV21字节数组。 

#include  #include  #include  #include "Converters.h" #define JNI(X) JNIEXPORT Java_algorithm_ImageConverter_##X #ifdef __cplusplus extern "C" { #endif void JNI(RGB565ToNV21)(JNIEnv *env, jclass *, jbyteArray aRGB565in, jbyteArray aYUVout, jint width, jint height) { //get jbyte array into C space from JVN jbyte *rgb565Pixels = env->GetByteArrayElements(aRGB565in, NULL); jbyte *yuv420sp = env->GetByteArrayElements(aYUVout, NULL); size_t pixelCount = width * height; uint16_t *rgb = (uint16_t *) rgb565Pixels; // This format (NV21) is the standard picture format on Android camera preview. YUV 4:2:0 planar // image, with 8 bit Y samples, followed by interleaved V/U plane with 8bit 2x2 subsampled // chroma samples. int uvIndex = pixelCount; for (int row = 0; row < height; row++) { for (int column = 0; column < width; column++) { int pixelIndex = row * width + column; uint8_t y = 0; uint8_t u = 0; uint8_t v = 0; chroma::RGB565ToYUV(rgb[pixelIndex], &y, &u, &v); yuv420sp[pixelIndex] = y; if (row % 2 == 0 && pixelIndex % 2 == 0) { #if __BYTE_ORDER == __LITTLE_ENDIAN yuv420sp[uvIndex++] = u; yuv420sp[uvIndex++] = v; #else yuv420sp[uvIndex++] = v; yuv420sp[uvIndex++] = u; #endif } } } //release temp reference of jbyte array env->ReleaseByteArrayElements(aYUVout, yuv420sp, 0); env->ReleaseByteArrayElements(aRGB565in, rgb565Pixels, 0); } #ifdef __cplusplus } #endif

Converters.h

正如您将在标题中看到的那样，有许多不同的转换选项可用于/来自任意数量的格式。 

 /* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef HW_EMULATOR_CAMERA_CONVERTERS_H #define HW_EMULATOR_CAMERA_CONVERTERS_H #include  #ifndef __BYTE_ORDER #error "could not determine byte order" #endif /* * Contains declaration of framebuffer conversion routines. * * NOTE: RGB and big/little endian considerations. Wherever in this code RGB * pixels are represented as WORD, or DWORD, the color order inside the * WORD / DWORD matches the one that would occur if that WORD / DWORD would have * been read from the typecasted framebuffer: * * const uint32_t rgb = *reinterpret_cast(framebuffer); * * So, if this code runs on the little endian CPU, red color in 'rgb' would be * masked as 0x000000ff, and blue color would be masked as 0x00ff0000, while if * the code runs on a big endian CPU, the red color in 'rgb' would be masked as * 0xff000000, and blue color would be masked as 0x0000ff00, */ namespace chroma { /* * RGB565 color masks */ #if __BYTE_ORDER == __LITTLE_ENDIAN static const uint16_t kRed5 = 0x001f; static const uint16_t kGreen6 = 0x07e0; static const uint16_t kBlue5 = 0xf800; #else // __BYTE_ORDER static const uint16_t kRed5 = 0xf800; static const uint16_t kGreen6 = 0x07e0; static const uint16_t kBlue5 = 0x001f; #endif // __BYTE_ORDER static const uint32_t kBlack16 = 0x0000; static const uint32_t kWhite16 = kRed5 | kGreen6 | kBlue5; /* * RGB32 color masks */ #if __BYTE_ORDER == __LITTLE_ENDIAN static const uint32_t kRed8 = 0x000000ff; static const uint32_t kGreen8 = 0x0000ff00; static const uint32_t kBlue8 = 0x00ff0000; #else // __BYTE_ORDER static const uint32_t kRed8 = 0x00ff0000; static const uint32_t kGreen8 = 0x0000ff00; static const uint32_t kBlue8 = 0x000000ff; #endif // __BYTE_ORDER static const uint32_t kBlack32 = 0x00000000; static const uint32_t kWhite32 = kRed8 | kGreen8 | kBlue8; /* * Extracting, and saving color bytes from / to WORD / DWORD RGB. */ #if __BYTE_ORDER == __LITTLE_ENDIAN /* Extract red, green, and blue bytes from RGB565 word. */ #define R16(rgb) static_cast((rgb) & kRed5) #define G16(rgb) static_cast(((rgb) & kGreen6) >> 5) #define B16(rgb) static_cast(((rgb) & kBlue5) >> 11) /* Make 8 bits red, green, and blue, extracted from RGB565 word. */ #define R16_32(rgb) static_cast((((rgb) & kRed5) << 3) | (((rgb) & kRed5) >> 2)) #define G16_32(rgb) static_cast((((rgb) & kGreen6) >> 3) | (((rgb) & kGreen6) >> 9)) #define B16_32(rgb) static_cast((((rgb) & kBlue5) >> 8) | (((rgb) & kBlue5) >> 14)) /* Extract red, green, and blue bytes from RGB32 dword. */ #define R32(rgb) static_cast((rgb) & kRed8) #define G32(rgb) static_cast((((rgb) & kGreen8) >> 8) & 0xff) #define B32(rgb) static_cast((((rgb) & kBlue8) >> 16) & 0xff) /* Build RGB565 word from red, green, and blue bytes. */ #define RGB565(r, g, b) static_cast((((static_cast(b) << 6) | (g)) << 5) | (r)) /* Build RGB32 dword from red, green, and blue bytes. */ #define RGB32(r, g, b) static_cast((((static_cast(b) << 8) | (g)) << 8) | (r)) #else // __BYTE_ORDER /* Extract red, green, and blue bytes from RGB565 word. */ #define R16(rgb) static_cast(((rgb) & kRed5) >> 11) #define G16(rgb) static_cast(((rgb) & kGreen6) >> 5) #define B16(rgb) static_cast((rgb) & kBlue5) /* Make 8 bits red, green, and blue, extracted from RGB565 word. */ #define R16_32(rgb) static_cast((((rgb) & kRed5) >> 8) | (((rgb) & kRed5) >> 14)) #define G16_32(rgb) static_cast((((rgb) & kGreen6) >> 3) | (((rgb) & kGreen6) >> 9)) #define B16_32(rgb) static_cast((((rgb) & kBlue5) << 3) | (((rgb) & kBlue5) >> 2)) /* Extract red, green, and blue bytes from RGB32 dword. */ #define R32(rgb) static_cast(((rgb) & kRed8) >> 16) #define G32(rgb) static_cast(((rgb) & kGreen8) >> 8) #define B32(rgb) static_cast((rgb) & kBlue8) /* Build RGB565 word from red, green, and blue bytes. */ #define RGB565(r, g, b) static_cast((((static_cast(r) << 6) | g) << 5) | b) /* Build RGB32 dword from red, green, and blue bytes. */ #define RGB32(r, g, b) static_cast((((static_cast(r) << 8) | g) << 8) | b) #endif // __BYTE_ORDER /* An union that simplifies breaking 32 bit RGB into separate R, G, and B colors. */ typedef union RGB32_t { uint32_t color; struct { #if __BYTE_ORDER == __LITTLE_ENDIAN uint8_t r; uint8_t g; uint8_t b; uint8_t a; #else // __BYTE_ORDER uint8_t a; uint8_t b; uint8_t g; uint8_t r; #endif // __BYTE_ORDER }; } RGB32_t; /* Clips a value to the unsigned 0-255 range, treating negative values as zero. */ static __inline__ int clamp(int x) { if (x > 255) return 255; if (x < 0) return 0; return x; } /******************************************************************************** * Basics of RGB -> YUV conversion *******************************************************************************/ /* * RGB -> YUV conversion macros */ #define RGB2Y(r, g, b) (uint8_t)(((66 * (r) + 129 * (g) + 25 * (b) + 128) >> 8) + 16) #define RGB2U(r, g, b) (uint8_t)(((-38 * (r) - 74 * (g) + 112 * (b) + 128) >> 8) + 128) #define RGB2V(r, g, b) (uint8_t)(((112 * (r) - 94 * (g) - 18 * (b) + 128) >> 8) + 128) /* Converts R8 G8 B8 color to YUV. */ static __inline__ void R8G8B8ToYUV(uint8_t r, uint8_t g, uint8_t b, uint8_t* y, uint8_t* u, uint8_t* v) { *y = RGB2Y((int)r, (int)g, (int)b); *u = RGB2U((int)r, (int)g, (int)b); *v = RGB2V((int)r, (int)g, (int)b); } /* Converts RGB565 color to YUV. */ static __inline__ void RGB565ToYUV(uint16_t rgb, uint8_t* y, uint8_t* u, uint8_t* v) { R8G8B8ToYUV(R16_32(rgb), G16_32(rgb), B16_32(rgb), y, u, v); } /* Converts RGB32 color to YUV. */ static __inline__ void RGB32ToYUV(uint32_t rgb, uint8_t* y, uint8_t* u, uint8_t* v) { RGB32_t rgb_c; rgb_c.color = rgb; R8G8B8ToYUV(rgb_c.r, rgb_c.g, rgb_c.b, y, u, v); } /******************************************************************************** * Basics of YUV -> RGB conversion. * Note that due to the fact that guest uses RGB only on preview window, and the * RGB format that is used is RGB565, we can limit YUV -> RGB conversions to * RGB565 only. *******************************************************************************/ /* * YUV -> RGB conversion macros */ /* "Optimized" macros that take specialy prepared Y, U, and V values: * C = Y - 16 * D = U - 128 * E = V - 128 */ #define YUV2RO(C, D, E) clamp((298 * (C) + 409 * (E) + 128) >> 8) #define YUV2GO(C, D, E) clamp((298 * (C) - 100 * (D) - 208 * (E) + 128) >> 8) #define YUV2BO(C, D, E) clamp((298 * (C) + 516 * (D) + 128) >> 8) /* * Main macros that take the original Y, U, and V values */ #define YUV2R(y, u, v) clamp((298 * ((y)-16) + 409 * ((v)-128) + 128) >> 8) #define YUV2G(y, u, v) clamp((298 * ((y)-16) - 100 * ((u)-128) - 208 * ((v)-128) + 128) >> 8) #define YUV2B(y, u, v) clamp((298 * ((y)-16) + 516 * ((u)-128) + 128) >> 8) /* Converts YUV color to RGB565. */ static __inline__ uint16_t YUVToRGB565(int y, int u, int v) { /* Calculate C, D, and E values for the optimized macro. */ y -= 16; u -= 128; v -= 128; const uint16_t r = (YUV2RO(y,u,v) >> 3) & 0x1f; const uint16_t g = (YUV2GO(y,u,v) >> 2) & 0x3f; const uint16_t b = (YUV2BO(y,u,v) >> 3) & 0x1f; return RGB565(r, g, b); } /* Converts YUV color to RGB32. */ static __inline__ uint32_t YUVToRGB32(int y, int u, int v) { /* Calculate C, D, and E values for the optimized macro. */ y -= 16; u -= 128; v -= 128; RGB32_t rgb; rgb.r = YUV2RO(y,u,v) & 0xff; rgb.g = YUV2GO(y,u,v) & 0xff; rgb.b = YUV2BO(y,u,v) & 0xff; return rgb.color; } /* YUV pixel descriptor. */ struct YUVPixel { uint8_t Y; uint8_t U; uint8_t V; inline YUVPixel() : Y(0), U(0), V(0) { } inline explicit YUVPixel(uint16_t rgb565) { RGB565ToYUV(rgb565, &Y, &U, &V); } inline explicit YUVPixel(uint32_t rgb32) { RGB32ToYUV(rgb32, &Y, &U, &V); } inline void get(uint8_t* pY, uint8_t* pU, uint8_t* pV) const { *pY = Y; *pU = U; *pV = V; } }; /* Converts an YV12 framebuffer to RGB565 framebuffer. * Param: * yv12 - YV12 framebuffer. * rgb - RGB565 framebuffer. * width, height - Dimensions for both framebuffers. */ void YV12ToRGB565(const void* yv12, void* rgb, int width, int height); /* Converts an YV12 framebuffer to RGB32 framebuffer. * Param: * yv12 - YV12 framebuffer. * rgb - RGB32 framebuffer. * width, height - Dimensions for both framebuffers. */ void YV12ToRGB32(const void* yv12, void* rgb, int width, int height); /* Converts an YU12 framebuffer to RGB32 framebuffer. * Param: * yu12 - YU12 framebuffer. * rgb - RGB32 framebuffer. * width, height - Dimensions for both framebuffers. */ void YU12ToRGB32(const void* yu12, void* rgb, int width, int height); /* Converts an NV12 framebuffer to RGB565 framebuffer. * Param: * nv12 - NV12 framebuffer. * rgb - RGB565 framebuffer. * width, height - Dimensions for both framebuffers. */ void NV12ToRGB565(const void* nv12, void* rgb, int width, int height); /* Converts an NV12 framebuffer to RGB32 framebuffer. * Param: * nv12 - NV12 framebuffer. * rgb - RGB32 framebuffer. * width, height - Dimensions for both framebuffers. */ void NV12ToRGB32(const void* nv12, void* rgb, int width, int height); /* Converts an NV21 framebuffer to RGB565 framebuffer. * Param: * nv21 - NV21 framebuffer. * rgb - RGB565 framebuffer. * width, height - Dimensions for both framebuffers. */ void NV21ToRGB565(const void* nv21, void* rgb, int width, int height); /* Converts an NV21 framebuffer to RGB32 framebuffer. * Param: * nv21 - NV21 framebuffer. * rgb - RGB32 framebuffer. * width, height - Dimensions for both framebuffers. */ void NV21ToRGB32(const void* nv21, void* rgb, int width, int height); }; /* namespace chroma */ #endif /* HW_EMULATOR_CAMERA_CONVERTERS_H */

Converters.cpp 

 /* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* * Contains implemenation of framebuffer conversion routines. */ #define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_Converter" #include "Converters.h" namespace chroma { static void _YUV420SToRGB565(const uint8_t* Y, const uint8_t* U, const uint8_t* V, int dUV, uint16_t* rgb, int width, int height) { const uint8_t* U_pos = U; const uint8_t* V_pos = V; for (int y = 0; y < height; y++) { for (int x = 0; x < width; x += 2, U += dUV, V += dUV) { const uint8_t nU = *U; const uint8_t nV = *V; *rgb = YUVToRGB565(*Y, nU, nV); Y++; rgb++; *rgb = YUVToRGB565(*Y, nU, nV); Y++; rgb++; } if (y & 0x1) { U_pos = U; V_pos = V; } else { U = U_pos; V = V_pos; } } } static void _YUV420SToRGB32(const uint8_t* Y, const uint8_t* U, const uint8_t* V, int dUV, uint32_t* rgb, int width, int height) { const uint8_t* U_pos = U; const uint8_t* V_pos = V; for (int y = 0; y < height; y++) { for (int x = 0; x < width; x += 2, U += dUV, V += dUV) { const uint8_t nU = *U; const uint8_t nV = *V; *rgb = YUVToRGB32(*Y, nU, nV); Y++; rgb++; *rgb = YUVToRGB32(*Y, nU, nV); Y++; rgb++; } if (y & 0x1) { U_pos = U; V_pos = V; } else { U = U_pos; V = V_pos; } } } void YV12ToRGB565(const void* yv12, void* rgb, int width, int height) { const int pix_total = width * height; const uint8_t* Y = reinterpret_cast(yv12); const uint8_t* U = Y + pix_total; const uint8_t* V = U + pix_total / 4; _YUV420SToRGB565(Y, U, V, 1, reinterpret_cast(rgb), width, height); } void YV12ToRGB32(const void* yv12, void* rgb, int width, int height) { const int pix_total = width * height; const uint8_t* Y = reinterpret_cast(yv12); const uint8_t* V = Y + pix_total; const uint8_t* U = V + pix_total / 4; _YUV420SToRGB32(Y, U, V, 1, reinterpret_cast(rgb), width, height); } void YU12ToRGB32(const void* yu12, void* rgb, int width, int height) { const int pix_total = width * height; const uint8_t* Y = reinterpret_cast(yu12); const uint8_t* U = Y + pix_total; const uint8_t* V = U + pix_total / 4; _YUV420SToRGB32(Y, U, V, 1, reinterpret_cast(rgb), width, height); } /* Common converter for YUV 4:2:0 interleaved to RGB565. * y, u, and v point to Y,U, and V panes, where U and V values are interleaved. */ static void _NVXXToRGB565(const uint8_t* Y, const uint8_t* U, const uint8_t* V, uint16_t* rgb, int width, int height) { _YUV420SToRGB565(Y, U, V, 2, rgb, width, height); } /* Common converter for YUV 4:2:0 interleaved to RGB32. * y, u, and v point to Y,U, and V panes, where U and V values are interleaved. */ static void _NVXXToRGB32(const uint8_t* Y, const uint8_t* U, const uint8_t* V, uint32_t* rgb, int width, int height) { _YUV420SToRGB32(Y, U, V, 2, rgb, width, height); } void NV12ToRGB565(const void* nv12, void* rgb, int width, int height) { const int pix_total = width * height; const uint8_t* y = reinterpret_cast(nv12); _NVXXToRGB565(y, y + pix_total, y + pix_total + 1, reinterpret_cast(rgb), width, height); } void NV12ToRGB32(const void* nv12, void* rgb, int width, int height) { const int pix_total = width * height; const uint8_t* y = reinterpret_cast(nv12); _NVXXToRGB32(y, y + pix_total, y + pix_total + 1, reinterpret_cast(rgb), width, height); } void NV21ToRGB565(const void* nv21, void* rgb, int width, int height) { const int pix_total = width * height; const uint8_t* y = reinterpret_cast(nv21); _NVXXToRGB565(y, y + pix_total + 1, y + pix_total, reinterpret_cast(rgb), width, height); } void NV21ToRGB32(const void* nv21, void* rgb, int width, int height) { const int pix_total = width * height; const uint8_t* y = reinterpret_cast(nv21); _NVXXToRGB32(y, y + pix_total + 1, y + pix_total, reinterpret_cast(rgb), width, height); } }; /* namespace chroma */

夹紧后，你就完成了。 它们变成了不同的颜色，你不能回去。 我已经写了一些我自己的代码来转换所有这些以及更多，如果你想看到，但它不会有助于将颜色反转到原始版本。

Interesting Posts

如何编译Linux C程序在另一台Linux机器上运行？

为什么c / c ++允许在函数调用中省略多维数组的最左边索引？

何时在扩展GCC内联汇编中使用earlyclobber约束？

C编程中的不动点算法

getline over socket

主要编译器/工具链中C99支持的状态是什么？

Lua 5.2 LUA_GLOBALSINDEX替代方案

使用按位和bitshift转换为二进制

在编写汇编函数时，序言和尾声是强制性的吗？

编写OS X内核扩展以实现Linux的SO_BINDTODEVICE套接字选项