Yuv数据简介 与压缩处理

于 2024-03-12 14:22:59 发布
阅读量974 收藏 11
点赞数 24
分类专栏： 音视频 文章标签： 图像处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yinsui1839/article/details/136617008
版权

YUV:

YUV，是一种颜色编码方法。常使用在各个影像处理组件中。 YUV在对照片或影片编码时，考虑到人类的感知能力，允许降低色度的带宽。

YUV是编译true-color颜色空间（color space）的种类，Y'UV, YUV, YCbCr，YPbPr等专有名词都可以称为YUV，彼此有重叠。“Y”表示明亮度（Luminance、Luma），“U”和“V”则是色度、浓度（Chrominance、Chroma），

Y′UV, YUV, YCbCr, YPbPr所指涉的范围，常有混淆或重叠的情况。从历史的演变来说，其中YUV和Y'UV通常用来编码电视的模拟信号，而YCbCr则是用来描述数字的影像信号，适合影片与图片压缩以及传输，例如MPEG、JPEG。 但在现今，YUV通常已经在电脑系统上广泛使用。

与RGB格式（红-绿-蓝）不同，YUV格式用一个称为Y（相当于灰度）的“亮度”分量和两个“色度”分量表示，分别称为U（蓝色投影）和V（红色投影）。             

YUV Formats分成两个格式：

紧缩格式（packed formats）：将Y、U、V值存储成Macro Pixels数组，和RGB的存放方式类似。
平面格式（planar formats）：将Y、U、V的三个分量分别存放在不同的矩阵中。

紧缩格式：

紧缩格式（packed format）中的YUV是混合在一起的，对于YUV4:2:2格式而言，用紧缩格式很合适的，因此就有了UYVY、YUYV等。

UYVY(YUV422)

平面格式：

平面格式（planar formats）是指每Y分量，U分量和V分量都是以独立的平面组织的，也就是说所有的U分量必须在Y分量后面，而V分量在所有的U分量后面，此一格式适用于采样（subsample）。平面格式（planar format）有I420（4:2:0）、YV12、IYUV、 NV21、 NV12等。平面格式较为常用

NV21

NV12

   

与RGB转换关系

对于同一个观测像素点，在RGB空间和YUV空间可进行了不同角度的表示，两者满足单射线性变换，两者可以通过线性变换公式进行转换，如图1所示

转换公式如下：

            Y = 0.299R + 0.587G + 0.114B

            U= -0.169R - 0.331G + 0.500B + 128

            V= 0.500R - 0.419G - 0.081B + 128

反向从YUV转换到RGB的公式为：

          R= Y + 1.402 (V − 128 )

          G= Y − 0.344136 (U − 128)− 0.714136 (V − 128)

          B= Y + 1.772(U − 128)​

YUV转RGB C语音代码：

#include <stdio.h>
#include <stdlib.h>

// YUV到RGB的转换公式
void YUV422_to_RGB888(int width, int height, unsigned char *yuv_buffer, unsigned char *rgb_buffer) {
    int y, u, v, r, g, b;
    for (int i = 0; i < width * height * 2; i += 4) {
        // 获取YUV分量
        u = yuv_buffer[i] - 128;
        y = yuv_buffer[i + 1];
        v = yuv_buffer[i + 2] - 128;
        // 第一个像素的RGB转换
        r = y + (1.370705 * v);
        g = y - (0.698001 * v) - (0.337633 * u);
        b = y + (1.732446 * u);
        // 确保RGB值在0-255范围内
        r = r < 0 ? 0 : r > 255 ? 255 : r;
        g = g < 0 ? 0 : g > 255 ? 255 : g;
        b = b < 0 ? 0 : b > 255 ? 255 : b;
        // 将RGB值写入缓冲区
        rgb_buffer[(i / 2) * 3] = r;
        rgb_buffer[(i / 2) * 3 + 1] = g;
        rgb_buffer[(i / 2) * 3 + 2] = b;
        // 获取下一个Y分量
        y = yuv_buffer[i + 3];
        // 第二个像素的RGB转换
        r = y + (1.370705 * v);
        g = y - (0.698001 * v) - (0.337633 * u);
        b = y + (1.732446 * u);
        // 确保RGB值在0-255范围内
        r = r < 0 ? 0 : r > 255 ? 255 : r;
        g = g < 0 ? 0 : g > 255 ? 255 : g;
        b = b < 0 ? 0 : b > 255 ? 255 : b;
        // 将RGB值写入缓冲区
        rgb_buffer[(i / 2) * 3 + 3] = r;
        rgb_buffer[(i / 2) * 3 + 4] = g;
        rgb_buffer[(i / 2) * 3 + 5] = b;
    }
}

