【視訊處理】YV12ToARGB

前面提到了YV12轉RGB的各種實現方法和優化方法，主要是CPU上的實現。本文主要介紹基於GPU的YV12轉RGB的實現。

1. 基於OpenGL的實現

利用OpenGL shader實現將YV12轉RGB，將Y、U、V分量資料作為紋理資料，並構造YUV轉RGB的shader程式碼，最終紋理資料在shader程式碼作用下，實現YV12轉RGB。該方法適合於將YV12轉RGB後直接顯示，若YV12轉化成RGB後，還需要進行影象處理操作，則利用OpenGL進行紋理資料的影象處理操作不方便。說明：由於本文著重於基於Cuda的實現，因而未驗證基於OpenGL的程式碼實現。

具體資料可參考：

http://blog.csdn.net/xiaoguaihai/article/details/8672631

http://www.fourcc.org/source/YUV420P-OpenGL-GLSLang.c

2. 基於Cuda的實現

YV12轉RGB的過程是逐一獲取畫素的Y、U、V分量，然後通過轉換公式計算得RGB。基於CUDA的實現關鍵在於兩個步驟：Y、U、V分量的獲取，RGB的計算。Y、U、V分量的獲取與YUV的記憶體佈局有關，RGB的計算公式一般是固定不變。具體的程式碼實現如下所示，主要參考NV12ToARGB.cu的程式碼，在該程式碼的基礎上，保持RGB的計算方法不變，修改了Y、U、V分量的獲取方法。

#include "cuda.h"

#include "cuda_runtime_api.h"

#define COLOR_COMPONENT_BIT_SIZE 10

#define COLOR_COMPONENT_MASK 0x3FF

__constant__ float constHueColorSpaceMat[9]={1.1644f,0.0f,1.596f,1.1644f,-0.3918f,-0.813f,1.1644f,2.0172f,0.0f};

__device__ staticvoid YUV2RGB(constint* yuvi,float* red,float* green,float* blue)

{

float luma, chromaCb, chromaCr;

// Prepare for hue adjustment

luma =(float)yuvi[0];

chromaCb =(float)((int)yuvi[1]-512.0f);

chromaCr =(float)((int)yuvi[2]-512.0f);

// Convert YUV To RGB with hue adjustment

*red =(luma * constHueColorSpaceMat[0])+

(chromaCb * constHueColorSpaceMat[1])+

(chromaCr * constHueColorSpaceMat[2]);

*green =(luma * constHueColorSpaceMat[3])+

(chromaCb * constHueColorSpaceMat[4])+

(chromaCr * constHueColorSpaceMat[5]);

*blue =(luma * constHueColorSpaceMat[6])+

(chromaCb * constHueColorSpaceMat[7])+

(chromaCr * constHueColorSpaceMat[8]);

}

__device__ staticint RGBA_pack_10bit(float red,float green,float blue,int alpha)

{

int ARGBpixel =0;

// Clamp final 10 bit results

red =::fmin(::fmax(red, 0.0f),1023.f);

green =::fmin(::fmax(green,0.0f),1023.f);

blue =::fmin(::fmax(blue, 0.0f),1023.f);

// Convert to 8 bit unsigned integers per color component

ARGBpixel =(((int)blue >>2)|

(((int)green >>2)<<8) |

(((int)red >>2)<<16)|

(int)alpha);

return ARGBpixel;

}

__global__ void YV12ToARGB_FourPixel(constunsignedchar* pYV12,unsignedint* pARGB,int width,int height)

