yuv转jpg（NV12，NV21）

已于 2024-04-02 14:20:33 修改
阅读量1.2k 收藏 7
点赞数 15
文章标签： c++ python 图像处理
于 2024-04-01 11:57:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40403979/article/details/137223036
版权

一、YUV格式

1、NV12、NV21格式

YUV420：NV12

YUV420：NV21

4个Y公用一个U、V，U、V是在Y之后存储的。Y的大小一般是width*height，U、V则在Y后面存储。

二、YUV转RGB公式

不同标准下RGB和YUV之间的转换公式不同，RGB的标准主要有BT601、BT709、BT2022三个标准。具体可以根据RGB标准进行进行转换，如果不了解应该转成什么标准，可以都试一下，看看哪种方式转换出的jpg和yuv更接近就用对应的转换公式。

1、BT601标准

1.1、8bit yuv

R、G、B ~ [0~255]

Y、U、V ~ [-128 ~ 128]

yuv -> rgb

R = Y + 1.4075 * (V - 128)

G = Y - 0.3455 * (U - 128) - 0.7169 * (V - 128)

B = Y + 1.779 * (U - 128)

rgb -> yuv

Y  = 0.299 * R + 0.587 * G + 0.114 * B

U = -0.169 * R - 0.331 * G + 0.5 * B + 128

V = 0.5 * R - 0.419 * G - 0.081 * B + 128

1.2、10bit yuv

R、G、B ~ [0~255]

Y、U、V ~ [-32768 ~ 32768]

yuv -> rgb

R = Y + 1.4075 * (V - 32768)

G = Y - 0.3455 * (U - 32768) - 0.7169 * (V - 32768)

B = Y + 1.779 * (U - 32768)

rgb -> yuv

Y  = 0.299 * R + 0.587 * G + 0.114 * B

U = -0.169 * R - 0.331 * G + 0.5 * B + 32768

V = 0.5 * R - 0.419 * G - 0.081 * B + 32768

2、BT709标准

 2.1、8bit yuv

R、G、B ~ [0~255]

Y、U、V ~ [-128 ~ 128]

yuv -> rgb

R = Y + 1.5748 * (V - 128)

G = Y - 0.1868 * (U - 128) - 0.4680 * (V - 128)

B = Y + 1.856 * (U - 128)

rgb -> yuv

Y  = 0.2126 * R + 0.7154 * G + 0.072 * B

U = -0.1145 * R - 0.3855 * G + 0.5 * B + 128

V = 0.5 * R - 0.4543 * G - 0.0457 * B + 128

2.2、10bit yuv

R、G、B ~ [0~255]

Y、U、V ~ [-32768 ~ 32768]

yuv -> rgb

R = Y + 1.5748 * (V - 32768)

G = Y - 0.1868 * (U - 32768) - 0.4680 * (V - 32768)

B = Y + 1.856 * (U - 32768)

rgb -> yuv

Y  = 0.2126 * R + 0.7154 * G + 0.072 * B

U = -0.1145 * R - 0.3855 * G + 0.5 * B + 32768

V = 0.5 * R - 0.4543 * G - 0.0457 * B + 32768

3、BT2020标准

 3.1、8bit yuv

R、G、B ~ [0~255]

Y、U、V ~ [-128 ~ 128]

yuv -> rgb

R = Y + 1.4746 * (V - 128)

G = Y - 0.1645 * (U - 128) - 0.5713 * (V - 128)

B = Y + 1.8814 * (U - 128)

rgb -> yuv

Y  = 0.2627 * R + 0.6780 * G + 0.0593 * B

U = -0.1396 * R - 0.3604 * G + 0.5 * B + 128

V = 0.5 * R - 0.4598 * G - 0.0402 * B + 128

3.2、10bit yuv

R、G、B ~ [0~255]

Y、U、V ~ [-32768 ~ 32768]

yuv -> rgb

R = Y + 1.4746 * (V - 32768)

G = Y - 0.1645 * (U - 32768) - 0.5731 * (V - 32768)

B = Y + 1.8814 * (U - 32768)

rgb -> yuv

