obs-studio/plugins/obs-qsv11/common_utils.cpp

307 lines
8.8 KiB
C++

/*****************************************************************************
INTEL CORPORATION PROPRIETARY INFORMATION
This software is supplied under the terms of a license agreement or
nondisclosure agreement with Intel Corporation and may not be copied
or disclosed except in accordance with the terms of that agreement.
Copyright(c) 2005-2014 Intel Corporation. All Rights Reserved.
*****************************************************************************/
#include "common_utils.h"
// =================================================================
// Utility functions, not directly tied to Intel Media SDK functionality
//
void PrintErrString(int err,const char* filestr,int line)
{
switch (err) {
case 0:
printf("\n No error.\n");
break;
case -1:
printf("\n Unknown error: %s %d\n",filestr,line);
break;
case -2:
printf("\n Null pointer. Check filename/path + permissions? %s %d\n",filestr,line);
break;
case -3:
printf("\n Unsupported feature/library load error. %s %d\n",filestr,line);
break;
case -4:
printf("\n Could not allocate memory. %s %d\n",filestr,line);
break;
case -5:
printf("\n Insufficient IO buffers. %s %d\n",filestr,line);
break;
case -6:
printf("\n Invalid handle. %s %d\n",filestr,line);
break;
case -7:
printf("\n Memory lock failure. %s %d\n",filestr,line);
break;
case -8:
printf("\n Function called before initialization. %s %d\n",filestr,line);
break;
case -9:
printf("\n Specified object not found. %s %d\n",filestr,line);
break;
case -10:
printf("\n More input data expected. %s %d\n",filestr,line);
break;
case -11:
printf("\n More output surfaces expected. %s %d\n",filestr,line);
break;
case -12:
printf("\n Operation aborted. %s %d\n",filestr,line);
break;
case -13:
printf("\n HW device lost. %s %d\n",filestr,line);
break;
case -14:
printf("\n Incompatible video parameters. %s %d\n",filestr,line);
break;
case -15:
printf("\n Invalid video parameters. %s %d\n",filestr,line);
break;
case -16:
printf("\n Undefined behavior. %s %d\n",filestr,line);
break;
case -17:
printf("\n Device operation failure. %s %d\n",filestr,line);
break;
case -18:
printf("\n More bitstream data expected. %s %d\n",filestr,line);
break;
case -19:
printf("\n Incompatible audio parameters. %s %d\n",filestr,line);
break;
case -20:
printf("\n Invalid audio parameters. %s %d\n",filestr,line);
break;
default:
printf("\nError code %d,\t%s\t%d\n\n", err, filestr, line);
}
}
mfxStatus ReadPlaneData(mfxU16 w, mfxU16 h, mfxU8* buf, mfxU8* ptr,
mfxU16 pitch, mfxU16 offset, FILE* fSource)
{
mfxU32 nBytesRead;
for (mfxU16 i = 0; i < h; i++) {
nBytesRead = (mfxU32) fread(buf, 1, w, fSource);
if (w != nBytesRead)
return MFX_ERR_MORE_DATA;
for (mfxU16 j = 0; j < w; j++)
ptr[i * pitch + j * 2 + offset] = buf[j];
}
return MFX_ERR_NONE;
}
mfxStatus LoadRawFrame(mfxFrameSurface1* pSurface, FILE* fSource)
{
if (!fSource) {
// Simulate instantaneous access to 1000 "empty" frames.
static int frameCount = 0;
if (1000 == frameCount++)
return MFX_ERR_MORE_DATA;
else
return MFX_ERR_NONE;
}
mfxStatus sts = MFX_ERR_NONE;
mfxU32 nBytesRead;
mfxU16 w, h, i, pitch;
mfxU8* ptr;
mfxFrameInfo* pInfo = &pSurface->Info;
mfxFrameData* pData = &pSurface->Data;
if (pInfo->CropH > 0 && pInfo->CropW > 0) {
w = pInfo->CropW;
h = pInfo->CropH;
} else {
w = pInfo->Width;
h = pInfo->Height;
}
pitch = pData->Pitch;
ptr = pData->Y + pInfo->CropX + pInfo->CropY * pData->Pitch;
// read luminance plane
for (i = 0; i < h; i++) {
nBytesRead = (mfxU32) fread(ptr + i * pitch, 1, w, fSource);
if (w != nBytesRead)
return MFX_ERR_MORE_DATA;
}
mfxU8 buf[2048]; // maximum supported chroma width for nv12
w /= 2;
h /= 2;
ptr = pData->UV + pInfo->CropX + (pInfo->CropY / 2) * pitch;
if (w > 2048)
return MFX_ERR_UNSUPPORTED;
// load U
sts = ReadPlaneData(w, h, buf, ptr, pitch, 0, fSource);
if (MFX_ERR_NONE != sts)
return sts;
// load V
sts = ReadPlaneData(w, h, buf, ptr, pitch, 1, fSource);
if (MFX_ERR_NONE != sts)
return sts;
return MFX_ERR_NONE;
}
mfxStatus LoadRawRGBFrame(mfxFrameSurface1* pSurface, FILE* fSource)
{
if (!fSource) {
// Simulate instantaneous access to 1000 "empty" frames.
static int frameCount = 0;
if (1000 == frameCount++)
return MFX_ERR_MORE_DATA;
else
return MFX_ERR_NONE;
}
size_t nBytesRead;
mfxU16 w, h;
mfxFrameInfo* pInfo = &pSurface->Info;
if (pInfo->CropH > 0 && pInfo->CropW > 0) {
w = pInfo->CropW;
h = pInfo->CropH;
} else {
w = pInfo->Width;
h = pInfo->Height;
}
for (mfxU16 i = 0; i < h; i++) {
nBytesRead = fread(pSurface->Data.B + i * pSurface->Data.Pitch,
1, w * 4, fSource);
if ((size_t)(w * 4) != nBytesRead)
return MFX_ERR_MORE_DATA;
}
return MFX_ERR_NONE;
}
mfxStatus WriteBitStreamFrame(mfxBitstream* pMfxBitstream, FILE* fSink)
{
mfxU32 nBytesWritten =
(mfxU32) fwrite(pMfxBitstream->Data + pMfxBitstream->DataOffset, 1,
pMfxBitstream->DataLength, fSink);
if (nBytesWritten != pMfxBitstream->DataLength)
return MFX_ERR_UNDEFINED_BEHAVIOR;
pMfxBitstream->DataLength = 0;
return MFX_ERR_NONE;
}
mfxStatus ReadBitStreamData(mfxBitstream* pBS, FILE* fSource)
{
memmove(pBS->Data, pBS->Data + pBS->DataOffset, pBS->DataLength);
pBS->DataOffset = 0;
mfxU32 nBytesRead = (mfxU32) fread(pBS->Data + pBS->DataLength, 1,
pBS->MaxLength - pBS->DataLength,
fSource);
if (0 == nBytesRead)
return MFX_ERR_MORE_DATA;
pBS->DataLength += nBytesRead;
return MFX_ERR_NONE;
}
mfxStatus WriteSection(mfxU8* plane, mfxU16 factor, mfxU16 chunksize,
mfxFrameInfo* pInfo, mfxFrameData* pData, mfxU32 i,
mfxU32 j, FILE* fSink)
{
if (chunksize !=
fwrite(plane +
(pInfo->CropY * pData->Pitch / factor + pInfo->CropX) +
i * pData->Pitch + j, 1, chunksize, fSink))
return MFX_ERR_UNDEFINED_BEHAVIOR;
return MFX_ERR_NONE;
}
mfxStatus WriteRawFrame(mfxFrameSurface1* pSurface, FILE* fSink)
{
mfxFrameInfo* pInfo = &pSurface->Info;
mfxFrameData* pData = &pSurface->Data;
mfxU32 i, j, h, w;
mfxStatus sts = MFX_ERR_NONE;
for (i = 0; i < pInfo->CropH; i++)
sts =
WriteSection(pData->Y, 1, pInfo->CropW, pInfo, pData, i, 0,
fSink);
h = pInfo->CropH / 2;
w = pInfo->CropW;
for (i = 0; i < h; i++)
for (j = 0; j < w; j += 2)
sts =
WriteSection(pData->UV, 2, 1, pInfo, pData, i, j,
fSink);
for (i = 0; i < h; i++)
for (j = 1; j < w; j += 2)
sts =
WriteSection(pData->UV, 2, 1, pInfo, pData, i, j,
fSink);
return sts;
}
int GetFreeTaskIndex(Task* pTaskPool, mfxU16 nPoolSize)
{
if (pTaskPool)
for (int i = 0; i < nPoolSize; i++)
if (!pTaskPool[i].syncp)
return i;
return MFX_ERR_NOT_FOUND;
}
void ClearYUVSurfaceSysMem(mfxFrameSurface1* pSfc, mfxU16 width, mfxU16 height)
{
// In case simulating direct access to frames we initialize the allocated surfaces with default pattern
memset(pSfc->Data.Y, 100, width * height); // Y plane
memset(pSfc->Data.U, 50, (width * height)/2); // UV plane
}
// Get free raw frame surface
int GetFreeSurfaceIndex(mfxFrameSurface1** pSurfacesPool, mfxU16 nPoolSize)
{
if (pSurfacesPool)
for (mfxU16 i = 0; i < nPoolSize; i++)
if (0 == pSurfacesPool[i]->Data.Locked)
return i;
return MFX_ERR_NOT_FOUND;
}
char mfxFrameTypeString(mfxU16 FrameType)
{
mfxU8 FrameTmp = FrameType & 0xF;
char FrameTypeOut;
switch (FrameTmp) {
case MFX_FRAMETYPE_I:
FrameTypeOut = 'I';
break;
case MFX_FRAMETYPE_P:
FrameTypeOut = 'P';
break;
case MFX_FRAMETYPE_B:
FrameTypeOut = 'B';
break;
default:
FrameTypeOut = '*';
}
return FrameTypeOut;
}