OpenCV cvtColor BGR2YUV420

喜欢ヅ旅行 2022-10-29 11:23 655阅读 0赞

OpenCV 中的 [cvtColor][] 将图像从一种颜色空间转换为另一种颜色空间。虽然 OpenCV 可以支持从各种 YUV 格式转换到 BGR，但反向到 YUV420 却仅能输出 I420。尽管内部有 [cvtBGRtoTwoPlaneYUV][] 函数，但是对外没有提供。

[Carotene][] 库并无该功能，所以 [cvtColorBGR2ThreePlaneYUV][] 使用统一向量指令（universal intrinsics）来加速，维护成本低效率同样不高。在图像大于320x240时可能会启用线程。

YCbCr 色彩空间是在制定全球数字分量视频标准（在第4章中讨论）的过程中开发的，是 ITU-R BT.601的一部分。YCbCr 是 YUV 颜色空间的缩放和偏移版本。Y 定义为标称8位范围为16–235； Cb 和 Cr 的标称范围为16–240。

[COLOR\_BGRA2YUV\_I420][COLOR_BGRA2YUV_I420] 是按照 RGB 为 full range 的 ITU-R BT.601 标准来转换的。

## [cvtColor][cvtColor 1] ##

cvtColor

cvtColorTwoPlaneYUV2BGR

cvtBGRtoThreePlaneYUV

[CV\_OCL\_RUN][CV_OCL_RUN] 检查输入输出及转换类型，若满足则调用 [ocl\_cvtColor][ocl_cvtColor] 并返回。

CV_INSTRUMENT_REGION();
    
        CV_Assert(!_src.empty());
    
        if(dcn <= 0)
                dcn = dstChannels(code);
    
        CV_OCL_RUN( _src.dims() <= 2 && _dst.isUMat() &&
                    !(CV_MAT_DEPTH(_src.type()) == CV_8U && (code == COLOR_Luv2BGR || code == COLOR_Luv2RGB)),
                    ocl_cvtColor(_src, _dst, code, dcn) )

根据不同的转换码来调用相应处理函数。  
[swapBlue][] 判断是否交换蓝色通道，源或目的为 RGB 顺序的数据需要处理。

