Metal实现YUV转RGB渲染视频

    
网络上有很多有关YUV4:2:2转YUV4:2:0的描述,但大多数都是讲解原理,没有实际性的做法,本文把自己在TI
DAVINCI DM6446
端的测试过的代码奉献出来,供大家参考和学习,同时抛砖引玉,希望得到大家的指点。本方法适合TI
DM642,DM643x,DM644x等DSP系列,前段图像采集格式一般都是YCbCr
4:2:2(YUV4:2:2),但很多视频应用都需要对YUV4:2:2进行转化成YUV4:2:0的格式,比如jpeg,MPEG4,H.264等,在DM643x,DM644x上,TI
采用EDMA3的方式实现转换,那是另外的方法,这里专门介绍通用的做法,在DM6441(513MHz)上处理640×480只需要7.5ms,而且还可以再优化,这个大家可以试试。
   
/***********************************************/
以PAL制为例,这里的YCbCr 4:2:2(YUV4:2:2)像素排列方式是: U0,0 Y0,0 V0,0
Y 0,1  U0,1 Y0,2 V0,1 Y 0,3……U0,359 Y0,718 V0,359 Y 0,719
………………………… U575,0 Y575,0 V575,0 Y 575,1
………..U575,359 Y575,718 V575,359 Y 575,719
图片 1     我们要转化成YUV4:2:0的格式:    
图片 2
/*视频输入格式定义*/ #define PAL    1   /*PAL制CCD摄像头图像采集*/
#define NTSC  0   /*NTSC制CCD摄像头图像采集*/ #define CMOS  0 
 /*CMOS摄像头图像采集*/ #if (1== PAL) #define ORG_IMG_WIDTH    
