The application developed by Unity engine uses computer shader to convert RGB images into YUV data。
Compute Shader code：
Texture2D<float4> InputTexture;
RWBuffer<uint> OutputBuffer;
bool useLinear;
#define GAMA_1 0.45
uint CalcValueY(uint yIndex, uint width)
{
uint3 tid;
tid.x = yIndex % width;
tid.y = yIndex / width;
vector fRGB = InputTexture[float2(tid.x,tid.y)];
if (useLinear)
{
fRGB.r = pow(abs(fRGB.r), GAMA_1);
fRGB.g = pow(abs(fRGB.g), GAMA_1);
fRGB.b = pow(abs(fRGB.b), GAMA_1);
}
uint rrr = fRGB.r * 255;
uint ggg = fRGB.g * 255;
uint bbb = fRGB.b * 255;
uint ret = (0.299 * rrr + 0.587 * ggg + 0.114 * bbb);
return ret;
}
uint CalcValueU(uint uIndex, uint width)
{
uint3 tid;
tid.x = (uIndex % (width / 2)) * 2;
tid.y = (uIndex / (width / 2)) * 2;
vector fRGB = InputTexture[float2(tid.x,tid.y)];
if (useLinear)
{
fRGB.r = pow(abs(fRGB.r), GAMA_1);
fRGB.g = pow(abs(fRGB.g), GAMA_1);
fRGB.b = pow(abs(fRGB.b), GAMA_1);
}
uint rrr = fRGB.r * 255;
uint ggg = fRGB.g * 255;
uint bbb = fRGB.b * 255;
uint ret = (-0.169 * rrr - 0.331 * ggg + 0.5 * bbb + 128);
return ret;
}
uint CalcValueV(uint vIndex, uint width)
{
uint3 tid;
tid.x = (vIndex % (width / 2)) * 2;
tid.y = (vIndex / (width / 2)) * 2 + 1;
vector fRGB = InputTexture[float2(tid.x,tid.y)];
if (useLinear)
{
fRGB.r = pow(abs(fRGB.r), GAMA_1);
fRGB.g = pow(abs(fRGB.g), GAMA_1);
fRGB.b = pow(abs(fRGB.b), GAMA_1);
}
uint rrr = fRGB.r * 255;
uint ggg = fRGB.g * 255;
uint bbb = fRGB.b * 255;
uint ret = (0.5 * rrr - 0.419 * ggg - 0.081 * bbb + 128);
return ret;
}
[numthreads(8, 8, 1)]
void ReadYUV420Data_Reverse(uint3 id : SV_DispatchThreadID)
{
uint w, h;
InputTexture.GetDimensions(w, h);
uint ySize = w * h / 4;
uint index = (id.x + id.y * w);
if (index < ySize)
{
uint yIndex = index * 4;
uint yy0 = CalcValueY(yIndex, w);
uint yy1 = CalcValueY(yIndex + 1, w);
uint yy2 = CalcValueY(yIndex + 2, w);
uint yy3 = CalcValueY(yIndex + 3, w);
uint yyy = (yy0 & 0x000000ff) | ((yy1<<8) & 0x0000ff00) | ((yy2<<16) & 0x00ff0000) | ((yy3<<24) & 0xff000000);
OutputBuffer[index] = yyy;
}
else if ((index >= ySize) && index < (ySize * 5 / 4))
{
uint uIndex = index * 4 - ySize * 4;
uint uu0 = CalcValueU(uIndex, w);
uint uu1 = CalcValueU(uIndex + 1, w);
uint uu2 = CalcValueU(uIndex + 2, w);
uint uu3 = CalcValueU(uIndex + 3, w);
uint uuu = (uu0 & 0x000000ff) | ((uu1<<8) & 0x0000ff00) | ((uu2<<16) & 0x00ff0000) | ((uu3<<24) & 0xff000000);
OutputBuffer[index] = uuu;
}
else if ((index >= (ySize * 5 / 4)) && index < (ySize * 3 / 2)) //V分量
{
uint vIndex = index * 4 - ySize * 5;
uint vv0 = CalcValueV(vIndex, w);
uint vv1 = CalcValueV(vIndex + 1, w);
uint vv2 = CalcValueV(vIndex + 2, w);
uint vv3 = CalcValueV(vIndex + 3, w);
uint vvv = (vv0 & 0x000000ff) | ((vv1<<8) & 0x0000ff00) | ((vv2<<16) & 0x00ff0000) | ((vv3<<24) & 0xff000000);
OutputBuffer[index] = vvv;
}
else if (index >= (ySize * 3 / 2))
{
return;
}
}
C# call code：
private byte[] GetYUVData(int width,int height)
{
byteSize = width * height * 3 / 2 ;
uintSize = byteSize / 4;
if (m_outputBuffer == null)
{
m_outputBuffer = new ComputeBuffer(uintSize, sizeof(uint));
if (m_yuv420RawData == null)
{
m_yuv420RawData = new uint[uintSize];
}
m_outputBuffer.SetData(m_yuv420RawData);
}
if (m_yuv420RawData ==null || uintSize != m_yuv420RawData.Length)
{
if (m_outputBuffer != null)
{
m_outputBuffer.Release();
m_outputBuffer = null;
}
m_outputBuffer = new ComputeBuffer(uintSize, sizeof(uint));
m_outputBuffer.SetData(m_yuv420RawData);
}
int handle = shader.FindKernel("ReadYUV420Data_Reverse");
if (rt != null)
{
rt.DiscardContents();
if (rt.width != width || rt.height != height)
{
RenderTexture.ReleaseTemporary(rt);
rt = null;
}
}
if (rt == null )
{
rt = RenderTexture.GetTemporary(width,height,24, RenderTextureFormat.Default, RenderTextureReadWrite.Default);
rt.enableRandomWrite= true;
rt.name = "ScreenFrameLiving";
}
ScreenCapture.CaptureScreenshotIntoRenderTexture(rt);
shader.SetTexture(handle, "InputTexture", rt);
shader.SetBuffer(handle, "OutputBuffer", m_outputBuffer);
shader.SetBool("useLinear", true);
shader.Dispatch(handle, width / 8, height / 8, 1);
if (result == null || result.Length != byteSize)
{
result = new byte[byteSize];
}
m_outputBuffer.GetData(m_yuv420RawData);
MeetingNativeBridge.CopyUintToByte(m_yuv420RawData, byteSize, result);
return result;
}
This code can obtain data normally on NVIDIA device, but on Intel UHD Graphics 770 device with ComputeBuffer.GetData failed to obtain valid data. And save tests by ScreenCapture. CaptureScreenshotIntoRenderTexture interface to get to the rt is normal pictures, and rt is 1920 * 1080 pixels.
What causes this and how can I fix it？
