mirror of
https://github.com/obsproject/obs-studio.git
synced 2024-09-20 13:08:50 +02:00
f53df7da64
Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
310 lines
7.6 KiB
C++
310 lines
7.6 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;
|
|
}
|