OMX_ERRORTYPE ResourceExhaustionTest_DeInitBuffer(ResourceExhaustionTestContext *pCtxt)
{
BufferList *pBufferListObject;
BufferList *pTemp;
OMX_ERRORTYPE eError = OMX_ErrorNone;
pTemp = pCtxt->pBufferList[pCtxt->nInst];
while (pTemp)
{
pBufferListObject = (BufferList *)pTemp;
if (pTemp->pBufHdr->nInputPortIndex != OMX_NOPORT)
eError = OMX_FreeBuffer(pCtxt->hWComp[pCtxt->nInst],
pTemp->pBufHdr->nInputPortIndex, pTemp->pBufHdr);
else
eError = OMX_FreeBuffer(pCtxt->hWComp[pCtxt->nInst],
pTemp->pBufHdr->nOutputPortIndex, pTemp->pBufHdr);
if (eError == OMX_ErrorInvalidState || eError == OMX_ErrorIncorrectStateOperation)
eError = OMX_ErrorNone;
OMX_CONF_BAIL_IF_ERROR(eError);
pTemp = pTemp->pNextBuf;
if (pBufferListObject)
OMX_OSAL_Free(pBufferListObject);
}
pCtxt->pBufferList[pCtxt->nInst] = NULL;
OMX_CONF_TEST_BAIL:
return eError;
}
/** mm_jpeg_session_free_buffers:
*
* Arguments:
* @data: job session
*
* Return:
* OMX error values
*
* Description:
* Free the buffers from OMX layer
*
**/
OMX_ERRORTYPE mm_jpegdec_session_free_buffers(void *data)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
uint32_t i = 0;
mm_jpeg_job_session_t* p_session = (mm_jpeg_job_session_t *)data;
mm_jpeg_decode_params_t *p_params = &p_session->dec_params;
for (i = 0; i < p_params->num_src_bufs; i++) {
CDBG("%s:%d] Source buffer %d", __func__, __LINE__, i);
ret = OMX_FreeBuffer(p_session->omx_handle, 0, p_session->p_in_omx_buf[i]);
if (ret) {
CDBG_ERROR("%s:%d] Error %d", __func__, __LINE__, ret);
return ret;
}
}
for (i = 0; i < p_params->num_dst_bufs; i++) {
CDBG("%s:%d] Dest buffer %d", __func__, __LINE__, i);
ret = OMX_FreeBuffer(p_session->omx_handle, 1, p_session->p_out_omx_buf[i]);
if (ret) {
CDBG_ERROR("%s:%d] Error", __func__, __LINE__);
return ret;
}
}
CDBG("%s:%d]", __func__, __LINE__);
return ret;
}
OMX_ERRORTYPE PortCommTest_DeInitBuffer(PortCommTestCtxt* pContext)
{
OMX_U8 *pBuffer;
BufferList *pBufferListObject;
BufferList *pTemp;
OMX_ERRORTYPE eError = OMX_ErrorNone;
OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Free all buffers\n");
pTemp = pContext->pInBufferList;
while (pTemp)
{
pBufferListObject = (BufferList *)pTemp;
pBuffer = (OMX_U8 *)pTemp->pOrigBufHdr->pBuffer;
if (pContext->bClientAllocBuf)
{
OMX_OSAL_Free(pBuffer);
pTemp->pOrigBufHdr->pBuffer = NULL;
}
eError = OMX_FreeBuffer(pContext->hWComp, pTemp->pOrigBufHdr->nInputPortIndex, pTemp->pOrigBufHdr);
if (eError == OMX_ErrorInvalidState)
eError = OMX_ErrorNone;
OMX_CONF_BAIL_IF_ERROR(eError);
pTemp = pTemp->pNextBuf;
if (pBufferListObject)
OMX_OSAL_Free(pBufferListObject);
pContext->nInBuf--;
}
pContext->pInBufferList = NULL;
pTemp = pContext->pOutBufferList;
while (pTemp)
{
pBufferListObject = (BufferList *)pTemp;
pBuffer = (OMX_U8 *)pTemp->pOrigBufHdr->pBuffer;
if (pContext->bClientAllocBuf)
{
OMX_OSAL_Free(pBuffer);
pTemp->pOrigBufHdr->pBuffer = NULL;
}
eError = OMX_FreeBuffer(pContext->hWComp, pTemp->pOrigBufHdr->nOutputPortIndex, pTemp->pOrigBufHdr);
if (eError == OMX_ErrorInvalidState)
eError = OMX_ErrorNone;
OMX_CONF_BAIL_IF_ERROR(eError);
pTemp = pTemp->pNextBuf;
if (pBufferListObject)
OMX_OSAL_Free(pBufferListObject);
pContext->nOutBuf--;
}
pContext->pOutBufferList = NULL;
OMX_CONF_TEST_BAIL:
return eError;
}
static av_cold void cleanup(OMXCodecContext *s)
{
int i, executing;
pthread_mutex_lock(&s->state_mutex);
executing = s->state == OMX_StateExecuting;
pthread_mutex_unlock(&s->state_mutex);
if (executing) {
OMX_SendCommand(s->handle, OMX_CommandStateSet, OMX_StateIdle, NULL);
wait_for_state(s, OMX_StateIdle);
OMX_SendCommand(s->handle, OMX_CommandStateSet, OMX_StateLoaded, NULL);
for (i = 0; i < s->num_in_buffers; i++) {
OMX_BUFFERHEADERTYPE *buffer = get_buffer(&s->input_mutex, &s->input_cond,
&s->num_free_in_buffers, s->free_in_buffers, 1);
if (s->input_zerocopy)
buffer->pBuffer = NULL;
OMX_FreeBuffer(s->handle, s->in_port, buffer);
}
for (i = 0; i < s->num_out_buffers; i++) {
OMX_BUFFERHEADERTYPE *buffer = get_buffer(&s->output_mutex, &s->output_cond,
&s->num_done_out_buffers, s->done_out_buffers, 1);
OMX_FreeBuffer(s->handle, s->out_port, buffer);
}
wait_for_state(s, OMX_StateLoaded);
}
if (s->handle) {
s->omx_context->ptr_FreeHandle(s->handle);
s->handle = NULL;
}
omx_deinit(s->omx_context);
s->omx_context = NULL;
if (s->mutex_cond_inited) {
pthread_cond_destroy(&s->state_cond);
pthread_mutex_destroy(&s->state_mutex);
pthread_cond_destroy(&s->input_cond);
pthread_mutex_destroy(&s->input_mutex);
pthread_cond_destroy(&s->output_cond);
pthread_mutex_destroy(&s->output_mutex);
s->mutex_cond_inited = 0;
}
av_freep(&s->in_buffer_headers);
av_freep(&s->out_buffer_headers);
av_freep(&s->free_in_buffers);
av_freep(&s->done_out_buffers);
av_freep(&s->output_buf);
}
OMX_ERRORTYPE COpenMaxVideo::FreeOMXInputBuffers(bool wait)
{
OMX_ERRORTYPE omx_err = OMX_ErrorNone;
/*
omx_err = OMX_SendCommand(m_omx_decoder, OMX_CommandFlush, m_omx_input_port, 0);
if (omx_err)
CLog::Log(LOGERROR, "%s::%s - OMX_CommandFlush failed with omx_err(0x%x)\n",
CLASSNAME, __func__, omx_err);
else if (wait)
sem_wait(m_omx_flush_input);
*/
// free omx input port buffers.
for (size_t i = 0; i < m_omx_input_buffers.size(); i++)
{
// using external buffers (OMX_UseBuffer), free our external buffers
// before calling OMX_FreeBuffer which frees the omx buffer.
delete [] m_omx_input_buffers[i]->pBuffer;
m_omx_input_buffers[i]->pBuffer = NULL;
omx_err = OMX_FreeBuffer(m_omx_decoder, m_omx_input_port, m_omx_input_buffers[i]);
}
m_omx_input_buffers.clear();
// empty input buffer queue. not decoding so don't need lock/unlock.
while (!m_omx_input_avaliable.empty())
m_omx_input_avaliable.pop();
while (!m_demux_queue.empty())
m_demux_queue.pop();
while (!m_dts_queue.empty())
m_dts_queue.pop();
return(omx_err);
}
void omxbufs_deinit(IOPort& iop) {
printf("%s: Port %d: Actual %u, %d\n",__FUNCTION__, iop.nPortIndex, iop.nBufferCountActual, (int)iop.size());
for (auto beg = iop.begin(); beg != iop.end(); ++beg) {
OMX_FreeBuffer(component, iop.nPortIndex, beg->buf);
}
iop.clear();
}
static void
port_free_buffers (GOmxPort *port)
{
guint i;
for (i = 0; i < port->num_buffers; i++)
{
OMX_BUFFERHEADERTYPE *omx_buffer;
omx_buffer = port->buffers[i];
if (omx_buffer)
{
#if 0
/** @todo how shall we free that buffer? */
if (!port->omx_allocate)
{
g_free (omx_buffer->pBuffer);
omx_buffer->pBuffer = NULL;
}
#endif
OMX_FreeBuffer (port->core->omx_handle, port->port_index, omx_buffer);
port->buffers[i] = NULL;
}
}
}
OMX_ERRORTYPE free_port_buffers(HCOMPONENT *component, OMX_U32 nPortIndex)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
OMX_COMPONENTTYPE *hComponent;
OMX_U32 i;
hComponent = component->hComponent;
for(i=0; i<component->nBufferHdr[nPortIndex]; i++)
{
OMX_U8 *ptr = component->pBufferHdr[nPortIndex][i]->pBuffer;
while(1)
{
ret = OMX_FreeBuffer(hComponent, nPortIndex, component->pBufferHdr[nPortIndex][i]);
if(ret == OMX_ErrorNotReady)
usleep(10000);
else
break;
}
component->pBufferHdr[nPortIndex][i] = 0;
if(component->bAllocater[nPortIndex] == OMX_FALSE)
FSL_FREE(ptr);
}
return OMX_ErrorNone;
}
OMX_ERRORTYPE COpenMaxVideo::FreeOMXOutputEGLTextures(bool wait)
{
OMX_ERRORTYPE omx_err = OMX_ErrorNone;
OpenMaxVideoBuffer *egl_buffer;
if (!eglDestroyImageKHR)
{
GETEXTENSION(PFNEGLDESTROYIMAGEKHRPROC, eglDestroyImageKHR);
}
for (size_t i = 0; i < m_omx_output_buffers.size(); i++)
{
egl_buffer = m_omx_output_buffers[i];
// tell decoder output port to stop using the EGLImage
omx_err = OMX_FreeBuffer(m_omx_decoder, m_omx_output_port, egl_buffer->omx_buffer);
// destroy egl_image
eglDestroyImageKHR(m_egl_display, egl_buffer->egl_image);
// free texture
glDeleteTextures(1, &egl_buffer->texture_id);
delete egl_buffer;
}
m_omx_output_buffers.clear();
return omx_err;
}
static OMX_ERRORTYPE
OMXDecoder_freeBuffers
(OMXDecoder *thiz,
OMX_BUFFERHEADERTYPE **buffers, OMX_U32 count,
OMX_U32 portIndex)
{
OMX_U32 i;
OMX_HANDLETYPE component = thiz->component;
OMX_ERRORTYPE ret = OMX_ErrorNone;
for (i = 0; i < count; i++)
{
OMX_BUFFERHEADERTYPE *buffer = *(buffers + i);
if (buffer)
{
OMX_U8 *buffer_;
OMX_ERRORTYPE omxerr;
buffer_ = buffer->pBuffer;
omxerr = OMX_FreeBuffer(component, portIndex, buffer);
if (OMX_ErrorNone == omxerr)
{
free(buffer_);
*(buffers + i) = NULL;
}
else
ret = omxerr;
}
}
if (OMX_ErrorNone == ret)
free(buffers);
return ret;
}
void AnatomyOMXClient::freeBuffers() {
LOGD("=============================================");
for (size_t i = mBufferInfo.size(); i--;) {
int port_index= mBufferInfo[i].mPortIndex;
OMX_BUFFERHEADERTYPE *header = mBufferInfo[i].mBufferHeader;
LOGD("mBufferInfo[%d] mPortIndex : %d, mBufferHeader %p",i, port_index, header);
removeOMXBufferInfo(port_index, header);
OMX_FreeBuffer(mComponentHandle, port_index, header);
}
LOGD("=============================================");
}
OMX_ERRORTYPE omxil_comp::FreeBuffer(OMX_U32 nPortIndex, OMX_BUFFERHEADERTYPE *pBuffer)
{
OMX_ERRORTYPE result;
result = OMX_FreeBuffer(comp, nPortIndex, pBuffer);
if (result != OMX_ErrorNone) {
fprintf(stderr, "OMX_FreeBuffer failed.\n");
}
return result;
}
void
omx_release_buffers(omx_component_t *oc, int port)
{
assert(oc->oc_inflight_buffers == 0);
OMX_BUFFERHEADERTYPE *buf, *n;
for(buf = oc->oc_avail; buf; buf = n) {
n = buf->pAppPrivate;
int r = OMX_FreeBuffer(oc->oc_handle, port, buf);
printf("%s freeing buf %p : %x\n", oc->oc_name, buf, r);
}
}
void omx_free_buffers(struct omx_component_t *component, int port)
{
OMX_BUFFERHEADERTYPE *buf, *prev;
int i=0;
buf = component->buffers;
while (buf) {
prev = buf->pAppPrivate;
OERR(OMX_FreeBuffer(component->h, port, buf)); /* This also calls free() */
buf = prev;
}
}
static void Close(vlc_object_t *obj)
{
filter_t *filter = (filter_t*) obj;
filter_sys_t *sys = filter->p_sys;
unsigned int i, j;
if (sys->omx_handle) {
OMX_STATETYPE state;
OMX_GetState(sys->omx_handle, &state);
if (state == OMX_StateExecuting) {
OMX_SendCommand(sys->omx_handle, OMX_CommandStateSet,
OMX_StateIdle, 0);
while (1) {
OMX_U32 cmd, state;
WaitForSpecificOmxEvent(&sys->event_queue, OMX_EventCmdComplete,
&cmd, &state, 0);
if (cmd == OMX_CommandStateSet && state == OMX_StateIdle)
break;
}
}
OMX_GetState(sys->omx_handle, &state);
if (state == OMX_StateIdle) {
OMX_SendCommand(sys->omx_handle, OMX_CommandStateSet,
OMX_StateLoaded, 0);
for (i = 0; i < sys->num_ports; i++) {
OmxPort *port = &sys->ports[i];
for (j = 0; j < sys->ports[i].i_buffers; j++) {
OMX_BUFFERHEADERTYPE *buffer;
OMX_FIFO_GET(&port->fifo, buffer);
OMX_FreeBuffer(sys->omx_handle, port->i_port_index,
buffer);
}
}
WaitForSpecificOmxEvent(&sys->event_queue, OMX_EventCmdComplete,
0, 0, 0);
}
for (i = 0; i < sys->num_ports; i++)
free(sys->ports[i].pp_buffers);
pf_free_handle(sys->omx_handle);
DeinitOmxEventQueue(&sys->event_queue);
}
free(sys);
DeinitOmxCore();
}
void
omx_release_buffers(omx_component_t *oc, int port)
{
assert(oc->oc_inflight_buffers == 0);
OMX_BUFFERHEADERTYPE *buf, *n;
for(buf = oc->oc_avail; buf; buf = n) {
n = buf->pAppPrivate;
int r = OMX_FreeBuffer(oc->oc_handle, port, buf);
if(r) {
TRACE(TRACE_ERROR, "OMX", "Unable to free buffer");
exit(1);
}
}
}
void PureOmxBufferData::ReleaseBuffer()
{
LOG_BUF("");
if (mBuffer) {
OMX_ERRORTYPE err;
err = OMX_FreeBuffer(mPlatformLayer.GetComponent(),
mPortDef.nPortIndex,
mBuffer);
if (err != OMX_ErrorNone) {
LOG_BUF("Failed to free the buffer!: 0x%08x", err);
}
mBuffer = nullptr;
}
}
OMX_ERRORTYPE COMXCoreComponent::FreeOutputBuffer(OMX_BUFFERHEADERTYPE *omx_buffer)
{
OMX_ERRORTYPE omx_err = OMX_ErrorNone;
if(!m_handle || !omx_buffer)
return OMX_ErrorUndefined;
omx_err = OMX_FreeBuffer(m_handle, m_output_port, omx_buffer);
if (omx_err != OMX_ErrorNone) {
Logger::LogOut(LOG_LEVEL_ERROR, "COMXCoreComponent::FreeOutputBuffer component(%s) - failed with result(0x%x)",
m_componentName.c_str(), omx_err);
}
return omx_err;
}
OMX_ERRORTYPE COMXCoreComponent::FreeOutputBuffers(bool wait)
{
OMX_ERRORTYPE omx_err = OMX_ErrorNone;
if(!m_handle)
return OMX_ErrorUndefined;
if(m_omx_output_buffers.empty())
return OMX_ErrorNone;
m_flush_output = true;
pthread_mutex_lock(&m_omx_output_mutex);
pthread_cond_broadcast(&m_output_buffer_cond);
omx_err = DisablePort(m_output_port, false);
for (size_t i = 0; i < m_omx_output_buffers.size(); i++)
{
uint8_t *buf = m_omx_output_buffers[i]->pBuffer;
omx_err = OMX_FreeBuffer(m_handle, m_output_port, m_omx_output_buffers[i]);
if(m_omx_output_use_buffers && buf)
_aligned_free(buf);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXCoreComponent::FreeOutputBuffers error deallocate omx output buffer on component %s omx_err(0x%08x)\n", m_componentName.c_str(), omx_err);
}
}
WaitForCommand(OMX_CommandPortDisable, m_output_port);
assert(m_omx_output_buffers.size() == m_omx_output_available.size());
m_omx_output_buffers.clear();
while (!m_omx_output_available.empty())
m_omx_output_available.pop();
m_output_alignment = 0;
m_output_buffer_size = 0;
m_output_buffer_count = 0;
pthread_mutex_unlock(&m_omx_output_mutex);
return omx_err;
}
status_t OMXNodeInstance::freeBuffer(
OMX_U32 portIndex, OMX::buffer_id buffer) {
Mutex::Autolock autoLock(mLock);
removeActiveBuffer(portIndex, buffer);
OMX_BUFFERHEADERTYPE *header = (OMX_BUFFERHEADERTYPE *)buffer;
BufferMeta *buffer_meta = static_cast<BufferMeta *>(header->pAppPrivate);
OMX_ERRORTYPE err = OMX_FreeBuffer(mHandle, portIndex, header);
delete buffer_meta;
buffer_meta = NULL;
return StatusFromOMXError(err);
}
void
g_omx_core_finish (GOmxCore *core)
{
change_state (core, OMX_StateIdle);
wait_for_state (core, OMX_StateIdle);
change_state (core, OMX_StateLoaded);
{
guint index;
guint i;
for (index = 0; index < core->ports->len; index++)
{
GOmxPort *port;
port = g_omx_core_get_port (core, index);
for (i = 0; i < port->num_buffers; i++)
{
OMX_BUFFERHEADERTYPE *omx_buffer;
omx_buffer = port->buffers[i];
g_free (omx_buffer->pBuffer);
OMX_FreeBuffer (core->omx_handle, index, omx_buffer);
}
}
}
wait_for_state (core, OMX_StateLoaded);
{
gint index;
for (index = 0; index < core->ports->len; index++)
{
GOmxPort *port;
port = g_omx_core_get_port (core, index);
g_omx_port_free (port);
}
g_ptr_array_clear (core->ports);
}
}
OMX_ERRORTYPE Component::FreeOutputBuffer(OMX_BUFFERHEADERTYPE *omxBuffer)
{
if(!handle)
{
ofLogError(__func__) << getName() << " NO HANDLE";
return OMX_ErrorNone;
}
if(!omxBuffer)
{
return OMX_ErrorUndefined;
}
OMX_ERRORTYPE error = OMX_FreeBuffer(handle, outputPort, omxBuffer);
OMX_TRACE(error);
return error;
}
OMX_ERRORTYPE free_port_buffers(HTEST *hTest, OMX_U32 nPortIndex)
{
OMX_COMPONENTTYPE *hComponent;
OMX_U32 i;
hComponent = hTest->hComponent;
for(i=0; i<hTest->nBufferHdr[nPortIndex]; i++) {
OMX_U8 *ptr = NULL;
if(hTest->pBufferHdr[nPortIndex][i] == NULL)
continue;
ptr = hTest->pBufferHdr[nPortIndex][i]->pBuffer;
OMX_FreeBuffer(hComponent, nPortIndex, hTest->pBufferHdr[nPortIndex][i]);
hTest->pBufferHdr[nPortIndex][i] = 0;
if(hTest->bAllocater[nPortIndex] == OMX_FALSE)
FSL_FREE(ptr);
}
return OMX_ErrorNone;
}
OMX_ERRORTYPE Component::freeInputBuffers()
{
if(!handle)
{
ofLogError(__func__) << getName() << " NO HANDLE";
return OMX_ErrorNone;
}
OMX_ERRORTYPE error = OMX_ErrorNone;
if(inputBuffers.empty())
{
return OMX_ErrorNone;
}
//m_flush_input = true;
pthread_mutex_lock(&m_omx_input_mutex);
pthread_cond_broadcast(&m_input_buffer_cond);
error = disablePort(inputPort);
OMX_TRACE(error);
for (size_t i = 0; i < inputBuffers.size(); i++)
{
error = OMX_FreeBuffer(handle, inputPort, inputBuffers[i]);
OMX_TRACE(error);
}
inputBuffers.clear();
//error = waitForCommand(OMX_CommandPortDisable, inputPort);
//OMX_TRACE(error);
while (!inputBuffersAvailable.empty())
{
inputBuffersAvailable.pop();
}
pthread_mutex_unlock(&m_omx_input_mutex);
return error;
}
OMX_ERRORTYPE EnableDataFlow::freeBuffers()
{
DBGT_PROLOG("");
OMX_ERRORTYPE err = OMX_ErrorNone;
if (NULL != mArmIvInBuffer) {
err = OMX_FreeBuffer(mArmIvProc, (OMX_U32)( 0 ), mArmIvInBuffer);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("OMX_FreeBuffer failed for ArmIVProc input port err = %d", err);
DBGT_EPILOG("");
return err;
}
mArmIvInBuffer = NULL;
}
DBGT_EPILOG("");
return err;
}
status_t OMXNodeInstance::freeBuffer(
OMX_U32 portIndex, OMX::buffer_id buffer) {
Mutex::Autolock autoLock(mLock);
OMX_BUFFERHEADERTYPE *header = (OMX_BUFFERHEADERTYPE *)buffer;
BufferMeta *buffer_meta = static_cast<BufferMeta *>(header->pAppPrivate);
OMX_ERRORTYPE err = OMX_FreeBuffer(mHandle, portIndex, header);
if (err != OMX_ErrorNone) {
ALOGW("OMX_FreeBuffer failed w/ err %x, do not remove from active buffer list", err);
} else {
ALOGE("OMX_FreeBuffer for buffer header %p successful", header);
removeActiveBuffer(portIndex, buffer);
delete buffer_meta;
buffer_meta = NULL;
}
return StatusFromOMXError(err);
}
OMX_ERRORTYPE TorcOMXPort::DestroyBuffers(void)
{
if (!m_handle || !m_parent)
return OMX_ErrorUndefined;
(void)EnablePort(false);
{
QMutexLocker locker(m_lock);
for (int i = 0; i < m_buffers.size(); ++i)
{
OMX_ERRORTYPE error = OMX_FreeBuffer(m_handle, m_port, m_buffers.at(i));
OMX_CHECKX(error, m_parent->GetName(), "Failed to free buffer");
}
m_buffers.clear();
m_availableBuffers.clear();
m_alignment = 0;
}
return OMX_ErrorNone;
}
OMX_ERRORTYPE BufferTest_PortFreeNumBuffers(
TEST_CTXTYPE *pCtx,
TEST_PORTTYPE *pPort,
OMX_U32 nNumBuffers)
{
OMX_ERRORTYPE eError = OMX_ErrorNone;
OMX_BUFFERHEADERTYPE *pBufHdr;
while ((0x0 != LIFO_INQUEUE(pPort->pLifo)) && (0x0 != nNumBuffers))
{
LIFO_REMOVE(pPort->pLifo, pBufHdr);
eError = OMX_FreeBuffer(pCtx->hWrappedComp, pPort->sPortDef.nPortIndex, pBufHdr);
OMX_CONF_BAIL_ON_ERROR(eError);
nNumBuffers--;
}
OMX_CONF_TEST_BAIL:
return(eError);
}
static void raspi_release_buffers(player_ctx_t *ctx)
{
media_buffer_t *buffers[VIDEO_BUFFERS];
OMX_ERRORTYPE err;
int i;
if (ilcore_disable_port(ctx->decoder, IL_VIDEO_DECODER_IN_PORT, 0) != L_OK)
return;
for (i = 0; i < VIDEO_BUFFERS; i++)
{
OMX_BUFFERHEADERTYPE *hdr;
buffers[i] = decode_get_free_video_buffer(ctx->common.demux_ctx);
if (!buffers[i])
{
DBG_E("Can not get demuxer buffer #%d\n", i);
continue;
}
hdr = buffers[i]->app_data;
err = OMX_FreeBuffer(ilcore_get_handle(ctx->decoder), IL_VIDEO_DECODER_IN_PORT, hdr);
if (err != OMX_ErrorNone)
{
DBG_E("OMX_UseBuffer failed. err=%d index=%d\n", err, i);
return;
}
}
err = omx_core_comp_wait_command(ctx->decoder, OMX_CommandPortDisable, IL_VIDEO_DECODER_IN_PORT, 2000);
if (err != OMX_ErrorNone)
{
DBG_E("Wait event failed. err=0x%x\n", err);
return;
}
for (i = 0; i < VIDEO_BUFFERS; i++)
if (buffers[i])
decode_release_video_buffer(ctx->common.demux_ctx, buffers[i]);
}
static void Close(vlc_object_t *p_this)
{
vout_display_t *vd = (vout_display_t *)p_this;
vout_display_sys_t *p_sys = vd->sys;
if (p_sys->omx_handle) {
OMX_STATETYPE state;
OMX_GetState(p_sys->omx_handle, &state);
if (state == OMX_StateExecuting) {
OMX_SendCommand(p_sys->omx_handle, OMX_CommandStateSet, OMX_StateIdle, 0);
while (1) {
OMX_U32 cmd, state;
WaitForSpecificOmxEvent(&p_sys->event_queue, OMX_EventCmdComplete, &cmd, &state, 0);
if (cmd == OMX_CommandStateSet && state == OMX_StateIdle)
break;
}
}
OMX_GetState(p_sys->omx_handle, &state);
if (state == OMX_StateIdle) {
OMX_SendCommand(p_sys->omx_handle, OMX_CommandStateSet, OMX_StateLoaded, 0);
for (unsigned int i = 0; i < p_sys->port.i_buffers; i++) {
OMX_BUFFERHEADERTYPE *p_buffer;
OMX_FIFO_GET(&p_sys->port.fifo, p_buffer);
OMX_FreeBuffer(p_sys->omx_handle, p_sys->port.i_port_index, p_buffer);
}
WaitForSpecificOmxEvent(&p_sys->event_queue, OMX_EventCmdComplete, 0, 0, 0);
}
free(p_sys->port.pp_buffers);
pf_free_handle(p_sys->omx_handle);
DeinitOmxEventQueue(&p_sys->event_queue);
OMX_FIFO_DESTROY(&p_sys->port.fifo);
}
if (p_sys->pool)
picture_pool_Release(p_sys->pool);
free(p_sys);
DeinitOmxCore();
}