720      /*D1 格式*/ #define ORG_IMG_HEIGHT    576 #elif 
(1==NTSC ) #define ORG_IMG_WIDTH     720      /*D1 格式*/ #define
ORG_IMG_HEIGHT    480 #elif (1==CMOS) #define
ORG_IMG_WIDTH     640     /*VGA 格式*/ #define
ORG_IMG_HEIGHT    480 #endif   yuv422to420const *unsigned char
YCbCr_buf) /*YCbCr_buf指向YUV4:2:2的空间*/ {         unsigned int
m0,m1,m2,m3,x,y;
        unsigned int tmp,tmp0,tmp1,tmp2;
        tmp = (unsigned
int)YCbCr_buf;/*对于D1,CIF,QCIF,VGA,QVGA的BUF肯定是4字节对齐,所以这里定义unsigned
int也是可以的,当然你也可以使用指针*/
        tmp0 = (unsigned int)Y_buf;
        for(y=0;y<ORG_IMG_HEIGHT;y++)
       {
            for(x=0;x<(ORG_IMG_WIDTH>>1);x+=4)
           {
                 m0 = *(unsigned
int*)(tmp+y*(ORG_IMG_WIDTH<<1) + (x<<2)); /
                 m1 = *(unsigned
int*)(tmp+y*(ORG_IMG_WIDTH<<1) + ((x+1)<<2));
                 m2 = *(unsigned
int*)(tmp+y*(ORG_IMG_WIDTH<<1) + ((x+2)<<2));
                m3 = *(unsigned
int*)(tmp+y*(ORG_IMG_WIDTH<<1) + ((x+3)<<2));
                *(unsigned short*)(tmp0+y*ORG_IMG_WIDTH +
(x<<1))=(unsigned short)(((m0>>16)&0xFF00)|((m0>>8)&0x00FF));
                 *(unsigned short*)(tmp0+y*ORG_IMG_WIDTH +
((x+1)<<1))=(unsigned
short)(((m1>>16)&0xFF00)|((m1>>8)&0x00FF));
                 *(unsigned short*)(tmp0+y*ORG_IMG_WIDTH +
((x+2)<<1))=(unsigned
short)(((m2>>16)&0xFF00)|((m2>>8)&0x00FF));
                 *(unsigned short*)(tmp0+y*RG_IMG_WIDTH +
((x+3)<<1))=(unsigned
short)(((m3>>16)&0xFF00)|((m3>>8)&0x00FF));
             }
       }
       tmp1=(unsigned int)U_buf;
       tmp2=(unsigned int)V_buf;
       for(y=0;y<(ORG_IMG_HEIGHT>>1);y++)
      {
             for(x=0;x<(ORG_IMG_WIDTH>>1);x+=4)
             {
                  m0 = *(unsigned
int*)(tmp+y*(ORG_IMG_WIDTH<<2) + (x<<2));
                  m1 = *(unsigned
int*)(tmp+y*(ORG_IMG_WIDTH<<2) + ((x+1)<<2));
                  m2 = *(unsigned
int*)(tmp+y*(ORG_IMG_WIDTH<<2) + ((x+2)<<2));
                 m3 = *(unsigned
int*)(tmp+y*(ORG_IMG_WIDTH<<2) + ((x+3)<<2));
     
                 *(unsigned char*)(tmp1+y*(ORG_IMG_WIDTH>>1)

视频与图像RGB/YUV格式详解(转)
计算机彩色显示器显示色彩的原理与彩色电视机一样,都是采用R(Red)G(Green)B(Blue)相加混色的原理:通过发射出三种不同强度的电子束,使屏幕内侧覆盖的红绿蓝磷光材料发光而产生色彩这种色彩的表示方法称为RGB色彩空间表示(它也是多媒体计算机技术中用得最多的一种色彩空间表示方法)
根据三基色原理,任意一种色光F都可以用不同分量的RGB三色相加混合而成
F = r [ R ] + g [ G ] + b [ B ]
其中,rgb分别为三基色参与混合的系数当三基色分量都为0(最弱)时混合为黑色光;而当三基色分量都为k(最强)时混合为白色光调整rgb三个系数的值,可以混合出介于黑色光和白色光之间的各种各样的色光
那么YUV又从何而来呢?在现代彩色电视系统中,通常采用三管彩色摄像机或彩色CCD摄像机进行摄像,然后把摄得的彩色图像信号经分色分别放大校正后得到RGB,再经过矩阵变换电路得到亮度信号Y和两个色差信号R-Y(即U)B-Y(即V),最后发送端将亮度和色差三个信号分别进行编码,用同一信道发送出去这种色彩的表示方法就是所谓的YUV色彩空间表示
采用YUV色彩空间的重要性是它的亮度信号Y和色度信号UV是分离的如果只有Y信号分量而没有UV分量,那么这样表示的图像就是黑白灰度图像彩色电视采用YUV空间正是为了用亮度信号Y解决彩色电视机与黑白电视机的兼容问题,使黑白电视机也能接收彩色电视信号
YUV与RGB相互转换的公式如下(RGB取值范围均为0-255):
Y = 0.299R + 0.587G + 0.114B
U = -0.147R – 0.289G + 0.436B
V = 0.615R – 0.515G – 0.100B
R = Y + 1.14V
G = Y – 0.39U – 0.58V
B = Y + 2.03U
在DirectShow中,常见的RGB格式有RGB1RGB4RGB8RGB565RGB555RGB24RGB32ARGB32等;常见的YUV格式有YUY2YUYVYVYUUYVYAYUVY41PY411Y211IF09IYUVYV12YVU9YUV411YUV420等作为视频媒体类型的辅助说明类型(Subtype),它们对应的GUID见表2.3
表2.3 常见的RGB和YUV格式
GUID 格式描述
MEDIASUBTYPE_RGB1 2色,每个像素用1位表示,需要调色板
MEDIASUBTYPE_RGB4 16色,每个像素用4位表示,需要调色板
MEDIASUBTYPE_RGB8 256色,每个像素用8位表示,需要调色板
MEDIASUBTYPE_RGB565 每个像素用16位表示,RGB分量分别使用5位6位5位
MEDIASUBTYPE_RGB555 每个像素用16位表示,RGB分量都使用5位(剩下的1位不用)
MEDIASUBTYPE_RGB24 每个像素用24位表示,RGB分量各使用8位
MEDIASUBTYPE_RGB32 每个像素用32位表示,RGB分量各使用8位(剩下的8位不用)
MEDIASUBTYPE_ARGB32 每个像素用32位表示,RGB分量各使用8位(剩下的8位用于表示Alpha通道值)
MEDIASUBTYPE_YUY2 YUY2格式,以4:2:2方式打包
MEDIASUBTYPE_YUYV YUYV格式(实际格式与YUY2相同)
MEDIASUBTYPE_YVYU YVYU格式,以4:2:2方式打包
MEDIASUBTYPE_UYVY UYVY格式,以4:2:2方式打包
MEDIASUBTYPE_AYUV 带Alpha通道的4:4:4 YUV格式
MEDIASUBTYPE_Y41P Y41P格式,以4:1:1方式打包
MEDIASUBTYPE_Y411 Y411格式(实际格式与Y41P相同)
MEDIASUBTYPE_Y211 Y211格式
MEDIASUBTYPE_IF09 IF09格式
MEDIASUBTYPE_IYUV IYUV格式
MEDIASUBTYPE_YV12 YV12格式
MEDIASUBTYPE_YVU9 YVU9格式
下面分别介绍各种RGB格式
¨ RGB1RGB4RGB8都是调色板类型的RGB格式,在描述这些媒体类型的格式细节时,通常会在BITMAPINFOHEADER数据结构后面跟着一个调色板(定义一系列颜色)它们的图像数据并不是真正的颜色值,而是当前像素颜色值在调色板中的索引以RGB1(2色位图)为例,比如它的调色板中定义的两种颜色值依次为0x000000(黑色)和0xFFFFFF(白色),那么图像数据001101010111(每个像素用1位表示)表示对应各像素的颜色为:黑黑白白黑白黑白黑白白白
¨ RGB565使用16位表示一个像素,这16位中的5位用于R,6位用于G,5位用于B程序中通常使用一个字(WORD,一个字等于两个字节)来操作一个像素当读出一个像素后,这个字的各个位意义如下:
高字节 低字节
R R R R R G G G G G G B B B B B
可以组合使用屏蔽字和移位操作来得到RGB各分量的值:
#define RGB565_MASK_RED 0xF800
#define RGB565_MASK_GREEN 0x07E0
#define RGB565_MASK_BLUE 0x001F
R = (wPixel & RGB565_MASK_RED) >> 11; // 取值范围0-31
G = (wPixel & RGB565_MASK_GREEN) >> 5; // 取值范围0-63
B = wPixel & RGB565_MASK_BLUE; // 取值范围0-31
¨ RGB555是另一种16位的RGB格式,RGB分量都用5位表示(剩下的1位不用)使用一个字读出一个像素后,这个字的各个位意义如下:
高字节 低字节
X R R R R G G G G G B B B B B (X表示不用,可以忽略)
可以组合使用屏蔽字和移位操作来得到RGB各分量的值:
#define RGB555_MASK_RED 0x7C00
#define RGB555_MASK_GREEN 0x03E0
#define RGB555_MASK_BLUE 0x001F
R = (wPixel & RGB555_MASK_RED) >> 10; // 取值范围0-31
G = (wPixel & RGB555_MASK_GREEN) >> 5; // 取值范围0-31
B = wPixel & RGB555_MASK_BLUE; // 取值范围0-31
¨ RGB24使用24位来表示一个像素,RGB分量都用8位表示,取值范围为0-255注意在内存中RGB各分量的排列顺序为:BGR BGR BGR通常可以使用RGBTRIPLE数据结构来操作一个像素,它的定义为:
typedef struct tagRGBTRIPLE {
BYTE rgbtBlue; // 蓝色分量
BYTE rgbtGreen; // 绿色分量
BYTE rgbtRed; // 红色分量
} RGBTRIPLE;
¨ RGB32使用32位来表示一个像素,RGB分量各用去8位,剩下的8位用作Alpha通道或者不用(ARGB32就是带Alpha通道的RGB32)注意在内存中RGB各分量的排列顺序为:BGRA BGRA BGRA通常可以使用RGBQUAD数据结构来操作一个像素,它的定义为:
typedef struct tagRGBQUAD {
BYTE rgbBlue; // 蓝色分量
BYTE rgbGreen; // 绿色分量
BYTE rgbRed; // 红色分量
BYTE rgbReserved; // 保留字节(用作Alpha通道或忽略)
} RGBQUAD;
下面介绍各种YUV格式YUV格式通常有两大类:打包(packed)格式和平面(planar)格式前者将YUV分量存放在同一个数组中,通常是几个相邻的像素组成一个宏像素(macro-pixel);而后者使用三个数组分开存放YUV三个分量,就像是一个三维平面一样表2.3中的YUY2到Y211都是打包格式,而IF09到YVU9都是平面格式(注意:在介绍各种具体格式时,YUV各分量都会带有下标,如Y0U0V0表示第一个像素的YUV分量,Y1U1V1表示第二个像素的YUV分量,以此类推)
¨ YUY2(和YUYV)格式为每个像素保留Y分量,而UV分量在水平方向上每两个像素采样一次一个宏像素为4个字节,实际表示2个像素(4:2:2的意思为一个宏像素中有4个Y分量2个U分量和2个V分量)图像数据中YUV分量排列顺序如下:
Y0 U0 Y1 V0 Y2 U2 Y3 V2
¨ YVYU格式跟YUY2类似,只是图像数据中YUV分量的排列顺序有所不同:
Y0 V0 Y1 U0 Y2 V2 Y3 U2
¨ UYVY格式跟YUY2类似,只是图像数据中YUV分量的排列顺序有所不同:
U0 Y0 V0 Y1 U2 Y2 V2 Y3
¨ AYUV格式带有一个Alpha通道,并且为每个像素都提取YUV分量,图像数据格式如下:
A0 Y0 U0 V0 A1 Y1 U1 V1
¨ Y41P(和Y411)格式为每个像素保留Y分量,而UV分量在水平方向上每4个像素采样一次一个宏像素为12个字节,实际表示8个像素图像数据中YUV分量排列顺序如下:
U0 Y0 V0 Y1 U4 Y2 V4 Y3 Y4 Y5 Y6 Y8
¨ Y211格式在水平方向上Y分量每2个像素采样一次,而UV分量每4个像素采样一次一个宏像素为4个字节,实际表示4个像素图像数据中YUV分量排列顺序如下:
Y0 U0 Y2 V0 Y4 U4 Y6 V4
¨ YVU9格式为每个像素都提取Y分量,而在UV分量的提取时,首先将图像分成若干个4 x 4的宏块,然后每个宏块提取一个U分量和一个V分量图像数据存储时,首先是整幅图像的Y分量数组,然后就跟着U分量数组,以及V分量数组IF09格式与YVU9类似
¨ IYUV格式为每个像素都提取Y分量,而在UV分量的提取时,首先将图像分成若干个2 x 2的宏块,然后每个宏块提取一个U分量和一个V分量YV12格式与IYUV类似
¨ YUV411YUV420格式多见于DV数据中,前者用于NTSC制,后者用于PAL制YUV411为每个像素都提取Y分量,而UV分量在水平方向上每4个像素采样一次YUV420并非V分量采样为0,而是跟YUV411相比,在水平方向上提高一倍色差采样频率,在垂直方向上以U/V间隔的方式减小一半色差采样,如下图所示

本次例子使用的是AVFoundation提供的AVCaptureVideoDataOutput获取每一帧的CVPixelBufferRef,详细步骤就不说了,网上有很多例子,这篇文章主要是介绍Metal中实现YUV转RGB格式的一些主要步骤,和OpenGL中的步骤差不多,主要是API和着色器不同,思路是一样的,这篇文章适合熟悉OpenGL视频渲染和有Metal基础的人观看,代码就不一一注释了,主要是本人理解的也不是很深,怕误人子弟。
源代码下载地址

1. http://processors.wiki.ti.com/index.php/C2000\_Flash\_FAQ

BOOL RGB2YUV(LPBYTE RgbBuf, UINT nWidth, UINT nHeight, LPBYTE yuvBuf, unsigned long *len)  
{
    if (RgbBuf == NULL)
    {
        return FALSE;
    }

    int i, j;  
    unsigned char*bufY, *bufU, *bufV, *bufRGB;
    memset(yuvBuf,0,(unsigned int )*len);  
    bufY = yuvBuf;  
    bufV = yuvBuf + nWidth * nHeight;  
    bufU = bufV + (nWidth * nHeight* 1/4);  
    *len = 0;   
    unsigned char y, u, v, r, g, b;  
    unsigned int ylen = nWidth * nHeight;  
    unsigned int ulen = (nWidth * nHeight)/4;  
    unsigned int vlen = (nWidth * nHeight)/4;   
    for (j = 0; j<nHeight;j++)  
    {  
        bufRGB = RgbBuf + nWidth * (nHeight - 1 - j) * 3 ;  
        for (i = 0;i<nWidth;i++)  
        {  
            int pos = nWidth * i + j;  
            r = *(bufRGB++);  
            g = *(bufRGB++);  
            b = *(bufRGB++);  
            y = (unsigned char)( ( 66 * r + 129 * g +  25 * b + 128) >> 8) + 16  ;            
            u = (unsigned char)( ( -38 * r -  74 * g + 112 * b + 128) >> 8) + 128 ;            
            v = (unsigned char)( ( 112 * r -  94 * g -  18 * b + 128) >> 8) + 128 ;  
            *(bufY++) = max( 0, min(y, 255 ));  
            if (j%2==0&&i%2 ==0)  
            {  
                if (u>255)  
                {  
                    u=255;  
                }  
                if (u<0)  
                {  
                    u = 0;  
                }  
                *(bufU++) =u;  
                //存u分量  
            }  
            else  
            {  
                //存v分量  
                if (i%2==0)  
                {  
                    if (v>255)  
                    {  
                        v = 255;  
                    }  
                    if (v<0)  
                    {  
                        v = 0;  
                    }  
                    *(bufV++) =v;  
                }  
            }  
        }  
    }  
    *len = nWidth * nHeight+(nWidth * nHeight)/2; 

    return TRUE;  
}   
  • x)=(unsigned char)m0;
                     *(unsigned char*)(tmp2+y*(ORG_IMG_WIDTH>>1)
  • x)=(unsigned char)(m0>>16);
                    *(unsigned char*)(tmp1+y*(ORG_IMG_WIDTH>>1) +
    x + 1)=(unsigned char)m1;
                    *(unsigned char*)(tmp2+y*(ORG_IMG_WIDTH>>1) +
    x + 1)=(unsigned char)(m1>>16);
                   *(unsigned char*)(tmp1+y*(ORG_IMG_WIDTH>>1) +
    x + 2)=(unsigned char)m2;
                   *(unsigned char*)(tmp2+y*(ORG_IMG_WIDTH>>1) +
    x + 2)=(unsigned char)(m2>>16);
                  *(unsigned char*)(tmp1+y*(ORG_IMG_WIDTH>>1) + x
  • 3)=(unsigned char)m3;
                  *(unsigned char*)(tmp2+y*(ORG_IMG_WIDTH>>1) + x
  • 3)=(unsigned char)(m3>>16);
                }
           } } 对上面的代码点评:DSP的优化原则,能移位,就不要乘除;能int
    读内存,就不要用char读内存,因为C64,C64+的DSP
    读内存指令需要4个时钟周期;循环能成4的倍数,最好拆4次操作,形成管道流水线操作,当然循环内部不能有if,
    break等语句。    
    另外,DM642或DM643有自己的效率更高的程序,这里也奉献给大家。 #include
    <csl.h>
    #include <csl_dat.h>
    #include <csl_cache.h> #pragma DATA_SECTION(int_mem_temp,
    “.img_buf”);/*可以把.img_buf定义到L2RAM*/
    #pragma DATA_ALIGN(int_mem_temp, 128);
    unsigned char int_mem_temp[720];   void yuv422to420( char
    *frameIn[], char *frm_out[],
                      int width, int height)
    {
        char *pSrcY = frameIn[0];
        char *pSrcU = frameIn[1];
        char *pSrcV = frameIn[2];     char *pDestY = frm_out[0];
        char *pDestU = frm_out[1];
        char *pDestV = frm_out[2];     unsigned int id;
        unsigned int i;     for( i = 0; i < height; i++)
        {
            id = DAT_copy(pSrcY + (i * 720), int_mem_temp, 720);
            id = DAT_copy(int_mem_temp,      pDestY + (i * 720), 
    720);
            DAT_wait(id);
        }     for( i = 0; i < (height >> 1); i++)
        {
            id = DAT_copy(pSrcU + (i * 720), int_mem_temp, 360);
            id = DAT_copy(int_mem_temp,      pDestU + (i * 360), 
    360);
            DAT_wait(id);
        }     for( i = 0; i < (height >> 1); i++)
        {
            id = DAT_copy(pSrcV + (i * 720), int_mem_temp, 360);
            id = DAT_copy(int_mem_temp,      pDestV + (i * 360), 
    360);
            DAT_wait(id);
        }     return ;
    } void yuv420to422( char *frameIn[], char *frm_out[],
                    int width, int height)
    {
        char *pSrcY = frameIn[0];
        char *pSrcU = frameIn[1];
        char *pSrcV = frameIn[2];     char *pDestY = frm_out[0];
        char *pDestU = frm_out[1];
        char *pDestV = frm_out[2];     unsigned int id;
        unsigned int i;     for( i = 0; i < height; i++)
        {
            id = DAT_copy(pSrcY + (i * 720), int_mem_temp, 720);
            id = DAT_copy(int_mem_temp,      pDestY + (i * 720), 
    720);
            DAT_wait(id);
        }     for( i = 0; i < (height >> 1); i++)
        {
            id = DAT_copy(pSrcU + (i * 360), int_mem_temp, 360);
            id = DAT_copy(int_mem_temp,      pDestU + ((2 * i) *
    360),   360);
            id = DAT_copy(int_mem_temp,      pDestU + ((2*i + 1)*
    360),  360);
            DAT_wait(id);
        }     for( i = 0; i < (height >> 1); i++)
        {
            id = DAT_copy(pSrcV + (i * 360), int_mem_temp, 360);
            id = DAT_copy(int_mem_temp,      pDestV + ((2*i) * 360),   
    360);
            id = DAT_copy(int_mem_temp,      pDestV + ((2*i+1) * 360), 
    360);
            DAT_wait(id);
        }    return ;
    }  