Y  = 0.2627 * R + 0.6780 * G + 0.0593 * B

U = -0.1396 * R - 0.3604 * G + 0.5 * B + 32768

V = 0.5 * R - 0.4598 * G - 0.0402 * B + 32768

三、代码实现

使用python调用c++的方式进行实现，这种方式比单独使用python更快，转化效率更高。

1、python端

这里是以矩阵的方式求逆矩阵进行的转化，求逆矩阵使用python提供的方法更方便。

其实可以直接用上面的公式在C++端进行转化。但是通过打印逆矩阵的值，发现逆矩阵转出的结果再进行计算更精确一点点。

这里以BT601标准进行转化的，大家可以根据自己的需求换成不同标准对应的矩阵。

代码如下：

from PIL import Image
import numpy as np

'''
yuv_height yuv的高
yuv_width yuv的宽，这里传入stride
yuv_path yuv所在路径
yuv_type yuv的类型，这里指YUV420 NV12/NV21
BPP 指yuv的位深度，当前支持10bit、8bit
'''
def converyuv2jpg_8bpp(yuv_height, yuv_width, yuv_path, yuv_type, BPP):
    print("opening file")
    dest = os.path.splitext(yuv_path)[0] + '_' + yuv_type + '.jpg'
    aa = np.array([[0.299, 0.587, 0.114], [-0.169, -0.331, 0.5], [0.5, -0.419, -0.081]])
    aa_n = np.linalg.inv(aa)
    print(aa_n[0][0])
    print(aa_n)
    c_data = (ctypes.c_double * 9)()
    c_index = 0
    for i in range(0, 3):
        for j in range(0, 3):
            c_data[c_index] = aa_n[i][j]
            c_index += 1

    flag_yuv_type = 0
    print("read file")
    lib = windll.LoadLibrary('./YUV2JPG.dll')
    lib.yuv2rgb.restype = POINTER(c_uint8)
    lib.yuv2rgb_ten.restype = POINTER(c_uint8)
    if yuv_type == 'NV12':
        flag_yuv_type = 0
    else:
        flag_yuv_type = 1
    with open(yuv_path, 'rb') as f:
        yuv = f.read()
        print(len(yuv))
        if BPP == '10':
            rgb_bytes = bytearray(
                lib.yuv2rgb_ten(c_data, yuv, len(yuv), flag_yuv_type, yuv_width, 
                                yuv_height)[0:yuv_width * yuv_height * 3])
        else:
            rgb_bytes = bytearray(
                lib.yuv2rgb(c_data, yuv, len(yuv), flag_yuv_type, yuv_width, yuv_height) 
                            [0:yuv_width * yuv_height * 3])
    print("finished conversion. Creating image object")
    img = Image.frombytes("RGB", (yuv_width, yuv_height), bytes(rgb_bytes))
    print("Image object created. Starting to save")
    img.save(dest, "JPEG")
    img.close()

2、C++端

这里需要编译成dll文件，将dll文件放到python同文件夹下。出问题可以使用cout或者printf进行打印，python运行窗口可以看见打印结果。

C++端10bit转换的时候，舍弃了低8位，这个没有想到更合理的方法，有懂的可以评论区进行讨论一下。

代码可拿去自行改进，加油！(ง •_•)ง

#include <iostream>
#include <stdio.h>
using namespace std;


extern "C" __declspec(dllexport) unsigned char* yuv2rgb(double* array, char* data, uint64_t data_length, int yuv_type, int width, int height);
extern "C" __declspec(dllexport) unsigned char* yuv2rgb_ten(double* array, uint16_t* data, uint64_t data_length, int yuv_type, int width, int height);

