图像处理：YUV_420_888介绍及YUV420转RGBA

最新推荐文章于 2024-04-30 22:21:10 发布
最新推荐文章于 2024-04-30 22:21:10 发布
阅读量449 收藏
点赞数
分类专栏： Android NDK/JNI 文章标签： YUV 图像处理
原文链接：https://www.jianshu.com/p/944ede616261
版权

刚开始做camera相关的开发时，对YUV_420_888这个格式很懵，不同平台的机型，从Image中转换出RGB的方法好像也不同，在终于初步了解YUV420格式后，写下本文，权当笔记总结。
YUV420转RGBA系列共三篇：

本文是其中的第一篇。

1. YUV简介

在了解YUV_420_888之前，我们先来了解一下YUV。我们知道，RGB是一种颜色编码方法，一个像素分别以R、G、B三个分量来表示。YUV也是一种颜色编码方法，一个像素分别以Y、U、V三个分量来表示。Y表示明亮度（Luminance、Luma），U和V则是色度、浓度（Chrominance、Chroma）。

YUV发明于彩色电视与黑白电视的过渡时期。黑白电视使用的黑白图像只有Y（Luma，Luminance）分量，也就是灰阶值。到了彩色电视规格的制定，是以YUV的格式来处理彩色电视图像，把UV视作表示彩度的C（Chrominance或Chroma），如果忽略C信号，那么剩下的Y（Luma）信号就跟之前的黑白电视频号相同，这样一来便解决了彩色电视机与黑白电视机的兼容问题。YUV在对照片或影片编码时，考虑到人类的感知能力，允许降低色度的采样。根据UV的采样不同，YUV分为多种格式：

  • YUV444：每4个Y，配上4个U，4个V
  • YUV422：每4个Y，配上2个U，2个V
  • YUV420：每4个Y，配上1个U，1个V

