YUV2BGR的C++版本代码

于 2024-05-27 14:30:04 发布
阅读量472 收藏 10
点赞数 8
文章标签： 算法 c++ 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012374012/article/details/139237397
版权

#include "YUV2BGR.h"

#define __ARM_NEON 0
#define __aarch64__ 1

#if __ARM_NEON 
#include <arm_neon.h>
#endif // __ARM_NEON


void yuv420sp2rgb(const unsigned char* yuv420sp, int w, int h, unsigned char* rgb)
{
    const unsigned char* yptr = yuv420sp;
    const unsigned char* vuptr = yuv420sp + w * h;

#if __ARM_NEON
    int8x8_t _v128 = vdup_n_s8(128);
    int8x8_t _v90 = vdup_n_s8(90);
    int8x8_t _v46 = vdup_n_s8(46);
    int8x8_t _v22 = vdup_n_s8(22);
    int8x8_t _v113 = vdup_n_s8(113);
#endif // __ARM_NEON

    for (int y=0; y<h; y+=2)
    {
        const unsigned char* yptr0 = yptr;
        const unsigned char* yptr1 = yptr + w;
        unsigned char* rgb0 = rgb;
        unsigned char* rgb1 = rgb + w*3;

#if __ARM_NEON
        int nn = w >> 3;
        int remain = w - (nn << 3);
#else
        int remain = w;
#endif // __ARM_NEON

#if __ARM_NEON
#if __aarch64__
        for (; nn>0; nn--)
        {
            int16x8_t _yy0 = vreinterpretq_s16_u16(vshll_n_u8(vld1_u8(yptr0), 6));
            int16x8_t _yy1 = vreinterpretq_s16_u16(vshll_n_u8(vld1_u8(yptr1), 6));

            int8x8_t _vvuu = vsub_s8(vreinterpret_s8_u8(vld1_u8(vuptr)), _v128);
            int8x8x2_t _vvvvuuuu = vtrn_s8(_vvuu, _vvuu);
            int8x8_t _vv = _vvvvuuuu.val[0];
            int8x8_t _uu = _vvvvuuuu.val[1];

            int16x8_t _r0 = vmlal_s8(_yy0, _vv, _v90);
            int16x8_t _g0 = vmlsl_s8(_yy0, _vv, _v46);
            _g0 = vmlsl_s8(_g0, _uu, _v22);
            int16x8_t _b0 = vmlal_s8(_yy0, _uu, _v113);

            int16x8_t _r1 = vmlal_s8(_yy1, _vv, _v90);
            int16x8_t _g1 = vmlsl_s8(_yy1, _vv, _v46);
            _g1 = vmlsl_s8(_g1, _uu, _v22);
            int16x8_t _b1 = vmlal_s8(_yy1, _uu, _v113);

            uint8x8x3_t _rgb0;
            _rgb0.val[0] = vqshrun_n_s16(_r0, 6);
            _rgb0.val[1] = vqshrun_n_s16(_g0, 6);
            _rgb0.val[2] = vqshrun_n_s16(_b0, 6);

            uint8x8x3_t _rgb1;
            _rgb1.val[0] = vqshrun_n_s16(_r1, 6);
            _rgb1.val[1] = vqshrun_n_s16(_g1, 6);
            _rgb1.val[2] = vqshrun_n_s16(_b1, 6);

            vst3_u8(rgb0, _rgb0);
            vst3_u8(rgb1, _rgb1);

            yptr0 += 8;
            yptr1 += 8;
            vuptr += 8;
            rgb0 += 24;
            rgb1 += 24;
        }
#else
        if (nn > 0)
        {
        asm volatile(
            "pld        [%3, #128]          \n"
            "vld1.u8    {d2}, [%3]!         \n"
            "vsub.s8    d2, d2, %12         \n"
            "0:                             \n"
            "pld        [%1, #128]          \n"
            "vld1.u8    {d0}, [%1]!         \n"
            "pld        [%2, #128]          \n"
            "vld1.u8    {d1}, [%2]!         \n"
            "vshll.u8   q2, d0, #6          \n"
            "vorr       d3, d2, d2          \n"
            "vshll.u8   q3, d1, #6          \n"
            "vorr       q9, q2, q2          \n"
            "vtrn.s8    d2, d3              \n"
            "vorr       q11, q3, q3         \n"
            "vmlsl.s8   q9, d2, %14         \n"
            "vorr       q8, q2, q2          \n"
            "vmlsl.s8   q11, d2, %14        \n"
            "vorr       q10, q3, q3         \n"
            "vmlal.s8   q8, d2, %13         \n"
            "vmlal.s8   q2, d3, %16         \n"
            "vmlal.s8   q10, d2, %13        \n"
            "vmlsl.s8   q9, d3, %15         \n"
            "vmlal.s8   q3, d3, %16         \n"
            "vmlsl.s8   q11, d3, %15        \n"
            "vqshrun.s16 d24, q8, #6        \n"
            "vqshrun.s16 d26, q2, #6        \n"
            "vqshrun.s16 d4, q10, #6        \n"
            "vqshrun.s16 d25, q9, #6        \n"
            "vqshrun.s16 d6, q3, #6         \n"
            "vqshrun.s16 d5, q11, #6        \n"
            "pld        [%3, #128]          \n"
            "vld1.u8    {d2}, [%3]!         \n"
            "subs       %0, #1              \n"
            "vst3.u8    {d24-d26}, [%4]!    \n"
            "vsub.s8    d2, d2, %12         \n"
            "vst3.u8    {d4-d6}, [%5]!      \n"
            "bne        0b                  \n"
            "sub        %3, #8              \n"
            : "=r"(nn),     // %0
              "=r"(yptr0),  // %1
              "=r"(yptr1),  // %2
              "=r"(vuptr),  // %3
              "=r"(rgb0),   // %4
              "=r"(rgb1)    // %5
            : "0"(nn),
              "1"(yptr0),
              "2"(yptr1),
              "3"(vuptr),
              "4"(rgb0),
              "5"(rgb1),
              "w"(_v128),   // %12
              "w"(_v90),    // %13
              "w"(_v46),    // %14
              "w"(_v22),    // %15
              "w"(_v113)    // %16
            : "cc", "memory", "q0", "q1", "q2", "q3", "q8", "q9", "q10", "q11", "q12", "d26"
        );
        }
#endif // __aarch64__
#endif // __ARM_NEON

#define SATURATE_CAST_UCHAR(X) (unsigned char)::std::min(::std::max((int)(X), 0), 255);
        for (; remain>0; remain-=2)
        {
            // R = 1.164 * yy + 1.596 * vv
            // G = 1.164 * yy - 0.813 * vv - 0.391 * uu
            // B = 1.164 * yy              + 2.018 * uu

            // R = Y + (1.370705 * (V-128))
            // G = Y - (0.698001 * (V-128)) - (0.337633 * (U-128))
            // B = Y + (1.732446 * (U-128))

            // R = ((Y << 6) + 87.72512 * (V-128)) >> 6
            // G = ((Y << 6) - 44.672064 * (V-128) - 21.608512 * (U-128)) >> 6
            // B = ((Y << 6) + 110.876544 * (U-128)) >> 6

            // R = ((Y << 6) + 90 * (V-128)) >> 6
            // G = ((Y << 6) - 46 * (V-128) - 22 * (U-128)) >> 6
            // B = ((Y << 6) + 113 * (U-128)) >> 6

            // R = (yy + 90 * vv) >> 6
            // G = (yy - 46 * vv - 22 * uu) >> 6
            // B = (yy + 113 * uu) >> 6

            int v = vuptr[0] - 128;
            int u = vuptr[1] - 128;

            int ruv = 90 * v;
            int guv = -46 * v + -22 * u;
            int buv = 113 * u;

            int y00 = yptr0[0] << 6;
            rgb0[0] = SATURATE_CAST_UCHAR((y00 + ruv) >> 6);
            rgb0[1] = SATURATE_CAST_UCHAR((y00 + guv) >> 6);
            rgb0[2] = SATURATE_CAST_UCHAR((y00 + buv) >> 6);

            int y01 = yptr0[1] << 6;
            rgb0[3] = SATURATE_CAST_UCHAR((y01 + ruv) >> 6);
            rgb0[4] = SATURATE_CAST_UCHAR((y01 + guv) >> 6);
            rgb0[5] = SATURATE_CAST_UCHAR((y01 + buv) >> 6);

            int y10 = yptr1[0] << 6;
            rgb1[0] = SATURATE_CAST_UCHAR((y10 + ruv) >> 6);
            rgb1[1] = SATURATE_CAST_UCHAR((y10 + guv) >> 6);
            rgb1[2] = SATURATE_CAST_UCHAR((y10 + buv) >> 6);

            int y11 = yptr1[1] << 6;
            rgb1[3] = SATURATE_CAST_UCHAR((y11 + ruv) >> 6);
            rgb1[4] = SATURATE_CAST_UCHAR((y11 + guv) >> 6);
            rgb1[5] = SATURATE_CAST_UCHAR((y11 + buv) >> 6);

            yptr0 += 2;
            yptr1 += 2;
            vuptr += 2;
            rgb0 += 6;
            rgb1 += 6;
        }
#undef SATURATE_CAST_UCHAR

        yptr += 2*w;
        rgb += 2*3*w;
    }
}