unsigned char* yuv2rgb(double* array, char* data, uint64_t data_length, int yuv_type, int width, int height)
{
    for (int i = 0; i < 9; i++) {
        printf("array[%d] = %f\n", i, array[i]);
    }
    printf("width = %d, height = %d\n", width, height);
    uint64_t red_index = 0;
    uint64_t green_index = 1;
    uint64_t blue_index = 2;
    uint64_t y_index = 0;
    uint64_t u_index = 0;
    uint64_t v_index = 0;
    uint8_t Y = 0;
    uint8_t U = 0;
    uint8_t V = 0;
    uint8_t R = 0;
    uint8_t G = 0;
    uint8_t B = 0;
    bool flag = true;
    static uint8_t rgb_bytes[9999 * 9999 * 3] = { 0 };
    if (width > 0 && height > 0)
    {
    }
    else
        return nullptr;
    // NV21
    if (yuv_type == 1) {
        for (int row = 0; row < height; row++) {
            for (int column = 0; column < width; column++) {
                v_index = width * height + (row / 2) * width + (column / 2) * 2;
                u_index = u_index + 1;
                if (y_index < data_length && v_index <= data_length && u_index <= data_length) {
                    Y = data[y_index];
                    U = data[u_index];
                    V = data[v_index];
                    if (array[0] * Y + array[1] * (U - 128) + array[2] * (V - 128) > 255) {
                        R = 255;
                    }
                    else if (array[0] * Y + array[1] * (U - 128) + array[2] * (V - 128) < 0) {
                        R = 0;
                    }
                    else {
                        R = array[0] * Y + array[1] * (U - 128) + array[2] * (V - 128);
                    }
                    if (array[3] * Y + array[4] * (U - 128) + array[5] * (V - 128) > 255) {
                        G = 255;
                    }
                    else if (array[3] * Y + array[4] * (U - 128) + array[5] * (V - 128) < 0) {
                        G = 0;
                    }
                    else {
                        G = array[3] * Y + array[4] * (U - 128) + array[5] * (V - 128);
                    }
                    if (array[6] * Y + array[7] * (U - 128) + array[8] * (V - 128) > 255) {
                        B = 255;
                    }
                    else if (array[6] * Y + array[7] * (U - 128) + array[8] * (V - 128) < 0) {
                        B = 0;
                    }
                    else {
                        B = array[6] * Y + array[7] * (U - 128) + array[8] * (V - 128);
                    }
                    //R = array[0] * Y + array[1] * U + array[2] * V;
                    //G = array[3] * Y + array[4] * U + array[5] * V;
                    //B = array[6] * Y + array[7] * U + array[8] * V;
                    rgb_bytes[red_index] = R;
                    rgb_bytes[green_index] = G;
                    rgb_bytes[blue_index] = B;
                    y_index += 1;
                    red_index += 3;
                    green_index += 3;
                    blue_index += 3;
                }
            }
        }
    }
    // NV12
    else {
        for (int row = 0; row < height; row++) {
            for (int column = 0; column < width; column++) {
                u_index = width * height + (row / 2) * width + (column / 2) * 2;
                v_index = u_index + 1;
                if (y_index < data_length && v_index <= data_length && u_index <= data_length) {
                    Y = data[y_index];
                    U = data[u_index];
                    V = data[v_index];
                    if (array[0] * Y + array[1] * (U - 128) + array[2] * (V - 128) > 255) {
                        R = 255;
                    }
                    else if (array[0] * Y + array[1] * (U - 128) + array[2] * (V - 128) < 0) {
                        R = 0;
                    }
                    else {
                        R = array[0] * Y + array[1] * (U - 128) + array[2] * (V - 128);
                    }
                    if (array[3] * Y + array[4] * (U - 128) + array[5] * (V - 128) > 255) {
                        G = 255;
                    }
                    else if (array[3] * Y + array[4] * (U - 128) + array[5] * (V - 128) < 0) {
                        G = 0;
                    }
                    else {
                        G = array[3] * Y + array[4] * (U - 128) + array[5] * (V - 128);
                    }
                    if (array[6] * Y + array[7] * (U - 128) + array[8] * (V - 128) > 255) {
                        B = 255;
                    }
                    else if (array[6] * Y + array[7] * (U - 128) + array[8] * (V - 128) < 0) {
                        B = 0;
                    }
                    else {
                        B = array[6] * Y + array[7] * (U - 128) + array[8] * (V - 128);
                    }
                    rgb_bytes[red_index] = R;
                    rgb_bytes[green_index] = G;
                    rgb_bytes[blue_index] = B;
                    y_index += 1;
                    red_index += 3;
                    green_index += 3;
                    blue_index += 3;
                }
            }
        }
    }
    return rgb_bytes;
}