void RGB888_to_YUV422(int width, int height, unsigned char *rgb_buffer, unsigned char *yuv_buffer) {
    int y0, u, y1, v;
    for (int i = 0; i < width * height * 3; i += 6) {
        // 获取RGB分量
        unsigned char r0 = rgb_buffer[i];
        unsigned char g0 = rgb_buffer[i + 1];
        unsigned char b0 = rgb_buffer[i + 2];
        unsigned char r1 = rgb_buffer[i + 3];
        unsigned char g1 = rgb_buffer[i + 4];
        unsigned char b1 = rgb_buffer[i + 5];

        // 转换第一个像素的Y分量
        y0 = (77 * r0 + 150 * g0 + 29 * b0) >> 8;
        // 转换U分量
        u = ((-43 * r0 - 85 * g0 + 128 * b0) >> 8) + 128;
        // 转换第二个像素的Y分量
        y1 = (77 * r1 + 150 * g1 + 29 * b1) >> 8;
        // 转换V分量
        v = ((128 * r0 - 107 * g0 - 21 * b0) >> 8) + 128;

        // 将YUV分量写入缓冲区
        yuv_buffer[i / 3 * 2] = u;
        yuv_buffer[i / 3 * 2 + 1] = y0;
        yuv_buffer[i / 3 * 2 + 2] = v;
        yuv_buffer[i / 3 * 2 + 3] = y1;
    }
}

int main() {
    // 假设yuv_buffer是包含YUV数据的缓冲区
    unsigned char *yuv_buffer = malloc(1920 * 1080 * 2); // YUV 4:2:2
    // 假设rgb_buffer是用于存储RGB数据的缓冲区
    unsigned char *rgb_buffer = malloc(1920 * 1080 * 3); // RGB 8:8:8

    // 填充yuv_buffer数据...
    // ...

    // 转换YUV到RGB
    YUV422_to_RGB888(1920, 1080, yuv_buffer, rgb_buffer);
    //RGB888_to_YUV422(1920, 1080, rgb_buffer, yuv_buffer);
    // 使用rgb_buffer数据...
    // ...

    // 释放内存
    free(yuv_buffer);
    free(rgb_buffer);

    return 0;
}

yuv422缩放：


void RGB888_to_YUV422(int width, int height, unsigned char *rgb_buffer, unsigned char *yuv_buffer) {
    int y0, u, y1, v;
    for (int i = 0; i < width * height * 3; i += 6) {
        // 获取RGB分量
        unsigned char r0 = rgb_buffer[i];
        unsigned char g0 = rgb_buffer[i + 1];
        unsigned char b0 = rgb_buffer[i + 2];
        unsigned char r1 = rgb_buffer[i + 3];
        unsigned char g1 = rgb_buffer[i + 4];
        unsigned char b1 = rgb_buffer[i + 5];

        // 转换第一个像素的Y分量
        y0 = (77 * r0 + 150 * g0 + 29 * b0) >> 8;
        // 转换U分量
        u = ((-43 * r0 - 85 * g0 + 128 * b0) >> 8) + 128;
        // 转换第二个像素的Y分量
        y1 = (77 * r1 + 150 * g1 + 29 * b1) >> 8;
        // 转换V分量
        v = ((128 * r0 - 107 * g0 - 21 * b0) >> 8) + 128;

        // 将YUV分量写入缓冲区
        yuv_buffer[i / 3 * 2] = u;
        yuv_buffer[i / 3 * 2 + 1] = y0;
        yuv_buffer[i / 3 * 2 + 2] = v;
        yuv_buffer[i / 3 * 2 + 3] = y1;
    }
}

