void CParametersDumper::SerializeVideoParamStruct(msdk_ostream& sstr,msdk_string sectionName,mfxVideoParam& info,bool shouldUseVPPSection)
{
msdk_string prefix=MSDK_STRING("");
sstr<<sectionName<<std::endl;
SERIALIZE_INFO(AllocId);
SERIALIZE_INFO_ARRAY(reserved);
SERIALIZE_INFO(reserved3);
SERIALIZE_INFO(AsyncDepth);
if(shouldUseVPPSection)
{
SERIALIZE_INFO_ARRAY(vpp.reserved);
SerializeFrameInfoStruct(sstr,MSDK_STRING("vpp.In."),info.vpp.In);
SerializeFrameInfoStruct(sstr,MSDK_STRING("vpp.Out."),info.vpp.Out);
}
else
{
SerializeMfxInfoMFXStruct(sstr,MSDK_STRING("mfx."),info.mfx);
}
SERIALIZE_INFO(Protected);
SERIALIZE_INFO(IOPattern);
for(int i=0;i<info.NumExtParam;i++)
{
SerializeExtensionBuffer(sstr,MSDK_STRING("ext."),info.ExtParam[i]);
}
SERIALIZE_INFO(reserved2);
}
void PTSMaker::PrintDumpInfo()
{
msdk_printf(MSDK_STRING("Error in PTS setting \n"));
msdk_printf(MSDK_STRING("Input frame number is %d\n"), m_NumFrame_In);
msdk_printf(MSDK_STRING("Output frame number is %d\n"), m_NumFrame_Out);
msdk_printf(MSDK_STRING("Initial time offset is %f\n"), m_TimeOffset);
msdk_printf(MSDK_STRING("PTS difference is %f\n"), m_CurrDiff);
}
int main(int argc, char *argv[])
#endif
{
sInputParams Params; // input parameters from command line
CDecodingPipeline Pipeline; // pipeline for decoding, includes input file reader, decoder and output file writer
mfxStatus sts = MFX_ERR_NONE; // return value check
sts = ParseInputString(argv, (mfxU8)argc, &Params);
MSDK_CHECK_PARSE_RESULT(sts, MFX_ERR_NONE, 1);
if (Params.bIsMVC)
Pipeline.SetMultiView();
sts = Pipeline.Init(&Params);
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, 1);
// print stream info
Pipeline.PrintInfo();
msdk_printf(MSDK_STRING("Decoding started\n"));
for (;;)
{
sts = Pipeline.RunDecoding();
if (MFX_ERR_INCOMPATIBLE_VIDEO_PARAM == sts || MFX_ERR_DEVICE_LOST == sts || MFX_ERR_DEVICE_FAILED == sts)
{
if (MFX_ERR_INCOMPATIBLE_VIDEO_PARAM == sts)
{
msdk_printf(MSDK_STRING("\nERROR: Incompatible video parameters detected. Recovering...\n"));
}
else
{
msdk_printf(MSDK_STRING("\nERROR: Hardware device was lost or returned unexpected error. Recovering...\n"));
sts = Pipeline.ResetDevice();
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, 1);
}
sts = Pipeline.ResetDecoder(&Params);
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, 1);
continue;
}
else
{
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, 1);
break;
}
}
msdk_printf(MSDK_STRING("\nDecoding finished\n"));
return 0;
}
mfxStatus CVAAPIDeviceDRM::Init(mfxHDL hWindow, mfxU16 nViews, mfxU32 nAdapterNum)
{
if (0 == nViews) {
return MFX_ERR_NONE;
}
if (1 == nViews) {
if (m_DRMLibVA.getBackendType() == MFX_LIBVA_DRM_RENDERNODE) {
return MFX_ERR_NONE;
}
mfxI32 * monitorType = (mfxI32*)hWindow;
if (!monitorType) return MFX_ERR_INVALID_VIDEO_PARAM;
try {
m_rndr = new drmRenderer(m_DRMLibVA.getFD(), *monitorType);
} catch(...) {
msdk_printf(MSDK_STRING("vaapi_device: failed to initialize drmrender\n"));
return MFX_ERR_UNKNOWN;
}
return MFX_ERR_NONE;
}
return MFX_ERR_UNSUPPORTED;
}
mfxStatus CParametersDumper::DumpLibraryConfiguration(msdk_string fileName, MFXVideoDECODE* pMfxDec, MFXVideoVPP* pMfxVPP, MFXVideoENCODE* pMfxEnc,
const mfxVideoParam* pDecoderPresetParams, const mfxVideoParam* pVPPPresetParams, const mfxVideoParam* pEncoderPresetParams)
{
try
{
msdk_fstream sstr(fileName.c_str(),std::fstream::out);
sstr<<MSDK_STRING("Configuration settings (fields from API ") <<
MFX_VERSION_MAJOR << MSDK_STRING(".") << MFX_VERSION_MINOR << MSDK_STRING(")\n");
mfxVideoParam params;
if(pMfxDec)
{
if (GetUnitParams(pMfxDec, pDecoderPresetParams,¶ms) == MFX_ERR_NONE)
{
SerializeVideoParamStruct(sstr, MSDK_STRING("*** Decoder ***"), params, false);
ClearExtBuffs(¶ms);
}
}
if(pMfxVPP)
{
if (GetUnitParams(pMfxVPP, pVPPPresetParams, ¶ms) == MFX_ERR_NONE)
{
SerializeVideoParamStruct(sstr, MSDK_STRING("*** VPP ***"), params, true);
ClearExtBuffs(¶ms);
}
}
if(pMfxEnc)
{
if (GetUnitParams(pMfxEnc, pEncoderPresetParams, ¶ms) == MFX_ERR_NONE)
{
SerializeVideoParamStruct(sstr, MSDK_STRING("*** Encoder ***"), params, false);
ClearExtBuffs(¶ms);
}
}
sstr.close();
}
catch(...)
{
msdk_printf(MSDK_STRING("Cannot save library settings into file.\n"));
return MFX_ERR_NULL_PTR;
}
return MFX_ERR_NONE;
}
mfxStatus D3DFrameAllocator::AllocImpl(mfxFrameAllocRequest *request, mfxFrameAllocResponse *response)
{
HRESULT hr;
MSDK_CHECK_POINTER(request, MFX_ERR_NULL_PTR);
if (request->NumFrameSuggested == 0)
return MFX_ERR_UNKNOWN;
D3DFORMAT format = ConvertMfxFourccToD3dFormat(request->Info.FourCC);
if (format == D3DFMT_UNKNOWN)
{
msdk_printf(MSDK_STRING("D3D Allocator: invalid fourcc is provided (%#X), exitting\n"),request->Info.FourCC);
return MFX_ERR_UNSUPPORTED;
}
DWORD target;
if (MFX_MEMTYPE_DXVA2_DECODER_TARGET & request->Type)
{
target = DXVA2_VideoDecoderRenderTarget;
}
else if (MFX_MEMTYPE_DXVA2_PROCESSOR_TARGET & request->Type)
{
target = DXVA2_VideoProcessorRenderTarget;
}
else
return MFX_ERR_UNSUPPORTED;
IDirectXVideoAccelerationService* videoService = NULL;
if (target == DXVA2_VideoProcessorRenderTarget) {
if (!m_hProcessor) {
hr = m_manager->OpenDeviceHandle(&m_hProcessor);
if (FAILED(hr))
return MFX_ERR_MEMORY_ALLOC;
hr = m_manager->GetVideoService(m_hProcessor, IID_IDirectXVideoProcessorService, (void**)&m_processorService);
if (FAILED(hr))
return MFX_ERR_MEMORY_ALLOC;
}
videoService = m_processorService;
}
else {
if (!m_hDecoder)
{
hr = m_manager->OpenDeviceHandle(&m_hDecoder);
if (FAILED(hr))
return MFX_ERR_MEMORY_ALLOC;
hr = m_manager->GetVideoService(m_hDecoder, IID_IDirectXVideoDecoderService, (void**)&m_decoderService);
if (FAILED(hr))
return MFX_ERR_MEMORY_ALLOC;
}
videoService = m_decoderService;
}
mfxHDLPair *dxMids = NULL, **dxMidPtrs = NULL;
dxMids = (mfxHDLPair*)calloc(request->NumFrameSuggested, sizeof(mfxHDLPair));
dxMidPtrs = (mfxHDLPair**)calloc(request->NumFrameSuggested, sizeof(mfxHDLPair*));
if (!dxMids || !dxMidPtrs) {
MSDK_SAFE_FREE(dxMids);
MSDK_SAFE_FREE(dxMidPtrs);
return MFX_ERR_MEMORY_ALLOC;
}
response->mids = (mfxMemId*)dxMidPtrs;
response->NumFrameActual = request->NumFrameSuggested;
if (request->Type & MFX_MEMTYPE_EXTERNAL_FRAME) {
for (int i = 0; i < request->NumFrameSuggested; i++) {
hr = videoService->CreateSurface(request->Info.Width, request->Info.Height, 0, format,
D3DPOOL_DEFAULT, m_surfaceUsage, target, (IDirect3DSurface9**)&dxMids[i].first, &dxMids[i].second);
if (FAILED(hr)) {
ReleaseResponse(response);
MSDK_SAFE_FREE(dxMids);
return MFX_ERR_MEMORY_ALLOC;
}
dxMidPtrs[i] = &dxMids[i];
}
} else {
safe_array<IDirect3DSurface9*> dxSrf(new IDirect3DSurface9*[request->NumFrameSuggested]);
if (!dxSrf.get())
{
MSDK_SAFE_FREE(dxMids);
return MFX_ERR_MEMORY_ALLOC;
}
hr = videoService->CreateSurface(request->Info.Width, request->Info.Height, request->NumFrameSuggested - 1, format,
D3DPOOL_DEFAULT, m_surfaceUsage, target, dxSrf.get(), NULL);
if (FAILED(hr))
{
MSDK_SAFE_FREE(dxMids);
return MFX_ERR_MEMORY_ALLOC;
}
for (int i = 0; i < request->NumFrameSuggested; i++) {
dxMids[i].first = dxSrf.get()[i];
dxMidPtrs[i] = &dxMids[i];
}
}
return MFX_ERR_NONE;
}
void PrintHelp(msdk_char *strAppName, const msdk_char *strErrorMessage)
{
msdk_printf(MSDK_STRING("Intel(R) Camera Expert SDK Sample Version %s\n\n"), MSDK_SAMPLE_VERSION);
if (strErrorMessage)
{
msdk_printf(MSDK_STRING("Error: %s\n"), strErrorMessage);
}
msdk_printf(MSDK_STRING("Usage: %s [Options] -p PathToCameraPlugin -i InputFileNameBase -o OutputFileNameBase [numberOfFilesToDump]\n"), strAppName);
msdk_printf(MSDK_STRING("Options: \n"));
msdk_printf(MSDK_STRING(" [-plugin_version ver] - define camera plugin version\n"));
msdk_printf(MSDK_STRING(" [-a asyncDepth] / [-asyncDepth asyncDepth] - set async depth, default %d \n"), CAM_SAMPLE_ASYNC_DEPTH);
msdk_printf(MSDK_STRING(" [-b bitDepth] / [-bitDepth bitDepth] - set bit depth, default 10 \n"));
msdk_printf(MSDK_STRING(" [-f format] / [-format format] - input Bayer format: rggb, bggr, grbg or gbrg\n"));
msdk_printf(MSDK_STRING(" [-of format] / [-outFormat format] - output format: of argb16 or 16 meaning 16 bit ARGB, 8 bit ARGB otherwise\n"));
msdk_printf(MSDK_STRING(" [-3DLUT_gamma] - use 3D LUT gamma correction\n"));
msdk_printf(MSDK_STRING(" [-ng] / [-noGamma] - no gamma correction\n"));
msdk_printf(MSDK_STRING(" [-gamma_points] - set specific gamma points (64 points expected)\n"));
msdk_printf(MSDK_STRING(" [-gamma_corrected] - set specific gamma corrected values (64 values expected)\n"));
msdk_printf(MSDK_STRING(" -gamma_points and -gamma_corrected options must be used together\n"));
msdk_printf(MSDK_STRING(" [-bdn threshold] / [-bayerDenoise threshold] - bayer denoise on\n"));
msdk_printf(MSDK_STRING(" [-hot_pixel Diff Num] - bayer hot pixel removal\n"));
msdk_printf(MSDK_STRING(" [-bbl B G0 G1 R] / [-bayerBlackLevel B G0 G1 R] - bayer black level correction\n"));
msdk_printf(MSDK_STRING(" [-bwb B G0 G1 R] / [-bayerWhiteBalance B G0 G1 R] - bayer white balance\n"));
msdk_printf(MSDK_STRING(" [-ccm n00 n01 ... n33 ] - color correction 3x3 matrix\n"));
msdk_printf(MSDK_STRING(" [-vignette maskfile ] - enable vignette correction using mask from specified file\n"));
msdk_printf(MSDK_STRING(" [-lens a b c d ] - enable lens geometry distortion correction\n"));
msdk_printf(MSDK_STRING(" [-chroma_aberration aR bR cR dR aG bG cG dG aB bB cB dB ] - enable chroma aberration correction\n"));
msdk_printf(MSDK_STRING(" [-w width] / [-width width] - input width, default 4096\n"));
msdk_printf(MSDK_STRING(" [-h height] / [-height height] - input height, default 2160\n"));
msdk_printf(MSDK_STRING(" [-n numFrames] / [-numFramesToProcess numFrames] - number of frames to process\n"));
msdk_printf(MSDK_STRING(" [-alpha alpha] - write value to alpha channel of output surface \n"));
msdk_printf(MSDK_STRING(" [-pd] / [-padding] - do input surface padding \n"));
msdk_printf(MSDK_STRING(" [-resetInterval resetInterval] - reset interval in frames, default 7 \n"));
msdk_printf(MSDK_STRING(" [-reset -i ... -o ... -f ... -w ... -h ... -bbl ... -bwb ... -ccm ...] - params to be used after next reset.\n"));
msdk_printf(MSDK_STRING(" Only params listed above are supported, if a param is not set here, the originally set value is used. \n"));
msdk_printf(MSDK_STRING(" There can be any number of resets, applied in order of appearance in the command line, \n"));
msdk_printf(MSDK_STRING(" after resetInterval frames are processed with the current params \n"));
msdk_printf(MSDK_STRING(" [-imem] - input memory type (sys|video). Default is system\n"));
#if D3D_SURFACES_SUPPORT
msdk_printf(MSDK_STRING(" [-omem] - output memory type (sys|video). Default is system\n"));
msdk_printf(MSDK_STRING(" [-accel] - type of acceleration device (d3d9|d3d11). Default is d3d9\n"));
msdk_printf(MSDK_STRING(" [-r] / [-render] - render output in a separate window \n"));
msdk_printf(MSDK_STRING(" [-wall w h n m f t tmo] - same as -r, and positioned rendering window in a particular cell on specific monitor \n"));
msdk_printf(MSDK_STRING(" w - number of columns of video windows on selected monitor\n"));
msdk_printf(MSDK_STRING(" h - number of rows of video windows on selected monitor\n"));
msdk_printf(MSDK_STRING(" n(0,.,w*h-1) - order of video window in table that will be rendered\n"));
msdk_printf(MSDK_STRING(" m(0,1..) - monitor id \n"));
msdk_printf(MSDK_STRING(" f - rendering framerate\n"));
msdk_printf(MSDK_STRING(" t(0/1) - enable/disable window's title\n"));
msdk_printf(MSDK_STRING(" tmo - timeout for -wall option\n"));
#endif
#if defined(_WIN32) || defined(_WIN64)
msdk_printf(MSDK_STRING("\nFeatures: \n"));
msdk_printf(MSDK_STRING(" Press 1 to toggle fullscreen rendering on/off\n"));
#endif
msdk_printf(MSDK_STRING("\n"));
}
void PrintHelp(msdk_char *strAppName, const msdk_char *strErrorMessage)
{
msdk_printf(MSDK_STRING("Decoding Sample Version %s\n\n"), MSDK_SAMPLE_VERSION);
if (strErrorMessage)
{
msdk_printf(MSDK_STRING("Error: %s\n"), strErrorMessage);
}
msdk_printf(MSDK_STRING("Usage: %s <codecid> [<options>] -i InputBitstream\n"), strAppName);
msdk_printf(MSDK_STRING(" or: %s <codecid> [<options>] -i InputBitstream -r\n"), strAppName);
msdk_printf(MSDK_STRING(" or: %s <codecid> [<options>] -i InputBitstream -o OutputYUVFile\n"), strAppName);
msdk_printf(MSDK_STRING("\n"));
msdk_printf(MSDK_STRING("Supported codecs (<codecid>):\n"));
msdk_printf(MSDK_STRING(" <codecid>=h264|mpeg2|vc1|mvc|jpeg - built-in Media SDK codecs\n"));
msdk_printf(MSDK_STRING(" <codecid>=h265|capture - in-box Media SDK plugins (may require separate downloading and installation)\n"));
msdk_printf(MSDK_STRING("\n"));
msdk_printf(MSDK_STRING("Work models:\n"));
msdk_printf(MSDK_STRING(" 1. Performance model: decoding on MAX speed, no rendering, no YUV dumping (no -r or -o option)\n"));
msdk_printf(MSDK_STRING(" 2. Rendering model: decoding with rendering on the screen (-r option)\n"));
msdk_printf(MSDK_STRING(" 3. Dump model: decoding with YUV dumping (-o option)\n"));
msdk_printf(MSDK_STRING("\n"));
msdk_printf(MSDK_STRING("Options:\n"));
msdk_printf(MSDK_STRING(" [-hw] - use platform specific SDK implementation (default)\n"));
msdk_printf(MSDK_STRING(" [-sw] - use software implementation, if not specified platform specific SDK implementation is used\n"));
msdk_printf(MSDK_STRING(" [-p guid] - 32-character hexadecimal guid string\n"));
msdk_printf(MSDK_STRING(" [-path path] - path to plugin (valid only in pair with -p option)\n"));
msdk_printf(MSDK_STRING(" (optional for Media SDK in-box plugins, required for user-decoder ones)\n"));
msdk_printf(MSDK_STRING(" [-f] - rendering framerate\n"));
msdk_printf(MSDK_STRING(" [-w] - output width\n"));
msdk_printf(MSDK_STRING(" [-h] - output height\n"));
msdk_printf(MSDK_STRING(" [-di bob/adi] - enable deinterlacing BOB/ADI\n"));
msdk_printf(MSDK_STRING("\n"));
msdk_printf(MSDK_STRING("Output format parameters:\n"));
msdk_printf(MSDK_STRING(" [-i420] - by default\n"));
msdk_printf(MSDK_STRING(" [-rgb4]\n"));
msdk_printf(MSDK_STRING(" [-p010]\n"));
msdk_printf(MSDK_STRING(" [-a2rgb10]\n"));
msdk_printf(MSDK_STRING("\n"));
#if D3D_SURFACES_SUPPORT
msdk_printf(MSDK_STRING(" [-d3d] - work with d3d9 surfaces\n"));
msdk_printf(MSDK_STRING(" [-d3d11] - work with d3d11 surfaces\n"));
msdk_printf(MSDK_STRING(" [-r] - render decoded data in a separate window \n"));
msdk_printf(MSDK_STRING(" [-wall w h n m t tmo] - same as -r, and positioned rendering window in a particular cell on specific monitor \n"));
msdk_printf(MSDK_STRING(" w - number of columns of video windows on selected monitor\n"));
msdk_printf(MSDK_STRING(" h - number of rows of video windows on selected monitor\n"));
msdk_printf(MSDK_STRING(" n(0,.,w*h-1) - order of video window in table that will be rendered\n"));
msdk_printf(MSDK_STRING(" m(0,1..) - monitor id \n"));
msdk_printf(MSDK_STRING(" t(0/1) - enable/disable window's title\n"));
msdk_printf(MSDK_STRING(" tmo - timeout for -wall option\n"));
msdk_printf(MSDK_STRING("Screen capture parameters:\n"));
msdk_printf(MSDK_STRING(" [-scr:w] - screen resolution width\n"));
msdk_printf(MSDK_STRING(" [-scr:h] - screen resolution height\n"));
msdk_printf(MSDK_STRING("\n"));
#endif
#if defined(LIBVA_SUPPORT)
msdk_printf(MSDK_STRING(" [-vaapi] - work with vaapi surfaces\n"));
#endif
#if defined(LIBVA_X11_SUPPORT)
msdk_printf(MSDK_STRING(" [-r] - render decoded data in a separate X11 window \n"));
#endif
#if defined(LIBVA_WAYLAND_SUPPORT)
msdk_printf(MSDK_STRING(" [-rwld] - render decoded data in a Wayland window \n"));
msdk_printf(MSDK_STRING(" [-perf] - turn on asynchronous flipping for Wayland rendering \n"));
#endif
#if defined(LIBVA_DRM_SUPPORT)
msdk_printf(MSDK_STRING(" [-rdrm] - render decoded data in a thru DRM frame buffer\n"));
msdk_printf(MSDK_STRING(" [-window x y w h]\n"));
#endif
msdk_printf(MSDK_STRING(" [-low_latency] - configures decoder for low latency mode (supported only for H.264 and JPEG codec)\n"));
msdk_printf(MSDK_STRING(" [-calc_latency] - calculates latency during decoding and prints log (supported only for H.264 and JPEG codec)\n"));
msdk_printf(MSDK_STRING(" [-async] - depth of asynchronous pipeline. default value is 4. must be between 1 and 20\n"));
msdk_printf(MSDK_STRING(" [-no_gpu_copy] - disable GPU Copy functionality\n"));
#if !defined(_WIN32) && !defined(_WIN64)
msdk_printf(MSDK_STRING(" [-threads_num] - number of mediasdk task threads\n"));
msdk_printf(MSDK_STRING(" [-threads_schedtype] - scheduling type of mediasdk task threads\n"));
msdk_printf(MSDK_STRING(" [-threads_priority] - priority of mediasdk task threads\n"));
msdk_printf(MSDK_STRING("\n"));
msdk_thread_printf_scheduling_help();
#endif
#if defined(_WIN32) || defined(_WIN64)
msdk_printf(MSDK_STRING(" [-jpeg_rotate n] - rotate jpeg frame n degrees \n"));
msdk_printf(MSDK_STRING(" n(90,180,270) - number of degrees \n"));
msdk_printf(MSDK_STRING("\nFeatures: \n"));
msdk_printf(MSDK_STRING(" Press 1 to toggle fullscreen rendering on/off\n"));
#endif
msdk_printf(MSDK_STRING("\n"));
msdk_printf(MSDK_STRING("Example:\n"));
msdk_printf(MSDK_STRING(" %s h265 -i in.bit -o out.yuv -p 15dd936825ad475ea34e35f3f54217a6\n"), strAppName);
}
mfxStatus ParseInputString(msdk_char* strInput[], mfxU8 nArgNum, sInputParams* pParams)
{
if (1 == nArgNum)
{
PrintHelp(strInput[0], NULL);
return MFX_ERR_UNSUPPORTED;
}
MSDK_CHECK_POINTER(pParams, MFX_ERR_NULL_PTR);
// set default implementation
pParams->bUseHWLib = true;
#if defined(LIBVA_SUPPORT)
pParams->libvaBackend = MFX_LIBVA_DRM;
#endif
for (mfxU8 i = 1; i < nArgNum; i++)
{
if (MSDK_CHAR('-') != strInput[i][0])
{
mfxStatus sts = StrFormatToCodecFormatFourCC(strInput[i], pParams->videoType);
if (sts != MFX_ERR_NONE)
{
PrintHelp(strInput[0], MSDK_STRING("Unknown codec"));
return MFX_ERR_UNSUPPORTED;
}
if (!IsDecodeCodecSupported(pParams->videoType))
{
PrintHelp(strInput[0], MSDK_STRING("Unsupported codec"));
return MFX_ERR_UNSUPPORTED;
}
if (pParams->videoType == CODEC_MVC)
{
pParams->videoType = MFX_CODEC_AVC;
pParams->bIsMVC = true;
}
continue;
}
if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-sw")))
{
pParams->bUseHWLib = false;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-hw")))
{
pParams->bUseHWLib = true;
}
#if D3D_SURFACES_SUPPORT
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-d3d")))
{
pParams->memType = D3D9_MEMORY;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-d3d11")))
{
pParams->memType = D3D11_MEMORY;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-r")))
{
pParams->mode = MODE_RENDERING;
// use d3d9 rendering by default
if (SYSTEM_MEMORY == pParams->memType)
pParams->memType = D3D9_MEMORY;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-wall")))
{
if(i + 6 >= nArgNum)
{
PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -wall key"));
return MFX_ERR_UNSUPPORTED;
}
// use d3d9 rendering by default
if (SYSTEM_MEMORY == pParams->memType)
pParams->memType = D3D9_MEMORY;
pParams->mode = MODE_RENDERING;
msdk_opt_read(strInput[++i], pParams->nWallW);
msdk_opt_read(strInput[++i], pParams->nWallH);
msdk_opt_read(strInput[++i], pParams->nWallCell);
msdk_opt_read(strInput[++i], pParams->nWallMonitor);
mfxU32 nTitle;
msdk_opt_read(strInput[++i], nTitle);
pParams->bWallNoTitle = 0 == nTitle;
msdk_opt_read(strInput[++i], pParams->nWallTimeout);
}
#endif
#if defined(LIBVA_SUPPORT)
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-vaapi")))
{
pParams->memType = D3D9_MEMORY;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-r")))
{
pParams->memType = D3D9_MEMORY;
pParams->mode = MODE_RENDERING;
pParams->libvaBackend = MFX_LIBVA_X11;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-rwld")))
{
pParams->memType = D3D9_MEMORY;
pParams->mode = MODE_RENDERING;
pParams->libvaBackend = MFX_LIBVA_WAYLAND;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-perf")))
{
pParams->bPerfMode = true;
}
else if (0 == msdk_strncmp(strInput[i], MSDK_STRING("-rdrm"), 5))
{
pParams->memType = D3D9_MEMORY;
pParams->mode = MODE_RENDERING;
pParams->libvaBackend = MFX_LIBVA_DRM_MODESET;
if (strInput[i][5]) {
if (strInput[i][5] != '-') {
PrintHelp(strInput[0], MSDK_STRING("unsupported monitor type"));
return MFX_ERR_UNSUPPORTED;
}
pParams->monitorType = getMonitorType(&strInput[i][6]);
if (pParams->monitorType >= MFX_MONITOR_MAXNUMBER) {
PrintHelp(strInput[0], MSDK_STRING("unsupported monitor type"));
return MFX_ERR_UNSUPPORTED;
}
} else {
pParams->monitorType = MFX_MONITOR_AUTO; // that's case of "-rdrm" pure option
}
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-window")))
{
if(i +4 >= nArgNum)
{
PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -window key"));
return MFX_ERR_UNSUPPORTED;
}
msdk_opt_read(strInput[++i], pParams->nRenderWinX);
msdk_opt_read(strInput[++i], pParams->nRenderWinY);
msdk_opt_read(strInput[++i], pParams->Width);
msdk_opt_read(strInput[++i], pParams->Height);
if (0 == pParams->Width)
pParams->Width = 320;
if (0 == pParams->Height)
pParams->Height = 240;
pParams->bRenderWin = true;
}
#endif
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-low_latency")))
{
switch (pParams->videoType)
{
case MFX_CODEC_HEVC:
case MFX_CODEC_AVC:
case MFX_CODEC_JPEG:
{
pParams->bLowLat = true;
if (!pParams->bIsMVC)
break;
}
default:
{
PrintHelp(strInput[0], MSDK_STRING("-low_latency mode is suppoted only for H.264 and JPEG codecs"));
return MFX_ERR_UNSUPPORTED;
}
}
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-jpeg_rotate")))
{
if(MFX_CODEC_JPEG != pParams->videoType)
return MFX_ERR_UNSUPPORTED;
if(i + 1 >= nArgNum)
{
PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -jpeg_rotate key"));
return MFX_ERR_UNSUPPORTED;
}
msdk_opt_read(strInput[++i], pParams->nRotation);
if((pParams->nRotation != 90)&&(pParams->nRotation != 180)&&(pParams->nRotation != 270))
{
PrintHelp(strInput[0], MSDK_STRING("-jpeg_rotate is supported only for 90, 180 and 270 angles"));
return MFX_ERR_UNSUPPORTED;
}
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-calc_latency")))
{
switch (pParams->videoType)
{
case MFX_CODEC_HEVC:
case MFX_CODEC_AVC:
case MFX_CODEC_JPEG:
{
pParams->bCalLat = true;
if (!pParams->bIsMVC)
break;
}
default:
{
PrintHelp(strInput[0], MSDK_STRING("-calc_latency mode is suppoted only for H.264 and JPEG codecs"));
return MFX_ERR_UNSUPPORTED;
}
}
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-async")))
{
if(i + 1 >= nArgNum)
{
PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -async key"));
return MFX_ERR_UNSUPPORTED;
}
if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->nAsyncDepth))
{
PrintHelp(strInput[0], MSDK_STRING("async is invalid"));
return MFX_ERR_UNSUPPORTED;
}
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-di")))
{
if(i + 1 >= nArgNum)
{
PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -di key"));
return MFX_ERR_UNSUPPORTED;
}
msdk_char diMode[4] = {};
if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], diMode))
{
PrintHelp(strInput[0], MSDK_STRING("deinterlace value is not set"));
return MFX_ERR_UNSUPPORTED;
}
if (0 == msdk_strcmp(diMode, MSDK_CHAR("bob")))
{
pParams->eDeinterlace = MFX_DEINTERLACING_BOB;
}
else if (0 == msdk_strcmp(diMode, MSDK_CHAR("adi")))
{
pParams->eDeinterlace = MFX_DEINTERLACING_ADVANCED;
}
else
{
PrintHelp(strInput[0], MSDK_STRING("deinterlace value is invalid"));
return MFX_ERR_UNSUPPORTED;
}
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-no_gpu_copy")))
{
pParams->gpuCopy = MFX_GPUCOPY_OFF;
}
#if !defined(_WIN32) && !defined(_WIN64)
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-threads_num")))
{
if(i + 1 >= nArgNum)
{
PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -threads_num key"));
return MFX_ERR_UNSUPPORTED;
}
if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->nThreadsNum))
{
PrintHelp(strInput[0], MSDK_STRING("threads_num is invalid"));
return MFX_ERR_UNSUPPORTED;
}
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-threads_schedtype")))
{
if(i + 1 >= nArgNum)
{
PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -threads_schedtype key"));
return MFX_ERR_UNSUPPORTED;
}
if (MFX_ERR_NONE != msdk_thread_get_schedtype(strInput[++i], pParams->SchedulingType))
{
PrintHelp(strInput[0], MSDK_STRING("threads_schedtype is invalid"));
return MFX_ERR_UNSUPPORTED;
}
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-threads_priority")))
{
if(i + 1 >= nArgNum)
{
PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -threads_priority key"));
return MFX_ERR_UNSUPPORTED;
}
if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->Priority))
{
PrintHelp(strInput[0], MSDK_STRING("threads_priority is invalid"));
return MFX_ERR_UNSUPPORTED;
}
}
#endif // #if !defined(_WIN32) && !defined(_WIN64)
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-f")))
{
if(i + 1 >= nArgNum)
{
PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -f key"));
return MFX_ERR_UNSUPPORTED;
}
if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->nMaxFPS))
{
PrintHelp(strInput[0], MSDK_STRING("rendering frame rate is invalid"));
return MFX_ERR_UNSUPPORTED;
}
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-scr:w")))
{
if (i + 1 >= nArgNum)
{
PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -scr:w key"));
return MFX_ERR_UNSUPPORTED;
}
if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->scrWidth))
{
PrintHelp(strInput[0], MSDK_STRING("screen width rate is invalid"));
return MFX_ERR_UNSUPPORTED;
}
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-scr:h")))
{
if (i + 1 >= nArgNum)
{
PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -scr:h key"));
return MFX_ERR_UNSUPPORTED;
}
if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->scrHeight))
{
PrintHelp(strInput[0], MSDK_STRING("screen height is invalid"));
return MFX_ERR_UNSUPPORTED;
}
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-w")))
{
if (i + 1 >= nArgNum)
{
PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -w key"));
return MFX_ERR_UNSUPPORTED;
}
if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->Width))
{
PrintHelp(strInput[0], MSDK_STRING("width is invalid"));
return MFX_ERR_UNSUPPORTED;
}
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-h")))
{
if (i + 1 >= nArgNum)
{
PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -h key"));
return MFX_ERR_UNSUPPORTED;
}
if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->Height))
{
PrintHelp(strInput[0], MSDK_STRING("height is invalid"));
return MFX_ERR_UNSUPPORTED;
}
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-n")))
{
if(i + 1 >= nArgNum)
{
PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -n key"));
return MFX_ERR_UNSUPPORTED;
}
if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->nFrames))
{
PrintHelp(strInput[0], MSDK_STRING("rendering frame rate is invalid"));
return MFX_ERR_UNSUPPORTED;
}
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-i420")))
{
pParams->fourcc = MFX_FOURCC_NV12;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-rgb4")))
{
pParams->fourcc = MFX_FOURCC_RGB4;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-p010")))
{
pParams->fourcc = MFX_FOURCC_P010;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-a2rgb10")))
{
pParams->fourcc = MFX_FOURCC_A2RGB10;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-path")))
{
i++;
#if defined(_WIN32) || defined(_WIN64)
msdk_char wchar[MSDK_MAX_FILENAME_LEN];
msdk_opt_read(strInput[i], wchar);
std::wstring wstr(wchar);
std::string str(wstr.begin(), wstr.end());
strcpy_s(pParams->pluginParams.strPluginPath, str.c_str());
#else
msdk_opt_read(strInput[i], pParams->pluginParams.strPluginPath);
#endif
pParams->pluginParams.type = MFX_PLUGINLOAD_TYPE_FILE;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-i:null")))
{
;
}
else // 1-character options
{
switch (strInput[i][1])
{
case MSDK_CHAR('p'):
if (++i < nArgNum) {
if (MFX_ERR_NONE == ConvertStringToGuid(strInput[i], pParams->pluginParams.pluginGuid))
{
pParams->pluginParams.type = MFX_PLUGINLOAD_TYPE_GUID;
}
else
{
PrintHelp(strInput[0], MSDK_STRING("Unknown options"));
}
}
else {
msdk_printf(MSDK_STRING("error: option '-p' expects an argument\n"));
}
break;
case MSDK_CHAR('i'):
if (++i < nArgNum) {
msdk_opt_read(strInput[i], pParams->strSrcFile);
}
else {
msdk_printf(MSDK_STRING("error: option '-i' expects an argument\n"));
}
break;
case MSDK_CHAR('o'):
if (++i < nArgNum) {
pParams->mode = MODE_FILE_DUMP;
msdk_opt_read(strInput[i], pParams->strDstFile);
}
else {
msdk_printf(MSDK_STRING("error: option '-o' expects an argument\n"));
}
break;
case MSDK_CHAR('?'):
PrintHelp(strInput[0], NULL);
return MFX_ERR_UNSUPPORTED;
default:
{
std::basic_stringstream<msdk_char> stream;
stream << MSDK_STRING("Unknown option: ") << strInput[i];
PrintHelp(strInput[0], stream.str().c_str());
return MFX_ERR_UNSUPPORTED;
}
}
}
}
if (0 == msdk_strlen(pParams->strSrcFile) && MFX_CODEC_CAPTURE != pParams->videoType)
{
msdk_printf(MSDK_STRING("error: source file name not found"));
return MFX_ERR_UNSUPPORTED;
}
if (MFX_CODEC_CAPTURE == pParams->videoType)
{
if (!pParams->scrWidth || !pParams->scrHeight)
{
msdk_printf(MSDK_STRING("error: for screen capture, width and height must be specified manually (-w and -h)"));
return MFX_ERR_UNSUPPORTED;
}
}
else if (pParams->scrWidth || pParams->scrHeight)
{
msdk_printf(MSDK_STRING("error: width and height parameters are supported only by screen capture decoder"));
return MFX_ERR_UNSUPPORTED;
}
if ((pParams->mode == MODE_FILE_DUMP) && (0 == msdk_strlen(pParams->strDstFile)))
{
msdk_printf(MSDK_STRING("error: destination file name not found"));
return MFX_ERR_UNSUPPORTED;
}
if (MFX_CODEC_MPEG2 != pParams->videoType &&
MFX_CODEC_AVC != pParams->videoType &&
MFX_CODEC_HEVC != pParams->videoType &&
MFX_CODEC_VC1 != pParams->videoType &&
MFX_CODEC_JPEG != pParams->videoType &&
MFX_CODEC_CAPTURE != pParams->videoType &&
CODEC_VP8 != pParams->videoType)
{
PrintHelp(strInput[0], MSDK_STRING("Unknown codec"));
return MFX_ERR_UNSUPPORTED;
}
if (pParams->nAsyncDepth == 0)
{
pParams->nAsyncDepth = 4; //set by default;
}
return MFX_ERR_NONE;
}
int main(int argc, char *argv[])
#endif
{
sInputParams Params; // input parameters from command line
CCameraPipeline Pipeline; // pipeline for decoding, includes input file reader, decoder and output file writer
mfxStatus sts = MFX_ERR_NONE; // return value check
sts = ParseInputString(argv, (mfxU8)argc, &Params);
MSDK_CHECK_PARSE_RESULT(sts, MFX_ERR_NONE, 1);
sts = Pipeline.Init(&Params);
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, 1);
// print stream info
Pipeline.PrintInfo();
msdk_printf(MSDK_STRING("Camera pipe started\n"));
#if defined(_WIN32) || defined(_WIN64)
LARGE_INTEGER timeBegin, timeEnd, m_Freq;
QueryPerformanceFrequency(&m_Freq);
QueryPerformanceCounter(&timeBegin);
#endif
int resetNum = 0;
for (;;) {
sts = Pipeline.Run();
if (MFX_WRN_VIDEO_PARAM_CHANGED == sts) {
sInputParams *pParams = &Params;
if (resetNum >= (int)Params.resetParams.size())
break;
msdk_strcopy(Params.strSrcFile, Params.resetParams[resetNum].strSrcFile);
msdk_strcopy(pParams->strDstFile, Params.resetParams[resetNum].strDstFile);
pParams->frameInfo[VPP_IN].nWidth = (mfxU16)Params.resetParams[resetNum].width;
pParams->frameInfo[VPP_IN].nHeight = (mfxU16)Params.resetParams[resetNum].height;
pParams->frameInfo[VPP_IN].CropW = pParams->frameInfo[VPP_IN].nWidth;
if ( Params.resetParams[resetNum].cropW )
pParams->frameInfo[VPP_IN].CropW = Params.resetParams[resetNum].cropW;
pParams->frameInfo[VPP_IN].CropH = pParams->frameInfo[VPP_IN].nHeight;
if ( Params.resetParams[resetNum].cropH )
pParams->frameInfo[VPP_IN].CropH = Params.resetParams[resetNum].cropH;
pParams->frameInfo[VPP_IN].CropX = align(Params.resetParams[resetNum].cropX);
pParams->frameInfo[VPP_IN].CropY = Params.resetParams[resetNum].cropY;
if ( ! pParams->frameInfo[VPP_IN].CropW )
{
pParams->frameInfo[VPP_IN].CropW = pParams->frameInfo[VPP_IN].nWidth;
}
if ( ! pParams->frameInfo[VPP_IN].CropH )
{
pParams->frameInfo[VPP_IN].CropH = pParams->frameInfo[VPP_IN].nHeight;
}
pParams->frameInfo[VPP_OUT].nWidth = pParams->frameInfo[VPP_IN].CropW;
pParams->frameInfo[VPP_OUT].nHeight = pParams->frameInfo[VPP_IN].CropH;
pParams->frameInfo[VPP_OUT].CropW = pParams->frameInfo[VPP_IN].CropW;
pParams->frameInfo[VPP_OUT].CropH = pParams->frameInfo[VPP_IN].CropH;
pParams->bayerType = Params.resetParams[resetNum].bayerType;
pParams->bHP = Params.resetParams[resetNum].bHP;
pParams->hp_diff = Params.resetParams[resetNum].hp_diff;
pParams->hp_num = Params.resetParams[resetNum].hp_num;
pParams->bBayerDenoise = Params.resetParams[resetNum].bDenoise;
pParams->denoiseThreshold = Params.resetParams[resetNum].denoiseThreshold;
pParams->bBlackLevel = Params.resetParams[resetNum].bBlackLevel;
pParams->black_level_B = Params.resetParams[resetNum].black_level_B;
pParams->black_level_G0= Params.resetParams[resetNum].black_level_G0;
pParams->black_level_G1= Params.resetParams[resetNum].black_level_G1;
pParams->black_level_R = Params.resetParams[resetNum].black_level_R;
pParams->bWhiteBalance = Params.resetParams[resetNum].bWhiteBalance;
pParams->white_balance_B = Params.resetParams[resetNum].white_balance_B;
pParams->white_balance_G0= Params.resetParams[resetNum].white_balance_G0;
pParams->white_balance_G1= Params.resetParams[resetNum].white_balance_G1;
pParams->white_balance_R = Params.resetParams[resetNum].white_balance_R;
pParams->bCCM = Params.resetParams[resetNum].bCCM;
for (int k = 0; k < 3; k++)
for (int z = 0; z < 3; z++)
pParams->CCM[k][z] = Params.resetParams[resetNum].CCM[k][z];
//pParams->frameInfo[VPP_OUT].FourCC = MFX_FOURCC_ARGB16;
//pParams->memTypeIn = pParams->memTypeOut = SYSTEM_MEMORY;
sts = Pipeline.Reset(&Params);
if (sts == MFX_ERR_INCOMPATIBLE_VIDEO_PARAM)
{
Pipeline.Close();
sts = Pipeline.Init(&Params);
}
if (sts != MFX_ERR_NONE)
break;
resetNum++;
} else
break;
}
#if defined(_WIN32) || defined(_WIN64)
QueryPerformanceCounter(&timeEnd);
double time = ((double)timeEnd.QuadPart - (double)timeBegin.QuadPart)/ (double)m_Freq.QuadPart;
int frames = Pipeline.GetNumberProcessedFrames();
_tprintf(_T("Total frames %d \n"), frames);
_tprintf(_T("Total time %.2lf sec\n"), time);
_tprintf(_T("Total FPS %.2lf fps\n"), frames/time);
#endif
//Pipeline.Close();
if(MFX_ERR_ABORTED != sts)
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, 1);
msdk_printf(MSDK_STRING("\nCamera pipe finished\n"));
return 0;
}
void CParametersDumper::SerializeExtensionBuffer(msdk_ostream& sstr,msdk_string prefix,mfxExtBuffer* pExtBuffer)
{
char name[6]=" .";
MSDK_MEMCPY(name,&pExtBuffer->BufferId,4);
std::string strName(name);
prefix+=msdk_string(strName.begin(),strName.end());
// Serializing header
{
mfxExtBuffer& info = *pExtBuffer;
SERIALIZE_INFO(BufferId);
SERIALIZE_INFO(BufferSz);
}
// Serializing particular Ext buffer.
switch(pExtBuffer->BufferId)
{
case MFX_EXTBUFF_THREADS_PARAM:
{
mfxExtThreadsParam& info = *(mfxExtThreadsParam*)pExtBuffer;
SERIALIZE_INFO(NumThread);
SERIALIZE_INFO(SchedulingType);
SERIALIZE_INFO(Priority);
SERIALIZE_INFO_ARRAY(reserved);
}
break;
case MFX_EXTBUFF_JPEG_QT:
{
mfxExtJPEGQuantTables& info = *(mfxExtJPEGQuantTables*)pExtBuffer;
SERIALIZE_INFO_ARRAY(reserved);
SERIALIZE_INFO(NumTable);
SERIALIZE_INFO_ARRAY(Qm[4]);
}
break;
case MFX_EXTBUFF_JPEG_HUFFMAN:
{
mfxExtJPEGHuffmanTables& info = *(mfxExtJPEGHuffmanTables*)pExtBuffer;
SERIALIZE_INFO_ARRAY(reserved);
SERIALIZE_INFO(NumDCTable);
SERIALIZE_INFO(NumACTable);
START_PROC_ARRAY(DCTables)
SERIALIZE_INFO_ARRAY_ELEMENT(DCTables,Bits);
SERIALIZE_INFO_ARRAY_ELEMENT(DCTables,Values);
END_PROC_ARRAY
START_PROC_ARRAY(DCTables)
SERIALIZE_INFO_ARRAY_ELEMENT(ACTables,Bits);
SERIALIZE_INFO_ARRAY_ELEMENT(ACTables,Values);
END_PROC_ARRAY
}
break;
case MFX_EXTBUFF_LOOKAHEAD_CTRL:
{
mfxExtLAControl& info = *(mfxExtLAControl*)pExtBuffer;
SERIALIZE_INFO(LookAheadDepth);
SERIALIZE_INFO(DependencyDepth);
SERIALIZE_INFO(DownScaleFactor);
SERIALIZE_INFO(BPyramid);
SERIALIZE_INFO_ARRAY(reserved1);
SERIALIZE_INFO(NumOutStream);
START_PROC_ARRAY(OutStream)
SERIALIZE_INFO_ELEMENT(OutStream,Width);
SERIALIZE_INFO_ELEMENT(OutStream,Height);
SERIALIZE_INFO_ARRAY_ELEMENT(OutStream,reserved2);
END_PROC_ARRAY
}
break;
case MFX_EXTBUFF_LOOKAHEAD_STAT:
{
mfxExtLAFrameStatistics& info = *(mfxExtLAFrameStatistics*)pExtBuffer;
SERIALIZE_INFO_ARRAY(reserved);
SERIALIZE_INFO(NumStream);
SERIALIZE_INFO(NumFrame);
//DO_MANUALLY: mfxLAFrameInfo *FrameStat; //frame statistics
//DO_MANUALLY: mfxFrameSurface1 *OutSurface; //reordered surface
}
break;
case MFX_EXTBUFF_MVC_SEQ_DESC:
{
mfxExtMVCSeqDesc& info = *(mfxExtMVCSeqDesc*)pExtBuffer;
SERIALIZE_INFO(NumView);
SERIALIZE_INFO(NumViewAlloc);
//DO_MANUALLY: mfxMVCViewDependency *View;
SERIALIZE_INFO(NumViewId);
SERIALIZE_INFO(NumViewIdAlloc);
SERIALIZE_INFO_MEMORY(ViewId,NumViewId);
SERIALIZE_INFO(NumOP);
SERIALIZE_INFO(NumOPAlloc);
//DO_MANUALLY: mfxMVCOperationPoint *OP;
SERIALIZE_INFO(NumRefsTotal);
SERIALIZE_INFO_ARRAY(Reserved);
}
break;
case MFX_EXTBUFF_MVC_TARGET_VIEWS:
{
mfxExtMVCTargetViews & info = *(mfxExtMVCTargetViews *)pExtBuffer;
SERIALIZE_INFO(TemporalId);
SERIALIZE_INFO(NumView);
SERIALIZE_INFO_ARRAY(ViewId);
}
break;
case MFX_EXTBUFF_VPP_PICSTRUCT_DETECTION:
{
// No structure accociated with MFX_EXTBUFF_VPP_PICSTRUCT_DETECTION
}
break;
case MFX_EXTBUFF_CODING_OPTION:
{
mfxExtCodingOption& info = *(mfxExtCodingOption*)pExtBuffer;
SERIALIZE_INFO(reserved1);
SERIALIZE_INFO(RateDistortionOpt);
SERIALIZE_INFO(MECostType);
SERIALIZE_INFO(MESearchType);
SERIALIZE_INFO(MVSearchWindow.x);
SERIALIZE_INFO(MVSearchWindow.y);
SERIALIZE_INFO(EndOfSequence);
SERIALIZE_INFO(FramePicture);
SERIALIZE_INFO(CAVLC);
SERIALIZE_INFO_ARRAY(reserved2);
SERIALIZE_INFO(RecoveryPointSEI);
SERIALIZE_INFO(ViewOutput);
SERIALIZE_INFO(NalHrdConformance);
SERIALIZE_INFO(SingleSeiNalUnit);
SERIALIZE_INFO(VuiVclHrdParameters);
SERIALIZE_INFO(RefPicListReordering);
SERIALIZE_INFO(ResetRefList);
SERIALIZE_INFO(RefPicMarkRep);
SERIALIZE_INFO(FieldOutput);
SERIALIZE_INFO(IntraPredBlockSize);
SERIALIZE_INFO(InterPredBlockSize);
SERIALIZE_INFO(MVPrecision);
SERIALIZE_INFO(MaxDecFrameBuffering);
SERIALIZE_INFO(AUDelimiter);
SERIALIZE_INFO(EndOfStream);
SERIALIZE_INFO(PicTimingSEI);
SERIALIZE_INFO(VuiNalHrdParameters);
}
break;
case MFX_EXTBUFF_CODING_OPTION2:
{
mfxExtCodingOption2& info = *(mfxExtCodingOption2*)pExtBuffer;
SERIALIZE_INFO(IntRefType);
SERIALIZE_INFO(IntRefCycleSize);
SERIALIZE_INFO(IntRefQPDelta);
SERIALIZE_INFO(MaxFrameSize);
SERIALIZE_INFO(MaxSliceSize);
SERIALIZE_INFO(BitrateLimit);
SERIALIZE_INFO(MBBRC);
SERIALIZE_INFO(ExtBRC);
SERIALIZE_INFO(LookAheadDepth);
SERIALIZE_INFO(Trellis);
SERIALIZE_INFO(RepeatPPS);
SERIALIZE_INFO(BRefType);
SERIALIZE_INFO(AdaptiveI);
SERIALIZE_INFO(AdaptiveB);
SERIALIZE_INFO(LookAheadDS);
SERIALIZE_INFO(NumMbPerSlice);
SERIALIZE_INFO(SkipFrame);
SERIALIZE_INFO(MinQPI);
SERIALIZE_INFO(MaxQPI);
SERIALIZE_INFO(MinQPP);
SERIALIZE_INFO(MaxQPP);
SERIALIZE_INFO(MinQPB);
SERIALIZE_INFO(MaxQPB);
SERIALIZE_INFO(FixedFrameRate);
SERIALIZE_INFO(DisableDeblockingIdc);
SERIALIZE_INFO(DisableVUI);
SERIALIZE_INFO(BufferingPeriodSEI);
SERIALIZE_INFO(EnableMAD);
SERIALIZE_INFO(UseRawRef);
}
break;
case MFX_EXTBUFF_CODING_OPTION3:
{
mfxExtCodingOption3& info = *(mfxExtCodingOption3*)pExtBuffer;
SERIALIZE_INFO(NumSliceI);
SERIALIZE_INFO(NumSliceP);
SERIALIZE_INFO(NumSliceB);
SERIALIZE_INFO(WinBRCMaxAvgKbps);
SERIALIZE_INFO(WinBRCSize);
SERIALIZE_INFO(QVBRQuality);
SERIALIZE_INFO(EnableMBQP);
SERIALIZE_INFO(IntRefCycleDist);
SERIALIZE_INFO(DirectBiasAdjustment);
SERIALIZE_INFO(GlobalMotionBiasAdjustment);
SERIALIZE_INFO(MVCostScalingFactor);
SERIALIZE_INFO(MBDisableSkipMap);
SERIALIZE_INFO(WeightedPred);
SERIALIZE_INFO(WeightedBiPred);
SERIALIZE_INFO(AspectRatioInfoPresent);
SERIALIZE_INFO(OverscanInfoPresent);
SERIALIZE_INFO(OverscanAppropriate);
SERIALIZE_INFO(TimingInfoPresent);
SERIALIZE_INFO(BitstreamRestriction);
SERIALIZE_INFO(LowDelayHrd);
SERIALIZE_INFO(MotionVectorsOverPicBoundaries);
SERIALIZE_INFO(ScenarioInfo);
SERIALIZE_INFO(ContentInfo);
SERIALIZE_INFO(PRefType);
SERIALIZE_INFO(FadeDetection);
SERIALIZE_INFO(GPB);
SERIALIZE_INFO(MaxFrameSizeI);
SERIALIZE_INFO(MaxFrameSizeP);
SERIALIZE_INFO_ARRAY(reserved1);
SERIALIZE_INFO(EnableQPOffset);
SERIALIZE_INFO_ARRAY(QPOffset);
SERIALIZE_INFO_ARRAY(NumRefActiveP);
SERIALIZE_INFO_ARRAY(NumRefActiveBL0);
SERIALIZE_INFO_ARRAY(NumRefActiveBL1);
SERIALIZE_INFO(BRCPanicMode);
SERIALIZE_INFO_ARRAY(reserved);
}
break;
case MFX_EXTBUFF_VPP_DONOTUSE:
{
mfxExtVPPDoNotUse& info = *(mfxExtVPPDoNotUse*)pExtBuffer;
SERIALIZE_INFO(NumAlg);
SERIALIZE_INFO_MEMORY(AlgList,NumAlg);
}
break;
case MFX_EXTBUFF_VPP_DENOISE:
{
mfxExtVPPDenoise& info = *(mfxExtVPPDenoise*)pExtBuffer;
SERIALIZE_INFO(DenoiseFactor);
}
break;
case MFX_EXTBUFF_VPP_DETAIL:
{
mfxExtVPPDetail& info = *(mfxExtVPPDetail*)pExtBuffer;
SERIALIZE_INFO(DetailFactor);
}
break;
case MFX_EXTBUFF_VPP_PROCAMP:
{
mfxExtVPPProcAmp& info = *(mfxExtVPPProcAmp*)pExtBuffer;
SERIALIZE_INFO(Brightness);
SERIALIZE_INFO(Contrast);
SERIALIZE_INFO(Hue);
SERIALIZE_INFO(Saturation);
}
break;
case MFX_EXTBUFF_VPP_AUXDATA:
{
mfxExtVppAuxData& info = *(mfxExtVppAuxData*)pExtBuffer;
SERIALIZE_INFO(SpatialComplexity);
SERIALIZE_INFO(TemporalComplexity);
SERIALIZE_INFO(PicStruct);
SERIALIZE_INFO_ARRAY(reserved);
SERIALIZE_INFO(SceneChangeRate);
SERIALIZE_INFO(RepeatedFrame);
}
break;
case MFX_EXTBUFF_CODING_OPTION_SPSPPS:
{
mfxExtCodingOptionSPSPPS& info = *(mfxExtCodingOptionSPSPPS*)pExtBuffer;
SERIALIZE_INFO(SPSBuffer);
SERIALIZE_INFO(PPSBuffer);
SERIALIZE_INFO(SPSBufSize);
SERIALIZE_INFO(PPSBufSize);
SERIALIZE_INFO(SPSId);
SERIALIZE_INFO(PPSId);
}
break;
case MFX_EXTBUFF_CODING_OPTION_VPS:
{
mfxExtCodingOptionVPS& info = *(mfxExtCodingOptionVPS*)pExtBuffer;
SERIALIZE_INFO(VPSBuffer);
SERIALIZE_INFO(reserved1);
SERIALIZE_INFO(VPSBufSize);
SERIALIZE_INFO(VPSId);
SERIALIZE_INFO_ARRAY(reserved);
}
break;
case MFX_EXTBUFF_VPP_VIDEO_SIGNAL_INFO:
{
mfxExtVideoSignalInfo& info = *(mfxExtVideoSignalInfo*)pExtBuffer;
SERIALIZE_INFO(VideoFormat);
SERIALIZE_INFO(VideoFullRange);
SERIALIZE_INFO(ColourDescriptionPresent);
SERIALIZE_INFO(ColourPrimaries);
SERIALIZE_INFO(TransferCharacteristics);
SERIALIZE_INFO(MatrixCoefficients);
}
break;
case MFX_EXTBUFF_VPP_DOUSE:
{
mfxExtVPPDoUse& info = *(mfxExtVPPDoUse*)pExtBuffer;
SERIALIZE_INFO(NumAlg);
SERIALIZE_INFO(AlgList);
}
break;
case MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION:
{
mfxExtOpaqueSurfaceAlloc& info = *(mfxExtOpaqueSurfaceAlloc*)pExtBuffer;
SERIALIZE_INFO_ARRAY(reserved1);
SERIALIZE_INFO_ARRAY(In.reserved2);
SERIALIZE_INFO(In.Type);
SERIALIZE_INFO(In.NumSurface);
SERIALIZE_INFO_ARRAY(Out.reserved2);
SERIALIZE_INFO(Out.Type);
SERIALIZE_INFO(Out.NumSurface);
}
break;
case MFX_EXTBUFF_AVC_REFLIST_CTRL:
{
mfxExtAVCRefListCtrl& info = *(mfxExtAVCRefListCtrl*)pExtBuffer;
SERIALIZE_INFO(NumRefIdxL0Active);
SERIALIZE_INFO(NumRefIdxL1Active);
START_PROC_ARRAY(PreferredRefList)
SERIALIZE_INFO_ELEMENT(PreferredRefList,FrameOrder);
SERIALIZE_INFO_ELEMENT(PreferredRefList,PicStruct);
SERIALIZE_INFO_ELEMENT(PreferredRefList,ViewId);
SERIALIZE_INFO_ELEMENT(PreferredRefList,LongTermIdx);
SERIALIZE_INFO_ARRAY_ELEMENT(PreferredRefList,reserved);
END_PROC_ARRAY
START_PROC_ARRAY(RejectedRefList)
SERIALIZE_INFO_ELEMENT(RejectedRefList,FrameOrder);
SERIALIZE_INFO_ELEMENT(RejectedRefList,PicStruct);
SERIALIZE_INFO_ELEMENT(RejectedRefList,ViewId);
SERIALIZE_INFO_ELEMENT(RejectedRefList,LongTermIdx);
SERIALIZE_INFO_ARRAY_ELEMENT(RejectedRefList,reserved);
END_PROC_ARRAY
START_PROC_ARRAY(LongTermRefList)
SERIALIZE_INFO_ELEMENT(LongTermRefList,FrameOrder);
SERIALIZE_INFO_ELEMENT(LongTermRefList,PicStruct);
SERIALIZE_INFO_ELEMENT(LongTermRefList,ViewId);
SERIALIZE_INFO_ELEMENT(LongTermRefList,LongTermIdx);
SERIALIZE_INFO_ARRAY_ELEMENT(LongTermRefList,reserved);
END_PROC_ARRAY
SERIALIZE_INFO(ApplyLongTermIdx);
SERIALIZE_INFO_ARRAY(reserved);
}
break;
case MFX_EXTBUFF_VPP_FRAME_RATE_CONVERSION:
{
mfxExtVPPFrameRateConversion& info = *(mfxExtVPPFrameRateConversion*)pExtBuffer;
SERIALIZE_INFO(Algorithm);
SERIALIZE_INFO(reserved);
SERIALIZE_INFO_ARRAY(reserved2);
}
break;
case MFX_EXTBUFF_VPP_IMAGE_STABILIZATION:
{
mfxExtVPPImageStab& info = *(mfxExtVPPImageStab*)pExtBuffer;
SERIALIZE_INFO(Mode);
SERIALIZE_INFO_ARRAY(reserved);
}
break;
case MFX_EXTBUFF_PICTURE_TIMING_SEI:
{
mfxExtPictureTimingSEI& info = *(mfxExtPictureTimingSEI*)pExtBuffer;
SERIALIZE_INFO_ARRAY(reserved);
SERIALIZE_INFO(TimeStamp[0].ClockTimestampFlag);
SERIALIZE_INFO(TimeStamp[0].CtType);
SERIALIZE_INFO(TimeStamp[0].NuitFieldBasedFlag);
SERIALIZE_INFO(TimeStamp[0].CountingType);
SERIALIZE_INFO(TimeStamp[0].FullTimestampFlag);
SERIALIZE_INFO(TimeStamp[0].DiscontinuityFlag);
SERIALIZE_INFO(TimeStamp[0].CntDroppedFlag);
SERIALIZE_INFO(TimeStamp[0].NFrames);
SERIALIZE_INFO(TimeStamp[0].SecondsFlag);
SERIALIZE_INFO(TimeStamp[0].MinutesFlag);
SERIALIZE_INFO(TimeStamp[0].HoursFlag);
SERIALIZE_INFO(TimeStamp[0].SecondsValue);
SERIALIZE_INFO(TimeStamp[0].MinutesValue);
SERIALIZE_INFO(TimeStamp[0].HoursValue);
SERIALIZE_INFO(TimeStamp[0].TimeOffset);
SERIALIZE_INFO(TimeStamp[1].ClockTimestampFlag);
SERIALIZE_INFO(TimeStamp[1].CtType);
SERIALIZE_INFO(TimeStamp[1].NuitFieldBasedFlag);
SERIALIZE_INFO(TimeStamp[1].CountingType);
SERIALIZE_INFO(TimeStamp[1].FullTimestampFlag);
SERIALIZE_INFO(TimeStamp[1].DiscontinuityFlag);
SERIALIZE_INFO(TimeStamp[1].CntDroppedFlag);
SERIALIZE_INFO(TimeStamp[1].NFrames);
SERIALIZE_INFO(TimeStamp[1].SecondsFlag);
SERIALIZE_INFO(TimeStamp[1].MinutesFlag);
SERIALIZE_INFO(TimeStamp[1].HoursFlag);
SERIALIZE_INFO(TimeStamp[1].SecondsValue);
SERIALIZE_INFO(TimeStamp[1].MinutesValue);
SERIALIZE_INFO(TimeStamp[1].HoursValue);
SERIALIZE_INFO(TimeStamp[1].TimeOffset);
SERIALIZE_INFO(TimeStamp[2].ClockTimestampFlag);
SERIALIZE_INFO(TimeStamp[2].CtType);
SERIALIZE_INFO(TimeStamp[2].NuitFieldBasedFlag);
SERIALIZE_INFO(TimeStamp[2].CountingType);
SERIALIZE_INFO(TimeStamp[2].FullTimestampFlag);
SERIALIZE_INFO(TimeStamp[2].DiscontinuityFlag);
SERIALIZE_INFO(TimeStamp[2].CntDroppedFlag);
SERIALIZE_INFO(TimeStamp[2].NFrames);
SERIALIZE_INFO(TimeStamp[2].SecondsFlag);
SERIALIZE_INFO(TimeStamp[2].MinutesFlag);
SERIALIZE_INFO(TimeStamp[2].HoursFlag);
SERIALIZE_INFO(TimeStamp[2].SecondsValue);
SERIALIZE_INFO(TimeStamp[2].MinutesValue);
SERIALIZE_INFO(TimeStamp[2].HoursValue);
SERIALIZE_INFO(TimeStamp[2].TimeOffset);
}
break;
case MFX_EXTBUFF_AVC_TEMPORAL_LAYERS:
{
mfxExtAvcTemporalLayers& info = *(mfxExtAvcTemporalLayers*)pExtBuffer;
SERIALIZE_INFO_ARRAY(reserved1);
SERIALIZE_INFO(reserved2);
SERIALIZE_INFO(BaseLayerPID);
SERIALIZE_INFO(Layer[0].Scale);
SERIALIZE_INFO_ARRAY(Layer[0].reserved);
SERIALIZE_INFO(Layer[1].Scale);
SERIALIZE_INFO_ARRAY(Layer[1].reserved);
SERIALIZE_INFO(Layer[2].Scale);
SERIALIZE_INFO_ARRAY(Layer[2].reserved);
SERIALIZE_INFO(Layer[3].Scale);
SERIALIZE_INFO_ARRAY(Layer[3].reserved);
SERIALIZE_INFO(Layer[4].Scale);
SERIALIZE_INFO_ARRAY(Layer[4].reserved);
SERIALIZE_INFO(Layer[5].Scale);
SERIALIZE_INFO_ARRAY(Layer[5].reserved);
SERIALIZE_INFO(Layer[6].Scale);
SERIALIZE_INFO_ARRAY(Layer[6].reserved);
SERIALIZE_INFO(Layer[7].Scale);
SERIALIZE_INFO_ARRAY(Layer[7].reserved);
}
break;
case MFX_EXTBUFF_ENCODER_CAPABILITY:
{
mfxExtEncoderCapability& info = *(mfxExtEncoderCapability*)pExtBuffer;
SERIALIZE_INFO(MBPerSec);
SERIALIZE_INFO_ARRAY(reserved);
}
break;
case MFX_EXTBUFF_ENCODER_RESET_OPTION:
{
mfxExtEncoderResetOption& info = *(mfxExtEncoderResetOption*)pExtBuffer;
SERIALIZE_INFO(StartNewSequence);
SERIALIZE_INFO_ARRAY(reserved);
}
break;
case MFX_EXTBUFF_ENCODED_FRAME_INFO:
{
mfxExtAVCEncodedFrameInfo& info = *(mfxExtAVCEncodedFrameInfo*)pExtBuffer;
SERIALIZE_INFO(FrameOrder);
SERIALIZE_INFO(PicStruct);
SERIALIZE_INFO(LongTermIdx);
SERIALIZE_INFO(MAD);
SERIALIZE_INFO(BRCPanicMode);
SERIALIZE_INFO(QP);
SERIALIZE_INFO(SecondFieldOffset);
SERIALIZE_INFO_ARRAY(reserved);
SERIALIZE_INFO(FrameOrder);
SERIALIZE_INFO(PicStruct);
SERIALIZE_INFO(LongTermIdx);
SERIALIZE_INFO_ARRAY(reserved);
}
break;
case MFX_EXTBUFF_VPP_COMPOSITE:
{
mfxExtVPPComposite& info = *(mfxExtVPPComposite*)pExtBuffer;
SERIALIZE_INFO(Y);
SERIALIZE_INFO(R);
SERIALIZE_INFO(U);
SERIALIZE_INFO(G);
SERIALIZE_INFO(V);
SERIALIZE_INFO(B);
SERIALIZE_INFO_ARRAY(reserved1);
SERIALIZE_INFO(NumInputStream);
for(int i=0;i<info.NumInputStream;i++)
{
msdk_char streamName[32];
msdk_sprintf(streamName,MSDK_STRING("InputStream[%d]."),i);
SerializeVPPCompInputStream(sstr,prefix+streamName,info.InputStream[i]);
}
}
break;
case MFX_EXTBUFF_VIDEO_SIGNAL_INFO:
{
mfxExtVPPVideoSignalInfo& info = *(mfxExtVPPVideoSignalInfo*)pExtBuffer;
SERIALIZE_INFO_ARRAY(reserved1);
SERIALIZE_INFO(In.TransferMatrix);
SERIALIZE_INFO(In.NominalRange);
SERIALIZE_INFO_ARRAY(In.reserved2);
SERIALIZE_INFO(Out.TransferMatrix);
SERIALIZE_INFO(Out.NominalRange);
SERIALIZE_INFO_ARRAY(Out.reserved2);
SERIALIZE_INFO(TransferMatrix);
SERIALIZE_INFO(NominalRange);
SERIALIZE_INFO_ARRAY(reserved3);
}
break;
case MFX_EXTBUFF_ENCODER_ROI:
{
mfxExtEncoderROI& info = *(mfxExtEncoderROI*)pExtBuffer;
SERIALIZE_INFO(NumROI);
#if _MSDK_API >= MSDK_API(1,22)
SERIALIZE_INFO(ROIMode);
#endif //_MSDK_API >= MSDK_API(1,22)
SERIALIZE_INFO_ARRAY(reserved1);
START_PROC_ARRAY_SIZE(ROI,NumROI)
SERIALIZE_INFO_ELEMENT(ROI,Left);
SERIALIZE_INFO_ELEMENT(ROI,Top);
SERIALIZE_INFO_ELEMENT(ROI,Right);
SERIALIZE_INFO_ELEMENT(ROI,Bottom);
SERIALIZE_INFO_ELEMENT(ROI,Priority);
#if _MSDK_API >= MSDK_API(1,22)
SERIALIZE_INFO_ELEMENT(ROI,DeltaQP);
#endif //_MSDK_API >= MSDK_API(1,22)
SERIALIZE_INFO_ARRAY_ELEMENT(ROI,reserved2);
END_PROC_ARRAY
}
break;
case MFX_EXTBUFF_VPP_DEINTERLACING:
{
mfxExtVPPDeinterlacing& info = *(mfxExtVPPDeinterlacing*)pExtBuffer;
SERIALIZE_INFO(Mode);
SERIALIZE_INFO(TelecinePattern);
SERIALIZE_INFO(TelecineLocation);
SERIALIZE_INFO_ARRAY(reserved);
}
break;
case MFX_EXTBUFF_AVC_REFLISTS:
{
mfxExtAVCRefLists& info = *(mfxExtAVCRefLists*)pExtBuffer;
SERIALIZE_INFO(NumRefIdxL0Active);
SERIALIZE_INFO(NumRefIdxL1Active);
SERIALIZE_INFO_ARRAY(reserved);
START_PROC_ARRAY(RefPicList0)
SERIALIZE_INFO_ELEMENT(RefPicList0,FrameOrder);
SERIALIZE_INFO_ELEMENT(RefPicList0,PicStruct);
SERIALIZE_INFO_ELEMENT(RefPicList0,reserved);
END_PROC_ARRAY
START_PROC_ARRAY(RefPicList1)
SERIALIZE_INFO_ELEMENT(RefPicList1,FrameOrder);
SERIALIZE_INFO_ELEMENT(RefPicList1,PicStruct);
SERIALIZE_INFO_ELEMENT(RefPicList1,reserved);
END_PROC_ARRAY
}
break;
case MFX_EXTBUFF_VPP_FIELD_PROCESSING:
{
mfxExtVPPFieldProcessing& info = *(mfxExtVPPFieldProcessing*)pExtBuffer;
SERIALIZE_INFO(Mode);
SERIALIZE_INFO(InField);
SERIALIZE_INFO(OutField);
SERIALIZE_INFO_ARRAY(reserved);
}
break;
#if _MSDK_API >= MSDK_API(1,22)
case MFX_EXTBUFF_DEC_VIDEO_PROCESSING:
{
mfxExtDecVideoProcessing& info = *(mfxExtDecVideoProcessing*)pExtBuffer;
SERIALIZE_INFO(In.CropX);
SERIALIZE_INFO(In.CropY);
SERIALIZE_INFO(In.CropW);
SERIALIZE_INFO(In.CropH);
SERIALIZE_INFO_ARRAY(In.reserved);
SERIALIZE_INFO(Out.FourCC);
SERIALIZE_INFO(Out.ChromaFormat);
SERIALIZE_INFO(Out.Width);
SERIALIZE_INFO(Out.Height);
SERIALIZE_INFO(Out.CropX);
SERIALIZE_INFO(Out.CropY);
SERIALIZE_INFO(Out.CropW);
SERIALIZE_INFO(Out.CropH);
SERIALIZE_INFO_ARRAY(Out.reserved);
}
break;
#endif //_MSDK_API >= MSDK_API(1,22)
case MFX_EXTBUFF_CHROMA_LOC_INFO:
{
mfxExtChromaLocInfo& info = *(mfxExtChromaLocInfo*)pExtBuffer;
SERIALIZE_INFO(ChromaLocInfoPresentFlag);
SERIALIZE_INFO(ChromaSampleLocTypeTopField);
SERIALIZE_INFO(ChromaSampleLocTypeBottomField);
SERIALIZE_INFO_ARRAY(reserved);
}
break;
case MFX_EXTBUFF_MBQP:
{
mfxExtMBQP& info = *(mfxExtMBQP*)pExtBuffer;
SERIALIZE_INFO_ARRAY(reserved);
SERIALIZE_INFO(NumQPAlloc);
SERIALIZE_INFO_MEMORY(QP,NumQPAlloc);
SERIALIZE_INFO(reserved2);
}
break;
case MFX_EXTBUFF_HEVC_TILES:
{
mfxExtHEVCTiles& info = *(mfxExtHEVCTiles*)pExtBuffer;
SERIALIZE_INFO(NumTileRows);
SERIALIZE_INFO(NumTileColumns);
SERIALIZE_INFO_ARRAY(reserved);
}
break;
case MFX_EXTBUFF_MB_DISABLE_SKIP_MAP:
{
mfxExtMBDisableSkipMap& info = *(mfxExtMBDisableSkipMap*)pExtBuffer;
SERIALIZE_INFO_ARRAY(reserved);
SERIALIZE_INFO(MapSize);
SERIALIZE_INFO_MEMORY(Map,MapSize);
SERIALIZE_INFO(reserved2);
}
break;
case MFX_EXTBUFF_HEVC_PARAM:
{
mfxExtHEVCParam& info = *(mfxExtHEVCParam*)pExtBuffer;
SERIALIZE_INFO(PicWidthInLumaSamples);
SERIALIZE_INFO(PicHeightInLumaSamples);
SERIALIZE_INFO(GeneralConstraintFlags);
SERIALIZE_INFO_ARRAY(reserved);
}
break;
case MFX_EXTBUFF_DECODED_FRAME_INFO:
{
mfxExtDecodedFrameInfo& info = *(mfxExtDecodedFrameInfo*)pExtBuffer;
SERIALIZE_INFO(FrameType);
SERIALIZE_INFO_ARRAY(reserved);
}
break;
case MFX_EXTBUFF_TIME_CODE:
{
mfxExtTimeCode& info = *(mfxExtTimeCode*)pExtBuffer;
SERIALIZE_INFO(DropFrameFlag);
SERIALIZE_INFO(TimeCodeHours);
SERIALIZE_INFO(TimeCodeMinutes);
SERIALIZE_INFO(TimeCodeSeconds);
SERIALIZE_INFO(TimeCodePictures);
SERIALIZE_INFO_ARRAY(reserved);
}
break;
case MFX_EXTBUFF_HEVC_REGION:
{
mfxExtHEVCRegion& info = *(mfxExtHEVCRegion*)pExtBuffer;
SERIALIZE_INFO(RegionId);
SERIALIZE_INFO(RegionType);
SERIALIZE_INFO(RegionEncoding);
SERIALIZE_INFO_ARRAY(reserved);
}
break;
case MFX_EXTBUFF_PRED_WEIGHT_TABLE:
{
mfxExtPredWeightTable& info = *(mfxExtPredWeightTable*)pExtBuffer;
SERIALIZE_INFO(LumaLog2WeightDenom);
SERIALIZE_INFO(ChromaLog2WeightDenom);
SERIALIZE_INFO_ARRAY(LumaWeightFlag[0]);
SERIALIZE_INFO_ARRAY(LumaWeightFlag[1]);
SERIALIZE_INFO_ARRAY(ChromaWeightFlag[0]);
SERIALIZE_INFO_ARRAY(ChromaWeightFlag[1]);
//DO_MANUALLY: Weights[2][32][3][2];
SERIALIZE_INFO_ARRAY(reserved);
}
break;
case MFX_EXTBUFF_DIRTY_RECTANGLES:
{
mfxExtDirtyRect& info = *(mfxExtDirtyRect*)pExtBuffer;
SERIALIZE_INFO(NumRect);
SERIALIZE_INFO_ARRAY(reserved1);
START_PROC_ARRAY_SIZE(Rect,NumRect)
SERIALIZE_INFO_ELEMENT(Rect,Left);
SERIALIZE_INFO_ELEMENT(Rect,Top);
SERIALIZE_INFO_ELEMENT(Rect,Right);
SERIALIZE_INFO_ELEMENT(Rect,Bottom);
SERIALIZE_INFO_ARRAY_ELEMENT(Rect,reserved2);
END_PROC_ARRAY
}
break;
case MFX_EXTBUFF_MOVING_RECTANGLES:
{
mfxExtMoveRect& info = *(mfxExtMoveRect*)pExtBuffer;
SERIALIZE_INFO(NumRect);
SERIALIZE_INFO_ARRAY(reserved1);
START_PROC_ARRAY_SIZE(Rect,NumRect)
SERIALIZE_INFO_ELEMENT(Rect,DestLeft);
SERIALIZE_INFO_ELEMENT(Rect,DestTop);
SERIALIZE_INFO_ELEMENT(Rect,DestRight);
SERIALIZE_INFO_ELEMENT(Rect,DestBottom);
SERIALIZE_INFO_ELEMENT(Rect,SourceLeft);
SERIALIZE_INFO_ELEMENT(Rect,SourceTop);
SERIALIZE_INFO_ARRAY_ELEMENT(Rect,reserved2);
END_PROC_ARRAY
}
break;
case MFX_EXTBUFF_VPP_ROTATION:
{
mfxExtVPPRotation& info = *(mfxExtVPPRotation*)pExtBuffer;
SERIALIZE_INFO(Angle);
SERIALIZE_INFO_ARRAY(reserved);
}
break;
case MFX_EXTBUFF_ENCODED_SLICES_INFO:
{
mfxExtEncodedSlicesInfo& info = *(mfxExtEncodedSlicesInfo*)pExtBuffer;
SERIALIZE_INFO(SliceSizeOverflow);
SERIALIZE_INFO(NumSliceNonCopliant);
SERIALIZE_INFO(NumEncodedSlice);
SERIALIZE_INFO(NumSliceSizeAlloc);
SERIALIZE_INFO_MEMORY(SliceSize,NumSliceSizeAlloc);
SERIALIZE_INFO(reserved1);
SERIALIZE_INFO_ARRAY(reserved);
}
break;
case MFX_EXTBUFF_VPP_SCALING:
{
mfxExtVPPScaling& info = *(mfxExtVPPScaling*)pExtBuffer;
SERIALIZE_INFO(ScalingMode);
SERIALIZE_INFO_ARRAY(reserved);
}
break;
case MFX_EXTBUFF_VPP_MIRRORING:
{
mfxExtVPPMirroring& info = *(mfxExtVPPMirroring*)pExtBuffer;
SERIALIZE_INFO(Type);
SERIALIZE_INFO_ARRAY(reserved);
}
break;
case MFX_EXTBUFF_MV_OVER_PIC_BOUNDARIES:
{
mfxExtMVOverPicBoundaries& info = *(mfxExtMVOverPicBoundaries*)pExtBuffer;
SERIALIZE_INFO(StickTop);
SERIALIZE_INFO(StickBottom);
SERIALIZE_INFO(StickLeft);
SERIALIZE_INFO(StickRight);
SERIALIZE_INFO_ARRAY(reserved);
}
break;
case MFX_EXTBUFF_VPP_COLORFILL:
{
mfxExtVPPColorFill& info = *(mfxExtVPPColorFill*)pExtBuffer;
SERIALIZE_INFO(Enable);
SERIALIZE_INFO_ARRAY(reserved);
}
break;
case MFX_EXTBUFF_VP8_CODING_OPTION:
{
mfxExtVP8CodingOption& info = *(mfxExtVP8CodingOption*)pExtBuffer;
SERIALIZE_INFO(Version);
SERIALIZE_INFO(EnableMultipleSegments);
SERIALIZE_INFO(LoopFilterType);
SERIALIZE_INFO_ARRAY(LoopFilterLevel);
SERIALIZE_INFO(SharpnessLevel);
SERIALIZE_INFO(NumTokenPartitions);
SERIALIZE_INFO_ARRAY(LoopFilterRefTypeDelta);
SERIALIZE_INFO_ARRAY(LoopFilterMbModeDelta);
SERIALIZE_INFO_ARRAY(SegmentQPDelta);
SERIALIZE_INFO_ARRAY(CoeffTypeQPDelta);
SERIALIZE_INFO(WriteIVFHeaders);
SERIALIZE_INFO(NumFramesForIVFHeader);
SERIALIZE_INFO_ARRAY(reserved);
}
break;
}
// End of autogenerated code
}
void CParametersDumper::SerializeMfxInfoMFXStruct(msdk_ostream& sstr,msdk_string prefix,mfxInfoMFX& info)
{
SERIALIZE_INFO_ARRAY(reserved);
SERIALIZE_INFO(LowPower);
SERIALIZE_INFO(BRCParamMultiplier);
SerializeFrameInfoStruct(sstr,prefix+MSDK_STRING("FrameInfo."),info.FrameInfo);
SERIALIZE_INFO(CodecId);
char strID[5]={};
MSDK_MEMCPY(strID,&info.CodecId,4);
sstr<<prefix<<"CodecID(string)"<<":"<<strID<<std::endl;
SERIALIZE_INFO(CodecProfile);
SERIALIZE_INFO(CodecLevel);
SERIALIZE_INFO(NumThread);
SERIALIZE_INFO(TargetUsage);
SERIALIZE_INFO(GopPicSize);
SERIALIZE_INFO(GopRefDist);
SERIALIZE_INFO(GopOptFlag);
SERIALIZE_INFO(IdrInterval);
SERIALIZE_INFO(RateControlMethod);
SERIALIZE_INFO(InitialDelayInKB);
SERIALIZE_INFO(QPI);
SERIALIZE_INFO(Accuracy);
SERIALIZE_INFO(BufferSizeInKB);
SERIALIZE_INFO(TargetKbps);
SERIALIZE_INFO(QPP);
SERIALIZE_INFO(ICQQuality);
SERIALIZE_INFO(MaxKbps);
SERIALIZE_INFO(QPB);
SERIALIZE_INFO(Convergence);
SERIALIZE_INFO(NumSlice);
SERIALIZE_INFO(NumRefFrame);
SERIALIZE_INFO(EncodedOrder);
/* Decoding Options */
SERIALIZE_INFO(DecodedOrder);
SERIALIZE_INFO(ExtendedPicStruct);
SERIALIZE_INFO(TimeStampCalc);
SERIALIZE_INFO(SliceGroupsPresent);
SERIALIZE_INFO(MaxDecFrameBuffering);
SERIALIZE_INFO(EnableReallocRequest);
/* JPEG Decoding Options */
SERIALIZE_INFO(JPEGChromaFormat);
SERIALIZE_INFO(Rotation);
SERIALIZE_INFO(JPEGColorFormat);
SERIALIZE_INFO(InterleavedDec);
SERIALIZE_INFO_ARRAY(SamplingFactorH);
SERIALIZE_INFO_ARRAY(SamplingFactorV);
/* JPEG Encoding Options */
SERIALIZE_INFO(Interleaved);
SERIALIZE_INFO(Quality);
SERIALIZE_INFO(RestartInterval);
}
mfxStatus ParseInputString(msdk_char* strInput[], mfxU8 nArgNum, sInputParams* pParams)
{
if (1 == nArgNum)
{
PrintHelp(strInput[0], NULL);
return MFX_ERR_UNSUPPORTED;
}
sResetParams resPar;
MSDK_CHECK_POINTER(pParams, MFX_ERR_NULL_PTR);
for (mfxU8 i = 1; i < nArgNum; i++)
{
// multi-character options
if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-plugin_version")))
{
msdk_opt_read(strInput[++i], pParams->CameraPluginVersion);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-accel")))
{
if(i + 1 >= nArgNum)
{
PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -accel key"));
return MFX_ERR_UNSUPPORTED;
}
if (0 == msdk_strcmp(strInput[i+1], MSDK_STRING("d3d9")))
{
pParams->accelType = D3D9;
}
else if (0 == msdk_strcmp(strInput[i+1], MSDK_STRING("d3d11")))
{
pParams->accelType = D3D11;
}
else
{
PrintHelp(strInput[0], MSDK_STRING("Unsupported value for -accel key"));
return MFX_ERR_UNSUPPORTED;
}
i++;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-imem")))
{
if(i + 1 >= nArgNum)
{
PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -imem key"));
return MFX_ERR_UNSUPPORTED;
}
if (0 == msdk_strcmp(strInput[i+1], MSDK_STRING("system")))
{
pParams->memTypeIn = SYSTEM;
}
else if (0 == msdk_strcmp(strInput[i+1], MSDK_STRING("video")))
{
pParams->memTypeIn = VIDEO;
}
else
{
PrintHelp(strInput[0], MSDK_STRING("Unsupported value for -imem key"));
return MFX_ERR_UNSUPPORTED;
}
i++;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-omem")))
{
if(i + 1 >= nArgNum)
{
PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -omem key"));
return MFX_ERR_UNSUPPORTED;
}
if (0 == msdk_strcmp(strInput[i+1], MSDK_STRING("system")))
{
pParams->memTypeOut = SYSTEM;
}
else if (0 == msdk_strcmp(strInput[i+1], MSDK_STRING("video")))
{
pParams->memTypeOut = VIDEO;
}
else
{
PrintHelp(strInput[0], MSDK_STRING("Unsupported value for -omem key"));
return MFX_ERR_UNSUPPORTED;
}
i++;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-r")) || 0 == msdk_strcmp(strInput[i], MSDK_STRING("-render")))
{
pParams->bRendering = true;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-a")) || 0 == msdk_strcmp(strInput[i], MSDK_STRING("-asyncDepth")))
{
msdk_opt_read(strInput[++i], pParams->asyncDepth);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-n")) || 0 == msdk_strcmp(strInput[i], MSDK_STRING("-numFramesToProcess")))
{
msdk_opt_read(strInput[++i], pParams->nFramesToProceed);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-ng")) || 0 == msdk_strcmp(strInput[i], MSDK_STRING("-noGamma")))
{
pParams->bGamma = false;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-3DLUT_gamma")))
{
pParams->b3DLUTGamma = false;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-bdn")) || 0 == msdk_strcmp(strInput[i], MSDK_STRING("-bayerDenoise")))
{
if(i + 1 >= nArgNum)
{
PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -bdn key"));
return MFX_ERR_UNSUPPORTED;
}
pParams->bBayerDenoise = true;
msdk_opt_read(strInput[++i], pParams->denoiseThreshold);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-bbl")) || 0 == msdk_strcmp(strInput[i], MSDK_STRING("-bayerBlackLevel")))
{
if(i + 4 >= nArgNum)
{
PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -bbl key"));
return MFX_ERR_UNSUPPORTED;
}
pParams->bBlackLevel = true;
msdk_opt_read(strInput[++i], pParams->black_level_B);
msdk_opt_read(strInput[++i], pParams->black_level_G0);
msdk_opt_read(strInput[++i], pParams->black_level_G1);
msdk_opt_read(strInput[++i], pParams->black_level_R);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-hot_pixel")))
{
if(i + 2 >= nArgNum)
{
PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -hot_pixel key"));
return MFX_ERR_UNSUPPORTED;
}
pParams->bHP = true;
msdk_opt_read(strInput[++i], pParams->hp_diff);
msdk_opt_read(strInput[++i], pParams->hp_num);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-bwb")) || 0 == msdk_strcmp(strInput[i], MSDK_STRING("-bayerWhiteBalance")))
{
if(i + 4 >= nArgNum)
{
PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -bwb key"));
return MFX_ERR_UNSUPPORTED;
}
pParams->bWhiteBalance = true;
msdk_opt_read(strInput[++i], pParams->white_balance_B);
msdk_opt_read(strInput[++i], pParams->white_balance_G0);
msdk_opt_read(strInput[++i], pParams->white_balance_G1);
msdk_opt_read(strInput[++i], pParams->white_balance_R);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-lens")) )
{
if(i + 4 >= nArgNum)
{
PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -lens key"));
return MFX_ERR_UNSUPPORTED;
}
pParams->bLens = true;
msdk_opt_read(strInput[++i], pParams->lens_aR);
msdk_opt_read(strInput[++i], pParams->lens_bR);
msdk_opt_read(strInput[++i], pParams->lens_cR);
msdk_opt_read(strInput[++i], pParams->lens_dR);
pParams->lens_aB = pParams->lens_aG = pParams->lens_aR;
pParams->lens_bB = pParams->lens_bG = pParams->lens_bR;
pParams->lens_cB = pParams->lens_cG = pParams->lens_cR;
pParams->lens_dB = pParams->lens_dG = pParams->lens_dR;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-chroma_aberration")) )
{
if(i + 12 >= nArgNum)
{
PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -chroma_aberration key"));
return MFX_ERR_UNSUPPORTED;
}
pParams->bLens = true;
msdk_opt_read(strInput[++i], pParams->lens_aR);
msdk_opt_read(strInput[++i], pParams->lens_bR);
msdk_opt_read(strInput[++i], pParams->lens_cR);
msdk_opt_read(strInput[++i], pParams->lens_dR);
msdk_opt_read(strInput[++i], pParams->lens_aB);
msdk_opt_read(strInput[++i], pParams->lens_bB);
msdk_opt_read(strInput[++i], pParams->lens_cB);
msdk_opt_read(strInput[++i], pParams->lens_dB);
msdk_opt_read(strInput[++i], pParams->lens_aG);
msdk_opt_read(strInput[++i], pParams->lens_bG);
msdk_opt_read(strInput[++i], pParams->lens_cG);
msdk_opt_read(strInput[++i], pParams->lens_dG);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-ccm")))
{
if(i + 9 >= nArgNum)
{
PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -ccm key."));
return MFX_ERR_UNSUPPORTED;
}
pParams->bCCM = true;
for(int k = 0; k < 3; k++)
for (int z = 0; z < 3; z++)
msdk_opt_read(strInput[++i], pParams->CCM[k][z]);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-gamma_points")))
{
if(i + 64 >= nArgNum)
{
PrintHelp(strInput[0], MSDK_STRING("There should be 64 points provided."));
return MFX_ERR_UNSUPPORTED;
}
for(int k = 0; k < 64; k++)
msdk_opt_read(strInput[++i], pParams->gamma_point[k]);
pParams->bExternalGammaLUT = true;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-gamma_corrected")))
{
if(i + 64 >= nArgNum)
{
PrintHelp(strInput[0], MSDK_STRING("There should be 64 points provided."));
return MFX_ERR_UNSUPPORTED;
}
for(int k = 0; k < 64; k++)
msdk_opt_read(strInput[++i], pParams->gamma_corrected[k]);
pParams->bExternalGammaLUT = true;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-pd")) || 0 == msdk_strcmp(strInput[i], MSDK_STRING("-padding")))
{
pParams->bDoPadding = true;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-vignette")))
{
pParams->bVignette = true;
msdk_strcopy(pParams->strVignetteMaskFile, strInput[++i]);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-i")))
{
msdk_strcopy(pParams->strSrcFile, strInput[++i]);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-o")))
{
msdk_strcopy(pParams->strDstFile, strInput[++i]);
pParams->bOutput = true;
if (i + 1 < nArgNum) {
int n;
if (msdk_opt_read(strInput[++i], n) == MFX_ERR_NONE) {
pParams->maxNumBmpFiles = n;
}
}
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-f")) || 0 == msdk_strcmp(strInput[i], MSDK_STRING("-format")))
{
i++;
if (0 == msdk_strcmp(strInput[i], MSDK_STRING("bggr")))
pParams->bayerType = MFX_CAM_BAYER_BGGR;
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("rggb")))
pParams->bayerType = MFX_CAM_BAYER_RGGB;
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("grbg")))
pParams->bayerType = MFX_CAM_BAYER_GRBG;
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("gbrg")))
pParams->bayerType = MFX_CAM_BAYER_GBRG;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-b")) || 0 == msdk_strcmp(strInput[i], MSDK_STRING("-bitDepth")))
{
msdk_opt_read(strInput[++i], pParams->bitDepth);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-of")) || 0 == msdk_strcmp(strInput[i], MSDK_STRING("-outFormat")))
{
i++;
if (0 == msdk_strcmp(strInput[i], MSDK_STRING("argb16")) || 0 == msdk_strcmp(strInput[i], MSDK_STRING("16")))
pParams->frameInfo[VPP_OUT].FourCC = MFX_FOURCC_ARGB16;
else
pParams->frameInfo[VPP_OUT].FourCC = MFX_FOURCC_RGB4;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-w")) || 0 == msdk_strcmp(strInput[i], MSDK_STRING("-width")))
{
msdk_opt_read(strInput[++i], pParams->frameInfo[VPP_IN].nWidth);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-3dlut")))
{
pParams->b3DLUT = true;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-h")) || 0 == msdk_strcmp(strInput[i], MSDK_STRING("-height")))
{
msdk_opt_read(strInput[++i], pParams->frameInfo[VPP_IN].nHeight);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-cropW")))
{
msdk_opt_read(strInput[++i], pParams->frameInfo[VPP_IN].CropW);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-cropH")))
{
msdk_opt_read(strInput[++i], pParams->frameInfo[VPP_IN].CropH);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-cropX")))
{
msdk_opt_read(strInput[++i], pParams->frameInfo[VPP_IN].CropX);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-cropY")))
{
msdk_opt_read(strInput[++i], pParams->frameInfo[VPP_IN].CropY);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-alpha")))
{
msdk_opt_read(strInput[++i], pParams->alphaValue);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-reset")))
{
resPar.bayerType = pParams->bayerType;
msdk_strcopy(resPar.strSrcFile, pParams->strSrcFile);
msdk_strcopy(resPar.strDstFile, pParams->strDstFile);
resPar.width = pParams->frameInfo[VPP_IN].nWidth;
resPar.height = pParams->frameInfo[VPP_IN].nHeight;
resPar.bHP = pParams->bHP;
resPar.hp_diff = pParams->hp_diff;
resPar.hp_num = pParams->hp_num;
resPar.bBlackLevel = pParams->bBlackLevel;
resPar.black_level_B = pParams->black_level_B;
resPar.black_level_G0 = pParams->black_level_G0;
resPar.black_level_G1 = pParams->black_level_G1;
resPar.black_level_R = pParams->black_level_R;
i++;
for (;i < nArgNum; i++)
{
if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-f")))
{
i++;
if (0 == msdk_strcmp(strInput[i], MSDK_STRING("bggr")))
resPar.bayerType = MFX_CAM_BAYER_BGGR;
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("rggb")))
resPar.bayerType = MFX_CAM_BAYER_RGGB;
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("grbg")))
resPar.bayerType = MFX_CAM_BAYER_GRBG;
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("gbrg")))
resPar.bayerType = MFX_CAM_BAYER_GBRG;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-bbl")))
{
if(i + 4 >= nArgNum)
{
PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -bbl key"));
return MFX_ERR_UNSUPPORTED;
}
resPar.bBlackLevel = true;
msdk_opt_read(strInput[++i], resPar.black_level_B);
msdk_opt_read(strInput[++i], resPar.black_level_G0);
msdk_opt_read(strInput[++i], resPar.black_level_G1);
msdk_opt_read(strInput[++i], resPar.black_level_R);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-hot_pixel")))
{
if(i + 2 >= nArgNum)
{
PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -hot_pixel key"));
return MFX_ERR_UNSUPPORTED;
}
resPar.bHP = true;
msdk_opt_read(strInput[++i], resPar.hp_diff);
msdk_opt_read(strInput[++i], resPar.hp_num);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-bdn")))
{
if(i + 1 >= nArgNum)
{
PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -bdn key"));
return MFX_ERR_UNSUPPORTED;
}
resPar.bDenoise = true;
msdk_opt_read(strInput[++i], resPar.denoiseThreshold);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-bwb")))
{
if(i + 4 >= nArgNum)
{
PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -bwb key"));
return MFX_ERR_UNSUPPORTED;
}
resPar.bWhiteBalance = true;
msdk_opt_read(strInput[++i], resPar.white_balance_B);
msdk_opt_read(strInput[++i], resPar.white_balance_G0);
msdk_opt_read(strInput[++i], resPar.white_balance_G1);
msdk_opt_read(strInput[++i], resPar.white_balance_R);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-ccm")))
{
if(i + 9 >= nArgNum)
{
PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -ccm key."));
return MFX_ERR_UNSUPPORTED;
}
resPar.bCCM = true;
for(int k = 0; k < 3; k++)
for (int z = 0; z < 3; z++)
msdk_opt_read(strInput[++i], resPar.CCM[k][z]);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-w")))
{
msdk_opt_read(strInput[++i], resPar.width);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-h")))
{
msdk_opt_read(strInput[++i], resPar.height);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-cropW")))
{
msdk_opt_read(strInput[++i], resPar.cropW);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-cropH")))
{
msdk_opt_read(strInput[++i], resPar.cropH);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-cropX")))
{
msdk_opt_read(strInput[++i], resPar.cropX);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-cropY")))
{
msdk_opt_read(strInput[++i], resPar.cropY);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-vignette")))
{
resPar.bVignette = true;
msdk_strcopy(resPar.strVignetteMaskFile, strInput[++i]);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-i")))
{
msdk_strcopy(resPar.strSrcFile, strInput[++i]);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-o")))
{
msdk_strcopy(resPar.strDstFile, strInput[++i]);
}
else
{
i--;
break;
}
}
pParams->resetParams.push_back(resPar);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-resetInterval")))
{
msdk_opt_read(strInput[++i], pParams->resetInterval);
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-?")))
{
PrintHelp(strInput[0], NULL);
return MFX_ERR_UNSUPPORTED;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-wall")))
{
if(i + 7 >= nArgNum)
{
PrintHelp(strInput[0], MSDK_STRING("Not enough parameters for -wall key"));
return MFX_ERR_UNSUPPORTED;
}
pParams->bRendering = true;
msdk_opt_read(strInput[++i], pParams->nWallW);
msdk_opt_read(strInput[++i], pParams->nWallH);
msdk_opt_read(strInput[++i], pParams->nWallCell);
msdk_opt_read(strInput[++i], pParams->nWallMonitor);
msdk_opt_read(strInput[++i], pParams->nWallFPS);
int nTitle;
msdk_opt_read(strInput[++i], nTitle);
pParams->bWallNoTitle = 0 == nTitle;
msdk_opt_read(strInput[++i], pParams->nWallTimeout);
}
else // 1-character options
{
std::basic_stringstream<msdk_char> stream;
stream << MSDK_STRING("Unknown option: ") << strInput[i];
PrintHelp(strInput[0], stream.str().c_str());
return MFX_ERR_UNSUPPORTED;
}
}
if (0 == msdk_strlen(pParams->strSrcFile))
{
PrintHelp(strInput[0], MSDK_STRING("Source file name not found"));
return MFX_ERR_UNSUPPORTED;
}
if (0 == msdk_strlen(pParams->strDstFile))
{
pParams->bOutput = false;
}
return MFX_ERR_NONE;
}
int main(int argc, char *argv[])
#endif
{
sInputParams Params = {}; // input parameters from command line
std::auto_ptr<CEncodingPipeline> pPipeline;
mfxStatus sts = MFX_ERR_NONE; // return value check
sts = ParseInputString(argv, (mfxU8)argc, &Params);
MSDK_CHECK_PARSE_RESULT(sts, MFX_ERR_NONE, 1);
// Choosing which pipeline to use
pPipeline.reset(CreatePipeline(Params));
MSDK_CHECK_POINTER(pPipeline.get(), MFX_ERR_MEMORY_ALLOC);
if (MVC_ENABLED & Params.MVC_flags)
{
pPipeline->SetMultiView();
pPipeline->SetNumView(Params.numViews);
}
sts = pPipeline->Init(&Params);
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
pPipeline->PrintInfo();
msdk_printf(MSDK_STRING("Processing started\n"));
if (pPipeline->CaptureStartV4L2Pipeline() != MFX_ERR_NONE)
{
msdk_printf(MSDK_STRING("V4l2 failure terminating the program\n"));
return 0;
}
for (;;)
{
sts = pPipeline->Run();
if (MFX_ERR_DEVICE_LOST == sts || MFX_ERR_DEVICE_FAILED == sts)
{
msdk_printf(MSDK_STRING("\nERROR: Hardware device was lost or returned an unexpected error. Recovering...\n"));
sts = pPipeline->ResetDevice();
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, 1);
sts = pPipeline->ResetMFXComponents(&Params);
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, 1);
continue;
}
else
{
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, 1);
break;
}
}
pPipeline->CaptureStopV4L2Pipeline();
pPipeline->Close();
msdk_printf(MSDK_STRING("\nProcessing finished\n"));
return 0;
}
void PrintHelp(msdk_char *strAppName, const msdk_char *strErrorMessage, ...)
{
msdk_printf(MSDK_STRING("Encoding Sample Version %s\n\n"), MSDK_SAMPLE_VERSION);
if (strErrorMessage)
{
va_list args;
msdk_printf(MSDK_STRING("ERROR: "));
va_start(args, strErrorMessage);
msdk_vprintf(strErrorMessage, args);
va_end(args);
msdk_printf(MSDK_STRING("\n\n"));
}
msdk_printf(MSDK_STRING("Usage: %s <msdk-codecid> [<options>] -i InputYUVFile -o OutputEncodedFile -w width -h height\n"), strAppName);
msdk_printf(MSDK_STRING("\n"));
msdk_printf(MSDK_STRING("Supported codecs, <msdk-codecid>:\n"));
msdk_printf(MSDK_STRING(" <codecid>=h264|mpeg2|vc1|mvc|jpeg - built-in Media SDK codecs\n"));
msdk_printf(MSDK_STRING(" <codecid>=h265|vp8 - in-box Media SDK plugins (may require separate downloading and installation)\n"));
msdk_printf(MSDK_STRING(" If codecid is jpeg, -q option is mandatory.)\n"));
msdk_printf(MSDK_STRING("Options: \n"));
MOD_ENC_PRINT_HELP;
msdk_printf(MSDK_STRING(" [-nv12|yuy2] - input is in NV12 color format, if not specified YUV420 is expected. YUY2 are for JPEG encode only\n"));
msdk_printf(MSDK_STRING(" [-tff|bff] - input stream is interlaced, top|bottom fielf first, if not specified progressive is expected\n"));
msdk_printf(MSDK_STRING(" [-bref] - arrange B frames in B pyramid reference structure\n"));
msdk_printf(MSDK_STRING(" [-nobref] - do not use B-pyramid (by default the decision is made by library)\n"));
msdk_printf(MSDK_STRING(" [-idr_interval size] - idr interval, default 0 means every I is an IDR, 1 means every other I frame is an IDR etc\n"));
msdk_printf(MSDK_STRING(" [-f frameRate] - video frame rate (frames per second)\n"));
msdk_printf(MSDK_STRING(" [-n number] - number of frames to process\n"));
msdk_printf(MSDK_STRING(" [-b bitRate] - encoded bit rate (Kbits per second), valid for H.264, H.265, MPEG2 and MVC encoders \n"));
msdk_printf(MSDK_STRING(" [-u speed|quality|balanced] - target usage, valid for H.264, H.265, MPEG2 and MVC encoders\n"));
msdk_printf(MSDK_STRING(" [-q quality] - mandatory quality parameter for JPEG encoder. In range [1,100]. 100 is the best quality. \n"));
msdk_printf(MSDK_STRING(" [-r distance] - Distance between I- or P- key frames (1 means no B-frames) \n"));
msdk_printf(MSDK_STRING(" [-g size] - GOP size (default 256)\n"));
msdk_printf(MSDK_STRING(" [-x numRefs] - number of reference frames\n"));
msdk_printf(MSDK_STRING(" [-la] - use the look ahead bitrate control algorithm (LA BRC) (by default constant bitrate control method is used)\n"));
msdk_printf(MSDK_STRING(" for H.264, H.265 encoder. Supported only with -hw option on 4th Generation Intel Core processors. \n"));
msdk_printf(MSDK_STRING(" [-lad depth] - depth parameter for the LA BRC, the number of frames to be analyzed before encoding. In range [10,100].\n"));
msdk_printf(MSDK_STRING(" may be 1 in the case when -mss option is specified \n"));
msdk_printf(MSDK_STRING(" [-dstw width] - destination picture width, invokes VPP resizing\n"));
msdk_printf(MSDK_STRING(" [-dsth height] - destination picture height, invokes VPP resizing\n"));
msdk_printf(MSDK_STRING(" [-hw] - use platform specific SDK implementation (default)\n"));
msdk_printf(MSDK_STRING(" [-sw] - use software implementation, if not specified platform specific SDK implementation is used\n"));
msdk_printf(MSDK_STRING(" [-p guid] - 32-character hexadecimal guid string\n"));
msdk_printf(MSDK_STRING(" (optional for Media SDK in-box plugins, required for user-encoder ones)\n"));
msdk_printf(MSDK_STRING(" [-path path] - path to plugin (valid only in pair with -p option)\n"));
msdk_printf(MSDK_STRING(" [-async] - depth of asynchronous pipeline. default value is 4. must be between 1 and 20.\n"));
msdk_printf(MSDK_STRING(" [-gpucopy::<on,off>] Enable or disable GPU copy mode\n"));
msdk_printf(MSDK_STRING(" [-cqp] - constant quantization parameter (CQP BRC) bitrate control method\n"));
msdk_printf(MSDK_STRING(" (by default constant bitrate control method is used), should be used along with -qpi, -qpp, -qpb.\n"));
msdk_printf(MSDK_STRING(" [-qpi] - constant quantizer for I frames (if bitrace control method is CQP). In range [1,51]. 0 by default, i.e.no limitations on QP.\n"));
msdk_printf(MSDK_STRING(" [-qpp] - constant quantizer for P frames (if bitrace control method is CQP). In range [1,51]. 0 by default, i.e.no limitations on QP.\n"));
msdk_printf(MSDK_STRING(" [-qpb] - constant quantizer for B frames (if bitrace control method is CQP). In range [1,51]. 0 by default, i.e.no limitations on QP.\n"));
msdk_printf(MSDK_STRING(" [-qsv-ff] Enable QSV-FF mode\n"));
msdk_printf(MSDK_STRING(" [-num_slice] - number of slices in each video frame. 0 by default.\n"));
msdk_printf(MSDK_STRING(" If num_slice equals zero, the encoder may choose any slice partitioning allowed by the codec standard.\n"));
msdk_printf(MSDK_STRING(" [-mss] - maximum slice size in bytes. Supported only with -hw and h264 codec. This option is not compatible with -num_slice option.\n"));
msdk_printf(MSDK_STRING(" [-re] - enable region encode mode. Works only with h265 encoder\n"));
msdk_printf(MSDK_STRING("Example: %s h265 -i InputYUVFile -o OutputEncodedFile -w width -h height -hw -p 2fca99749fdb49aeb121a5b63ef568f7\n"), strAppName);
#if D3D_SURFACES_SUPPORT
msdk_printf(MSDK_STRING(" [-d3d] - work with d3d surfaces\n"));
msdk_printf(MSDK_STRING(" [-d3d11] - work with d3d11 surfaces\n"));
msdk_printf(MSDK_STRING("Example: %s h264|h265|mpeg2|jpeg -i InputYUVFile -o OutputEncodedFile -w width -h height -d3d -hw \n"), strAppName);
msdk_printf(MSDK_STRING("Example for MVC: %s mvc -i InputYUVFile_1 -i InputYUVFile_2 -o OutputEncodedFile -w width -h height \n"), strAppName);
#endif
#ifdef LIBVA_SUPPORT
msdk_printf(MSDK_STRING(" [-vaapi] - work with vaapi surfaces\n"));
msdk_printf(MSDK_STRING("Example: %s h264|mpeg2|mvc -i InputYUVFile -o OutputEncodedFile -w width -h height -angle 180 -g 300 -r 1 \n"), strAppName);
#endif
#if defined (ENABLE_V4L2_SUPPORT)
msdk_printf(MSDK_STRING(" [-d] - Device video node (eg: /dev/video0)\n"));
msdk_printf(MSDK_STRING(" [-p] - Mipi Port number (eg: Port 0)\n"));
msdk_printf(MSDK_STRING(" [-m] - Mipi Mode Configuration [PREVIEW/CONTINUOUS/STILL/VIDEO]\n"));
msdk_printf(MSDK_STRING(" [-uyvy] - Input Raw format types V4L2 Encode\n"));
msdk_printf(MSDK_STRING(" [-YUY2] - Input Raw format types V4L2 Encode\n"));
msdk_printf(MSDK_STRING(" [-i::v4l2] - To enable v4l2 option\n"));
msdk_printf(MSDK_STRING("Example: %s h264|mpeg2|mvc -i::v4l2 -o OutputEncodedFile -w width -h height -d /dev/video0 -uyvy -m preview -p 0\n"), strAppName);
#endif
msdk_printf(MSDK_STRING(" [-viewoutput] - instruct the MVC encoder to output each view in separate bitstream buffer. Depending on the number of -o options behaves as follows:\n"));
msdk_printf(MSDK_STRING(" 1: two views are encoded in single file\n"));
msdk_printf(MSDK_STRING(" 2: two views are encoded in separate files\n"));
msdk_printf(MSDK_STRING(" 3: behaves like 2 -o opitons was used and then one -o\n\n"));
msdk_printf(MSDK_STRING("Example: %s mvc -i InputYUVFile_1 -i InputYUVFile_2 -o OutputEncodedFile_1 -o OutputEncodedFile_2 -viewoutput -w width -h height \n"), strAppName);
// user module options
msdk_printf(MSDK_STRING("User module options: \n"));
msdk_printf(MSDK_STRING(" [-angle 180] - enables 180 degrees picture rotation before encoding, CPU implementation by default. Rotation requires NV12 input. Options -tff|bff, -dstw, -dsth, -d3d are not effective together with this one, -nv12 is required.\n"));
msdk_printf(MSDK_STRING(" [-opencl] - rotation implementation through OPENCL\n"));
msdk_printf(MSDK_STRING("Example: %s h264|h265|mpeg2|mvc|jpeg -i InputYUVFile -o OutputEncodedFile -w width -h height -angle 180 -opencl \n"), strAppName);
msdk_printf(MSDK_STRING("\n"));
}
mfxStatus ParseInputString(msdk_char* strInput[], mfxU8 nArgNum, sInputParams* pParams)
{
if (1 == nArgNum)
{
PrintHelp(strInput[0], NULL);
return MFX_ERR_UNSUPPORTED;
}
MSDK_CHECK_POINTER(pParams, MFX_ERR_NULL_PTR);
msdk_opt_read(MSDK_CPU_ROTATE_PLUGIN, pParams->strPluginDLLPath);
// default implementation
pParams->bUseHWLib = true;
pParams->isV4L2InputEnabled = false;
pParams->nNumFrames = 0;
#if defined (ENABLE_V4L2_SUPPORT)
pParams->MipiPort = -1;
pParams->MipiMode = NONE;
pParams->v4l2Format = NO_FORMAT;
#endif
// parse command line parameters
for (mfxU8 i = 1; i < nArgNum; i++)
{
MSDK_CHECK_POINTER(strInput[i], MFX_ERR_NULL_PTR);
if (MSDK_CHAR('-') != strInput[i][0])
{
mfxStatus sts = StrFormatToCodecFormatFourCC(strInput[i], pParams->CodecId);
if (sts != MFX_ERR_NONE)
{
PrintHelp(strInput[0], MSDK_STRING("Unknown codec"));
return MFX_ERR_UNSUPPORTED;
}
if (!IsEncodeCodecSupported(pParams->CodecId))
{
PrintHelp(strInput[0], MSDK_STRING("Unsupported codec"));
return MFX_ERR_UNSUPPORTED;
}
if (pParams->CodecId == CODEC_MVC)
{
pParams->CodecId = MFX_CODEC_AVC;
pParams->MVC_flags |= MVC_ENABLED;
}
continue;
}
// process multi-character options
if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-dstw")))
{
VAL_CHECK(i+1 >= nArgNum, i, strInput[i]);
if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->nDstWidth))
{
PrintHelp(strInput[0], MSDK_STRING("Destination picture Width is invalid"));
return MFX_ERR_UNSUPPORTED;
}
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-dsth")))
{
VAL_CHECK(i+1 >= nArgNum, i, strInput[i]);
if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->nDstHeight))
{
PrintHelp(strInput[0], MSDK_STRING("Destination picture Height is invalid"));
return MFX_ERR_UNSUPPORTED;
}
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-sw")))
{
pParams->bUseHWLib = false;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-hw")))
{
pParams->bUseHWLib = true;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-yuy2")))
{
#if defined (ENABLE_V4L2_SUPPORT)
pParams->v4l2Format = YUY2;
#endif
pParams->ColorFormat = MFX_FOURCC_YUY2;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-nv12")))
{
pParams->ColorFormat = MFX_FOURCC_NV12;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-tff")))
{
pParams->nPicStruct = MFX_PICSTRUCT_FIELD_TFF;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-bff")))
{
pParams->nPicStruct = MFX_PICSTRUCT_FIELD_BFF;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-bref")))
{
pParams->nBRefType = MFX_B_REF_PYRAMID;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-nobref")))
{
pParams->nBRefType = MFX_B_REF_OFF;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-idr_interval")))
{
if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->nIdrInterval))
{
PrintHelp(strInput[0], MSDK_STRING("IdrInterval is invalid"));
return MFX_ERR_UNSUPPORTED;
}
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-angle")))
{
VAL_CHECK(i+1 >= nArgNum, i, strInput[i]);
if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->nRotationAngle))
{
PrintHelp(strInput[0], MSDK_STRING("Rotation Angle is invalid"));
return MFX_ERR_UNSUPPORTED;
}
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-opencl")))
{
msdk_opt_read(MSDK_OCL_ROTATE_PLUGIN, pParams->strPluginDLLPath);
pParams->nRotationAngle = 180;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-viewoutput")))
{
if (!(MVC_ENABLED & pParams->MVC_flags))
{
PrintHelp(strInput[0], MSDK_STRING("-viewoutput option is supported only when mvc codec specified"));
return MFX_ERR_UNSUPPORTED;
}
pParams->MVC_flags |= MVC_VIEWOUTPUT;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-la")))
{
pParams->nRateControlMethod = MFX_RATECONTROL_LA;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-lad")))
{
VAL_CHECK(i+1 >= nArgNum, i, strInput[i]);
pParams->nRateControlMethod = MFX_RATECONTROL_LA;
if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->nLADepth))
{
PrintHelp(strInput[0], MSDK_STRING("Look Ahead Depth is invalid"));
return MFX_ERR_UNSUPPORTED;
}
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-mss")))
{
VAL_CHECK(i+1 >= nArgNum, i, strInput[i]);
if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->nMaxSliceSize))
{
PrintHelp(strInput[0], MSDK_STRING("MaxSliceSize is invalid"));
return MFX_ERR_UNSUPPORTED;
}
}
#if D3D_SURFACES_SUPPORT
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-d3d")))
{
pParams->memType = D3D9_MEMORY;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-d3d11")))
{
pParams->memType = D3D11_MEMORY;
}
#endif
#ifdef LIBVA_SUPPORT
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-vaapi")))
{
pParams->memType = D3D9_MEMORY;
}
#endif
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-async")))
{
VAL_CHECK(i+1 >= nArgNum, i, strInput[i]);
if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->nAsyncDepth))
{
PrintHelp(strInput[0], MSDK_STRING("Async Depth is invalid"));
return MFX_ERR_UNSUPPORTED;
}
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-gpucopy::on")))
{
pParams->gpuCopy = MFX_GPUCOPY_ON;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-gpucopy::off")))
{
pParams->gpuCopy = MFX_GPUCOPY_OFF;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-cqp")))
{
pParams->nRateControlMethod = MFX_RATECONTROL_CQP;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-qpi")))
{
VAL_CHECK(i+1 >= nArgNum, i, strInput[i]);
if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->nQPI))
{
PrintHelp(strInput[0], MSDK_STRING("Quantizer for I frames is invalid"));
return MFX_ERR_UNSUPPORTED;
}
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-qpp")))
{
VAL_CHECK(i+1 >= nArgNum, i, strInput[i]);
if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->nQPP))
{
PrintHelp(strInput[0], MSDK_STRING("Quantizer for P frames is invalid"));
return MFX_ERR_UNSUPPORTED;
}
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-qpb")))
{
VAL_CHECK(i+1 >= nArgNum, i, strInput[i]);
if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->nQPB))
{
PrintHelp(strInput[0], MSDK_STRING("Quantizer for B frames is invalid"));
return MFX_ERR_UNSUPPORTED;
}
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-qsv-ff")))
{
pParams->enableQSVFF=true;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-num_slice")))
{
VAL_CHECK(i+1 >= nArgNum, i, strInput[i]);
if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->nNumSlice))
{
PrintHelp(strInput[0], MSDK_STRING("Number of slices is invalid"));
return MFX_ERR_UNSUPPORTED;
}
} else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-path")))
{
i++;
#if defined(_WIN32) || defined(_WIN64)
msdk_char wchar[MSDK_MAX_FILENAME_LEN];
msdk_opt_read(strInput[i], wchar);
std::wstring wstr(wchar);
std::string str(wstr.begin(), wstr.end());
strcpy_s(pParams->pluginParams.strPluginPath, str.c_str());
#else
msdk_opt_read(strInput[i], pParams->pluginParams.strPluginPath);
#endif
pParams->pluginParams.type = MFX_PLUGINLOAD_TYPE_FILE;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-re")))
{
pParams->UseRegionEncode = true;
}
MOD_ENC_PARSE_INPUT
#if defined (ENABLE_V4L2_SUPPORT)
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-d")))
{
VAL_CHECK(i+1 >= nArgNum, i, strInput[i]);
if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->DeviceName))
{
PrintHelp(strInput[0], MSDK_STRING("Device name is invalid"));
return MFX_ERR_UNSUPPORTED;
}
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-uyvy")))
{
pParams->v4l2Format = UYVY;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-p")))
{
VAL_CHECK(i+1 >= nArgNum, i, strInput[i]);
if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->MipiPort))
{
PrintHelp(strInput[0], MSDK_STRING("Mipi-port is invalid"));
return MFX_ERR_UNSUPPORTED;
}
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-m")))
{
VAL_CHECK(i+1 >= nArgNum, i, strInput[i]);
if (MFX_ERR_NONE != msdk_opt_read(strInput[++i], pParams->MipiModeName))
{
PrintHelp(strInput[0], MSDK_STRING("Device name is invalid"));
return MFX_ERR_UNSUPPORTED;
}
if(strcasecmp(pParams->MipiModeName,"STILL") == 0)
pParams->MipiMode = STILL;
else if(strcasecmp(pParams->MipiModeName,"VIDEO") == 0)
pParams->MipiMode = VIDEO;
else if(strcasecmp(pParams->MipiModeName,"PREVIEW") == 0)
pParams->MipiMode = PREVIEW;
else if(strcasecmp(pParams->MipiModeName,"CONTINUOUS") == 0)
pParams->MipiMode = CONTINUOUS;
else
pParams->MipiMode = NONE;
}
else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-i::v4l2")))
{
pParams->isV4L2InputEnabled = true;
}
#endif
else // 1-character options
{
switch (strInput[i][1])
{
case MSDK_CHAR('u'):
if (++i < nArgNum) {
pParams->nTargetUsage = StrToTargetUsage(strInput[i]);
}
else {
msdk_printf(MSDK_STRING("error: option '-u' expects an argument\n"));
}
break;
case MSDK_CHAR('w'):
if (++i < nArgNum) {
if (MFX_ERR_NONE != msdk_opt_read(strInput[i], pParams->nWidth))
{
PrintHelp(strInput[0], MSDK_STRING("Width is invalid"));
return MFX_ERR_UNSUPPORTED;
}
}
else {
msdk_printf(MSDK_STRING("error: option '-w' expects an argument\n"));
}
break;
case MSDK_CHAR('h'):
if (++i < nArgNum) {
if (MFX_ERR_NONE != msdk_opt_read(strInput[i], pParams->nHeight))
{
PrintHelp(strInput[0], MSDK_STRING("Height is invalid"));
return MFX_ERR_UNSUPPORTED;
}
}
else {
msdk_printf(MSDK_STRING("error: option '-h' expects an argument\n"));
}
break;
case MSDK_CHAR('f'):
if (++i < nArgNum) {
if (MFX_ERR_NONE != msdk_opt_read(strInput[i], pParams->dFrameRate))
{
PrintHelp(strInput[0], MSDK_STRING("Frame Rate is invalid"));
return MFX_ERR_UNSUPPORTED;
}
}
else {
msdk_printf(MSDK_STRING("error: option '-f' expects an argument\n"));
}
break;
case MSDK_CHAR('n'):
if (++i < nArgNum) {
if (MFX_ERR_NONE != msdk_opt_read(strInput[i], pParams->nNumFrames))
{
PrintHelp(strInput[0], MSDK_STRING("Number of frames to process is invalid"));
return MFX_ERR_UNSUPPORTED;
}
}
else {
msdk_printf(MSDK_STRING("error: option '-n' expects an argument\n"));
}
break;
case MSDK_CHAR('b'):
if (++i < nArgNum) {
if (MFX_ERR_NONE != msdk_opt_read(strInput[i], pParams->nBitRate))
{
PrintHelp(strInput[0], MSDK_STRING("Bit Rate is invalid"));
return MFX_ERR_UNSUPPORTED;
}
}
else {
msdk_printf(MSDK_STRING("error: option '-b' expects an argument\n"));
}
break;
case MSDK_CHAR('x'):
if (++i < nArgNum) {
if (MFX_ERR_NONE != msdk_opt_read(strInput[i], pParams->nNumRefFrame))
{
PrintHelp(strInput[0], MSDK_STRING("Ref Num is invalid"));
return MFX_ERR_UNSUPPORTED;
}
}
else {
msdk_printf(MSDK_STRING("error: option '-x' expects an argument\n"));
}
break;
case MSDK_CHAR('g'):
if (++i < nArgNum) {
if (MFX_ERR_NONE != msdk_opt_read(strInput[i], pParams->nGopPicSize))
{
PrintHelp(strInput[0], MSDK_STRING("Gop Size is invalid"));
return MFX_ERR_UNSUPPORTED;
}
}
else {
msdk_printf(MSDK_STRING("error: option '-g' expects an argument\n"));
}
break;
case MSDK_CHAR('r'):
if (++i < nArgNum) {
if (MFX_ERR_NONE != msdk_opt_read(strInput[i], pParams->nGopRefDist))
{
PrintHelp(strInput[0], MSDK_STRING("Ref Dist is invalid"));
return MFX_ERR_UNSUPPORTED;
}
}
else {
msdk_printf(MSDK_STRING("error: option '-r' expects an argument\n"));
}
break;
case MSDK_CHAR('i'):
if (++i < nArgNum) {
msdk_opt_read(strInput[i], pParams->strSrcFile);
if (MVC_ENABLED & pParams->MVC_flags)
{
pParams->srcFileBuff.push_back(strInput[i]);
}
}
else {
msdk_printf(MSDK_STRING("error: option '-i' expects an argument\n"));
}
break;
case MSDK_CHAR('o'):
if (++i < nArgNum) {
pParams->dstFileBuff.push_back(strInput[i]);
}
else {
msdk_printf(MSDK_STRING("error: option '-o' expects an argument\n"));
}
break;
case MSDK_CHAR('q'):
if (++i < nArgNum) {
if (MFX_ERR_NONE != msdk_opt_read(strInput[i], pParams->nQuality))
{
PrintHelp(strInput[0], MSDK_STRING("Quality is invalid"));
return MFX_ERR_UNSUPPORTED;
}
}
else {
msdk_printf(MSDK_STRING("error: option '-q' expects an argument\n"));
}
break;
case MSDK_CHAR('p'):
if (++i < nArgNum) {
if (MFX_ERR_NONE == ConvertStringToGuid(strInput[i], pParams->pluginParams.pluginGuid))
{
pParams->pluginParams.type = MFX_PLUGINLOAD_TYPE_GUID;
}
else
{
PrintHelp(strInput[0], MSDK_STRING("Unknown options"));
}
}
else {
msdk_printf(MSDK_STRING("error: option '-p' expects an argument\n"));
}
break;
case MSDK_CHAR('?'):
PrintHelp(strInput[0], NULL);
return MFX_ERR_UNSUPPORTED;
default:
PrintHelp(strInput[0], MSDK_STRING("Unknown options"));
}
}
}
#if defined (ENABLE_V4L2_SUPPORT)
if (pParams->isV4L2InputEnabled)
{
if (0 == msdk_strlen(pParams->DeviceName))
{
PrintHelp(strInput[0], MSDK_STRING("Device Name not found"));
return MFX_ERR_UNSUPPORTED;
}
if ((pParams->MipiPort > -1 && pParams->MipiMode == NONE) ||
(pParams->MipiPort < 0 && pParams->MipiMode != NONE))
{
PrintHelp(strInput[0], MSDK_STRING("Invalid Mipi Configuration\n"));
return MFX_ERR_UNSUPPORTED;
}
if (pParams->v4l2Format == NO_FORMAT)
{
PrintHelp(strInput[0], MSDK_STRING("NO input v4l2 format\n"));
return MFX_ERR_UNSUPPORTED;
}
}
#endif
// check if all mandatory parameters were set
if (0 == msdk_strlen(pParams->strSrcFile) && !pParams->isV4L2InputEnabled)
{
PrintHelp(strInput[0], MSDK_STRING("Source file name not found"));
return MFX_ERR_UNSUPPORTED;
};
if (pParams->dstFileBuff.empty())
{
PrintHelp(strInput[0], MSDK_STRING("Destination file name not found"));
return MFX_ERR_UNSUPPORTED;
};
if (0 == pParams->nWidth || 0 == pParams->nHeight)
{
PrintHelp(strInput[0], MSDK_STRING("-w, -h must be specified"));
return MFX_ERR_UNSUPPORTED;
}
if (MFX_CODEC_MPEG2 != pParams->CodecId &&
MFX_CODEC_AVC != pParams->CodecId &&
MFX_CODEC_JPEG != pParams->CodecId &&
MFX_CODEC_VP8 != pParams->CodecId &&
MFX_CODEC_HEVC != pParams->CodecId)
{
PrintHelp(strInput[0], MSDK_STRING("Unknown codec"));
return MFX_ERR_UNSUPPORTED;
}
if (MFX_CODEC_JPEG != pParams->CodecId &&
pParams->ColorFormat == MFX_FOURCC_YUY2 &&
!pParams->isV4L2InputEnabled)
{
PrintHelp(strInput[0], MSDK_STRING("-yuy2 option is supported only for JPEG encoder"));
return MFX_ERR_UNSUPPORTED;
}
// check parameters validity
if (pParams->nRotationAngle != 0 && pParams->nRotationAngle != 180)
{
PrintHelp(strInput[0], MSDK_STRING("Angles other than 180 degrees are not supported."));
return MFX_ERR_UNSUPPORTED; // other than 180 are not supported
}
if (pParams->nQuality && (MFX_CODEC_JPEG != pParams->CodecId))
{
PrintHelp(strInput[0], MSDK_STRING("-q option is supported only for JPEG encoder"));
return MFX_ERR_UNSUPPORTED;
}
if ((pParams->nTargetUsage || pParams->nBitRate) && (MFX_CODEC_JPEG == pParams->CodecId))
{
PrintHelp(strInput[0], MSDK_STRING("-u and -b options are supported only for H.264, MPEG2 and MVC encoders. For JPEG encoder use -q"));
return MFX_ERR_UNSUPPORTED;
}
// set default values for optional parameters that were not set or were set incorrectly
mfxU32 nviews = (mfxU32)pParams->srcFileBuff.size();
if ((nviews <= 1) || (nviews > 2))
{
if (!(MVC_ENABLED & pParams->MVC_flags))
{
pParams->numViews = 1;
}
else
{
PrintHelp(strInput[0], MSDK_STRING("Only 2 views are supported right now in this sample."));
return MFX_ERR_UNSUPPORTED;
}
}
else
{
pParams->numViews = nviews;
}
if (MFX_TARGETUSAGE_BEST_QUALITY != pParams->nTargetUsage && MFX_TARGETUSAGE_BEST_SPEED != pParams->nTargetUsage)
{
pParams->nTargetUsage = MFX_TARGETUSAGE_BALANCED;
}
if (pParams->dFrameRate <= 0)
{
pParams->dFrameRate = 30;
}
// if no destination picture width or height wasn't specified set it to the source picture size
if (pParams->nDstWidth == 0)
{
pParams->nDstWidth = pParams->nWidth;
}
if (pParams->nDstHeight == 0)
{
pParams->nDstHeight = pParams->nHeight;
}
// calculate default bitrate based on the resolution (a parameter for encoder, so Dst resolution is used)
if (pParams->nBitRate == 0)
{
pParams->nBitRate = CalculateDefaultBitrate(pParams->CodecId, pParams->nTargetUsage, pParams->nDstWidth,
pParams->nDstHeight, pParams->dFrameRate);
}
// if nv12 option wasn't specified we expect input YUV file in YUV420 color format
if (!pParams->ColorFormat)
{
pParams->ColorFormat = MFX_FOURCC_YV12;
}
if (!pParams->nPicStruct)
{
pParams->nPicStruct = MFX_PICSTRUCT_PROGRESSIVE;
}
if ((pParams->nRateControlMethod == MFX_RATECONTROL_LA) && (!pParams->bUseHWLib))
{
PrintHelp(strInput[0], MSDK_STRING("Look ahead BRC is supported only with -hw option!"));
return MFX_ERR_UNSUPPORTED;
}
if ((pParams->nMaxSliceSize) && (!pParams->bUseHWLib))
{
PrintHelp(strInput[0], MSDK_STRING("MaxSliceSize option is supported only with -hw option!"));
return MFX_ERR_UNSUPPORTED;
}
if ((pParams->nMaxSliceSize) && (pParams->nNumSlice))
{
PrintHelp(strInput[0], MSDK_STRING("-mss and -num_slice options are not compatible!"));
return MFX_ERR_UNSUPPORTED;
}
if ((pParams->nRateControlMethod == MFX_RATECONTROL_LA) && (pParams->CodecId != MFX_CODEC_AVC))
{
PrintHelp(strInput[0], MSDK_STRING("Look ahead BRC is supported only with H.264 encoder!"));
return MFX_ERR_UNSUPPORTED;
}
if ((pParams->nMaxSliceSize) && (pParams->CodecId != MFX_CODEC_AVC))
{
PrintHelp(strInput[0], MSDK_STRING("MaxSliceSize option is supported only with H.264 encoder!"));
return MFX_ERR_UNSUPPORTED;
}
if (pParams->nLADepth && (pParams->nLADepth < 10 || pParams->nLADepth > 100))
{
if ((pParams->nLADepth != 1) || (!pParams->nMaxSliceSize))
{
PrintHelp(strInput[0], MSDK_STRING("Unsupported value of -lad parameter, must be in range [10, 100] or 1 in case of -mss option!"));
return MFX_ERR_UNSUPPORTED;
}
}
// not all options are supported if rotate plugin is enabled
if (pParams->nRotationAngle == 180 && (
MFX_PICSTRUCT_PROGRESSIVE != pParams->nPicStruct ||
pParams->nDstWidth != pParams->nWidth ||
pParams->nDstHeight != pParams->nHeight ||
MVC_ENABLED & pParams->MVC_flags ||
pParams->nRateControlMethod == MFX_RATECONTROL_LA))
{
PrintHelp(strInput[0], MSDK_STRING("Some of the command line options are not supported with rotation plugin!"));
return MFX_ERR_UNSUPPORTED;
}
if (pParams->nAsyncDepth == 0)
{
pParams->nAsyncDepth = 4; //set by default;
}
// Ignoring user-defined Async Depth for LA
if (pParams->nMaxSliceSize)
{
pParams->nAsyncDepth = 1;
}
if (pParams->nRateControlMethod == 0)
{
pParams->nRateControlMethod = MFX_RATECONTROL_CBR;
}
if(pParams->UseRegionEncode)
{
if(pParams->CodecId != MFX_CODEC_HEVC)
{
msdk_printf(MSDK_STRING("Region encode option is compatible with h265(HEVC) encoder only.\nRegion encoding is disabled\n"));
pParams->UseRegionEncode=false;
}
if (pParams->nWidth != pParams->nDstWidth ||
pParams->nHeight != pParams->nDstHeight ||
pParams->nRotationAngle!=0)
{
msdk_printf(MSDK_STRING("Region encode option is not compatible with VPP processing.\nRegion encoding is disabled\n"));
pParams->UseRegionEncode=false;
}
}
return MFX_ERR_NONE;
}
/* Custom methods */
mfxStatus Rotate::Init(mfxVideoParam *mfxParam)
{
MSDK_CHECK_POINTER(mfxParam, MFX_ERR_NULL_PTR);
MSDK_CHECK_POINTER(m_pmfxCore, MFX_ERR_NULL_PTR);
mfxStatus sts = MFX_ERR_NONE;
// whether we use d3d memory on
int bd3d[2] = { 0, // input
0}; // output
m_VideoParam = *mfxParam;
// map opaque surfaces array in case of opaque surfaces
m_bIsInOpaque = (m_VideoParam.IOPattern & MFX_IOPATTERN_IN_OPAQUE_MEMORY) ? true : false;
m_bIsOutOpaque = (m_VideoParam.IOPattern & MFX_IOPATTERN_OUT_OPAQUE_MEMORY) ? true : false;
mfxExtOpaqueSurfaceAlloc* pluginOpaqueAlloc = NULL;
if (m_bIsInOpaque || m_bIsOutOpaque)
{
pluginOpaqueAlloc = (mfxExtOpaqueSurfaceAlloc*)GetExtBuffer(m_VideoParam.ExtParam,
m_VideoParam.NumExtParam, MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION);
MSDK_CHECK_POINTER(pluginOpaqueAlloc, MFX_ERR_INVALID_VIDEO_PARAM);
}
// check existence of corresponding allocs
if ((m_bIsInOpaque && ! pluginOpaqueAlloc->In.Surfaces) || (m_bIsOutOpaque && !pluginOpaqueAlloc->Out.Surfaces))
return MFX_ERR_INVALID_VIDEO_PARAM;
if (m_bIsInOpaque)
{
sts = m_pmfxCore->MapOpaqueSurface(m_pmfxCore->pthis, pluginOpaqueAlloc->In.NumSurface,
pluginOpaqueAlloc->In.Type, pluginOpaqueAlloc->In.Surfaces);
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, MFX_ERR_MEMORY_ALLOC);
bd3d[0] = pluginOpaqueAlloc->In.Type &
(MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET | MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET);
}
else
{
bd3d[0] = m_VideoParam.IOPattern & MFX_IOPATTERN_IN_VIDEO_MEMORY;
}
if (m_bIsOutOpaque)
{
sts = m_pmfxCore->MapOpaqueSurface(m_pmfxCore->pthis, pluginOpaqueAlloc->Out.NumSurface,
pluginOpaqueAlloc->Out.Type, pluginOpaqueAlloc->Out.Surfaces);
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, MFX_ERR_MEMORY_ALLOC);
bd3d[1] = pluginOpaqueAlloc->Out.Type &
(MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET | MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET);
}
else
{
bd3d[1] = m_VideoParam.IOPattern & MFX_IOPATTERN_OUT_VIDEO_MEMORY;
}
m_MaxNumTasks = 1;
m_pTasks = new RotateTask [m_MaxNumTasks];
MSDK_CHECK_POINTER(m_pTasks, MFX_ERR_MEMORY_ALLOC);
memset(m_pTasks, 0, sizeof(RotateTask) * m_MaxNumTasks);
m_NumChunks = 1;
m_pChunks = new DataChunk [m_NumChunks];
MSDK_CHECK_POINTER(m_pChunks, MFX_ERR_MEMORY_ALLOC);
memset(m_pChunks, 0, sizeof(DataChunk) * m_NumChunks);
// divide frame into data chunks
mfxU32 num_lines_in_chunk = mfxParam->vpp.In.CropH / m_NumChunks; // integer division
mfxU32 remainder_lines = mfxParam->vpp.In.CropH % m_NumChunks; // get remainder
// remaining lines are distributed among first chunks (+ extra 1 line each)
for (mfxU32 i = 0; i < m_NumChunks; i++)
{
m_pChunks[i].StartLine = (i == 0) ? 0 : m_pChunks[i-1].EndLine + 1;
m_pChunks[i].EndLine = (i < remainder_lines) ? (i + 1) * num_lines_in_chunk : (i + 1) * num_lines_in_chunk - 1;
}
// enable surface sharing in case both input and output are d3d surfaces
if (bd3d[0] && bd3d[1])
m_bOpenCLSurfaceSharing = true;
if (m_bOpenCLSurfaceSharing)
{
// init OpenCLFilter
cl_int error = CL_SUCCESS;
#if defined(_WIN32) || defined(_WIN64)
if (MFX_IMPL_VIA_MASK(m_impl) == MFX_IMPL_VIA_D3D11) {
m_OpenCLFilter.reset(new OpenCLFilterDX11());
} else {
m_OpenCLFilter.reset(new OpenCLFilterDX9());
}
error = m_OpenCLFilter.get()->AddKernel(readFile("ocl_rotate.cl").c_str(), "rotate_Y", "rotate_UV");
if (error) return MFX_ERR_DEVICE_FAILED;
error = m_OpenCLFilter.get()->OCLInit(m_device);
#else
m_OpenCLFilter.reset(new OpenCLFilterVA());
error = m_OpenCLFilter.get()->AddKernel(readFile("ocl_rotate.cl").c_str(), "rotate_Y", "rotate_UV");
if (error) return MFX_ERR_DEVICE_FAILED;
error = m_OpenCLFilter.get()->OCLInit(m_device);
#endif
if (error)
{
error = CL_SUCCESS;
std::cout << "\nWARNING: Initializing plugin with media sharing failed" << std::endl;
m_bOpenCLSurfaceSharing = false; // try init plugin without sharing
}
else
{
error = m_OpenCLFilter->SelectKernel(0);
if (error) return MFX_ERR_DEVICE_FAILED;
}
}
if (!m_bOpenCLSurfaceSharing)
{
try
{
m_pOpenCLRotator180Context.reset(new OpenCLRotator180Context(readFile("ocl_rotate.cl").c_str()));
}
catch (const std::exception &err)
{
std::cout << "Error: The readFile method throws an exception: " << err.what() << std::endl;
return MFX_ERR_DEVICE_FAILED;
}
}
if (m_bOpenCLSurfaceSharing)
{
msdk_printf(MSDK_STRING("info: using GPU OpenCL device with media sharing extension\n"));
}
else
{
msdk_printf(MSDK_STRING("info: using CPU OpenCL device without media sharing extension\n"));
}
m_bInited = true;
return MFX_ERR_NONE;
}
