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(); }