图像压缩：

一般可以使用libyuv进行压缩，如果项目上存储容量不够可以使用下面比较简单的转换做压缩处理

yuv422(UYVY)

1760*1280转1280*720 由于每两个y分量共用一组uv色差值，所以视为宽880 高1280 转换宽比值为：11：9 高比值：16：9

C：

#include <stdio.h>
#include <cstring>
int readFile(unsigned char* buf, int len,char*name){
    FILE* fp = NULL;
    fp = fopen(name, "rb+");
    if (fp != NULL) {
        fread((char*)buf, 1, len, fp);
        fclose(fp);
    } 
}

int writeFile(unsigned char* buf, int len,char*name){
    FILE* fp = NULL;
    fp = fopen(name, "wb+");
    if (fp != NULL) {
        fwrite((char*)buf, 1, len, fp);
        fclose(fp);
    } 
}

void RGB888_to_YUV422(int width, int height,  unsigned char *rgb_buffer,  unsigned char *yuv_buffer) {
    int y0, u, y1, v;
    for (int i = 0; i < width * height * 3; i += 6) {
        // 获取RGB分量
        unsigned char r0 = rgb_buffer[i];
        unsigned char g0 = rgb_buffer[i + 1];
        unsigned char b0 = rgb_buffer[i + 2];
        unsigned char r1 = rgb_buffer[i + 3];
        unsigned char g1 = rgb_buffer[i + 4];
        unsigned char b1 = rgb_buffer[i + 5];

        // 转换第一个像素的Y分量
        y0 = (77 * r0 + 150 * g0 + 29 * b0) >> 8;
        // 转换U分量
        u = ((-43 * r0 - 85 * g0 + 128 * b0) >> 8) + 128;
        // 转换第二个像素的Y分量
        y1 = (77 * r1 + 150 * g1 + 29 * b1) >> 8;
        // 转换V分量
        v = ((128 * r0 - 107 * g0 - 21 * b0) >> 8) + 128;

        // 将YUV分量写入缓冲区
        yuv_buffer[i / 3 * 2] = u;
        yuv_buffer[i / 3 * 2 + 1] = y0;
        yuv_buffer[i / 3 * 2 + 2] = v;
        yuv_buffer[i / 3 * 2 + 3] = y1;
    }
}