1 首先是shader上的片元着色器转换YUV到RGB
#include <metal_stdlib>
using namespace metal;
#define YUV_SHADER_ARGS  VertexOut      inFrag    [[ stage_in ]],\
texture2d<float>  lumaTex     [[ texture(0) ]],\
texture2d<float>  chromaTex     [[ texture(1) ]],\
sampler bilinear [[ sampler(0) ]], \
constant ColorParameters *colorParameters [[ buffer(0) ]]// RGB到YUV的转换矩阵
struct VertexIn{
    packed_float3 position;
    packed_float4 color;
    packed_float2 st;
};

struct VertexOut{
    float4 position [[position]];  //1
    float4 color;
    float2 st;
};
struct ColorParameters
{
    float3x3 yuvToRGB;
};
vertex VertexOut texture_vertex(
                              const device VertexIn* vertex_array [[ buffer(0) ]],           //1
                              unsigned int vid [[ vertex_id ]]) {


    VertexIn VertexIn = vertex_array[vid];

    VertexOut VertexOut;
    VertexOut.position = float4(VertexIn.position,1);  //3
    VertexOut.color = VertexIn.color;
    VertexOut.st = VertexIn.st;
    return VertexOut;
}
fragment half4 yuv_rgb(YUV_SHADER_ARGS)
{
    float3 yuv;
    yuv.x = lumaTex.sample(bilinear, inFrag.st).r;
    yuv.yz = chromaTex.sample(bilinear,inFrag.st).rg - float2(0.5);
    return half4(half3(colorParameters->yuvToRGB * yuv),yuv.x);
}