unsigned char* yuv2rgb_ten(double* array, uint16_t* data, uint64_t data_length, int yuv_type, int width, int height)
{
    data_length = data_length / 2;
    printf("data len = %llu\n", data_length);
    for (int i = 0; i < 9; i++) {
        printf("array[%d] = %f\n", i, array[i]);
    }
    printf("width = %d, height = %d\n", width, height);
    uint64_t red_index = 0;
    uint64_t green_index = 1;
    uint64_t blue_index = 2;
    uint64_t y_index = 0;
    uint64_t u_index = 0;
    uint64_t v_index = 0;
    uint16_t Y = 0;
    uint16_t U = 0;
    uint16_t V = 0;
    uint16_t R = 0;
    uint16_t G = 0;
    uint16_t B = 0;
    bool flag = true;
    int iii = 0;
    static uint8_t rgb_bytes[9999 * 9999 * 3 * 2] = { 0 };
    if (width > 0 && height > 0)
    {
    }
    else
        return nullptr;
    // NV21
    if (yuv_type == 1) {
        for (int row = 0; row < height; row++) {
            for (int column = 0; column < width; column++) {
                v_index = width * height + ((row / 2) * width + (column / 2) * 2) * 2;
                u_index = u_index + 1;
                if (y_index < data_length && v_index <= data_length && u_index <= data_length) {
                    Y = data[y_index];
                    U = data[u_index];
                    V = data[v_index];
                    if (array[0] * Y + array[1] * (U - 32767) + array[2] * (V - 32767) > 0xffff) {
                        R = 0xffff;
                    }
                    else if (array[0] * Y + array[1] * (U - 32767) + array[2] * (V - 32767) < 0) {
                        R = 0;
                    }
                    else {
                        R = array[0] * Y + array[1] * (U - 32767) + array[2] * (V - 32767);
                    }
                    if (array[3] * Y + array[4] * (U - 32767) + array[5] * (V - 32767) > 0xffff) {
                        G = 0xffff;
                    }
                    else if (array[3] * Y + array[4] * (U - 32767) + array[5] * (V - 32767) < 0) {
                        G = 0;
                    }
                    else {
                        G = array[3] * Y + array[4] * (U - 32767) + array[5] * (V - 32767);
                    }
                    if (array[6] * Y + array[7] * (U - 32767) + array[8] * (V - 32767) > 0xffff) {
                        B = 0xffff;
                    }
                    else if (array[6] * Y + array[7] * (U - 32767) + array[8] * (V - 32767) < 0) {
                        B = 0;
                    }
                    else {
                        B = array[6] * Y + array[7] * (U - 32767) + array[8] * (V - 32767);
                    }
                    rgb_bytes[red_index] = (R >> 8) & 0xff;
                    rgb_bytes[green_index] = (G >> 8) & 0xff;
                    rgb_bytes[blue_index] = (B >> 8) & 0xff;;
                    y_index += 1;
                    red_index += 3;
                    green_index += 3;
                    blue_index += 3;
                }
            }
        }
    }
    // NV12
    else {
        for (int row = 0; row < height; row++) {
            for (int column = 0; column < width; column++) {
                u_index = width * height + (row / 2) * width + (column / 2) * 2;
                v_index = u_index + 1;
                if (y_index < data_length && v_index <= data_length && u_index <= data_length) {
                    Y = data[y_index];
                    U = data[u_index];
                    V = data[v_index];
                    if (array[0] * Y + array[1] * (U - 32767) + array[2] * (V - 32767) > 0xffff) {
                        R = 0xffff;
                    }
                    else if (array[0] * Y + array[1] * (U - 32767) + array[2] * (V - 32767) < 0) {
                        R = 0;
                    }
                    else {
                        R = array[0] * Y + array[1] * (U - 32767) + array[2] * (V - 32767);
                    }
                    if (array[3] * Y + array[4] * (U - 32767) + array[5] * (V - 32767) > 0xffff) {
                        G = 0xffff;
                    }
                    else if (array[3] * Y + array[4] * (U - 32767) + array[5] * (V - 32767) < 0) {
                        G = 0;
                    }
                    else {
                        G = array[3] * Y + array[4] * (U - 32767) + array[5] * (V - 32767);
                    }
                    if (array[6] * Y + array[7] * (U - 32767) + array[8] * (V - 32767) > 0xffff) {
                        B = 0xffff;
                    }
                    else if (array[6] * Y + array[7] * (U - 32767) + array[8] * (V - 32767) < 0) {
                        B = 0;
                    }
                    else {
                        B = array[6] * Y + array[7] * (U - 32767) + array[8] * (V - 32767);
                    }
                    rgb_bytes[red_index] = (R >> 8) & 0xff;
                    rgb_bytes[green_index] = (G >> 8) & 0xff;
                    rgb_bytes[blue_index] = (B >> 8) & 0xff;;
                    y_index += 1;
                    red_index += 3;
                    green_index += 3;
                    blue_index += 3;
                }
            }
        }
    }
    return rgb_bytes;
}