void yuv420sp2bgr(const unsigned char* yuv420sp, int w, int h, unsigned char* bgr)
{
    const unsigned char* yptr = yuv420sp;
    const unsigned char* vuptr = yuv420sp + w * h;

#if __ARM_NEON
    int8x8_t _v128 = vdup_n_s8(128);
    int8x8_t _v90 = vdup_n_s8(90);
    int8x8_t _v46 = vdup_n_s8(46);
    int8x8_t _v22 = vdup_n_s8(22);
    int8x8_t _v113 = vdup_n_s8(113);
#endif // __ARM_NEON

    for (int y=0; y<h; y+=2)
    {
        const unsigned char* yptr0 = yptr;
        const unsigned char* yptr1 = yptr + w;
        unsigned char* bgr0 = bgr;
        unsigned char* bgr1 = bgr + w*3;

#if __ARM_NEON
        int nn = w >> 3;
        int remain = w - (nn << 3);
#else
        int remain = w;
#endif // __ARM_NEON

#if __ARM_NEON
#if __aarch64__
        for (; nn>0; nn--)
        {
            int16x8_t _yy0 = vreinterpretq_s16_u16(vshll_n_u8(vld1_u8(yptr0), 6));
            int16x8_t _yy1 = vreinterpretq_s16_u16(vshll_n_u8(vld1_u8(yptr1), 6));

            int8x8_t _vvuu = vsub_s8(vreinterpret_s8_u8(vld1_u8(vuptr)), _v128);
            int8x8x2_t _vvvvuuuu = vtrn_s8(_vvuu, _vvuu);
            int8x8_t _vv = _vvvvuuuu.val[0];
            int8x8_t _uu = _vvvvuuuu.val[1];

            int16x8_t _r0 = vmlal_s8(_yy0, _vv, _v90);
            int16x8_t _g0 = vmlsl_s8(_yy0, _vv, _v46);
            _g0 = vmlsl_s8(_g0, _uu, _v22);
            int16x8_t _b0 = vmlal_s8(_yy0, _uu, _v113);

            int16x8_t _r1 = vmlal_s8(_yy1, _vv, _v90);
            int16x8_t _g1 = vmlsl_s8(_yy1, _vv, _v46);
            _g1 = vmlsl_s8(_g1, _uu, _v22);
            int16x8_t _b1 = vmlal_s8(_yy1, _uu, _v113);

            uint8x8x3_t _bgr0;
            _bgr0.val[0] = vqshrun_n_s16(_b0, 6);
            _bgr0.val[1] = vqshrun_n_s16(_g0, 6);
            _bgr0.val[2] = vqshrun_n_s16(_r0, 6);

            uint8x8x3_t _bgr1;
            _bgr1.val[0] = vqshrun_n_s16(_b1, 6);
            _bgr1.val[1] = vqshrun_n_s16(_g1, 6);
            _bgr1.val[2] = vqshrun_n_s16(_r1, 6);

            vst3_u8(bgr0, _bgr0);
            vst3_u8(bgr1, _bgr1);

            yptr0 += 8;
            yptr1 += 8;
            vuptr += 8;
            bgr0 += 24;
            bgr1 += 24;
        }
#else
        if (nn > 0)
        {
        asm volatile(
            "pld        [%3, #128]          \n"
            "vld1.u8    {d2}, [%3]!         \n"
            "vsub.s8    d2, d2, %12         \n"
            "0:                             \n"
            "pld        [%1, #128]          \n"
            "vld1.u8    {d0}, [%1]!         \n"
            "pld        [%2, #128]          \n"
            "vld1.u8    {d1}, [%2]!         \n"
            "vshll.u8   q2, d0, #6          \n"
            "vorr       d3, d2, d2          \n"
            "vshll.u8   q3, d1, #6          \n"
            "vorr       q9, q2, q2          \n"
            "vtrn.s8    d2, d3              \n"
            "vorr       q11, q3, q3         \n"
            "vmlsl.s8   q9, d2, %14         \n"
            "vorr       q8, q2, q2          \n"
            "vmlsl.s8   q11, d2, %14        \n"
            "vorr       q10, q3, q3         \n"
            "vmlal.s8   q8, d2, %13         \n"
            "vmlal.s8   q2, d3, %16         \n"
            "vmlal.s8   q10, d2, %13        \n"
            "vmlsl.s8   q9, d3, %15         \n"
            "vmlal.s8   q3, d3, %16         \n"
            "vmlsl.s8   q11, d3, %15        \n"
            "vqshrun.s16 d24, q8, #6        \n"
            "vqshrun.s16 d26, q2, #6        \n"
            "vqshrun.s16 d4, q10, #6        \n"
            "vqshrun.s16 d25, q9, #6        \n"
            "vqshrun.s16 d6, q3, #6         \n"
            "vqshrun.s16 d5, q11, #6        \n"
            "pld        [%3, #128]          \n"
            "vld1.u8    {d2}, [%3]!         \n"
            "subs       %0, #1              \n"
            "vst3.u8    {d24-d26}, [%4]!    \n"
            "vsub.s8    d2, d2, %12         \n"
            "vst3.u8    {d4-d6}, [%5]!      \n"
            "bne        0b                  \n"
            "sub        %3, #8              \n"
            : "=r"(nn),     // %0
              "=r"(yptr0),  // %1
              "=r"(yptr1),  // %2
              "=r"(vuptr),  // %3
              "=r"(bgr0),   // %4
              "=r"(bgr1)    // %5
            : "0"(nn),
              "1"(yptr0),
              "2"(yptr1),
              "3"(vuptr),
              "4"(bgr0),
              "5"(bgr1),
              "w"(_v128),   // %12
              "w"(_v90),    // %13
              "w"(_v46),    // %14
              "w"(_v22),    // %15
              "w"(_v113)    // %16
            : "cc", "memory", "q0", "q1", "q2", "q3", "q8", "q9", "q10", "q11", "q12", "d26"
        );
        }
#endif // __aarch64__
#endif // __ARM_NEON

#define SATURATE_CAST_UCHAR(X) (unsigned char)::std::min(::std::max((int)(X), 0), 255);
        for (; remain>0; remain-=2)
        {
            // R = 1.164 * yy + 1.596 * vv
            // G = 1.164 * yy - 0.813 * vv - 0.391 * uu
            // B = 1.164 * yy              + 2.018 * uu

            // R = Y + (1.370705 * (V-128))
            // G = Y - (0.698001 * (V-128)) - (0.337633 * (U-128))
            // B = Y + (1.732446 * (U-128))

            // R = ((Y << 6) + 87.72512 * (V-128)) >> 6
            // G = ((Y << 6) - 44.672064 * (V-128) - 21.608512 * (U-128)) >> 6
            // B = ((Y << 6) + 110.876544 * (U-128)) >> 6

            // R = ((Y << 6) + 90 * (V-128)) >> 6
            // G = ((Y << 6) - 46 * (V-128) - 22 * (U-128)) >> 6
            // B = ((Y << 6) + 113 * (U-128)) >> 6

            // R = (yy + 90 * vv) >> 6
            // G = (yy - 46 * vv - 22 * uu) >> 6
            // B = (yy + 113 * uu) >> 6

            int v = vuptr[0] - 128;
            int u = vuptr[1] - 128;

            int ruv = 90 * v;
            int guv = -46 * v + -22 * u;
            int buv = 113 * u;

            int y00 = yptr0[0] << 6;
            bgr0[0] = SATURATE_CAST_UCHAR((y00 + ruv) >> 6);
            bgr0[1] = SATURATE_CAST_UCHAR((y00 + guv) >> 6);
            bgr0[2] = SATURATE_CAST_UCHAR((y00 + buv) >> 6);

            int y01 = yptr0[1] << 6;
            bgr0[3] = SATURATE_CAST_UCHAR((y01 + ruv) >> 6);
            bgr0[4] = SATURATE_CAST_UCHAR((y01 + guv) >> 6);
            bgr0[5] = SATURATE_CAST_UCHAR((y01 + buv) >> 6);

            int y10 = yptr1[0] << 6;
            bgr1[0] = SATURATE_CAST_UCHAR((y10 + ruv) >> 6);
            bgr1[1] = SATURATE_CAST_UCHAR((y10 + guv) >> 6);
            bgr1[2] = SATURATE_CAST_UCHAR((y10 + buv) >> 6);

            int y11 = yptr1[1] << 6;
            bgr1[3] = SATURATE_CAST_UCHAR((y11 + ruv) >> 6);
            bgr1[4] = SATURATE_CAST_UCHAR((y11 + guv) >> 6);
            bgr1[5] = SATURATE_CAST_UCHAR((y11 + buv) >> 6);

            yptr0 += 2;
            yptr1 += 2;
            vuptr += 2;
            bgr0 += 6;
            bgr1 += 6;
        }
#undef SATURATE_CAST_UCHAR

        yptr += 2*w;
        bgr += 2*3*w;
    }
}


 