{

// Pad borders with duplicate pixels, and we multiply by 2 because we process 4 pixels per thread

constint x = blockIdx.x *(blockDim.x <<1)+(threadIdx.x <<1);

constint y = blockIdx.y *(blockDim.y <<1)+(threadIdx.y <<1);

if((x +1)>= width ||(y +1)>= height)

return;

// Read 4 Luma components at a time

int yuv101010Pel[4];

yuv101010Pel[0]=(pYV12[y * width + x ])<<2;

yuv101010Pel[1]=(pYV12[y * width + x +1])<<2;

yuv101010Pel[2]=(pYV12[(y +1)* width + x ])<<2;

yuv101010Pel[3]=(pYV12[(y +1)* width + x +1])<<2;

constunsignedint vOffset = width * height;

constunsignedint uOffset = vOffset +(vOffset >>2);

constunsignedint vPitch = width >>1;

constunsignedint uPitch = vPitch;

constint x_chroma = x >>1;

constint y_chroma = y >>1;

int chromaCb = pYV12[uOffset + y_chroma * uPitch + x_chroma]; //U

int chromaCr = pYV12[vOffset + y_chroma * vPitch + x_chroma]; //V

yuv101010Pel[0]|=(chromaCb <<( COLOR_COMPONENT_BIT_SIZE +2));

yuv101010Pel[0]|=(chromaCr <<((COLOR_COMPONENT_BIT_SIZE <<1)+2));

yuv101010Pel[1]|=(chromaCb <<( COLOR_COMPONENT_BIT_SIZE +2));

yuv101010Pel[1]|=(chromaCr <<((COLOR_COMPONENT_BIT_SIZE <<1)+2));

yuv101010Pel[2]|=(chromaCb <<( COLOR_COMPONENT_BIT_SIZE +2));

yuv101010Pel[2]|=(chromaCr <<((COLOR_COMPONENT_BIT_SIZE <<1)+2));

yuv101010Pel[3]|=(chromaCb <<( COLOR_COMPONENT_BIT_SIZE +2));

yuv101010Pel[3]|=(chromaCr <<((COLOR_COMPONENT_BIT_SIZE <<1)+2));

// this steps performs the color conversion

int yuvi[12];

float red[4], green[4], blue[4];

yuvi[0]=(yuv101010Pel[0]& COLOR_COMPONENT_MASK );

yuvi[1]=((yuv101010Pel[0]>> COLOR_COMPONENT_BIT_SIZE) & COLOR_COMPONENT_MASK);

yuvi[2]=((yuv101010Pel[0]>>(COLOR_COMPONENT_BIT_SIZE <<1))& COLOR_COMPONENT_MASK);

yuvi[3]=(yuv101010Pel[1]& COLOR_COMPONENT_MASK );

yuvi[4]=((yuv101010Pel[1]>> COLOR_COMPONENT_BIT_SIZE) & COLOR_COMPONENT_MASK);

yuvi[5]=((yuv101010Pel[1]>>(COLOR_COMPONENT_BIT_SIZE <<1))& COLOR_COMPONENT_MASK);

yuvi[6]=(yuv101010Pel[2]& COLOR_COMPONENT_MASK );

yuvi[7]=((yuv101010Pel[2]>> COLOR_COMPONENT_BIT_SIZE) & COLOR_COMPONENT_MASK);

yuvi[8]=((yuv101010Pel[2]>>(COLOR_COMPONENT_BIT_SIZE <<1))& COLOR_COMPONENT_MASK);

yuvi[9]=(yuv101010Pel[3]& COLOR_COMPONENT_MASK );

yuvi[10]=((yuv101010Pel[3]>> COLOR_COMPONENT_BIT_SIZE) & COLOR_COMPONENT_MASK);

yuvi[11]=((yuv101010Pel[3]>>(COLOR_COMPONENT_BIT_SIZE <<1))& COLOR_COMPONENT_MASK);

// YUV to RGB Transformation conversion

YUV2RGB(&yuvi[0],&red[0],&green[0],&blue[0]);

YUV2RGB(&yuvi[3],&red[1],&green[1],&blue[1]);

YUV2RGB(&yuvi[6],&red[2],&green[2],&blue[2]);

YUV2RGB(&yuvi[9],&red[3],&green[3],&blue[3]);

pARGB[y * width + x ]= RGBA_pack_10bit(red[0], green[0], blue[0],((int)0xff<<24));

pARGB[y * width + x +1]= RGBA_pack_10bit(red[1], green[1], blue[1],((int)0xff<<24));

pARGB[(y +1)* width + x ]= RGBA_pack_10bit(red[2], green[2], blue[2],((int)0xff<<24));

pARGB[(y +1)* width + x +1]= RGBA_pack_10bit(red[3], green[3], blue[3],((int)0xff<<24));

}

bool YV12ToARGB(unsignedchar* pYV12,unsignedchar* pARGB,int width,int height)

{

unsignedchar* d_src;

unsignedchar* d_dst;

unsignedint srcMemSize =sizeof(unsignedchar)* width * height *3/2;

unsignedint dstMemSize =sizeof(unsignedchar)* width * height *4;

cudaMalloc((void**)&d_src,srcMemSize);

cudaMalloc((void**)*d_dst,dstMemSize);

cudaMemcpy(d_src,pYV12,srcMemSize,cudaMemcpyHostToDevice);

dim3 block(32,8);

int gridx =(width +2*block.x -1)/(2*block.x);

int gridy =(height +2*block.y -1)/(2*block.y);

dim3 grid(gridx,gridy);

YV12ToARGB<<<grid,block>>>(d_src,(unsignedint*)d_dst,width,height);

cudaMemcpy(pARGB,d_dst,dstMemSize,cudaMemcpyDeviceToHost);

returntrue;

}

　　執行緒記憶體訪問示意圖如下所示，每個執行緒訪問4個Y、1個U、1個V，最終轉換得到4個ARGB值。由於YV12屬於YUV4:2:0取樣，每四個Y共用一組UV分量，即Y(0,0)、Y(0,1)、Y(1,0)、Y(1,1)共用V(0,0)和U(0,0)，如紅色框標註所示。

3. 基於Cuda的實現優化

優化主要關注於兩個方面：單個執行緒處理畫素粒度和資料傳輸。單個執行緒處理粒度分為：OnePixelPerThread,TwoPixelPerThread,FourPixelPerThread。資料傳輸優化主要採用Pageable Memory，Pinned Memory，Mapped Memory(Zero Copy)。經測試，不同實現版本的轉換效率如下表所示，測試序列：1920*1080，時間統計包括核心函式執行時間和資料傳輸時間，單位為ms。

	OnePixel	TwoPixel	FourPixel
Pageable	6.91691	6.64319	6.2873
Pinned	5.31999	5.01890	4.71937
Mapped	3.39043	48.5298	23.8327

由上表可知，不使用Mapped Memory(Zero Copy)時，單個執行緒處理畫素的粒度越大，核心函式執行的時間越小，轉換效率越好。使用Mapped Memory(Zero Copy)時，單執行緒處理單畫素時，轉換效率最好。

單個執行緒處理四個畫素時，核心函式執行時間最少；使用Pinned Memory會減少資料傳輸時間；使用Mapped Memory消除資料傳輸過程，但會增加核心函式執行時間，最終優化效果與核心函式訪問記憶體的方式有關。建議使用Pinned Memory+FourPixelPerThread的優化版本。

　　利用NVIDIA提供的效能分析工具，分析Pinned Memory+FourPixelPerThread版本程式，分析結果如下圖所示，核心計算時間佔1/4左右，資料傳輸時間佔3/4左右，總體而言，核心計算任務過少，導致並行優化的效果無法抵消資料傳輸的開銷。

【視訊處理】YV12ToARGB

相關文章