int main()
{
    return 0;
}

瓦力wow
关注
  • 15
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
NV21、NV12、JPG互相转换python脚本
06-21
python3 脚本 依赖opencv3 PIL，能够将jpg和NV21、NV12格式相互转化，附带YUV文件查看器 修改自大佬原有的代码，侵删
将yuv各种格式的图片转换为jpg格式的
04-17
将yuv各种格式的图片转换为jpg格式的，在程序中定义文件按路径即可。
[OpenCL] 利用opencl-buffer，读取一张JPG图像，并转为灰度图。
AndreLe的博客
07-03 184
本文利用opencv读取一张jpg图像，将数据传入opencl-buffer中，使用kernel快速灰度化图像，并且保存输出图像到本地。最后，实际灰度图像的kernel函数。
[OpenCL] 读取一张raw图像(NV12格式)，转为jpg图像（rgb格式）,并进行耗时统计。
最新发布
AndreLe的博客
07-03 471
对于raw文件而言，读取其中的NV12格式的数据，需要利用二进制进行读取，再经过GPU处理后，保存输出的数据为jpg文件。验证是否转换正确，可以分别用opencv和自己生成的结果做对比。
yuv 和jpg互相转
fu6543210的博客
12-01 9444
目的很明确就是批量把jpg图片转为YUV格式。 ------------------------------------------------------------------ 先看一下win下具体如何操作的： 1. 下载ffmpeg，转码图片和视频的利器啊！官方免费下载地址：https://ffmpeg.zeranoe.com/builds/win64/static/ffmpeg-4....
ffmpeg 将yuv数据转化成jpeg的图片
gnimey的博客
11-08 530
i：指定输入文件名 注意：frame.yuv的后缀格式。使用了frame.yuy2的后缀，导致到处的图片有问题。-pix_fmt：指定输入文件的像素格式，我的是yuyv422。frame.jpeg：指定输出文件名。-s：指定输入文件的分辨率。
将yuv422二进制数据保存为JPG图片
我的博客
11-20 1520
以下代码演示了如何将一个已经存在的yuv422二进制数据的文件 output.yuv 转换为jpg图片。
YUV转为jpg图像
u013925378的博客
08-28 4799
调用opencv库，将yuv图像转为jpg图像。 代码如下： # define _CRT_SECURE_NO_WARNINGS #include &lt;string&gt; #include &lt;iostream&gt; #include &lt;fstream&gt; #include &lt;cv.h&gt;   #include &lt;highgui.h&gt;  #incl...
yuv格式转jpg格式
12-08
c++视频解析 yuv转jpg
YUV视频流生成转成jpg图片
Alex的博客
07-07 4142
android9系统 相机Camera类的PreviewCallback回调中，这个接口回调的是相机的预览图片，是YUV格式的数据，这是，利用YuvImage对象的compressToJpeg方法生成Jpeg格式的图片保存在本地。 主要参数解析 new YuvImage(data, ImageFormat.NV21, width, height, null); format：压缩格式，目前仅支持ImageFormat.NV21与ImageFormat.YUY2两个格式。 width：Yuv
YUV420序列转成图片
大指挥官
11-21 7509
关于YUV格式的图片，
YUV2Jpg YUV转换成 JPEG格式
10-18
一个 Y U V 转换成 JPEG图片格式的例子.
yuv格式转换成jpg格式
09-01
yuv格式转换成jpg格式的一个小程序 对于格式转换的初学有很大帮助
yuv转jpg，不用库，linux c程序
09-21
yuv转jpg，不用库，linux c程序，yuv420，现将yuv各比分提取出来，然后调用函数。 420不是指没有V，而是指一行采样只取U，另一行采样只取V。在取U和V时，每两个Y之间取一个U或V。但从4x4矩阵列来看，每4个矩阵点Y区域中，只有一个U和V，所以它们的比值是4:1。
yuv转jpg源码 带jpeg库 c语言
12-11
此软件主要将YUV420视频流转码成单帧jpg图片，运行环境为LINUX。所有需要用到的库都以静态库方式存在于lib路径下。具体编译和使用参见readme.txt
基于libjpeg的将yuv转成jpg
01-03
本程序是调用了libjpeg库实现将yuv格式的图片转换成mpeg
rgb 和 yuv_nv12 数据相互转换
06-30
RGB和YUV_NV12是两种常见的颜色空间表示方式，它们在图像处理和视频编码领域广泛应用。RGB代表红绿蓝三原色模型，而YUV_NV12是一种节省存储空间的YUV格式，主要用于视频编码和解码。本篇文章将深入探讨这两种颜色...
Python 读取 YUV(NV12) 视频文件实例
09-18
YUV420有两种存储方式，一种是NV12和NV21，它们将亮度信息Y存储在一个数组中，而色度信息UV打包存储在另一个矩阵中，UV的排列顺序不同导致了NV12和NV21格式的区别。另一种是I420和YV12，这三种格式的不同之处在于...
通过封装的opencv函数进行yuv.nv12到jpg的转换并画框显示
12-17
1、读取yuv.nv12文件转换成jpg格式文件输出； 2、通过封装opencv函数进行画框输出；
C++ cv::Mat 2 yuv_nv12
04-01
Para convertir una imagen en formato cv::Mat a yuv_nv12, se puede utilizar la siguiente función: ``` void mat2yuv_nv12(const cv::Mat& mat, unsigned char* yuv_nv12_data) { int width = mat.cols; int height = mat.rows; // Convertir a YUV cv::Mat yuv; cv::cvtColor(mat, yuv, cv::COLOR_BGR2YUV); // Obtener los datos de YUV int y_size = width * height; int uv_size = y_size / 2; unsigned char* y_data = yuv_nv12_data; unsigned char* uv_data = yuv_nv12_data + y_size; // Copiar el plano Y memcpy(y_data, yuv.data, y_size); // Copiar los planos U y V (intercalados) for (int i = 0; i < uv_size; i++) { uv_data[2 * i] = yuv.data[y_size + i * 2]; uv_data[2 * i + 1] = yuv.data[y_size + i * 2 + 1]; } } ``` La función recibe como parámetros la imagen en formato cv::Mat y un puntero a un array de bytes donde se almacenará la imagen en formato yuv_nv12. Primero se convierte la imagen a formato YUV utilizando la función cv::cvtColor(). Luego se copian los planos Y, U y V al array de bytes, respetando el orden intercalado que tiene el formato yuv_nv12. Para utilizar esta función, se puede llamar de la siguiente manera: ``` cv::Mat image = cv::imread("imagen.jpg"); unsigned char* yuv_nv12_data = new unsigned char[image.cols * image.rows * 3 / 2]; mat2yuv_nv12(image, yuv_nv12_data); ``` Se carga la imagen en formato cv::Mat utilizando la función cv::imread(), y se crea un array de bytes donde se almacenará la imagen en formato yuv_nv12. Luego se llama a la función mat2yuv_nv12() para convertir la imagen y almacenarla en el array de bytes.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值