2. http://www.add.ece.ufl.edu/4924/docs/flash\_vs\_RAM\_C2000.pdf

 

DAVINCI DM6446 端的测试过的代码奉献出…

2 添加纹理缓存CVMetalTextureCacheRef和纹理MTLTexture变量
  CVMetalTextureCacheRef _videoTextureCache;
   id<MTLTexture> _videoTexture[2];
   CVPixelBufferRef _pixelBuffer;

添加转换矩阵的接收变量

@property (nonatomic, strong)  id<MTLBuffer> parametersBuffer;

以下几个都是YUV转RGB的矩阵算法,给parametersBuffer赋值,拷贝到GPU中计算

 _parametersBuffer = [_device newBufferWithLength:sizeof(ColorParameters) * 2 options:MTLResourceOptionCPUCacheModeDefault];
     ColorParameters matrix;
     simd::float3 A;
     simd::float3 B;
     simd::float3 C;

     // 1
     //    A.x = 1;
     //    A.y = 1;
     //    A.z = 1;
     //
     //    B.x = 0;
     //    B.y = -0.343;
     //    B.z = 1.765;
     //
     //    C.x = 1.4;
     //    C.y = -0.765;
     //    C.z = 0;

     // 2
     //    A.x = 1.164;
     //    A.y = 1.164;
     //    A.z = 1.164;
     //
     //    B.x = 0;
     //    B.y = -0.392;
     //    B.z = 2.017;
     //
     //    C.x = 1.596;
     //    C.y = -0.813;
     //    C.z = 0;

     // 3
     A.x = 1.164;
     A.y = 1.164;
     A.z = 1.164;

     B.x = 0;
     B.y = -0.231;
     B.z = 2.112;

     C.x = 1.793;
     C.y = -0.533;
     C.z = 0;
     matrix.yuvToRGB = simd::float3x3{A, B, C}; 
     memcpy(self.parametersBuffer.contents, &matrix, sizeof(ColorParameters));

