ImxVpuDecReturnCodes imx_vpu_dec_register_framebuffers(ImxVpuDecoder *decoder, ImxVpuFramebuffer *framebuffers, unsigned int num_framebuffers)
{
unsigned int i;
VpuDecRetCode ret;
VpuFrameBuffer *temp_fbs;
IMX_VPU_TRACE("attempting to register %u framebuffers", num_framebuffers);
decoder->wrapper_framebuffers = NULL;
temp_fbs = IMX_VPU_ALLOC(sizeof(VpuFrameBuffer) * num_framebuffers);
if (temp_fbs == NULL)
{
IMX_VPU_ERROR("allocating memory for framebuffers failed");
return IMX_VPU_DEC_RETURN_CODE_ERROR;
}
for (i = 0; i < num_framebuffers; ++i)
convert_to_wrapper_framebuffer(&framebuffers[i], &(temp_fbs[i]));
ret = VPU_DecRegisterFrameBuffer(decoder->handle, temp_fbs, num_framebuffers);
IMX_VPU_FREE(temp_fbs, sizeof(VpuFrameBuffer) * num_framebuffers);
if (ret != VPU_DEC_RET_SUCCESS)
{
ImxVpuDecReturnCodes imxret = dec_convert_retcode(ret);
IMX_VPU_ERROR("registering framebuffers failed: %s", imx_vpu_dec_error_string(imxret));
return ret;
}
decoder->wrapper_framebuffers = IMX_VPU_ALLOC(sizeof(VpuFrameBuffer*) * num_framebuffers);
{
int out_num;
VPU_DecAllRegFrameInfo(decoder->handle, decoder->wrapper_framebuffers, &out_num);
IMX_VPU_LOG("out_num: %d num_framebuffers: %u", out_num, num_framebuffers);
}
decoder->framebuffers = framebuffers;
decoder->num_framebuffers = num_framebuffers;
decoder->num_available_framebuffers = num_framebuffers;
decoder->user_data_for_frames = IMX_VPU_ALLOC(sizeof(void*) * num_framebuffers);
if (decoder->user_data_for_frames == NULL)
{
IMX_VPU_ERROR("allocating memory for user data failed");
IMX_VPU_FREE(decoder->wrapper_framebuffers, sizeof(VpuFrameBuffer*) * num_framebuffers);
decoder->wrapper_framebuffers = NULL;
return IMX_VPU_DEC_RETURN_CODE_ERROR;
}
memset(decoder->user_data_for_frames, 0, sizeof(void*) * num_framebuffers);
decoder->num_user_data = 0;
return IMX_VPU_DEC_RETURN_CODE_OK;
}
gboolean gst_fsl_vpu_framebuffers_register_with_decoder(GstFslVpuFramebuffers *framebuffers, VpuDecHandle handle)
{
VpuDecRetCode vpu_ret;
if (framebuffers->registration_state != GST_FSL_VPU_FRAMEBUFFERS_UNREGISTERED)
{
GST_ERROR_OBJECT(framebuffers, "framebuffers already registered");
return FALSE;
}
framebuffers->decenc_states.dec.handle = handle;
vpu_ret = VPU_DecRegisterFrameBuffer(handle, framebuffers->framebuffers, framebuffers->num_framebuffers);
if (vpu_ret != VPU_DEC_RET_SUCCESS)
{
GST_ERROR_OBJECT(framebuffers, "registering framebuffers failed: %s", gst_fsl_vpu_strerror(vpu_ret));
return FALSE;
}
framebuffers->registration_state = GST_FSL_VPU_FRAMEBUFFERS_DECODER_REGISTERED;
framebuffers->decenc_states.dec.decoder_open = TRUE;
return TRUE;
}
int CDVDVideoCodecIMX::Decode(BYTE *pData, int iSize, double dts, double pts)
{
VpuDecFrameLengthInfo frameLengthInfo;
VpuBufferNode inData;
VpuDecRetCode ret;
int decRet = 0;
int retStatus = 0;
int demuxer_bytes = iSize;
uint8_t *demuxer_content = pData;
int retries = 0;
int idx;
#ifdef IMX_PROFILE
static unsigned long long previous, current;
unsigned long long before_dec;
#endif
if (!m_vpuHandle)
{
VpuOpen();
if (!m_vpuHandle)
return VC_ERROR;
}
for (int i=0; i < m_vpuFrameBufferNum; i++)
{
if (m_outputBuffers[i]->Rendered())
{
ret = m_outputBuffers[i]->ReleaseFramebuffer(&m_vpuHandle);
if(ret != VPU_DEC_RET_SUCCESS)
{
CLog::Log(LOGERROR, "%s: vpu clear frame display failure: ret=%d \r\n",__FUNCTION__,ret);
}
}
}
#ifdef IMX_PROFILE
current = XbmcThreads::SystemClockMillis();
CLog::Log(LOGDEBUG, "%s - delta time decode : %llu - demux size : %d dts : %f - pts : %f\n", __FUNCTION__, current - previous, iSize, dts, pts);
previous = current;
#endif
if ((pData && iSize) ||
(m_bytesToBeConsumed))
{
if ((m_convert_bitstream) && (iSize))
{
// convert demuxer packet from bitstream to bytestream (AnnexB)
if (m_converter->Convert(demuxer_content, demuxer_bytes))
{
demuxer_content = m_converter->GetConvertBuffer();
demuxer_bytes = m_converter->GetConvertSize();
}
else
CLog::Log(LOGERROR,"%s - bitstream_convert error", __FUNCTION__);
}
inData.nSize = demuxer_bytes;
inData.pPhyAddr = NULL;
inData.pVirAddr = demuxer_content;
if ((m_decOpenParam.CodecFormat == VPU_V_MPEG2) ||
(m_decOpenParam.CodecFormat == VPU_V_VC1_AP)||
(m_decOpenParam.CodecFormat == VPU_V_XVID))
{
inData.sCodecData.pData = (unsigned char *)m_hints.extradata;
inData.sCodecData.nSize = m_hints.extrasize;
}
else
{
inData.sCodecData.pData = NULL;
inData.sCodecData.nSize = 0;
}
while (true) // Decode as long as the VPU consumes data
{
#ifdef IMX_PROFILE
before_dec = XbmcThreads::SystemClockMillis();
#endif
if (m_frameReported)
m_bytesToBeConsumed += inData.nSize;
ret = VPU_DecDecodeBuf(m_vpuHandle, &inData, &decRet);
#ifdef IMX_PROFILE
CLog::Log(LOGDEBUG, "%s - VPU dec 0x%x decode takes : %lld\n\n", __FUNCTION__, decRet, XbmcThreads::SystemClockMillis() - before_dec);
#endif
if (ret != VPU_DEC_RET_SUCCESS)
{
CLog::Log(LOGERROR, "%s - VPU decode failed with error code %d.\n", __FUNCTION__, ret);
goto out_error;
}
if (decRet & VPU_DEC_INIT_OK)
// VPU decoding init OK : We can retrieve stream info
{
ret = VPU_DecGetInitialInfo(m_vpuHandle, &m_initInfo);
if (ret == VPU_DEC_RET_SUCCESS)
{
if (g_advancedSettings.CanLogComponent(LOGVIDEO))
{
CLog::Log(LOGDEBUG, "%s - VPU Init Stream Info : %dx%d (interlaced : %d - Minframe : %d)"\
" - Align : %d bytes - crop : %d %d %d %d - Q16Ratio : %x\n", __FUNCTION__,
m_initInfo.nPicWidth, m_initInfo.nPicHeight, m_initInfo.nInterlace, m_initInfo.nMinFrameBufferCount,
m_initInfo.nAddressAlignment, m_initInfo.PicCropRect.nLeft, m_initInfo.PicCropRect.nTop,
m_initInfo.PicCropRect.nRight, m_initInfo.PicCropRect.nBottom, m_initInfo.nQ16ShiftWidthDivHeightRatio);
}
if (VpuAllocFrameBuffers())
{
ret = VPU_DecRegisterFrameBuffer(m_vpuHandle, m_vpuFrameBuffers, m_vpuFrameBufferNum);
if (ret != VPU_DEC_RET_SUCCESS)
{
CLog::Log(LOGERROR, "%s - VPU error while registering frame buffers (%d).\n", __FUNCTION__, ret);
goto out_error;
}
}
else
{
goto out_error;
}
}
else
{
CLog::Log(LOGERROR, "%s - VPU get initial info failed (%d).\n", __FUNCTION__, ret);
goto out_error;
}
} //VPU_DEC_INIT_OK
if (decRet & VPU_DEC_ONE_FRM_CONSUMED)
{
ret = VPU_DecGetConsumedFrameInfo(m_vpuHandle, &frameLengthInfo);
if (ret != VPU_DEC_RET_SUCCESS)
{
CLog::Log(LOGERROR, "%s - VPU error retireving info about consummed frame (%d).\n", __FUNCTION__, ret);
}
m_bytesToBeConsumed -= (frameLengthInfo.nFrameLength + frameLengthInfo.nStuffLength);
if (frameLengthInfo.pFrame)
{
idx = VpuFindBuffer(frameLengthInfo.pFrame->pbufY);
if (m_bytesToBeConsumed < 50)
m_bytesToBeConsumed = 0;
if (idx != -1)
{
if (m_previousPts != DVD_NOPTS_VALUE)
{
m_outputBuffers[idx]->SetPts(m_previousPts);
m_previousPts = DVD_NOPTS_VALUE;
}
else
m_outputBuffers[idx]->SetPts(pts);
}
else
CLog::Log(LOGERROR, "%s - could not find frame buffer\n", __FUNCTION__);
}
} //VPU_DEC_ONE_FRM_CONSUMED
if (decRet & VPU_DEC_OUTPUT_DIS)
// Frame ready to be displayed
{
if (retStatus & VC_PICTURE)
CLog::Log(LOGERROR, "%s - Second picture in the same decode call !\n", __FUNCTION__);
ret = VPU_DecGetOutputFrame(m_vpuHandle, &m_frameInfo);
if(ret != VPU_DEC_RET_SUCCESS)
{
CLog::Log(LOGERROR, "%s - VPU Cannot get output frame(%d).\n", __FUNCTION__, ret);
goto out_error;
}
// Some codecs (VC1?) lie about their frame size (mod 16). Adjust...
m_frameInfo.pExtInfo->nFrmWidth = (((m_frameInfo.pExtInfo->nFrmWidth) + 15) & ~15);
m_frameInfo.pExtInfo->nFrmHeight = (((m_frameInfo.pExtInfo->nFrmHeight) + 15) & ~15);
retStatus |= VC_PICTURE;
} //VPU_DEC_OUTPUT_DIS
// According to libfslvpuwrap: If this flag is set then the frame should
// be dropped. It is just returned to gather decoder information but not
// for display.
if (decRet & VPU_DEC_OUTPUT_MOSAIC_DIS)
{
ret = VPU_DecGetOutputFrame(m_vpuHandle, &m_frameInfo);
if(ret != VPU_DEC_RET_SUCCESS)
{
CLog::Log(LOGERROR, "%s - VPU Cannot get output frame(%d).\n", __FUNCTION__, ret);
goto out_error;
}
// Display frame
ret = VPU_DecOutFrameDisplayed(m_vpuHandle, m_frameInfo.pDisplayFrameBuf);
if(ret != VPU_DEC_RET_SUCCESS)
{
CLog::Log(LOGERROR, "%s: VPU Clear frame display failure(%d)\n",__FUNCTION__,ret);
goto out_error;
}
} //VPU_DEC_OUTPUT_MOSAIC_DIS
if (decRet & VPU_DEC_OUTPUT_REPEAT)
{
if (g_advancedSettings.CanLogComponent(LOGVIDEO))
CLog::Log(LOGDEBUG, "%s - Frame repeat.\n", __FUNCTION__);
}
if (decRet & VPU_DEC_OUTPUT_DROPPED)
{
if (g_advancedSettings.CanLogComponent(LOGVIDEO))
CLog::Log(LOGDEBUG, "%s - Frame dropped.\n", __FUNCTION__);
}
if (decRet & VPU_DEC_NO_ENOUGH_BUF)
{
CLog::Log(LOGERROR, "%s - No frame buffer available.\n", __FUNCTION__);
}
if (decRet & VPU_DEC_SKIP)
{
if (g_advancedSettings.CanLogComponent(LOGVIDEO))
CLog::Log(LOGDEBUG, "%s - Frame skipped.\n", __FUNCTION__);
}
if (decRet & VPU_DEC_FLUSH)
{
CLog::Log(LOGNOTICE, "%s - VPU requires a flush.\n", __FUNCTION__);
Reset();
retStatus = VC_FLUSHED;
}
if (decRet & VPU_DEC_OUTPUT_EOS)
{
CLog::Log(LOGNOTICE, "%s - EOS encountered.\n", __FUNCTION__);
}
if ((decRet & VPU_DEC_NO_ENOUGH_INBUF) ||
(decRet & VPU_DEC_OUTPUT_DIS))
{
// We are done with VPU decoder that time
break;
}
retries++;
if (retries >= m_maxVpuDecodeLoops)
{
CLog::Log(LOGERROR, "%s - Leaving VPU decoding loop after %d iterations\n", __FUNCTION__, m_maxVpuDecodeLoops);
break;
}
if (!(decRet & VPU_DEC_INPUT_USED))
{
CLog::Log(LOGERROR, "%s - input not used : addr %p size :%d!\n", __FUNCTION__, inData.pVirAddr, inData.nSize);
}
// Let's process again as VPU_DEC_NO_ENOUGH_INBUF was not set
// and we don't have an image ready if we reach that point
inData.pVirAddr = NULL;
inData.nSize = 0;
} // Decode loop
} //(pData && iSize)
if (retStatus == 0)
{
retStatus |= VC_BUFFER;
}
if (m_bytesToBeConsumed > 0)
{
// Remember the current pts because the data which has just
// been sent to the VPU has not yet been consumed.
// This pts is related to the frame that will be consumed
// at next call...
m_previousPts = pts;
}
// Store current dts (will be used only if VC_PICTURE is set)
m_dts = dts;
#ifdef IMX_PROFILE
CLog::Log(LOGDEBUG, "%s - returns %x - duration %lld\n", __FUNCTION__, retStatus, XbmcThreads::SystemClockMillis() - previous);
#endif
return retStatus;
out_error:
return VC_ERROR;
}