switch( code )
        {
        
            case COLOR_BGR2BGRA: case COLOR_RGB2BGRA: case COLOR_BGRA2BGR:
            case COLOR_RGBA2BGR: case COLOR_RGB2BGR:  case COLOR_BGRA2RGBA:
                if(_src.channels() == 1)
                    cvtColorGray2BGR(_src, _dst, dcn);
                else
                    cvtColorBGR2BGR(_src, _dst, dcn, swapBlue(code));
                break;
    
            case COLOR_BGR2BGR565:  case COLOR_BGR2BGR555: case COLOR_BGRA2BGR565: case COLOR_BGRA2BGR555:
            case COLOR_RGB2BGR565:  case COLOR_RGB2BGR555: case COLOR_RGBA2BGR565: case COLOR_RGBA2BGR555:
                cvtColorBGR25x5(_src, _dst, swapBlue(code), greenBits(code));
                break;
    
            case COLOR_BGR5652BGR:  case COLOR_BGR5552BGR: case COLOR_BGR5652BGRA: case COLOR_BGR5552BGRA:
            case COLOR_BGR5652RGB:  case COLOR_BGR5552RGB: case COLOR_BGR5652RGBA: case COLOR_BGR5552RGBA:
                cvtColor5x52BGR(_src, _dst, dcn, swapBlue(code), greenBits(code));
                break;
    
            case COLOR_BGR2GRAY: case COLOR_BGRA2GRAY:
            case COLOR_RGB2GRAY: case COLOR_RGBA2GRAY:
                cvtColorBGR2Gray(_src, _dst, swapBlue(code));
                break;
    
            case COLOR_BGR5652GRAY:
            case COLOR_BGR5552GRAY:
                cvtColor5x52Gray(_src, _dst, greenBits(code));
                break;
    
            case COLOR_GRAY2BGR:
            case COLOR_GRAY2BGRA:
                cvtColorGray2BGR(_src, _dst, dcn);
                break;
    
            case COLOR_GRAY2BGR565:
            case COLOR_GRAY2BGR555:
                cvtColorGray25x5(_src, _dst, greenBits(code));
                break;
    
            case COLOR_BGR2YCrCb: case COLOR_RGB2YCrCb:
            case COLOR_BGR2YUV:   case COLOR_RGB2YUV:
                cvtColorBGR2YUV(_src, _dst, swapBlue(code), code == COLOR_BGR2YCrCb || code == COLOR_RGB2YCrCb);
                break;
    
            case COLOR_YCrCb2BGR: case COLOR_YCrCb2RGB:
            case COLOR_YUV2BGR:   case COLOR_YUV2RGB:
                cvtColorYUV2BGR(_src, _dst, dcn, swapBlue(code), code == COLOR_YCrCb2BGR || code == COLOR_YCrCb2RGB);
                break;
    
            case COLOR_BGR2XYZ:
            case COLOR_RGB2XYZ:
                cvtColorBGR2XYZ(_src, _dst, swapBlue(code));
                break;
    
            case COLOR_XYZ2BGR:
            case COLOR_XYZ2RGB:
                cvtColorXYZ2BGR(_src, _dst, dcn, swapBlue(code));
                break;
    
            case COLOR_BGR2HSV: case COLOR_BGR2HSV_FULL:
            case COLOR_RGB2HSV: case COLOR_RGB2HSV_FULL:
                cvtColorBGR2HSV(_src, _dst, swapBlue(code), isFullRangeHSV(code));
                break;
    
            case COLOR_BGR2HLS: case COLOR_BGR2HLS_FULL:
            case COLOR_RGB2HLS: case COLOR_RGB2HLS_FULL:
                cvtColorBGR2HLS(_src, _dst, swapBlue(code), isFullRangeHSV(code));
                break;
    
            case COLOR_HSV2BGR: case COLOR_HSV2BGR_FULL:
            case COLOR_HSV2RGB: case COLOR_HSV2RGB_FULL:
                cvtColorHSV2BGR(_src, _dst, dcn, swapBlue(code), isFullRangeHSV(code));
                break;
    
            case COLOR_HLS2BGR: case COLOR_HLS2BGR_FULL:
            case COLOR_HLS2RGB: case COLOR_HLS2RGB_FULL:
                cvtColorHLS2BGR(_src, _dst, dcn, swapBlue(code), isFullRangeHSV(code));
                break;
    
            case COLOR_BGR2Lab: case COLOR_LBGR2Lab:
            case COLOR_RGB2Lab: case COLOR_LRGB2Lab:
                cvtColorBGR2Lab(_src, _dst, swapBlue(code), is_sRGB(code));
                break;
    
            case COLOR_BGR2Luv: case COLOR_LBGR2Luv:
            case COLOR_RGB2Luv: case COLOR_LRGB2Luv:
                cvtColorBGR2Luv(_src, _dst, swapBlue(code), is_sRGB(code));
                break;
    
            case COLOR_Lab2BGR: case COLOR_Lab2LBGR:
            case COLOR_Lab2RGB: case COLOR_Lab2LRGB:
                cvtColorLab2BGR(_src, _dst, dcn, swapBlue(code), is_sRGB(code));
                break;
    
            case COLOR_Luv2BGR: case COLOR_Luv2LBGR:
            case COLOR_Luv2RGB: case COLOR_Luv2LRGB:
                cvtColorLuv2BGR(_src, _dst, dcn, swapBlue(code), is_sRGB(code));
                break;
    
            case COLOR_BayerBG2GRAY: case COLOR_BayerGB2GRAY: case COLOR_BayerRG2GRAY: case COLOR_BayerGR2GRAY:
            case COLOR_BayerBG2BGR: case COLOR_BayerGB2BGR: case COLOR_BayerRG2BGR: case COLOR_BayerGR2BGR:
            case COLOR_BayerBG2BGR_VNG: case COLOR_BayerGB2BGR_VNG: case COLOR_BayerRG2BGR_VNG: case COLOR_BayerGR2BGR_VNG:
            case COLOR_BayerBG2BGR_EA: case COLOR_BayerGB2BGR_EA: case COLOR_BayerRG2BGR_EA: case COLOR_BayerGR2BGR_EA:
            case COLOR_BayerBG2BGRA: case COLOR_BayerGB2BGRA: case COLOR_BayerRG2BGRA: case COLOR_BayerGR2BGRA:
                {
        
                    Mat src;
                    if (_src.getObj() == _dst.getObj()) // inplace processing (#6653)
                        _src.copyTo(src);
                    else
                        src = _src.getMat();
                    demosaicing(src, _dst, code, dcn);
                    break;
                }

[uIndex][] 返回 U 在三个通道中的排位。  
[cvtColorTwoPlaneYUV2BGR][]  
[cvtColorThreePlaneYUV2BGR][]  
[cvtColorYUV2Gray\_420][cvtColorYUV2Gray_420]

case COLOR_YUV2BGR_NV21:  case COLOR_YUV2RGB_NV21:  case COLOR_YUV2BGR_NV12:  case COLOR_YUV2RGB_NV12:
            case COLOR_YUV2BGRA_NV21: case COLOR_YUV2RGBA_NV21: case COLOR_YUV2BGRA_NV12: case COLOR_YUV2RGBA_NV12:
                // http://www.fourcc.org/yuv.php#NV21 == yuv420sp -> a plane of 8 bit Y samples followed by an interleaved V/U plane containing 8 bit 2x2 subsampled chroma samples
                // http://www.fourcc.org/yuv.php#NV12 -> a plane of 8 bit Y samples followed by an interleaved U/V plane containing 8 bit 2x2 subsampled colour difference samples
                cvtColorTwoPlaneYUV2BGR(_src, _dst, dcn, swapBlue(code), uIndex(code));
                break;
    
            case COLOR_YUV2BGR_YV12: case COLOR_YUV2RGB_YV12: case COLOR_YUV2BGRA_YV12: case COLOR_YUV2RGBA_YV12:
            case COLOR_YUV2BGR_IYUV: case COLOR_YUV2RGB_IYUV: case COLOR_YUV2BGRA_IYUV: case COLOR_YUV2RGBA_IYUV:
                //http://www.fourcc.org/yuv.php#YV12 == yuv420p -> It comprises an NxM Y plane followed by (N/2)x(M/2) V and U planes.
                //http://www.fourcc.org/yuv.php#IYUV == I420 -> It comprises an NxN Y plane followed by (N/2)x(N/2) U and V planes
                cvtColorThreePlaneYUV2BGR(_src, _dst, dcn, swapBlue(code), uIndex(code));
                break;
    
            case COLOR_YUV2GRAY_420:
                cvtColorYUV2Gray_420(_src, _dst);
                break;

[cvtBGRtoThreePlaneYUV][]  
[cvtColorOnePlaneYUV2BGR][] 调用 [cvtOnePlaneYUVtoBGR][]

case COLOR_RGB2YUV_YV12: case COLOR_BGR2YUV_YV12: case COLOR_RGBA2YUV_YV12: case COLOR_BGRA2YUV_YV12:
            case COLOR_RGB2YUV_IYUV: case COLOR_BGR2YUV_IYUV: case COLOR_RGBA2YUV_IYUV: case COLOR_BGRA2YUV_IYUV:
                cvtColorBGR2ThreePlaneYUV(_src, _dst, swapBlue(code), uIndex(code));
                break;
    
            case COLOR_YUV2RGB_UYVY: case COLOR_YUV2BGR_UYVY: case COLOR_YUV2RGBA_UYVY: case COLOR_YUV2BGRA_UYVY:
            case COLOR_YUV2RGB_YUY2: case COLOR_YUV2BGR_YUY2: case COLOR_YUV2RGB_YVYU: case COLOR_YUV2BGR_YVYU:
            case COLOR_YUV2RGBA_YUY2: case COLOR_YUV2BGRA_YUY2: case COLOR_YUV2RGBA_YVYU: case COLOR_YUV2BGRA_YVYU:
                //http://www.fourcc.org/yuv.php#UYVY
                //http://www.fourcc.org/yuv.php#YUY2
                //http://www.fourcc.org/yuv.php#YVYU
                {
        
                    int ycn  = (code==COLOR_YUV2RGB_UYVY || code==COLOR_YUV2BGR_UYVY ||
                                code==COLOR_YUV2RGBA_UYVY || code==COLOR_YUV2BGRA_UYVY) ? 1 : 0;
                    cvtColorOnePlaneYUV2BGR(_src, _dst, dcn, swapBlue(code), uIndex(code), ycn);
                    break;
                }
    
            case COLOR_YUV2GRAY_UYVY:
            case COLOR_YUV2GRAY_YUY2:
                cvtColorYUV2Gray_ch(_src, _dst, code == COLOR_YUV2GRAY_UYVY ? 1 : 0);
                break;
    
            case COLOR_RGBA2mRGBA:
                cvtColorRGBA2mRGBA(_src, _dst);
                break;
    
            case COLOR_mRGBA2RGBA:
                cvtColormRGBA2RGBA(_src, _dst);
                break;
            default:
                CV_Error( CV_StsBadFlag, "Unknown/unsupported color conversion code" );

## [cvtColorBGR2ThreePlaneYUV][] ##

cvtColorBGR2ThreePlaneYUV

CvtHelper

hal::cvtBGRtoThreePlaneYUV

[CvtHelper][] 检查输入输出并做必要准备。  
[hal::cvtBGRtoThreePlaneYUV][cvtBGRtoThreePlaneYUV] 为 hal 层实现。

CvtHelper< Set<3, 4>, Set<1>, Set<CV_8U>, TO_YUV > h(_src, _dst, 1);
    
        hal::cvtBGRtoThreePlaneYUV(h.src.data, h.src.step, h.dst.data, h.dst.step, h.src.cols, h.src.rows,
                                   h.scn, swapb, uidx);

## [CvtHelper][] ##

检查输入输出是否与外部指定的类型相同。

CvtHelper(InputArray _src, OutputArray _dst, int dcn)
        {
        
            CV_Assert(!_src.empty());
    
            int stype = _src.type();
            scn = CV_MAT_CN(stype), depth = CV_MAT_DEPTH(stype);
    
            CV_Check(scn, VScn::contains(scn), "Invalid number of channels in input image");
            CV_Check(dcn, VDcn::contains(dcn), "Invalid number of channels in output image");
            CV_CheckDepth(depth, VDepth::contains(depth), "Unsupported depth of input image");

如果是原地处理，将输入拷贝到`src`中。

if (_src.getObj() == _dst.getObj()) // inplace processing (#6653)
                _src.copyTo(src);
            else
                src = _src.getMat();

如果是转换到 YUV，要求输入的宽高为2的倍数；  
如果输入是 YUV，要求宽为2的倍数同时高为3的倍数。  
[CV\_MAKETYPE][CV_MAKETYPE] 根据色深和通道数合成类型。

Size sz = src.size();
            switch (sizePolicy)
            {
        
            case TO_YUV:
                CV_Assert( sz.width % 2 == 0 && sz.height % 2 == 0);
                dstSz = Size(sz.width, sz.height / 2 * 3);
                break;
            case FROM_YUV:
                CV_Assert( sz.width % 2 == 0 && sz.height % 3 == 0);
                dstSz = Size(sz.width, sz.height * 2 / 3);
                break;
            case NONE:
            default:
                dstSz = sz;
                break;
            }
            _dst.create(dstSz, CV_MAKETYPE(depth, dcn));
            dst = _dst.getMat();
        }
        Mat src, dst;
        int depth, scn;
        Size dstSz;

## [hal::cvtBGRtoThreePlaneYUV][cvtBGRtoThreePlaneYUV] ##

[CV\_INSTRUMENT\_REGION][CV_INSTRUMENT_REGION]  
[CALL\_HAL][CALL_HAL] 调用 [cv\_hal\_cvtBGRtoThreePlaneYUV][cv_hal_cvtBGRtoThreePlaneYUV] 函数并检查返回值。[hal\_ni\_cvtBGRtoThreePlaneYUV][hal_ni_cvtBGRtoThreePlaneYUV] 未实现。  
[CV\_CPU\_DISPATCH][CV_CPU_DISPATCH] 调用 [\_\_CV\_CPU\_DISPATCH\_EXPAND][CV_CPU_DISPATCH_EXPAND], 而 [\_\_CV\_EXPAND][CV_EXPAND] 会执行函数。  
调用 [color\_yuv.simd.hpp][color_yuv.simd.hpp] 中的函数来执行。

CV_INSTRUMENT_REGION();
    
        CALL_HAL(cvtBGRtoThreePlaneYUV, cv_hal_cvtBGRtoThreePlaneYUV, src_data, src_step, dst_data, dst_step, width, height, scn, swapBlue, uIdx);
    
        CV_CPU_DISPATCH(cvtBGRtoThreePlaneYUV, (src_data, src_step, dst_data, dst_step, width, height, scn, swapBlue, uIdx),
            CV_CPU_DISPATCH_MODES_ALL);

## [cvtBGRtoThreePlaneYUV][cvtBGRtoThreePlaneYUV 1] ##

cvtBGRtoThreePlaneYUV

RGB8toYUV420pInvoker

parallel\_for\_

[RGB8toYUV420pInvoker][] 类执行变换。  
如果输入大于320x240，调用 [parallel\_for\_][parallel_for] 多线程处理。  
传入的行数除以2,在内部使用时又乘以2。使得最终高度为偶数。

CV_INSTRUMENT_REGION();
    
        uchar * uv_data = dst_data + dst_step * height;
    
        RGB8toYUV420pInvoker cvt(src_data, src_step, dst_data, uv_data, dst_step, width, height,
                                 scn, swapBlue, uIdx == 2, false);
    
        if( width * height >= 320*240 )
            parallel_for_(Range(0, height/2), cvt);
        else
            cvt(Range(0, height/2));

## [RGB8toYUV420pInvoker][] ##

RGB8toYUV420pInvoker

ParallelLoopBody

[ParallelLoopBody][] 是并行数据处理器的基类，重载括号运算符。  
Y 和 UV 分开表示。  
`_swapUV`和`_interleave`两个参数使得 [RGB8toYUV420pInvoker][] 可以输出 YUV420 的4种格式。

RGB8toYUV420pInvoker(const uchar * _srcData, size_t _srcStep,
                               uchar * _yData, uchar * _uvData, size_t _dstStep,
                               int _srcWidth, int _srcHeight, int _scn, bool _swapBlue, bool _swapUV, bool _interleave)
            : srcData(_srcData), srcStep(_srcStep),
              yData(_yData), uvData(_uvData), dstStep(_dstStep),
              srcWidth(_srcWidth), srcHeight(_srcHeight),
              srcCn(_scn), swapBlue(_swapBlue), swapUV(_swapUV), interleave(_interleave) {
         }

逐行处理。遇到偶数行时 UV 指针换行。

void operator()(const Range& rowRange) const CV_OVERRIDE
        {
        
            const int w = srcWidth;
            const int h = srcHeight;
            const int scn = srcCn;
            const uchar* srcRow = (uchar*)0;
            uchar* yRow = (uchar*)0, *uRow = (uchar*)0, *vRow = (uchar*)0, *uvRow = (uchar*)0;
            for( int sRow = rowRange.start*2; sRow < rowRange.end*2; sRow++)
            {
        
                srcRow = srcData + srcStep*sRow;
                yRow = yData + dstStep * sRow;
                bool evenRow = (sRow % 2) == 0;
                if(evenRow)
                {
        
                    if (interleave)
                    {
        
                        uvRow = uvData + dstStep*(sRow/2);
                    }
                    else
                    {
        
                        uRow = uvData + dstStep * (sRow/4) + ((sRow/2) % 2) * (w/2);
                        vRow = uvData + dstStep * ((sRow + h)/4) + (((sRow + h)/2) % 2) * (w/2);
                    }
                }

`vsize`为16，每次循环处理`2*vsize`个像素。  
根据 SIMD 宽度来定义 [v\_uint8][v_uint8] 的实际类型，可能是 [v\_uint8x16][v_uint8x16]。  
[v\_load\_deinterleave][v_load_deinterleave] 从存储器解交织加载数据并存储到3个寄存器。[OPENCV\_HAL\_IMPL\_NEON\_INTERLEAVED][OPENCV_HAL_IMPL_NEON_INTERLEAVED] 宏定义了 arm 下的实现。  
[rgbToY42x][] 按照 ITUR\_BT\_601 标准转换。  
[v\_store][v_store] 将寄存器向量中的值保存到数组。  
[v\_store\_interleave][v_store_interleave] 将3个寄存器中的数据交织并存储到内存中。  
偶数行调用 [rgbToUV42x][] 得到 U 和 V 的值。

int i = 0;
    #if CV_SIMD
                const int vsize = v_uint8::nlanes;
    
                for( ; i <= w/2 - vsize;
                     i += vsize)
                {
        
                    // processing (2*vsize) pixels at once
                    v_uint8 b0, b1, g0, g1, r0, r1, a0, a1;
                    if(scn == 4)
                    {
        
                        v_load_deinterleave(srcRow + 2*4*i + 0*vsize, b0, g0, r0, a0);
                        v_load_deinterleave(srcRow + 2*4*i + 4*vsize, b1, g1, r1, a1);
                    }
                    else // scn == 3
                    {
        
                        v_load_deinterleave(srcRow + 2*3*i + 0*vsize, b0, g0, r0);
                        v_load_deinterleave(srcRow + 2*3*i + 3*vsize, b1, g1, r1);
                    }
    
                    if(swapBlue)
                    {
        
                        swap(b0, r0); swap(b1, r1);
                    }
    
                    v_uint8 y0, y1;
    
                    y0 = rgbToY42x(r0, g0, b0);
                    y1 = rgbToY42x(r1, g1, b1);
    
                    v_store(yRow + 2*i + 0*vsize, y0);
                    v_store(yRow + 2*i + 1*vsize, y1);
    
                    if(evenRow)
                    {
        
                        v_uint8 u, v;
                        rgbToUV42x(r0, r1, g0, g1, b0, b1, u, v);
    
                        if(swapUV)
                        {
        
                            swap(u, v);
                        }
    
                        if(interleave)
                        {
        
                            v_store_interleave(uvRow + 2*i, u, v);
                        }
                        else
                        {
        
                            v_store(uRow + i, u);
                            v_store(vRow + i, v);
                        }
                    }
                }
                vx_cleanup();
    #endif

处理行尾未对齐的数据，每次转换一对像素。  
此处的 [rgbToY42x][rgbToY42x 1] 接受`uchar`输入，与上面的不同。

// processing two pixels at once
                for( ; i < w/2; i++)
                {
        
                    uchar b0, g0, r0;
                    uchar b1, g1, r1;
                    b0 = srcRow[(2*i+0)*scn + 0];
                    g0 = srcRow[(2*i+0)*scn + 1];
                    r0 = srcRow[(2*i+0)*scn + 2];
                    b1 = srcRow[(2*i+1)*scn + 0];
                    g1 = srcRow[(2*i+1)*scn + 1];
                    r1 = srcRow[(2*i+1)*scn + 2];
    
                    if(swapBlue)
                    {
        
                        swap(b0, r0); swap(b1, r1);
                    }
    
                    uchar y0 = rgbToY42x(r0, g0, b0);
                    uchar y1 = rgbToY42x(r1, g1, b1);
    
                    yRow[2*i+0] = y0;
                    yRow[2*i+1] = y1;
    
                    if(evenRow)
                    {
        
                        uchar uu, vv;
                        rgbToUV42x(r0, g0, b0, uu, vv);
                        if(swapUV)
                        {
        
                            swap(uu, vv);
                        }
    
                        if(interleave)
                        {
        
                            uvRow[2*i+0] = uu;
                            uvRow[2*i+1] = vv;
                        }
                        else
                        {
        
                            uRow[i] = uu;
                            vRow[i] = vv;
                        }
                    }
                }
            }
        }

类成员变量。

const uchar * srcData;
        size_t srcStep;
        uchar *yData, *uvData;
        size_t dstStep;
        int srcWidth;
        int srcHeight;
        const int srcCn;
        bool swapBlue;
        bool swapUV;
        bool interleave;

## [rgbToY42x][] ##

Y 601 = 0.257 R ′ + 0.504 G ′ + 0.098 B ′ + 16 C b = – 0.148 R ′ – 0.291 G ′ + 0.439 B ′ + 128 C r = 0.439 R ′ – 0.368 G ′ – 0.071 B ′ + 128 \\begin\{aligned\} Y\_\{601\} &= 0.257R' + 0.504G' + 0.098B' + 16 \\\\ C\_b &= –0.148R' – 0.291G' + 0.439B' + 128 \\\\ Cr &= 0.439R' – 0.368G' – 0.071B' + 128 \\end\{aligned\} Y601CbCr=0.257R′\+0.504G′\+0.098B′\+16=–0.148R′–0.291G′\+0.439B′\+128=0.439R′–0.368G′–0.071B′\+128  
 R ′ = 1.164 ( Y 601 – 16 ) + 1.596 ( C r – 128 ) G ′ = 1.164 ( Y 601 – 16 ) – 0.813 ( C r – 128 ) – 0.391 ( C b – 128 ) B ′ = 1.164 ( Y 601 – 16 ) + 2.018 ( C b – 128 ) \\begin\{aligned\} R' &= 1.164(Y\_\{601\} – 16) + 1.596(C\_r – 128) \\\\ G' &= 1.164(Y\_\{601\} – 16) – 0.813(C\_r – 128) – 0.391(C\_b – 128)\\\\ B' &= 1.164(Y\_\{601\} – 16) + 2.018(C\_b – 128) \\end\{aligned\} R′G′B′=1.164(Y601–16)\+1.596(Cr–128)=1.164(Y601–16)–0.813(Cr–128)–0.391(Cb–128)=1.164(Y601–16)\+2.018(Cb–128)  
[ITUR\_BT\_601\_SHIFT][ITUR_BT_601_SHIFT] 为20。[ITUR\_BT\_601\_CRY][ITUR_BT_601_CRY]、[ITUR\_BT\_601\_CGY][ITUR_BT_601_CGY] 和 [ITUR\_BT\_601\_CBY][ITUR_BT_601_CBY] 为左移放大后的系数。  
[v\_expand][v_expand] 将寄存器的内容复制到两个2倍宽包装类型的寄存器中。  
[CV\_INTRIN\_DEFINE\_WIDE\_INTRIN][CV_INTRIN_DEFINE_WIDE_INTRIN] 定义特定类型的数据操作。[CV\_INTRIN\_DEFINE\_WIDE\_INTRIN\_ALL\_TYPES][CV_INTRIN_DEFINE_WIDE_INTRIN_ALL_TYPES] 定义所有数据类型的操作。  
[intrin.hpp][] 会根据宏符号选择包含相应的平台头文件。  
对于 arm 而言，`vx_setall_u32`会调用 [v\_setall\_u32][v_setall_u32]，后者由 [OPENCV\_HAL\_IMPL\_NEON\_INIT][OPENCV_HAL_IMPL_NEON_INIT] 定义。

const int shifted16 = (16 << ITUR_BT_601_SHIFT);
        const int halfShift = (1 << (ITUR_BT_601_SHIFT - 1));
        v_uint16 r0, r1, g0, g1, b0, b1;
        v_expand(r, r0, r1);
        v_expand(g, g0, g1);
        v_expand(b, b0, b1);
    
        v_uint32 rq[4], gq[4], bq[4];
        v_expand(r0, rq[0], rq[1]); v_expand(r1, rq[2], rq[3]);
        v_expand(g0, gq[0], gq[1]); v_expand(g1, gq[2], gq[3]);
        v_expand(b0, bq[0], bq[1]); v_expand(b1, bq[2], bq[3]);
    
        v_uint32 ry = vx_setall_u32(ITUR_BT_601_CRY), gy = vx_setall_u32(ITUR_BT_601_CGY);
        v_uint32 by = vx_setall_u32(ITUR_BT_601_CBY), shift = vx_setall_u32(halfShift + shifted16);
    
        v_uint32 y[4];
        for(int k = 0; k < 4; k++)
        {
        
            y[k] = (rq[k]*ry + gq[k]*gy + bq[k]*by + shift) >> ITUR_BT_601_SHIFT;
        }

[v\_pack][v_pack] 由 [OPENCV\_HAL\_IMPL\_NEON\_PACK][OPENCV_HAL_IMPL_NEON_PACK] 宏定义。  
将值从两个向量压缩到一个。

v_uint16 y0, y1;
        y0 = v_pack(y[0], y[1]);
        y1 = v_pack(y[2], y[3]);
    
        return v_pack(y0, y1);

## [rgbToUV42x][] ##

[OPENCV\_HAL\_IMPL\_C\_REINTERPRET][OPENCV_HAL_IMPL_C_REINTERPRET] 通过 [v\_reg::reinterpret\_as][v_reg_reinterpret_as] 函数实现转义。  
将输入颜色值转为 int16，丢弃了奇数索引的像素值。  
然后将值扩展为 int32。

// [r0, r1, r2, r3,..] => [r0, 0, r2, 0,..]
        v_int16 vlowByte = vx_setall_s16(0x00ff);
        v_int16 rd0, rd1, gd0, gd1, bd0, bd1;
        rd0 = v_reinterpret_as_s16(r0) & vlowByte;
        rd1 = v_reinterpret_as_s16(r1) & vlowByte;
        gd0 = v_reinterpret_as_s16(g0) & vlowByte;
        gd1 = v_reinterpret_as_s16(g1) & vlowByte;
        bd0 = v_reinterpret_as_s16(b0) & vlowByte;
        bd1 = v_reinterpret_as_s16(b1) & vlowByte;
    
        v_int32 rq[4], gq[4], bq[4];
        v_expand(rd0, rq[0], rq[1]);
        v_expand(rd1, rq[2], rq[3]);
        v_expand(gd0, gq[0], gq[1]);
        v_expand(gd1, gq[2], gq[3]);
        v_expand(bd0, bq[0], bq[1]);
        v_expand(bd1, bq[2], bq[3]);

加上`halfShift`实现四舍五入。

const int halfShift = (1 << (ITUR_BT_601_SHIFT - 1));
        const int shifted128 = (128 << ITUR_BT_601_SHIFT);
        v_int32 shift = vx_setall_s32(halfShift + shifted128);
        v_int32 ru, gu, bu, gv, bv;
        ru = vx_setall_s32(ITUR_BT_601_CRU);
        gu = vx_setall_s32(ITUR_BT_601_CGU);
        gv = vx_setall_s32(ITUR_BT_601_CGV);
        bu = vx_setall_s32(ITUR_BT_601_CBU);
        bv = vx_setall_s32(ITUR_BT_601_CBV);
    
        v_int32 uq[4], vq[4];
        for(int k = 0; k < 4; k++)
        {
        
            uq[k] = (ru*rq[k] + gu*gq[k] + bu*bq[k] + shift) >> ITUR_BT_601_SHIFT;
            vq[k] = (bu*rq[k] + gv*gq[k] + bv*bq[k] + shift) >> ITUR_BT_601_SHIFT;
        }
    
        v_int16 u0, u1, v0, v1;
        u0 = v_pack(uq[0], uq[1]);
        u1 = v_pack(uq[2], uq[3]);
        v0 = v_pack(vq[0], vq[1]);
        v1 = v_pack(vq[2], vq[3]);
    
        u = v_pack_u(u0, u1);
        v = v_pack_u(v0, v1);

## [parallel\_for\_][parallel_for] ##

调用重载函数。  
[ParallelLoopBodyLambdaWrapper][] 将 lambda 表达式封装成对象。

parallel_for_(range, ParallelLoopBodyLambdaWrapper(functor), nstripes);

## [parallel\_for\_][parallel_for 1] ##

parallel\_for\_

parallel\_for\_impl

[CV\_INSTRUMENT\_REGION\_MT\_FORK][CV_INSTRUMENT_REGION_MT_FORK] 调用 [CV\_INSTRUMENT\_REGION\_META][CV_INSTRUMENT_REGION_META]  
使用静态变量检查操作有无嵌套。

#ifdef OPENCV_TRACE
        CV__TRACE_OPENCV_FUNCTION_NAME_("parallel_for", 0);
        CV_TRACE_ARG_VALUE(range_start, "range.start", (int64)range.start);
        CV_TRACE_ARG_VALUE(range_end, "range.end", (int64)range.end);
        CV_TRACE_ARG_VALUE(nstripes, "nstripes", (int64)nstripes);
    #endif
    
        CV_INSTRUMENT_REGION_MT_FORK();
        if (range.empty())
            return;
    
        static std::atomic<bool> flagNestedParallelFor(false);
        bool isNotNestedRegion = !flagNestedParallelFor.load();
        if (isNotNestedRegion)
          isNotNestedRegion = !flagNestedParallelFor.exchange(true);

没有嵌套的话调用 [parallel\_for\_impl][parallel_for_impl]，否则直接运行。

if (isNotNestedRegion)
        {
        
            try
            {
        
                parallel_for_impl(range, body, nstripes);
                flagNestedParallelFor = false;
            }
            catch (...)
            {
        
                flagNestedParallelFor = false;
                throw;
            }
        }
        else // nested parallel_for_() calls are not parallelized
        {
        
            CV_UNUSED(nstripes);
            body(range);
        }

## [parallel\_for\_impl][parallel_for_impl] ##

如果线程数不为1则调用各种并行技术。  
[ParallelLoopBodyWrapperContext][] 为上下文环境，不允许拷贝。  
[ProxyLoopBody][] 在不同环境下的实现不同。  
[ParallelLoopBodyWrapper::stripeRange][ParallelLoopBodyWrapper_stripeRange] 返回 [ParallelLoopBodyWrapperContext][] 中的细条数。  
如果`stripeRange`中仅一个元素则直接执行。

using namespace cv::parallel;
        if ((numThreads < 0 || numThreads > 1) && range.end - range.start > 1)
        {
        
            ParallelLoopBodyWrapperContext ctx(body, range, nstripes);
            ProxyLoopBody pbody(ctx);
            cv::Range stripeRange = pbody.stripeRange();
            if( stripeRange.end - stripeRange.start == 1 )
            {
        
                body(range);
                return;
            }

[getCurrentParallelForAPI][] 获取 [ParallelForAPI][]，由 [setParallelForBackend][] 进行设置。  
具体实现有 [cv::parallel::tbb::ParallelForBackend][cv_parallel_tbb_ParallelForBackend] 和 [cv::parallel::openmp::ParallelForBackend][cv_parallel_openmp_ParallelForBackend] 两种。  
`api`不为空意味着已显式进行了设置。  
[parallel\_for\_cb][parallel_for_cb] 执行传入的函数。

std::shared_ptr<ParallelForAPI>& api = getCurrentParallelForAPI();
            if (api)
            {
        
                CV_CheckEQ(stripeRange.start, 0, "");
                api->parallel_for(stripeRange.end, parallel_for_cb, (void*)&pbody);
                ctx.finalize();  // propagate exceptions if exists
                return;
            }

[CV\_PARALLEL\_FRAMEWORK][CV_PARALLEL_FRAMEWORK] 的值根据编译选项设置。

#ifdef CV_PARALLEL_FRAMEWORK
    #if defined HAVE_TBB
    
    #if TBB_INTERFACE_VERSION >= 8000
            tbbArena.execute(pbody);
    #else
            pbody();
    #endif
    
    #elif defined HAVE_HPX
            pbody();
    
    #elif defined HAVE_OPENMP
    
            #pragma omp parallel for schedule(dynamic) num_threads(numThreads > 0 ? numThreads : numThreadsMax)
            for (int i = stripeRange.start; i < stripeRange.end; ++i)
                pbody(Range(i, i + 1));
    
    #elif defined HAVE_GCD
    
            dispatch_queue_t concurrent_queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
            dispatch_apply_f(stripeRange.end - stripeRange.start, concurrent_queue, &pbody, block_function);
    
    #elif defined WINRT
    
            Concurrency::parallel_for(stripeRange.start, stripeRange.end, pbody);
    
    #elif defined HAVE_CONCURRENCY
    
            if(!pplScheduler || pplScheduler->Id() == Concurrency::CurrentScheduler::Id())
            {
        
                Concurrency::parallel_for(stripeRange.start, stripeRange.end, pbody);
            }
            else
            {
        
                pplScheduler->Attach();
                Concurrency::parallel_for(stripeRange.start, stripeRange.end, pbody);
                Concurrency::CurrentScheduler::Detach();
            }
    
    #elif defined HAVE_PTHREADS_PF
    
            parallel_for_pthreads(pbody.stripeRange(), pbody, pbody.stripeRange().size());
    
    #else
    
    #error You have hacked and compiling with unsupported parallel framework
    
    #endif
    
            ctx.finalize();  // propagate exceptions if exists
            return;
    #endif // CV_PARALLEL_FRAMEWORK
        }

对应线程数或任务数为1，直接执行。

body(range);

## 参考资料： ##

*  [C语言 \#\# **VA\_ARGS** 宏][C_ _ _VA_ARGS_]
 *  [Xilinx OpenCV User Guide][]
 *  [ermig1979/Simd][ermig1979_Simd]
 *  [虹软人脸识别SDK在网络摄像头中的实际应用][SDK]
 *  [OpenCV并行加速Parallel\_for\_与ParallelLoopBody教程][OpenCV_Parallel_for_ParallelLoopBody]
 *  [OpenCV源码解析：直方图均衡化的详细算法和过程][OpenCV]
 *  [BT.601-7 (03/2011)][BT.601-7 _03_2011]
 *  [YCbCr][]
 *  [YUV to RGB Conversion][]
 *  [Color Space Converter: R’G’B’ to Y’CbCr][Color Space Converter_ R_G_B_ to Y_CbCr]
 *  [EXT\_YUV\_target][EXT_YUV_target]
 *  [1© 2014 Cisco and/or its affiliates. All rights reserved.Colorspaces and HDMI][1_ 2014 Cisco and_or its affiliates. All rights reserved.Colorspaces and HDMI]
 *  [图像颜色空间转换-CSC][-CSC]
 *  [ImageCodingResearchTools/YUV/rgb2yuv.m][ImageCodingResearchTools_YUV_rgb2yuv.m]
 *  [Color Spaces][]
 *  [Chapter 3 颜色空间（2）——YUV、YCbCr][Chapter 3 _2_YUV_YCbCr]
 *  [聊聊OpenCV的SIMD机制][OpenCV_SIMD]
 *  [使用OpenCV中的universal intrinsics为算法提速][OpenCV_universal intrinsics]

[cvtColor]: https://docs.opencv.org/master/d8/d01/group__imgproc__color__conversions.html#ga397ae87e1288a81d2363b61574eb8cab
[cvtBGRtoTwoPlaneYUV]: https://github.com/opencv/opencv/blob/master/modules/imgproc/src/color_yuv.dispatch.cpp#L168
[Carotene]: https://github.com/opencv/opencv/tree/master/3rdparty/carotene
[cvtColorBGR2ThreePlaneYUV]: https://github.com/opencv/opencv/blob/master/modules/imgproc/src/color_yuv.dispatch.cpp#L355
[COLOR_BGRA2YUV_I420]: https://docs.opencv.org/master/d8/d01/group__imgproc__color__conversions.html#gga4e0972be5de079fed4e3a10e24ef5ef0ae9c2defc5268f6c7938895b0f675df08
[cvtColor 1]: https://github.com/opencv/opencv/blob/master/modules/imgproc/src/color.cpp#L178
[CV_OCL_RUN]: https://github.com/opencv/opencv/blob/master/modules/core/include/opencv2/core/opencl/ocl_defs.hpp#L80
[ocl_cvtColor]: https://github.com/opencv/opencv/blob/master/modules/imgproc/src/color.cpp#L14
[swapBlue]: https://github.com/opencv/opencv/blob/master/modules/imgproc/src/color.hpp#L54
[uIndex]: https://github.com/opencv/opencv/blob/master/modules/imgproc/src/color.hpp#L143
[cvtColorTwoPlaneYUV2BGR]: https://github.com/opencv/opencv/blob/master/modules/imgproc/src/color_yuv.dispatch.cpp#L389
[cvtColorThreePlaneYUV2BGR]: https://github.com/opencv/opencv/blob/master/modules/imgproc/src/color_yuv.dispatch.cpp#L377
[cvtColorYUV2Gray_420]: https://github.com/opencv/opencv/blob/master/modules/imgproc/src/color_yuv.dispatch.cpp#L363
[cvtBGRtoThreePlaneYUV]: https://github.com/opencv/opencv/blob/master/modules/imgproc/src/color_yuv.dispatch.cpp#L155
[cvtColorOnePlaneYUV2BGR]: https://github.com/opencv/opencv/blob/master/modules/imgproc/src/color_yuv.dispatch.cpp#L340
[cvtOnePlaneYUVtoBGR]: https://github.com/opencv/opencv/blob/master/modules/imgproc/src/color_yuv.simd.hpp#L1946
[CvtHelper]: https://github.com/opencv/opencv/blob/master/modules/imgproc/src/color.simd_helpers.hpp#L83
[CV_MAKETYPE]: https://github.com/opencv/opencv/blob/master/modules/core/include/opencv2/core/hal/interface.h#L85
[CV_INSTRUMENT_REGION]: https://github.com/opencv/opencv/blob/master/modules/core/include/opencv2/core/private.hpp#L801
[CALL_HAL]: https://github.com/opencv/opencv/blob/master/modules/core/src/hal_replacement.hpp#L755
[cv_hal_cvtBGRtoThreePlaneYUV]: https://github.com/opencv/opencv/blob/master/modules/imgproc/src/hal_replacement.hpp#L580
[hal_ni_cvtBGRtoThreePlaneYUV]: https://github.com/opencv/opencv/blob/master/modules/imgproc/src/hal_replacement.hpp#L525
[CV_CPU_DISPATCH]: https://github.com/opencv/opencv/blob/master/modules/core/include/opencv2/core/cv_cpu_dispatch.h#L25
[CV_CPU_DISPATCH_EXPAND]: https://github.com/opencv/opencv/blob/master/modules/core/include/opencv2/core/cv_cpu_dispatch.h#L24
[CV_EXPAND]: https://github.com/opencv/opencv/blob/master/modules/core/include/opencv2/core/cvdef.h#L77
[color_yuv.simd.hpp]: https://github.com/opencv/opencv/blob/master/modules/imgproc/src/color_yuv.simd.hpp
[cvtBGRtoThreePlaneYUV 1]: https://github.com/opencv/opencv/blob/master/modules/imgproc/src/color_yuv.simd.hpp#L1905
[RGB8toYUV420pInvoker]: https://github.com/opencv/opencv/blob/master/modules/imgproc/src/color_yuv.simd.hpp#L1518
[parallel_for]: https://github.com/opencv/opencv/blob/master/modules/core/include/opencv2/core/utility.hpp#L610
[ParallelLoopBody]: https://github.com/opencv/opencv/blob/master/modules/core/include/opencv2/core/utility.hpp#L576
[v_uint8]: https://github.com/opencv/opencv/blob/master/modules/core/include/opencv2/core/hal/intrin.hpp#L483
[v_uint8x16]: https://docs.opencv.org/master/d7/df9/structcv_1_1v__uint8x16.html#a3774e41eeda8ebe6d2af486065d9be4e
[v_load_deinterleave]: https://github.com/opencv/opencv/blob/master/modules/core/include/opencv2/core/hal/intrin_cpp.hpp#L1614
[OPENCV_HAL_IMPL_NEON_INTERLEAVED]: https://github.com/opencv/opencv/blob/master/modules/core/include/opencv2/core/hal/intrin_neon.hpp#L1801
[rgbToY42x]: https://github.com/opencv/opencv/blob/master/modules/imgproc/src/color_yuv.simd.hpp#L1428
[v_store]: https://github.com/opencv/opencv/blob/master/modules/core/include/opencv2/core/hal/intrin_cpp.hpp#L1739
[v_store_interleave]: https://github.com/opencv/opencv/blob/master/modules/core/include/opencv2/core/hal/intrin_cpp.hpp#L1688
[rgbToUV42x]: https://github.com/opencv/opencv/blob/master/modules/imgproc/src/color_yuv.simd.hpp#L1469
[rgbToY42x 1]: https://github.com/opencv/opencv/blob/master/modules/imgproc/src/color_yuv.simd.hpp#L1419
[ITUR_BT_601_SHIFT]: https://github.com/opencv/opencv/blob/master/modules/imgproc/src/color_yuv.simd.hpp#L1014
[ITUR_BT_601_CRY]: https://github.com/opencv/opencv/blob/master/modules/imgproc/src/color_yuv.simd.hpp#L1017
[ITUR_BT_601_CGY]: https://github.com/opencv/opencv/blob/master/modules/imgproc/src/color_yuv.simd.hpp#L1018
[ITUR_BT_601_CBY]: https://github.com/opencv/opencv/blob/master/modules/imgproc/src/color_yuv.simd.hpp#L1019
[v_expand]: https://github.com/opencv/opencv/blob/master/modules/core/include/opencv2/core/hal/intrin_cpp.hpp#L1359
[CV_INTRIN_DEFINE_WIDE_INTRIN]: https://github.com/opencv/opencv/blob/master/modules/core/include/opencv2/core/hal/intrin.hpp#L317
[CV_INTRIN_DEFINE_WIDE_INTRIN_ALL_TYPES]: https://github.com/opencv/opencv/blob/master/modules/core/include/opencv2/core/hal/intrin.hpp#L344
[intrin.hpp]: https://github.com/opencv/opencv/blob/master/modules/core/include/opencv2/core/hal/intrin.hpp#L205
[v_setall_u32]: https://docs.opencv.org/master/df/d91/group__core__hal__intrin.html#gaae37de475214f1461ec66090fee2fa9f
[OPENCV_HAL_IMPL_NEON_INIT]: https://github.com/opencv/opencv/blob/master/modules/core/include/opencv2/core/hal/intrin_neon.hpp#L337
[v_pack]: https://docs.opencv.org/master/df/d91/group__core__hal__intrin.html#gaf47a1974cbc3cf8e3947a53de492fe40
[OPENCV_HAL_IMPL_NEON_PACK]: https://github.com/opencv/opencv/blob/master/modules/core/include/opencv2/core/hal/intrin_neon.hpp#L376
[OPENCV_HAL_IMPL_C_REINTERPRET]: https://github.com/opencv/opencv/blob/master/modules/core/include/opencv2/core/hal/intrin_cpp.hpp#L2387
[v_reg_reinterpret_as]: https://github.com/opencv/opencv/blob/master/modules/core/include/opencv2/core/hal/intrin_cpp.hpp#L373
[ParallelLoopBodyLambdaWrapper]: https://github.com/opencv/opencv/blob/master/modules/core/include/opencv2/core/utility.hpp#L590
[parallel_for 1]: https://github.com/opencv/opencv/blob/master/modules/core/src/parallel.cpp#L510
[CV_INSTRUMENT_REGION_MT_FORK]: https://github.com/opencv/opencv/blob/master/modules/core/include/opencv2/core/private.hpp#L764
[CV_INSTRUMENT_REGION_META]: https://github.com/opencv/opencv/blob/master/modules/core/include/opencv2/core/private.hpp#L714
[parallel_for_impl]: https://github.com/opencv/opencv/blob/master/modules/core/src/parallel.cpp#L555
[ParallelLoopBodyWrapperContext]: https://github.com/opencv/opencv/blob/master/modules/core/src/parallel.cpp#L217
[ProxyLoopBody]: https://github.com/opencv/opencv/blob/master/modules/core/src/parallel.cpp#L434
[ParallelLoopBodyWrapper_stripeRange]: https://github.com/opencv/opencv/blob/master/modules/core/src/parallel.cpp#L388
[getCurrentParallelForAPI]: https://github.com/opencv/opencv/blob/master/modules/core/src/parallel.cpp#L166
[ParallelForAPI]: https://github.com/opencv/opencv/blob/master/modules/core/include/opencv2/core/parallel/parallel_backend.hpp#L45
[setParallelForBackend]: https://github.com/opencv/opencv/blob/master/modules/core/src/parallel.cpp#L177
[cv_parallel_tbb_ParallelForBackend]: https://github.com/opencv/opencv/blob/master/modules/core/include/opencv2/core/parallel/backend/parallel_for.tbb.hpp#L46
[cv_parallel_openmp_ParallelForBackend]: https://github.com/opencv/opencv/blob/master/modules/core/include/opencv2/core/parallel/backend/parallel_for.openmp.hpp#L23
[parallel_for_cb]: https://github.com/opencv/opencv/blob/master/modules/core/src/parallel.cpp#L548
[CV_PARALLEL_FRAMEWORK]: https://github.com/opencv/opencv/blob/master/modules/core/src/parallel.cpp#L134
[C_ _ _VA_ARGS_]: https://www.cnblogs.com/alexshi/archive/2012/03/09/2388453.html
[Xilinx OpenCV User Guide]: https://www.xilinx.com/support/documentation/sw_manuals/xilinx2018_1/ug1233-xilinx-opencv-user-guide.pdf
[ermig1979_Simd]: https://github.com/ermig1979/Simd
[SDK]: https://blog.csdn.net/Rising_sun2017/article/details/97102667
[OpenCV_Parallel_for_ParallelLoopBody]: https://blog.csdn.net/qq_27825451/article/details/103878676
[OpenCV]: https://blog.csdn.net/tanmx219/article/details/81701865
[BT.601-7 _03_2011]: https://www.itu.int/dms_pubrec/itu-r/rec/bt/R-REC-BT.601-7-201103-I!!PDF-C.pdf
[YCbCr]: https://en.wikipedia.org/wiki/YCbCr
[YUV to RGB Conversion]: https://www.fourcc.org/fccyvrgb.php
[Color Space Converter_ R_G_B_ to Y_CbCr]: https://www.xilinx.com/support/documentation/application_notes/xapp637.pdf
[EXT_YUV_target]: https://www.khronos.org/registry/OpenGL/extensions/EXT/EXT_YUV_target.txt
[1_ 2014 Cisco and_or its affiliates. All rights reserved.Colorspaces and HDMI]: https://gstreamer.freedesktop.org/data/events/gstreamer-conference/2015/Hans%20Verkuil%20-%20Colorspaces%20and%20HDMI.pdf
[-CSC]: https://blog.csdn.net/helimin12345/article/details/78536520
[ImageCodingResearchTools_YUV_rgb2yuv.m]: https://github.com/nsprljan/ImageCodingResearchTools/blob/master/YUV/rgb2yuv.m
[Color Spaces]: http://www.compression.ru/download/articles/color_space/ch03.pdf
[Chapter 3 _2_YUV_YCbCr]: https://zhuanlan.zhihu.com/p/28766366
[OpenCV_SIMD]: https://zhuanlan.zhihu.com/p/165384048
[OpenCV_universal intrinsics]: https://blog.csdn.net/dulingwen/article/details/104083473