int main(void){
    int width = 1706;
    int heigh = 1280;
//===========1706 *1279 --> 1706 *1280 ===============
    unsigned char *rgbBuf = new unsigned char[1760*1280*3];
    unsigned char *yuvBuf = new unsigned char[1760*1280*2];
    readFile(rgbBuf,width * 1279 *3,"20240308094827.rgb");
    memcpy(rgbBuf+width * 1279 *3,rgbBuf+width * 1278 *3,width*3);
    writeFile(rgbBuf,width * heigh *3,"1706x1280.rgb");
//=============================================================

//===========1706 *1280 --> 1760 *1280 ===============
    unsigned char *dstBuf = new unsigned char[1760*1280*3];
    int dstH = 0;
    int dstW = 0;
    for(int h=0;h<1280;h++){
        for(int w=0;w<1706;w++){
            dstBuf[((dstW + dstH*1760)*3)]=  rgbBuf[((w+h*width)*3)] ;//r
            dstBuf[((dstW + dstH*1760)*3)+1] = rgbBuf[((w+h*width)*3)+1] ;//g
            dstBuf[((dstW + dstH*1760)*3)+2] = rgbBuf[((w+h*width)*3)+2] ;//b
    
            dstW++;
            if((dstW % 32 == 0) && dstW < 1760){
                
                dstBuf[((dstW + dstH*1760)*3)]=  rgbBuf[((w+h*width)*3)] ;//r
                dstBuf[((dstW + dstH*1760)*3)+1] = rgbBuf[((w+h*width)*3)+1] ;//g
                dstBuf[((dstW + dstH*1760)*3)+2] = rgbBuf[((w+h*width)*3)+2] ;//b
                dstW++;
            }
        }
        dstH++;
        dstW= 0;
    }
    writeFile(dstBuf,1760*1280*3,"1760x1280.rgb");
    memcpy(rgbBuf,dstBuf,1760*1280*3);

   dstW = 0;
   RGB888_to_YUV422(1760, 1280, dstBuf, yuvBuf);
   writeFile(yuvBuf,1760 *1280 *2,"1760x1280.uyuv");
   //===============1760*1280 UYUV --> 1280*720 UYUV=============
   dstH = 0;
   unsigned char u,y,v,r,g,b;
    //高取一半数据
    for(int h=0;h<1280;h+=2){
        //由于y和y1共用一组uv数据，所以宽为2个y数据为一组像素 ，1760/2  ==880
        for(int w=0;w<880;w++){//880   //1280
            //判断宽数据比例11取8，进行数据填充
            if(w % 11 == 0 || w % 11 == 2 || w % 11 == 3 || w % 11 == 4
            || w % 11 == 6 || w % 11 == 7 || w % 11 == 8 || w % 11 == 10
            ){
                dstBuf[(dstW + dstH*640)*4+0] = yuvBuf[(w + h*880)*4+0];//u数据填充
                dstBuf[(dstW + dstH*640)*4+1] = yuvBuf[(w + h*880)*4+1];//y数据填充
                dstBuf[(dstW + dstH*640)*4+2] = yuvBuf[(w + h*880)*4+2];//v数据填充
                dstBuf[(dstW + dstH*640)*4+3] = yuvBuf[(w + h*880)*4+3];//y1数据填充
                dstW++;              
            }
        }
         dstH++;
          dstW= 0;
        //判断高数据比例16比9 ，额外补多一行进行数据填充
        if(h % 16 == 14){
           for(int w=0;w<880;w++){
             //判断宽数据比例11取8，进行数据填充
            if(w % 11 == 0 || w % 11 == 2 || w % 11 == 3 || w % 11 == 4
            || w % 11 == 6 || w % 11 == 7 || w % 11 == 8 || w % 11 == 10
            ){
                dstBuf[(dstW + dstH*640)*4+0] = yuvBuf[(w + h*880)*4+0];//u数据填充
                dstBuf[(dstW + dstH*640)*4+1] = yuvBuf[(w + h*880)*4+1];//y数据填充
                dstBuf[(dstW + dstH*640)*4+2] = yuvBuf[(w + h*880)*4+2];//v数据填充
                dstBuf[(dstW + dstH*640)*4+3] = yuvBuf[(w + h*880)*4+3];//y1数据填充
                dstW++;              
            }
       
        }
           dstH++;
        }
        
        dstW= 0;

    }
    writeFile(dstBuf,1280 *720 *2,"1280x720.uyuv");
}

  

图像效果：

测试代码在附近上