降低UV的采样后，传输时只需占用极少的带宽。(本节内容来自维基百科：https://zh.wikipedia.org/wiki/YUV)

2. YUV的紧缩格式（packed）和平面格式（planar）

YUV根据Y、U、V存储方式的不同，可以分成两个格式：

  • 紧缩格式（packed）：每个像素点的Y、U、V连续存储，Y1U1V1...YnUnVn。
  • 平面格式（planar）：先存储所有像素点的Y分量，再存储所有像素点的UV分量，Y和UV分别连续存储在不同矩阵当中。

平面格式（planar）又分为：

  • 平面格式（planar）：先存储所有像素的Y，再存储所有像素点U或者V，最后存储V或者U。其中U、V分别连续存储：Y1...Yn U1...Un V1...Vn 或者 Y1...Yn V1...Vn U1...Un。
  • 半平面格式（semi-planar）：先存储所有像素的Y，再存储所有像素点UV或者VU。其中U、V交替存储：Y1...Yn U1V1...UnVn 或者 Y1...Yn V1U1...VnUn。

采样方式采用YUV420、存储方式采用平面格式（planar）称为YUV420P。YUV420P根据U和V顺序不同又分为：

  • I420： Y1...Y4n U1...Un V1...Vn (例如：YYYYYYYYUUVV)
  • YV12：Y1...Y4n V1...Vn U1...Un (例如：YYYYYYYYVVUU)

采样方式采用YUV420、存储方式采用半平面格式（semi-planar）称为YUV420SP，YUV420SP根据U和V顺序不同又分为：

  • NV12： Y1...Y4n U1V1...UnVn (例如：YYYYYYYYUVUV)
  • NV21：Y1...Y4n V1U1...VnUn (例如：YYYYYYYYVUVU)

3. Android YUV_420_888

3.1 YUV_420_888API描述

我们先来看Android API中对YUV_420_888的介绍（https://developer.android.google.cn/reference/android/graphics/ImageFormat?hl=en#YUV_420_888）：

Multi-plane Android YUV 420 format

This format is a generic YCbCr format, capable of describing any 4:2:0 chroma-subsampled planar or semiplanar buffer (but not fully interleaved), with 8 bits per color sample.

Images in this format are always represented by three separate buffers of data, one for each color plane. Additional information always accompanies the buffers, describing the row stride and the pixel stride for each plane.

The order of planes in the array returned by Image#getPlanes() is guaranteed such that plane #0 is always Y, plane #1 is always U (Cb), and plane #2 is always V (Cr).

The Y-plane is guaranteed not to be interleaved with the U/V planes (in particular, pixel stride is always 1 in yPlane.getPixelStride()).

The U/V planes are guaranteed to have the same row stride and pixel stride (in particular, uPlane.getRowStride() == vPlane.getRowStride() and uPlane.getPixelStride() == vPlane.getPixelStride(); ).

Google翻译下：

多平面Android YUV 420格式

此格式是通用的YCbCr格式，能够描述任何4：2：0色度采样的平面或半平面缓冲区（但不完全交织），每个颜色样本有8位。

这种格式的图像始终由三个单独的数据缓冲区表示，每个颜色缓冲区一个。 缓冲区中始终会附带其他信息，描述每个平面的行步长和像素步长。

确保Image＃getPlanes（）返回的数组中平面的顺序，使得平面＃0始终为Y，平面＃1始终为U（Cb），平面＃2始终为V（Cr）。

保证Y平面不与U / V平面交错（特别是yPlane.getPixelStride（）中的像素步长始终为1）。

确保U / V平面具有相同的行步长和像素步长（尤其是uPlane.getRowStride（）== vPlane.getRowStride（）和uPlane.getPixelStride（）== vPlane.getPixelStride（）;）。

3.2 YUV_420_888使用实践

根据API中的介绍，我们可以知道，YUV_420_888是可以兼容所有YUV420P和YUV420SP格式的。也就是说上面提到的I420、YV12、NV12、NV21都可以是YUV_420_888的具体实现。虽然同样是Image对象，不同平台的机型可能有不同的实现。

根据本人测试，创建ImageReader时参数format传入YUV_420_888，Image.getPlanes()后，分别获取Plane0、Plane1、Plane2的buffer：

MTK平台:

//MTK

width:3264, height:2448,

yRowStride:3264, yPixelStride:1, yPixelSize:7990272,

uRowStride:1632, uPixelStride:1, uPixelSize:1997568,

vRowStride:1632, vPixelStride:1, vPixelSize:1997568

可以看到 Y:U:V = 4:1:1，说明这是YUV420采样格式。实测：

Plane0 + Plane1 + Plane2 得到的是I420
展锐平台:

展锐平台就比较奇怪了，即使创建ImageReader时传了YUV_420_888，用的似乎还是YUV422，但这明显不符合Andoid API的设计意图。并且用的是YUV422就算了，又还缺了一个UV色度分量。

//SPRD

width:3264, height:2448,

yRowStride:3264, yPixelStride:1, yPixelSize:7990272,

uRowStride:3264, uPixelStride:2, uPixelSize:3995135, //正常是3995136

vRowStride:3264, vPixelStride:2, vPixelSize:3995135 //正常是3995136

可以看到 Y:U:V = 4:2:2，说明这是YUV422采样格式。所以展锐平台的转换有两种方法：

Plane0 + Plane1 得到NV12
Plane0 + Plane2 得到NV21

其它平台暂未测试，有兴趣的童鞋可以自行测试下。采用YUV422虽然也能正常使用，但是个人认为这个明显是不合理的，YUV422不符合YUV_420_888的API描述，并且采用YUV420处理速度、存储速度都会比YUV422更快，传输带宽占用更少。

根据 API 我们可以知道，创建ImageReader时参数format除了YUV_420_888，还可以传，YUV_422_888、YUV_444_888这样就可以得到不同YUV采样模式的图像，但根据展锐平台的异常现象，我们也可以知道这都依赖于平台实现。

4. I420、YV12、NV12、N21转RGBA

I420、YV12、NV12、N21转换时都有一些共性：

  • 每个像素有自己独立的Y分量，Y的数量与像素点数量相等。
  • 4个像素共用一个U分量和V分量。

因此，我们只要找到每个像素Y、U、V分量的对应关系就可以进行转换。

4.1 I420转RGB

i420.png

4.2 YV12转RGB

yv12.png

4.3 NV12转RGB

nv12.png

4.4 NV21转RGB

nv21.png

4.5 代码实现

https://github.com/tensorflow/tensorflow/blob/master/tensorflow/examples/android/src/org/tensorflow/demo/中有相关的YUV转RGB和RGB转YUV的代码。本文也是参考其中的转换代码，分别封装了一下I420转RGBA、YV12转RGBA、NV12转RGBA、NV21转RGBA。

定义常量：
const int K_MAX_CHANNEL_VALUE = 262143;
const int YUV420P_I420 = 1;
const int YUV420P_YV12 = 2;
const int YUV420SP_NV12 = 3;
const int YUV420SP_NV21 = 4;
YUV转RGBA：
/*
 * This function come from:
 * https://github.com/tensorflow/tensorflow/blob/master/tensorflow/examples/android/jni/yuv2rgb.cc
 */
static inline int YUV2RGBA(int nY, int nU, int nV) {
    nY -= 16;
    nU -= 128;
    nV -= 128;
    if (nY < 0) nY = 0;

    // This is the floating point equivalent. We do the conversion in integer
    // because some Android devices do not have floating point in hardware.
    // nR = (int)(1.164 * nY + 2.018 * nU);
    // nG = (int)(1.164 * nY - 0.813 * nV - 0.391 * nU);
    // nB = (int)(1.164 * nY + 1.596 * nV);

    int nR = 1192 * nY + 1634 * nV;
    int nG = 1192 * nY - 833 * nV - 400 * nU;
    int nB = 1192 * nY + 2066 * nU;

    nR = nR > K_MAX_CHANNEL_VALUE ? K_MAX_CHANNEL_VALUE : (nR < 0 ? 0 : nR);
    nG = nG > K_MAX_CHANNEL_VALUE ? K_MAX_CHANNEL_VALUE : (nG < 0 ? 0 : nG);
    nB = nB > K_MAX_CHANNEL_VALUE ? K_MAX_CHANNEL_VALUE : (nB < 0 ? 0 : nB);

    nR = (nR >> 10) & 0xff;
    nG = (nG >> 10) & 0xff;
    nB = (nB >> 10) & 0xff;
    return 0xff000000 | (nR << 16) | (nG << 8) | nB;
}

/*
 * int  order: ARGB
 * byte order: RGBA
 */
static inline void rgbaIntToBytes(int rgba, unsigned char *b) {
    b[0] = (unsigned char) ((rgba >> 16) & 0xff);  //R
    b[1] = (unsigned char) ((rgba >> 8) & 0xff);   //G
    b[2] = (unsigned char) (rgba & 0xff);          //B
    b[3] = (unsigned char) ((rgba >> 24) & 0xff);  //A
}
YUV420P转RGB：
    void YUV420PToRGBAByte(unsigned char *src, unsigned char *dst, int width, int height,
                           int yRowStride, int uvRowStride, int uvPixelStride, int format) {
        if (format == YUV420P_I420 || format == YUV420P_YV12) {
            unsigned char *pRGBA = dst;
            unsigned char *pY = src;
            unsigned char *pU;
            unsigned char *pV;
            if (format == YUV420P_I420) {
                pU = src + width * height;
                pV = src + width * height / 4 * 5;
            } else {
                pU = src + width * height / 4 * 5;
                pV = src + width * height;
            }
            for (int y = 0; y < height; y++) {
                //const int yRowStart = yRowStride * y;
                const int uvRowStart = uvRowStride * (y >> 1);
                for (int x = 0; x < width; x++) {
                    const int uvRowOffset = (x >> 1) * uvPixelStride;
                    rgbaIntToBytes(YUV2RGBA(*pY++,//pY[yRowStart + x],
                                            pU[uvRowStart + uvRowOffset],
                                            pV[uvRowStart + uvRowOffset]),
                                   pRGBA);
                    pRGBA += 4;
                }
            }
        }
    }

    void YUV420PToRGBAInt(unsigned char *src, int *dst, int width, int height,
                          int yRowStride, int uvRowStride, int uvPixelStride, int format) {
        if (format == YUV420P_I420 || format == YUV420P_YV12) {
            unsigned char *pY = src;
            unsigned char *pU;
            unsigned char *pV;
            int rgbaIndex = 0;
            if (format == YUV420P_I420) {
                pU = src + width * height;
                pV = src + width * height / 4 * 5;
            } else {
                pU = src + width * height / 4 * 5;
                pV = src + width * height;
            }
            for (int y = 0; y < height; y++) {
                //const int yRowStart = yRowStride * y;
                const int uvRowStart = uvRowStride * (y >> 1);
                for (int x = 0; x < width; x++) {
                    const int uvRowOffset = (x >> 1) * uvPixelStride;
                    dst[rgbaIndex++] = YUV2RGBA(*pY++,//pY[yRowStart + x],
                                                 pU[uvRowStart + uvRowOffset],
                                                pV[uvRowStart + uvRowOffset]);
                }
            }
        }
    }
YUV420SP转RGB：
    void YUV420SPToRGBAByte(unsigned char *src, unsigned char *dst, int width, int height,
                            int format) {
        if (format == YUV420SP_NV12 || format == YUV420SP_NV21) {
            unsigned char *pRGBA = dst;
            unsigned char *pY = src;
            unsigned char *pUV = src + width * height;
            for (int y = 0; y < height; y++) {
                for (int x = 0; x < width; x++) {
                    int uvOffset = (y >> 1) * width + 2 * (x >> 1);
                    int uOffset;
                    int vOffset;
                    if (format == YUV420SP_NV12) {
                        uOffset = uvOffset;
                        vOffset = uvOffset + 1;
                    } else {
                        uOffset = uvOffset + 1;
                        vOffset = uvOffset;
                    }
                    rgbaIntToBytes(YUV2RGBA(*pY++, pUV[uOffset], pUV[vOffset]), pRGBA);
                    pRGBA += 4;
                }
            }
        }
    }

    void YUV420SPToRGBAInt(unsigned char *src, int *dst, int width, int height,
                           int format) {
        if (format == YUV420SP_NV12 || format == YUV420SP_NV21) {
            unsigned char *pY = src;
            unsigned char *pUV = src + width * height;
            int rgbaIndex = 0;
            for (int y = 0; y < height; y++) {
                for (int x = 0; x < width; x++) {
                    int uvOffset = (y >> 1) * width + 2 * (x >> 1);
                    int uOffset;
                    int vOffset;
                    if (format == YUV420SP_NV12) {
                        uOffset = uvOffset;
                        vOffset = uvOffset + 1;
                    } else {
                        uOffset = uvOffset + 1;
                        vOffset = uvOffset;
                    }
                    dst[rgbaIndex++] = YUV2RGBA(*pY++, pUV[uOffset], pUV[vOffset]);
                }
            }
        }
    }
JNI接口
extern "C"
JNIEXPORT void JNICALL
Java_com_qxt_yuv420_NativeUtils_I420ToRGBAByte(JNIEnv *env, jclass clazz,
                                               jbyteArray src, jbyteArray dst,
                                               jint width, jint height, jint yRowStride,
                                               jint uvRowStride, jint uvPixelStride) {
    jbyte *_src = env->GetByteArrayElements(src, nullptr);
    jbyte *_dst = env->GetByteArrayElements(dst, nullptr);
    YUV420PToRGBAByte(reinterpret_cast<unsigned char *>(_src),
                      reinterpret_cast<unsigned char *>(_dst),
                      width, height, yRowStride, uvRowStride, uvPixelStride, YUV420P_I420);
    env->ReleaseByteArrayElements(src, _src, JNI_ABORT);
    env->ReleaseByteArrayElements(dst, _dst, 0);
}

extern "C"
JNIEXPORT void JNICALL
Java_com_qxt_yuv420_NativeUtils_I420ToRGBAInt(JNIEnv *env, jclass clazz,
                                              jbyteArray src, jintArray dst,
                                              jint width, jint height, jint yRowStride,
                                              jint uvRowStride, jint uvPixelStride) {
    jbyte *_src = env->GetByteArrayElements(src, NULL);
    jint *_dst = env->GetIntArrayElements(dst, NULL);
    YUV420PToRGBAInt(reinterpret_cast<unsigned char *>(_src), _dst, width, height, yRowStride,
                     uvRowStride, uvPixelStride, YUV420P_I420);
    env->ReleaseByteArrayElements(src, _src, JNI_ABORT);
    env->ReleaseIntArrayElements(dst, _dst, 0);
}

extern "C"
JNIEXPORT void JNICALL
Java_com_qxt_yuv420_NativeUtils_YV12ToRGBAByte(JNIEnv *env, jclass clazz,
                                               jbyteArray src, jbyteArray dst,
                                               jint width, jint height, jint yRowStride,
                                               jint uvRowStride, jint uvPixelStride) {
    jbyte *_src = env->GetByteArrayElements(src, nullptr);
    jbyte *_dst = env->GetByteArrayElements(dst, nullptr);
    YUV420PToRGBAByte(reinterpret_cast<unsigned char *>(_src),
                      reinterpret_cast<unsigned char *>(_dst),
                      width, height, yRowStride, uvRowStride, uvPixelStride, YUV420P_YV12);
    env->ReleaseByteArrayElements(src, _src, JNI_ABORT);
    env->ReleaseByteArrayElements(dst, _dst, 0);
}

extern "C"
JNIEXPORT void JNICALL
Java_com_qxt_yuv420_NativeUtils_YV12ToRGBAInt(JNIEnv *env, jclass clazz,
                                              jbyteArray src, jintArray dst,
                                              jint width, jint height, jint yRowStride,
                                              jint uvRowStride, jint uvPixelStride) {
    jbyte *_src = env->GetByteArrayElements(src, NULL);
    jint *_dst = env->GetIntArrayElements(dst, NULL);
    YUV420PToRGBAInt(reinterpret_cast<unsigned char *>(_src),
                     _dst, width, height, yRowStride, uvRowStride, uvPixelStride, YUV420P_YV12);
    env->ReleaseByteArrayElements(src, _src, JNI_ABORT);
    env->ReleaseIntArrayElements(dst, _dst, 0);
}

extern "C"
JNIEXPORT void JNICALL
Java_com_qxt_yuv420_NativeUtils_NV12ToRGBAByte(JNIEnv *env, jclass clazz,
                                               jbyteArray src, jbyteArray dst,
                                               jint width, jint height) {
    jbyte *_src = env->GetByteArrayElements(src, NULL);
    jbyte *_dst = env->GetByteArrayElements(dst, NULL);
    YUV420SPToRGBAByte(reinterpret_cast<unsigned char *>(_src),
                       reinterpret_cast<unsigned char *>(_dst), width, height, YUV420SP_NV12);
    env->ReleaseByteArrayElements(src, _src, JNI_ABORT);
    env->ReleaseByteArrayElements(dst, _dst, 0);
}

extern "C"
JNIEXPORT void JNICALL
Java_com_qxt_yuv420_NativeUtils_NV12ToRGBAInt(JNIEnv *env, jclass clazz,
                                              jbyteArray src, jintArray dst,
                                              jint width, jint height) {
    jbyte *_src = env->GetByteArrayElements(src, NULL);
    jint *_dst = env->GetIntArrayElements(dst, NULL);
    YUV420SPToRGBAInt(reinterpret_cast<unsigned char *>(_src), _dst, width, height, YUV420SP_NV12);
    env->ReleaseByteArrayElements(src, _src, JNI_ABORT);
    env->ReleaseIntArrayElements(dst, _dst, 0);
}

extern "C"
JNIEXPORT void JNICALL
Java_com_qxt_yuv420_NativeUtils_NV21ToRGBAByte(JNIEnv *env, jclass clazz,
                                               jbyteArray src, jbyteArray dst,
                                               jint width, jint height) {
    jbyte *_src = env->GetByteArrayElements(src, NULL);
    jbyte *_dst = env->GetByteArrayElements(dst, NULL);
    YUV420SPToRGBAByte(reinterpret_cast<unsigned char *>(_src),
                       reinterpret_cast<unsigned char *>(_dst), width, height, YUV420SP_NV21);
    env->ReleaseByteArrayElements(src, _src, JNI_ABORT);
    env->ReleaseByteArrayElements(dst, _dst, 0);
}

extern "C"
JNIEXPORT void JNICALL
Java_com_qxt_yuv420_NativeUtils_NV21ToRGBAInt(JNIEnv *env, jclass clazz,
                                              jbyteArray src, jintArray dst,
                                              jint width, jint height) {
    jbyte *_src = env->GetByteArrayElements(src, NULL);
    jint *_dst = env->GetIntArrayElements(dst, NULL);
    YUV420SPToRGBAInt(reinterpret_cast<unsigned char *>(_src), _dst, width, height, YUV420SP_NV21);
    env->ReleaseByteArrayElements(src, _src, JNI_ABORT);
    env->ReleaseIntArrayElements(dst, _dst, 0);
}
java 函数及参数说明
package com.qxt.yuv420;


/**
 * @author Tyler Qiu
 * @date: 2020/05/09
 */
public class NativeUtils {
    /*
     * YYYYYYYY UU VV    =>I420  =>YUV420P
     * YYYYYYYY VV UU    =>YV12  =>YUV420P
     * YYYYYYYY UV UV    =>NV12  =>YUV420SP
     * YYYYYYYY VU VU    =>NV21  =>YUV420SP
     */
    static {
        System.loadLibrary("NativeUtils");
    }

    /**
     * convert I420 to ARGB_8888
     *
     * @param src           src I420 byte array
     * @param dst           dst RGBA byte array, the length of the dst array must be >= width*height*4
     * @param width         image width
     * @param height        image height
     * @param yRowStride    The row stride of plane y.
     * @param uvRowStride   The row stride of plane u or v.
     * @param uvPixelStride The pixel stride of plane u or v.
     */
    public static native void I420ToRGBAByte(byte[] src, byte[] dst, int width, int height,
                                             int yRowStride, int uvRowStride, int uvPixelStride);

    /**
     * convert I420 to ARGB_8888
     *
     * @param src           src I420 byte array
     * @param dst           dst RGBA int array, the length of the dst array must be >= width*height
     * @param width         image width
     * @param height        image height
     * @param yRowStride    The row stride of plane y.
     * @param uvRowStride   The row stride of plane u or v.
     * @param uvPixelStride The pixel stride of plane u or v.
     */
    public static native void I420ToRGBAInt(byte[] src, int[] dst, int width, int height,
                                            int yRowStride, int uvRowStride, int uvPixelStride);

    /**
     * convert YV12 to ARGB_8888
     *
     * @param src           src YV12 byte array
     * @param dst           dst RGBA byte array, the length of the dst array must be >= width*height*4
     * @param width         image width
     * @param height        image height
     * @param yRowStride    The row stride of plane y.
     * @param uvRowStride   The row stride of plane u or v.
     * @param uvPixelStride The pixel stride of plane u or v.
     */
    public static native void YV12ToRGBAByte(byte[] src, byte[] dst, int width, int height,
                                             int yRowStride, int uvRowStride, int uvPixelStride);

    /**
     * convert YV12 to ARGB_8888
     *
     * @param src           src YV12 byte array
     * @param dst           dst RGBA int array, the length of the dst array must be >= width*height
     * @param width         image width
     * @param height        image height
     * @param yRowStride    The row stride of plane y.
     * @param uvRowStride   The row stride of plane u or v.
     * @param uvPixelStride The pixel stride of plane u or v.
     */
    public static native void YV12ToRGBAInt(byte[] src, int[] dst, int width, int height,
                                            int yRowStride, int uvRowStride, int uvPixelStride);

    /**
     * convert NV12 to ARGB_8888
     *
     * @param src      src NV12 byte array
     * @param dst      dst RGBA byte array, the length of the dst array must be >= width*height*4
     * @param width    image width
     * @param height   image height
     */
    public static native void NV12ToRGBAByte(byte[] src, byte[] dst, int width, int height);

    /**
     * convert NV12 to ARGB_8888
     *
     * @param src      src NV12 byte array
     * @param dst      dst RGBA int array, the length of the dst array must be >= width*height
     * @param width    image width
     * @param height   image height
     */
    public static native void NV12ToRGBAInt(byte[] src, int[] dst, int width, int height);

    /**
     * convert NV21 to ARGB_8888
     *
     * @param src      src NV21 byte array
     * @param dst      dst RGBA byte array, the length of the dst array must be >= width*height*4
     * @param width    image width
     * @param height   image height
     */
    public static native void NV21ToRGBAByte(byte[] src, byte[] dst, int width, int height);

    /**
     * convert NV21 to ARGB_8888
     *
     * @param src      src NV21 byte array
     * @param dst      dst RGBA int array, the length of the dst array must be >= width*height
     * @param width    image width
     * @param height   image height
     */
    public static native void NV21ToRGBAInt(byte[] src, int[] dst, int width, int height);
}

本文中的代码和i420/yv12/nv12/n21文件已经上传到github：https://github.com/qiuxintai/YUV420Converter，如果本文代码对你有帮助，烦请在github上给我一个小小的star。除转换外，YUV420Converter中还有旋转RGB和YUV420的代码，如果还想了解RGB和YUV420的旋转，请戳：
RGB和YUV420旋转90/180/270度

5. 使用7yuv

除了用代码转换，我们还可以用7yuv工具来查看和转换YUV格式的图像。
7yuv下载地址：https://www.onlinedown.net/soft/1225925.htm

5.1 查看

打开7yuv，File -> open 或者直接将yuv图像拖入7yuv界面进行查看：

7yuv使用1.png

5.2 转换

选择 Edit -> Convert Format 转换：

7yuv使用2.png

6. 本文参考：

  1. https://zh.wikipedia.org/wiki/YUV
  2. https://developer.android.google.cn/reference/android/graphics/ImageFormat?hl=en#YUV_420_888
  3. https://blog.csdn.net/lbknxy/article/details/54633008?tdsourcetag=s_pcqq_aiomsg



链接：https://www.jianshu.com/p/944ede616261

今人不见古时月,今月曾经照古人
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RGB888转NV21(yuv420sp)源代码详解
06-12
完整c源代码，直接编译即可测试，方便简单，编译移植，nv21网上资源比较少，需要测试rgb图片里面也已经放了两张供测试用，大家共同学习共同进步
YUVRenderScript:史上最强YUV转换RenderScript，支持转换为RGBA、BGRA，同时支持旋转和翻转。 YUV数据格式支持NV21、YV12、YUV420_888，对应Android Camera1API和Camera2 API的YUV处理
05-31
YUV数据格式支持NV21、YV12、YUV420_888，对应Android Camera1API和Camera2 API的YUV处理。 这段时间在做一些Android Camera数据处理相关的工作，涉及到YUV转RGBA。 由于对性能要求极高，我采用了多种解决方案。 ...
YUV420格式解析
jason诚
05-18 1629
<br />YUV是指亮度参量和色度参量分开表示的像素格式，而这样分开的好处就是不但可以避免相互干扰，还可以降低色度的采样率而不会对图像质量影响太大。YUV是一个比较笼统地说法，针对它的具体排列方式，可以分为很多种具体的格式。YUV格式解析1（播放器——project2）根据板卡api设计实现yuv420格式的视频播放器打开*.mp4;*.264类型的文件，实现其播放。使用的视频格式是YUV420格式YUV格式通常有两大类：打包（packed）格式和平面（planar）格式。前者将YUV分量存放在同一个数组
yuv转rgb,420,422,NV12, NV21,I420,YV12,YVYU,YUY2,UYVY, NV16, NV61,NV24, NV42,888,101010图像视频格式
最新发布
邹九的个人博客
04-30 1050
参考：下面的yuv转rgb，或者rgb转yuv，都和Opencv对齐了，转换公式也对齐了，也就是下面的program产生的YUYV，UYVY, NV12, NV21, I420, YV12等都可以直接使用Opencv来恢复到rgb格式。电视、显示屏显示图像，都是根据数字来显示的，人们都知道色彩空间的三原色是红、绿、蓝，所以三种颜色不同程度的混合，就可以形成各种各样的颜色，显示屏和电视也是根据红绿蓝来显示的，最开始的彩色电视每个像素点都要通过红绿蓝来显示，所以rgb也就是红绿蓝的数字形式。
【Android Camera2】彻底弄清图像数据YUV420_888转NV21问题/良心教学/避坑必读!
weixin_41937380的博客
11-11 6455
Android camera2中yuv420 image转nv21数据教程：比较网上各种版本代码，说明他们的问题，并讲解原理。帮助大家避坑，彻底掌握yuv数据的转换
YUV各种格式对比
All_Zhen
10-13 4086
YUV420P又叫plane平面模式，Y , U , V分别在不同平面，也就是有三个平面，它是YUV标准格式4:2:0，主要分为：YU12和YV12。
图像编码YUV420格式
yh13572438258的博客
12-08 7307
一、YUV简介 YUV，是一种颜色编码方法。常使用在各个视频处理组件中。 YUV在对照片或视频编码时，考虑到人类的感知能力，允许降低色度的带宽。 “Y”表示明亮度（Luminance或Luma），也就是灰阶值，“U”和“V”表示的则是色度（Chrominance或Chroma），作用是描述影像色彩及饱和度，用于指定像素的颜色。RGB 和 YUV 为两种经常使用的像素格式。下面有对RGB编码详细的解释 编码 RGB图像具有三个通道 R、G、B，分别对应红、绿、蓝三个分量，由三个分量的值决定...
YUV420 总结 (YU12、YV12、NV12 和 NV21)
dss875914213的博客
10-18 4014
YUV模型是根据一个亮度(Y分量)和两个色度(UV分量)来定义颜色空间。最常见的格式为 YUV420分为两种：YUV420P和YUV420SP。 YUV420P YUV420P 为 plane平面模式，Y, U, V分量处于不同平面，即在 ffmpeg 中数据存放在 3 个数组中。 其可再细分为 YU12 和 YV12 。 YU12 该格式的数据分布如下图所示，data[0] 中存放的是 Y 数据，data[1] 中存放的是 U 数据，data[2] 中存放的是 V 数据。 其中 Y、U、V 颜色相同的为一
HDR转SDR实践之旅(三)YUV420转YUV公式
weixin_53290519的博客
05-10 486
YUV420转YUV的常规方案是把YUV420的颜色通道拆成3个图像(Y图像U图像V图像)再组装成YUV，这种方式比较耗时其实可以省去YUV拆图像的步骤直接用公式从YUV420算出YUV
RGB与YUV
yunxiaobaobei的博客
04-11 1905
YUV也叫YCbCr模型，是相对于RGB模型的一种广泛使用的颜色表示模型，YUV格式是1938年由一个法国通信工程师M. Georges Valensi发明的。YUV中的Y表示亮度luminance，UV表示色度chrominance；我们知道人眼是个复杂的器官，有许多部分组成，但我们最感兴趣的是视锥细胞和视杆细胞。眼睛有1.2亿个视杆细胞和6百万个视锥细胞。让我们把颜色和亮度放在眼睛的功能部位上。视杆细胞主要负责亮度，而视锥细胞负责颜色。
YUV颜色空间转换（YV12、NV12、NV21、I420、RGB等）
08-17
本程序实现了简单的YUV数据之间的转换和YUV与RGB的转换。 注：1、本程序只是简单YUV之间的颜色空间转换和YUV与RGB的转换。 2、本程序使用的vs2019创建的，需使用2019打开工程。 3、包含功能： 1）YV12_2_I420； ...
YUV视频数据
08-22
YUV420 格式的视频，另外还有个播放器，直接安装即可。
Android常用的几种格式：NV21/NV12/YV12/YUV420P的转换
04-24
Android常用的几种格式：NV21/NV12/YV12/YUV420P相互转换 java代码， YV12 To NV21， I420 To NV21，YV12Resize， flipYUV420， NV21ToBitmap
YUV_2_RGB:使用本机代码（Java）在Dart中将YUV转换为RGB的完整工作示例
05-24
由于该库要求使用RGBA图像类型进行预测，并且插件会生成YUV图像，因此，我花了几天时间寻找有效的转换解决方案。 在阅读了很多与我一样处境艰难的例子之后，并经过大量的反复试验，我设法为我的目的找到了一个不错...
rgb转yuv420sp_nv12 硬件加速（opengl es,shader）
07-14
rgb转yuv420sp_nv12的硬件加速，opengles 的shader实现
图文详解YUV420数据格式
热门推荐
jefry_xdz的专栏
08-31 5万+
很多人对YUV数据格式不清楚，以至于在做视频的时候出现了一些不可预知的错误(比如说图像带有点、颜色不对等)。今晚是周末放假，我就抽点时间来给大家介绍一下。        提示: 读下面的文字时，希望大家结合图片看，这样更易理解        在YUV420中，一个像素点对应一个Y，一个2X2的小方块对应一个U和V。对于所有YUV420图像，它们的Y值排列是完全相同的，因为只有Y的图像就是灰度图
Android: Image类浅析(结合YUV_420_888)
liang9zi的专栏
02-09 1万+
简介Image类在API 19中引入，但真正开始发挥作用还是在API 21引入CameraDevice和MediaCodec的增强后。API 21引入了Camera2，deprecated掉了Camera，确立Image作为相机得到的原始帧数据的载体；硬件编解码的MediaCodec类加入了对Image和Image的封装ImageReader的全面支持。可以预见，Image将会用来统一Androi...
解析yuv420图片并转换成RGB显示
羽凌寒
11-08 7878
简介 　　本篇为学习yuv图片格式转化笔记。 原理讲解 参考资料 　　YUV格式哟很多种，本篇记录的格式为YUV420。 有关YUV420的详细介绍，可以参考资料：1、图文详解YUV420数据格式 http://blog.csdn.net/jefry_xdz/article/details/7931018 大致讲解 　　首先yuv420的存储大小为：width * he
YUV420转RGB
weixin_34392843的博客
09-29 1274
一、YUV420数据存储   YUV格式有两大类：planar和packed。 对于planar的YUV格式，先连续存储所有像素点的Y，紧接着存储所有像素点的U，随后是所有像素点的V。 对于packed的YUV格式，每个像素点的Y,U,V是连续交*存储的。 以dm642的H263loopback例子程序为例， 发送线程中，视频捕获后我们得到YUV422 planar数据， 然后转化成Y...
ffmpeg RGBA转YUV720P
10-03
要将RGBA转换为YUV720P，您可以使用ffmpeg命令行工具。以下是转换命令： ```shell ffmpeg -f rawvideo -pix_fmt rgba -s 1280x720 -i input.raw -vf "format=yuv420p" output.yuv ``` 请确保将`input.raw`替换为您的RGBA原始图像文件名，并将`output.yuv`替换为您想要输出的YUV720P文件名。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值