cv2016_DL
关注
  • 8
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
三种方式YUV420转RGB24/BGR24，实测可用
icee
09-09 1万+
YUV420转换为RGB24/BR24YUV格式具有亮度信息和色彩信息分离的特点，但大多数图像处理操作都是基于RGB格式。因此当要对图像进行后期处理显示时，需要把YUV格式转换成RGB格式。RGB与YUV的变换公式如下： YUV(256 级别) 可以从8位 RGB 直接计算： Y = 0.299 R + 0.587 G + 0.114 B U = - 0.1687 R - 0
YUV420转RGB
weixin_34392843的博客
09-29 1284
一、YUV420数据存储   YUV格式有两大类：planar和packed。 对于planar的YUV格式，先连续存储所有像素点的Y，紧接着存储所有像素点的U，随后是所有像素点的V。 对于packed的YUV格式，每个像素点的Y,U,V是连续交*存储的。 以dm642的H263loopback例子程序为例， 发送线程中，视频捕获后我们得到YUV422 planar数据， 然后转化成Y...
解析yuv420图片并转换成RGB显示
羽凌寒
11-08 7901
简介 　　本篇为学习yuv图片格式转化笔记。 原理讲解 参考资料 　　YUV格式哟很多种，本篇记录的格式为YUV420。 有关YUV420的详细介绍，可以参考资料：1、图文详解YUV420数据格式 http://blog.csdn.net/jefry_xdz/article/details/7931018 大致讲解 　　首先yuv420的存储大小为：width * he
YUV视频帧转RGB------------c++中yuv420p视频格式转RGB24
自由的雨的博客
07-15 1219
近期中视频流处理，需实现视频在QT中显示，视频源利用Gstreamer采集，得到一帧YUV视频数据帧； bool yuv420pToRgb24(char* ch_YuvData,uint i_width,uint i_height,uchar* ch_RgbData) { int temp = 0; int numOfPixel = i_width * i_height; ...
YUV格式学习：I420(YUV420P)、YV12、NV12、NV21格式转换成RGB24
此心安处是吾乡的博客
11-27 1907
对于YUV420的格式，网上有一大堆资料，这里就不说了。直奔主题，给出如何转换的函数，一如既往，只用代码说事。 YUV420有打包格式(Packed)，一如前文所述。同时还有平面格式(Planar)，即Y、U、V是分开存储的，每个分量占一块地方，其中Y为width*height，而U、V合占Y的一半，该种格式每个像素占12比特。根据U、V的顺序，分出2种格式，U前V后即YUV420P，也叫I420，V前U后，叫YV12(YV表示Y后面跟着V，12表示12bit)。另外，还有一种半平面格式(Semi-plan
rgb24转yuv420高效率 完整代码，C++实现
08-25
在`rgb2yuv.cpp`和`rgb2yuv.h`文件中，会包含一个或多个函数，用于执行上述的转换过程。这些函数可能接受RGB像素缓冲区作为输入，输出YUV像素缓冲区。代码可能会使用指针操作和循环来遍历每个像素，进行计算。为了...
NV21 旋转缩放转BGR
03-01
`yuv2rgb.cpp`可能包含具体的实现代码，如`convertNV21ToBGR()`函数，用于执行NV21到BGR的转换；而`yuv2rgb.h`则可能定义了相关的结构和接口，供其他模块调用。 为了实现低耗时的操作，开发者可能会利用SIMD...
C/C++源码,图像RGB转换为YUV420sp和YUV420sp格式转换为YUV422
10-26
C/C++ 源码，图像RGB格式转换为YUV420格式和图像YUV420sp格式转换为YUV422，亲测有效，已经得到验证过
基于C++ YUV色域转换和LZW编码的BMP图像压缩程序【100012789】
06-20
在BMP图像的BGR（蓝绿红）到YUV的转换过程中，可以通过矩阵运算将每个像素的BGR值转换成对应的YUV值，从而达到压缩的目的。转换后，通常可以将图像数据的大小减少约50%。 2. **LZW（Lempel-Ziv-Welch）编码**： ...
C++实现图像处理RGB图转灰度图代码
06-25
在这个C++项目中，`RGB2GRAY.cpp`文件包含了实现这个转换的代码。代码可能包括以下几个关键部分： 1. **包含必要的头文件**：为了处理图像，可能需要包含如`<iostream>`、`<fstream>`、`<opencv2/opencv.hpp>`等...
RGB与YUV420P互转
02-03
代码从工程抽出，不能直接运行，但有相应注释 ╮(╯▽╰)╭
【OPENCV】颜色通道YUV420与RGB的转换
热门推荐
Shwan_ma的博客
10-10 1万+
1. YUV420p 这里不详细介绍 在查阅opencv的手册
图像处理：YUV_420_888介绍及YUV420转RGBA
最新发布
weixin_42602900的博客
04-10 674
在了解YUV_420_888之前，我们先来了解一下YUV。我们知道，RGB是一种颜色编码方法，一个像素分别以R、G、B三个分量来表示。YUV也是一种颜色编码方法，一个像素分别以Y、U、V三个分量来表示。Y表示明亮度（Luminance、Luma），U和V则是色度、浓度（Chrominance、Chroma）。YUV发明于彩色电视与黑白电视的过渡时期。黑白电视使用的黑白图像只有Y（Luma，Luminance）分量，也就是灰阶值。
在OpenCV中实现YUV420sp2RGB
MrLee的博客
07-12 5660
YUV420是视频设备常用的编码方式，其内部数据排列方式可参照此博客：图文详解YUV420数据格式 。       使用OpenCV内部函数cvCvtColor（对应OpenCV2函数名为cvtColor）可方便地实现RGB与YUV420两种格式之间的相互转换。但在转换过程中，我们需要关心YUV420的内部数据结构，即对于一张width×height的彩色图片来说，它的数据大小为wid
YUV420转RGB的代码(C++/JAVA)
阳光柠檬_的技术笔记
03-10 6876
Android中MediaCodec解码出来的是YUV420数据, 转换成RGB的C++代码如下:static uchar pBGR24[MAX_BUF_SIZE];static int Table_fv1[256] = { -180, -179, -177, -176, -174, -173, -172, -170, -169, -167, -166, -165, -163, -162, -160
YUV420转RGB888
weixin_44471761的博客
04-04 3020
YUV420转RGB888 yuv420的数据存储方式是planar，就是在一帧中先存y分量，存完y存u，接着v分量。而在yuv420中有y分量widthheight byte，uv分量各是widthheight1/4，一帧中总的数据是widthheight3/2（widthheight12/8）.所以当时认为，yuv分量代入转换公式的话，uv分量是不是少了。其实不然，因为是每四个y分量共用一个u分量一个v分量，但也不是[YiYi+1Yi+2Yi+3]共用[Ui],[Vi]，因为是一个22的窗口内的Y分量
C++ YUV420文件读取与显示，绘制矩形框，绘制线段（绘制直线），绘制多边形（常用YUV数据格式——YUV420P中的YU12与YUV420SP中的NV21）
Dontla的博客
09-22 2624
YUV查看器及测试图片参考文章1：C++使用fread读取yuv一帧并写入新的yuv参考文章：YUV帧结构（紧缩格式packed【打包格式】和平面格式planar）（A:B:C表示法）我这也写得不太好，具体可参考这篇大佬文章：图解YU12、I420、YV12、NV12、NV21、YUV420P、YUV420SP、YUV422P、YUV444P的区别YUV420P：YUV420SP：共用关系：4个Y共用一个U一个V共用关系： 共用关系： 以我们下的这个YUV文件为例，它是YU12的，YUV查看工具（windo
使用C++实现YUV格式图像与RGB格式图像之间相互转换
weixin_45847421的博客
03-24 4748
使用C++实现YUV格式图像与RGB格式图像之间相互转换一、RGB与YUV转换公式1、RGB转YUV1）RGB转换亮度与色差信号公试：2）归一化为YUV的转化公试为：2、YUV转RGB二、利用命令参数实现读取文件的简单化安全化三、使用C++实现YUV格式图像转换为RGB格式图像（一）、YUV格式到RGB格式的转换（yuv2rgb.cpp）1、实现YUV转RGB公式2、图像数据的读入3、将U、V分量扩充到256*2564、将YUV转化为RGB（二）主函数（main.cpp）（三）结果演示（四）整体代码1、ma
C++ cv::Mat 2 yuv_nv12
04-01
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...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值