hmbbPdx_
关注
  • 24
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Android 使用libyuv对 yuv数据进行缩放，旋转，镜像，裁剪等操作
10-12
Android 使用libyuv对Android yuv数据进行缩放，旋转，镜像，裁剪等操作
视音频数据处理入门：RGB、YUV像素数据处理
热门推荐
雷霄骅(leixiaohua1020)的专栏
01-29 26万+
有段时间没有写博客了，这两天写起博客来竟然感觉有些兴奋，仿佛找回了原来的感觉。前一阵子在梳理以前文章的时候，发现自己虽然总结了各种视音频应用程序，却还缺少一个适合无视音频背景人员学习的“最基础”的程序。因此抽时间将以前写过的代码整理成了一个小项目。
数据压缩实验一：yuv转rgb
fang_na的博客
03-12 591
一、实验原理 1.彩色空间转换的基本思想及转换公式 （1）YUV与RGB空间的相互转换 RGBàYUV基本公式： Y＝0.2990R+0.5870G+0.1140B R-Y＝0.7010R-0.5870G-0.1140B B-Y＝-0.2990R-0.5870G+0.8860B 为了使色差信号的动态范围控制在0.5之间，需要进行归一化，对色差信号引入压缩系数。归一化后的色差信号为：
数据压缩——rgb转yuv
Bingyeshinvwang的博客
05-04 1457
RGB转YUV
YUV数据格式简介
是二条呢！的博客
04-28 375
YUV420：每四个Y共用一组UV分量，在内存中的长度是h * w + h * w / 4 + h * w / 4 = h * w *1.5，是RGB（h * w * 3）格式视频数据内存的一半，每个像素的Y数据保留，两个像素数据只保留一个U或者V数据；YUV422：每两个Y共用一组UV分量，在内存中的长度是h * w + h * w / 2 + h * w / 2 = h * w *2，是RGB（h * w * 3）格式视频数据内存2/3，每两个相邻的像素，一个丢弃V数据，一个丢弃U数据；
YUV数据和格式
俗科技的博客
02-11 2960
YUV是一种颜色编码方法， 与RGB（红 - 绿 - 蓝）不同。Y表示亮度分量，也叫灰阶值：如果只显示Y，图片会是一张黑白照U（Cb）表示色度分量：是照片蓝色部分去掉亮度V（Cr）表示色度分量：是照片红色部分去掉亮度。
Multimedia学习_YUV数据格式
白衣木木三的博客
10-12 478
YUV数据格式 https://technet.microsoft.com/en-us/subscriptions/dd206750(v=vs.85).aspx 概要： 与RGB编码方法类似，YUV也是一种图像编码方法，主要用于电视系统以及模拟视频领域，它是指将亮度分量（Y：Luminance或Luma）和色度分量（UV：Chrominance或Chroma）分开进行表示的像素编码格式。而这...
YUV原理和格式详解
LiggerBill的博客
01-30 7575
YUV是指亮度参数和色度参量分开表示的像素格式，其中“Y”表示明亮度（Luminance或Luma），也就是灰度值；而“U”和“V”表示的则是色度（Chrominance或Chrima），作用是描述色彩及饱和度,用于指定像素的颜色。Y：亮度分量，表示物理线性空间亮度。U：蓝色投影。V：红色投影。YUV同RGB 类似，也是一种颜色编码方法，主要用于电视系统以及模拟视频领域，它讲亮度信息（Y）与色彩信息（UV）分离，没有UV信息一样能够显示完整的图像，只不过是黑白色的。
YUV
qq_36314864的博客
08-03 845
YUV YUV是被欧洲电视系统所采用的一种颜色编码方法（属于PAL），是PAL和SECAM模拟彩色电视制式采用的颜色空间。 在现代彩色电视系统中，通常采用三管彩色摄影机或彩色CCD摄影机进行取像，然后把取得的彩色图像信号经分色、分别放大校正后得到RGB，再经过矩阵变换电路得到亮度信号Y和两个色差信号B－Y（即U）、R－Y（即V），最后发送端将亮度和色差三个信号分别进行编码，用同一信道发送出去。这种色彩的表示方法就是所谓的YUV色彩空间表示。 YUV中“Y”表示明亮度（Luminance或Luma），也就是灰
视频学习笔记：Android OpenGL渲染YUV420P图像
lidec的专栏
06-26 7525
背景Android 开发中，当得到一张yuv图需要显示时，之前的做法是利用ffmpeg自带的方法将其转换为RGB565或者RGBA，然后将RGB数据拷贝到aNativeWindow的图像缓冲区，达到显示的目的。这样做比较耗CPU, 最近在阅读ijkplayer源码时，整理了一下OpenGL直接渲染YUV420P相关流程，参考网上一些代码，总结了一个最简单的小例子。例子下载地址 http://dow
对yuv视频文件用zigzag方法进行压缩解压缩
06-21
对yuv视频文件用zigzag方法进行压缩解压缩，并计算了视频压缩比率和psnr
文件格式转换（BMP转YUV）
04-21
6. **文件写入**：创建新的YUV文件，并将缓冲区的YUV数据写入文件。 在实际操作中，需要注意YUV的量化范围，比如Y的范围是16-235，U和V的范围是16-240。在转换过程中，可能会对U和V分量加上128来对齐码电平。此外，...
基于Android视频监控系统的数据处理及实现.pdf
08-15
二、视频采集与数据处理 2.1 视频采集 视频采集阶段涉及对摄像头的控制，包括视频帧率、分辨率等参数的设置，以及实时视频数据的捕获。MJPEG-streamer负责这一过程，将摄像头的原始视频流转化为可以通过网络传输的...
YUV--YUV.doc
02-08
此外，色差信号的处理也更容易实现对图像的压缩，这对于视频传输和存储至关重要。 在实际应用中，常见的视频接口如复合视频（Composite video）、S-Video（Y/C Video）和分量视频（Component video）都利用了YUV的...
视频编码格式与RGB、YUV
09-09
视频编码格式与RGB、YUV 视频编码格式是视频开发的基础，理解视频编码格式对于...视频编码格式与RGB、YUV之间存在着紧密的联系，了解视频编码格式、颜色空间表示方法和视频信号处理 pipeline 对于视频开发非常重要。
YUV图像格式详解
最新发布
肖云鹤的博客
11-04 2430
相对于常见且直观的RGB颜色编码，YUV的产生自有其意义，它基于人眼对亮度比色彩的敏感度更高的特点，使用Y、U、V三个分量来表示颜色，并通过降低U、V分量的采样率，尽可能保证图像质量的情况下，做到如下3点： 占用更低的存储空间 数据传输效率更高 兼容黑白与彩色显示 具体是怎么做到的，本博文一一讲解
yuv数据格式
qq_39524121的博客
10-20 167
媒体芯片中的YUV格式
使用libjpeg库将yuv420sp压缩为jpeg
dawudayudaxue的博客
05-26 983
由于yuv原始数据比较大，在进行一些视频流传输的过程中为了减少数据量，通常需要进行压缩。本文探讨的是将yuv420sp压缩为jpeg流，包含灰度和彩色两种方式，下面是代码： int codeJpeg(const char *scr_frame, int iWidth, int iHeight, int iQuality, int iColorSpace, char *coded_frame, int& code_frame_size) { //struct jpeg_decompress_stru
c,jpeg_lib.so 压缩yuv ，nv21 图像
m0_49415938的博客
09-02 283
c,jpeg_lib.so 压缩yuv ，nv21 图像 背景 1，实际需求，将nv21格式的图片，通过jpeg_lib.so压缩成jpeg格式，存储 2，jpeg_lib.so本身是不支持指定yuv格式，来进行压缩的. 通过实验之后发现，jpeg_lib.so 支持将存储数据格式为yuvyuv的图片直接压缩，（通过jpeg库直接解压缩出来的数据也是yuvyuv格式存储的）。 处理流程 1，将nv21格式图片，转换成yuvyuv存储（我这边测试20ms内），之后直接jpeg库的标准流程压缩， 其他
视频处理中什么是RAW数据什么是YUV数据
05-18
在视频处理中，RAW数据和YUV数据都是常见的格式。 RAW数据是指未经过编码的原始视频数据，通常是由相机或摄像机直接输出的。它包含了每个像素的亮度和颜色信息，但没有经过任何压缩或编码处理。由于RAW数据包含大量的信息，它通常需要进行后期处理和压缩以便于存储和传输。 YUV数据是指经过压缩编码后的视频数据格式，其中Y表示亮度信息，U和V分别表示蓝色和红色的色度信息。YUV数据通常比RAW数据更适合存储和传输，因为它们经过了压缩和编码处理，可以大大减少数据量并提高传输速度。 在实际应用中，视频处理通常需要将RAW数据转换为YUV数据，然后进行编码和压缩处理。这些处理可以使用各种算法和技术来实现，例如H.264、MPEG-4等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

hmbbPdx_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值