获取每一帧视频信息生成纹理的代码

- (void)makeYUVTexture:(CVPixelBufferRef)pixelBuffer {
    CVMetalTextureRef y_texture ;
    float y_width = CVPixelBufferGetWidthOfPlane(pixelBuffer, 0);
    float y_height = CVPixelBufferGetHeightOfPlane(pixelBuffer, 0);
 CVMetalTextureCacheCreateTextureFromImage(kCFAllocatorDefault, _videoTextureCache, pixelBuffer, nil, MTLPixelFormatR8Unorm, y_width, y_height, 0, &y_texture);

    CVMetalTextureRef uv_texture;
    float uv_width = CVPixelBufferGetWidthOfPlane(pixelBuffer, 1);
    float uv_height = CVPixelBufferGetHeightOfPlane(pixelBuffer, 1);
    CVMetalTextureCacheCreateTextureFromImage(kCFAllocatorDefault, _videoTextureCache, pixelBuffer, nil, MTLPixelFormatRG8Unorm, uv_width, uv_height, 1, &uv_texture);

    id<MTLTexture> luma = CVMetalTextureGetTexture(y_texture);
    id<MTLTexture> chroma = CVMetalTextureGetTexture(uv_texture);

    _videoTexture[0] = luma;
    _videoTexture[1] = chroma;

    CVBufferRelease(y_texture);
    CVBufferRelease(uv_texture);
}

- (void)display:(CVPixelBufferRef)overlay {
    if (!overlay) {
        return;
    }
    if (!_videoTextureCache) {
        NSLog(@"No video texture cache");
        return;
    }
    [self makeYUVTexture:overlay];
}
- (void)setVideoTexture {
 CVMetalTextureCacheFlush(_videoTextureCache, 0);
    CVReturn err = CVMetalTextureCacheCreate(kCFAllocatorDefault, NULL, _device, NULL, &_videoTextureCache);
    if (err) {
        NSLog(@">> ERROR: Could not create a texture cache");
        assert(0);
    }
}

图片 3

效果图.PNG

~~~~ For Singing Snow ~~~~~

(最后PS: 有大神知道怎么使用Metal实现渲染到纹理的么,求指导)

相关文章