mfxStatus CRendererPipeline::Init(mfxU16 nWidth, mfxU16 nHeight, MemType memType, HWND hParentWnd)
{
mfxStatus sts = MFX_ERR_NONE;
mfxVersion min_version;
mfxVersion version; // real API version with which library is initialized
// we set version to 1.0 and later we will query actual version of the library which will got leaded
min_version.Major = 1;
min_version.Minor = 0;
//sts = m_mfxSession.Init(MFX_IMPL_SOFTWARE, &min_version);
//sts = m_mfxSession.Init(MFX_IMPL_HARDWARE, &min_version);
sts = m_mfxSession.Init(MFX_IMPL_RUNTIME, &min_version);
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
sts = MFXQueryVersion(m_mfxSession , &version); // get real API version of the loaded library
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
// set memory type
m_nHeight = nHeight;
m_nWidth = nWidth;
m_memType = memType;
m_hParentWnd=hParentWnd;
m_nY = m_nWidth*m_nHeight;
m_nUV = (m_nY / 4);
// create and init frame allocator
sts = CreateAllocator();
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
sts = AllocFrames();
MSDK_CHECK_RESULT(sts, MFX_ERR_NONE, sts);
return MFX_ERR_NONE;
}
mfxStatus MSDKVpp::InitVpp(mfxFrameSurface1* pFrameSurface)
{
if (m_pMeasuremnt)
{
m_pMeasuremnt->GetLock();
m_pMeasuremnt->TimeStpStart(VPP_INIT_TIME_STAMP, this);
m_pMeasuremnt->RelLock();
}
//Input data
m_mfxVideoParam.vpp.In.FrameRateExtN = pFrameSurface->Info.FrameRateExtN;
m_mfxVideoParam.vpp.In.FrameRateExtD = pFrameSurface->Info.FrameRateExtD;
m_mfxVideoParam.vpp.In.FourCC = pFrameSurface->Info.FourCC;
m_mfxVideoParam.vpp.In.ChromaFormat = pFrameSurface->Info.ChromaFormat;
m_mfxVideoParam.vpp.In.PicStruct = pFrameSurface->Info.PicStruct;
m_mfxVideoParam.vpp.In.CropX = pFrameSurface->Info.CropX;
m_mfxVideoParam.vpp.In.CropY = pFrameSurface->Info.CropY;
m_mfxVideoParam.vpp.In.CropW = pFrameSurface->Info.CropW;
m_mfxVideoParam.vpp.In.CropH = pFrameSurface->Info.CropH;
VPP_TRACE_INFO("[MSDKVpp]-----Init VPP, in dst %d/%d\n", m_mfxVideoParam.vpp.In.CropW, m_mfxVideoParam.vpp.In.CropH);
m_mfxVideoParam.vpp.In.Width = MSDK_ALIGN16(m_mfxVideoParam.vpp.In.CropW);
m_mfxVideoParam.vpp.In.Height = MSDK_ALIGN16(m_mfxVideoParam.vpp.In.CropH);
//Output data
MSDKDecode* pDecode = NULL;
for (std::map<MSDKDecodeVpp*, MediaBuf>::iterator it = m_mapMediaBuf.begin();
it != m_mapMediaBuf.end(); it++)
{
pDecode = dynamic_cast<MSDKDecode*>(it->first);
//select the maximum frame rate among the multiplex stream to set the composite frame rate
if (pDecode->GetFrameRateExtN()/pDecode->GetFrameRateExtD() > m_frameRate)
{
m_mfxVideoParam.vpp.Out.FrameRateExtN = pDecode->GetFrameRateExtN();
m_mfxVideoParam.vpp.Out.FrameRateExtD = pDecode->GetFrameRateExtD();
m_frameRate = m_mfxVideoParam.vpp.Out.FrameRateExtN/m_mfxVideoParam.vpp.Out.FrameRateExtD;
}
}
for (std::map<MSDKDecodeVpp*, MediaBuf>::iterator it = m_mapMediaBuf.begin();
it != m_mapMediaBuf.end(); it++)
dynamic_cast<MSDKDecode*>(it->first)->SetCompFrameRate(m_frameRate);
m_nInterFrameSpace = 1000*1000/m_frameRate;
m_nSleepInterval = m_nInterFrameSpace; //sleep full of the inter-frame space
//calculate the arg `growth potential` in logistic equation
m_argMasterGrowthPotential = log(2*m_nInterFrameSpace-1)/(LOGISTIC_INTERVAL_UPPER/2);
VPP_TRACE_INFO("[MSDKVpp]-----Vpp output frame rate: %d\n", m_frameRate);
m_mfxVideoParam.vpp.Out.FourCC = m_mfxVideoParam.vpp.In.FourCC;
m_mfxVideoParam.vpp.Out.ChromaFormat = m_mfxVideoParam.vpp.In.ChromaFormat;
m_mfxVideoParam.vpp.Out.PicStruct = m_mfxVideoParam.vpp.In.PicStruct;
m_mfxVideoParam.vpp.Out.CropX = 0;
m_mfxVideoParam.vpp.Out.CropY = 0;
m_mfxVideoParam.vpp.Out.CropW = m_vppCfg.out_width;
m_mfxVideoParam.vpp.Out.CropH = m_vppCfg.out_height;
m_mfxVideoParam.vpp.Out.Width = MSDK_ALIGN16(m_mfxVideoParam.vpp.Out.CropW);
m_mfxVideoParam.vpp.Out.Height = MSDK_ALIGN16(m_mfxVideoParam.vpp.Out.CropH);
#ifdef CONFIG_USE_MFXALLOCATOR
m_mfxVideoParam.IOPattern = MFX_IOPATTERN_IN_VIDEO_MEMORY | MFX_IOPATTERN_OUT_VIDEO_MEMORY;
VPP_TRACE_INFO("----------------vpp using video memory\n");
#else
m_mfxVideoParam.IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY | MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
VPP_TRACE_INFO("----------------vpp using system memory\n");
#endif
mfxStatus sts = MFX_ERR_NONE;
mfxFrameAllocRequest vppRequest[2]; //[0]-in, [1]-out
memset(&vppRequest, 0, sizeof(mfxFrameAllocRequest)*2);
sts = m_pVpp->QueryIOSurf(&m_mfxVideoParam, vppRequest);
if (sts < MFX_ERR_NONE)
return sts;
m_nSurfaces = vppRequest[1].NumFrameSuggested+15;
VPP_TRACE_INFO("[MSDKVpp]-----VPP suggest number of surfaces is in/out %d/%d\n",
vppRequest[0].NumFrameSuggested, m_nSurfaces);
VPP_TRACE_INFO("[MSDKVpp]-----Creating VPP surface pool, surface num %d\n", m_nSurfaces);
sts = AllocFrames(&vppRequest[1]);
mfxExtVPPComposite vppComp;
if (VPP_COMP == m_mode) {
SetVppCompParam(&vppComp);
m_mfxVideoParam.ExtParam[0] = (mfxExtBuffer*)&vppComp;
m_mfxVideoParam.NumExtParam = 1;
}
sts = m_pVpp->Init(&m_mfxVideoParam);
if (MFX_WRN_FILTER_SKIPPED == sts) {
VPP_TRACE_INFO("[MSDKVpp]-----Got MFX_WRN_FILTER_SKIPPED\n");
sts = MFX_ERR_NONE;
}
if (VPP_COMP == m_mode)
delete[] vppComp.InputStream;
if (m_pMeasuremnt)
{
m_pMeasuremnt->GetLock();
m_pMeasuremnt->TimeStpFinish(VPP_INIT_TIME_STAMP, this);
m_pMeasuremnt->RelLock();
}
return sts;
}
mfxStatus MSDKEncode::InitEncoder(mfxFrameSurface1* pFrameSurface)
{
if (m_pMeasuremnt)
{
m_pMeasuremnt->GetLock();
m_pMeasuremnt->TimeStpStart(ENC_INIT_TIME_STAMP, this);
m_pMeasuremnt->RelLock();
}
if (pFrameSurface)
{
m_mfxVideoParam.mfx.FrameInfo.FrameRateExtN = pFrameSurface->Info.FrameRateExtN;
m_mfxVideoParam.mfx.FrameInfo.FrameRateExtD = pFrameSurface->Info.FrameRateExtD;
m_mfxVideoParam.mfx.FrameInfo.FourCC = pFrameSurface->Info.FourCC;
m_mfxVideoParam.mfx.FrameInfo.ChromaFormat = pFrameSurface->Info.ChromaFormat;
m_mfxVideoParam.mfx.FrameInfo.CropX = pFrameSurface->Info.CropX;
m_mfxVideoParam.mfx.FrameInfo.CropY = pFrameSurface->Info.CropY;
m_mfxVideoParam.mfx.FrameInfo.CropW = pFrameSurface->Info.CropW;
m_mfxVideoParam.mfx.FrameInfo.CropH = pFrameSurface->Info.CropH;
m_mfxVideoParam.mfx.FrameInfo.Width = pFrameSurface->Info.Width;
m_mfxVideoParam.mfx.FrameInfo.Height = pFrameSurface->Info.Height;
m_mfxVideoParam.mfx.FrameInfo.PicStruct = pFrameSurface->Info.PicStruct;
}
//extcoding option2
m_codingOpt2.Header.BufferId = MFX_EXTBUFF_CODING_OPTION2;
m_codingOpt2.Header.BufferSz = sizeof(m_codingOpt2);
m_codingOpt2.RepeatPPS = MFX_CODINGOPTION_OFF; //No repeat pps
m_encExtParams.push_back(reinterpret_cast<mfxExtBuffer*>(&m_codingOpt2));
#ifdef CONFIG_USE_MFXALLOCATOR
m_mfxVideoParam.IOPattern = MFX_IOPATTERN_IN_VIDEO_MEMORY;
H264E_TRACE_INFO("----------------encoder using video memory\n");
#else
m_mfxVideoParam.IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
H264E_TRACE_INFO("----------------encoder using system memory\n");
#endif
//set mfx video ExtParam
if (!m_encExtParams.empty())
{
m_mfxVideoParam.ExtParam = &m_encExtParams.front(); //vector is stored linearly in memory
m_mfxVideoParam.NumExtParam = (mfxU16)m_encExtParams.size();
H264E_TRACE_INFO("[MSDKEncode]-----init encoder, ext param number is %d\n", m_mfxVideoParam.NumExtParam);
}
mfxFrameAllocRequest encRequest;
memset(&encRequest, 0, sizeof(encRequest));
mfxStatus sts = m_pEncode->QueryIOSurf(&m_mfxVideoParam, &encRequest);
if (MFX_ERR_NONE > sts)
return sts;
H264E_TRACE_INFO("[MSDKEncode]-----Enc suggest surfaces %d\n", encRequest.NumFrameSuggested);
#ifdef CONFIG_READ_RAW_BUFFER
m_nSurfaces = encRequest.NumFrameSuggested+FRAME_POOL_SIZE;
sts = AllocFrames(&encRequest);
#endif
sts = m_pEncode->Init(&m_mfxVideoParam);
if (sts != MFX_ERR_NONE) {
H264E_TRACE_ERROR("[MSDKEncode]-----enc init return %d\n", sts);
assert(sts >= MFX_ERR_NONE);
}
mfxVideoParam par;
memset(&par, 0, sizeof(par));
sts = m_pEncode->GetVideoParam(&par);
//Prepare Media SDK bit stream buffer for encoder
memset(&m_outputBs, 0, sizeof(m_outputBs));
m_outputBs.MaxLength = par.mfx.BufferSizeInKB*2000;
m_outputBs.Data = new mfxU8[m_outputBs.MaxLength];
if (!m_outputBs.Data)
return MFX_ERR_MEMORY_ALLOC;
H264E_TRACE_INFO("[MSDKEncode]-----output bitstream buffer size %d\n", m_outputBs.MaxLength);
if (m_pMeasuremnt)
{
m_pMeasuremnt->GetLock();
m_pMeasuremnt->TimeStpFinish(ENC_INIT_TIME_STAMP, this);
m_pMeasuremnt->RelLock();
}
return sts;
}