OMX_ERRORTYPE TorcOMXPort::EnablePort(bool Enable)
{
if (!m_handle || !m_parent)
return OMX_ErrorUndefined;
OMX_PARAM_PORTDEFINITIONTYPE portdefinition;
OMX_INITSTRUCTURE(portdefinition);
portdefinition.nPortIndex = m_port;
OMX_ERRORTYPE error = OMX_GetParameter(m_handle, OMX_IndexParamPortDefinition, &portdefinition);
OMX_CHECK(error, m_parent->GetName(), "Failed to get port definition");
if (portdefinition.bEnabled == OMX_FALSE && Enable)
{
LOG(VB_GENERAL, LOG_INFO, QString("%1: Enabling port %2").arg(m_parent->GetName()).arg(m_port));
error = OMX_SendCommand(m_handle, OMX_CommandPortEnable, m_port, NULL);
OMX_CHECK(error, m_parent->GetName(), "Failed to send command");
return m_parent->WaitForResponse(OMX_CommandPortEnable, m_port, 1000);
}
else if (portdefinition.bEnabled == OMX_TRUE && !Enable)
{
LOG(VB_GENERAL, LOG_INFO, QString("%1: Disabling port %2").arg(m_parent->GetName()).arg(m_port));
error = OMX_SendCommand(m_handle, OMX_CommandPortDisable, m_port, NULL);
OMX_CHECK(error, m_parent->GetName(), "Failed to send command");
return m_parent->WaitForResponse(OMX_CommandPortDisable, m_port, 1000);
}
return OMX_ErrorNone;
}
ret_code_t ilcore_flush_tunnel(ilcore_tunnel_h h)
{
OMX_ERRORTYPE omx_err;
omx_tunnel_t *tunnel = (omx_tunnel_t *)h;
if (!tunnel || !tunnel->src_comp || !tunnel->dst_comp)
{
DBG_E("%s: Incorrect parameters\n", __FUNCTION__);
return L_FAILED;
}
omx_err = OMX_SendCommand(ilcore_get_handle(tunnel->src_comp), OMX_CommandFlush, tunnel->src_port, NULL);
if(omx_err != OMX_ErrorNone && omx_err != OMX_ErrorSameState)
{
DBG_E("%s: Error flush port %d on component %s err = 0x%08x\n", __FUNCTION__, tunnel->src_port,
ilcore_get_comp_name(tunnel->src_comp), omx_err);
}
omx_err = OMX_SendCommand(ilcore_get_handle(tunnel->dst_comp), OMX_CommandFlush, tunnel->dst_port, NULL);
if(omx_err != OMX_ErrorNone && omx_err != OMX_ErrorSameState)
{
DBG_E("%s: Error flush port %d on component %s err = 0x%08x\n", __FUNCTION__, tunnel->dst_port,
ilcore_get_comp_name(tunnel->dst_comp), omx_err);
}
omx_core_comp_wait_command(tunnel->src_comp, OMX_CommandFlush, tunnel->src_port, 2000);
omx_core_comp_wait_command(tunnel->dst_comp, OMX_CommandFlush, tunnel->dst_port, 2000);
return L_OK;
}
OMX_ERRORTYPE EnableDataFlow::resetComponents()
{
DBGT_PROLOG("");
OMX_ERRORTYPE err = OMX_ErrorNone;
DBGT_PTRACE("Sending Command StateIdle to SwJpegEnc");
err = OMX_SendCommand(mSwJpegEnc, OMX_CommandStateSet, OMX_StateIdle, NULL);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("Sending OMX_StateIdle failed for SwJpegEnc err = %d", err);
DBGT_EPILOG("");
return err;
}
DBGT_PTRACE("Sending Command StateIdle to ArmIv");
err = OMX_SendCommand(mArmIvProc, OMX_CommandStateSet, OMX_StateIdle, NULL);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("Sending OMX_StateIdle failed for ArmIVProc err = %d", err);
DBGT_EPILOG("");
return err;
}
mStateArmIvSem.wait();
mStateSWJpegSem.wait();
DBGT_PTRACE("Sending Command StateLoaded to ArmIv");
err = OMX_SendCommand(mArmIvProc, OMX_CommandStateSet, OMX_StateLoaded, NULL);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("Sending OMX_StateLoaded failed for ArmIVProc err = %d", err);
DBGT_EPILOG("");
return err;
}
DBGT_PTRACE("Sending Command StateLoaded to SwJpegEnc");
err = OMX_SendCommand(mSwJpegEnc, OMX_CommandStateSet, OMX_StateLoaded, NULL);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("Sending OMX_StateLoaded failed for SwJpegEnc err = %d", err);
DBGT_EPILOG("");
return err;
}
err = freeBuffers();
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("Free buffers err = %d", err);
DBGT_EPILOG("");
return err;
}
mStateSWJpegSem.wait();
mStateArmIvSem.wait();
DBGT_EPILOG("");
return err;
}
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();
}
OMX_ERRORTYPE EnableDataFlow::sendComponentToExecuting()
{
DBGT_PROLOG("");
OMX_ERRORTYPE err = OMX_ErrorNone;
DBGT_PTRACE("Sending Command StateIdle to ArmIv");
err = OMX_SendCommand(mArmIvProc, OMX_CommandStateSet, OMX_StateIdle, NULL);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("OMX_CommandStateSet IDLE failed for mArmIvProc err = %d", err);
DBGT_EPILOG("");
return err;
}
DBGT_PTRACE("Sending Command StateIdle to SWJpeg");
err = OMX_SendCommand(mSwJpegEnc, OMX_CommandStateSet, OMX_StateIdle, NULL);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("OMX_CommandStateSet IDLE failed for mSwJpegEnc err = %d", err);
DBGT_EPILOG("");
return err;
}
mStateArmIvSem.wait();
mStateSWJpegSem.wait();
DBGT_PTRACE("Sending Command StateExecuting to ArmIv");
err = OMX_SendCommand(mArmIvProc, OMX_CommandStateSet, OMX_StateExecuting, NULL);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("OMX_CommandStateSet EXECUTING failed for mArmIvProc err = %d", err);
DBGT_EPILOG("");
return err;
}
DBGT_PTRACE("Sending Command StateExecuting to SWJpeg");
err = OMX_SendCommand(mSwJpegEnc, OMX_CommandStateSet, OMX_StateExecuting, NULL);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("OMX_CommandStateSet EXECUTING failed for mSwJpegEnc err = %d", err);
DBGT_EPILOG("");
return err;
}
mStateArmIvSem.wait();
mStateSWJpegSem.wait();
DBGT_EPILOG("");
return err;
}
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 ResourceExhaustionTest_TransitionWait(ResourceExhaustionTestContext* pCtxt,
OMX_STATETYPE eToState)
{
OMX_ERRORTYPE eError = OMX_ErrorNone;
OMX_BOOL bTimeout = OMX_FALSE;
OMX_STATETYPE eState;
OMX_OSAL_EventReset(pCtxt->hStateSetEvent);
pCtxt->eLastError = OMX_ErrorNone;
OMX_CONF_BAIL_IF_ERROR(OMX_GetState(pCtxt->hWComp[pCtxt->nInst], &eState));
eError = OMX_SendCommand(pCtxt->hWComp[pCtxt->nInst], OMX_CommandStateSet, eToState, 0);
OMX_CONF_BAIL_IF_ERROR(eError);
if (eToState == OMX_StateIdle && (eState == OMX_StateLoaded))
{
OMX_CONF_BAIL_IF_ERROR(ResourceExhaustionTest_AllocateAllBuffers(pCtxt));
}
else if (eToState == OMX_StateLoaded && eState == OMX_StateIdle)
{
OMX_CONF_BAIL_IF_ERROR(ResourceExhaustionTest_DeInitBuffer(pCtxt));
}
OMX_OSAL_EventWait(pCtxt->hStateSetEvent, OMX_CONF_TIMEOUT_EXPECTING_SUCCESS, &bTimeout);
OMX_CONF_BAIL_IF_ERROR(pCtxt->eLastError);
if (bTimeout == OMX_TRUE)
OMX_CONF_SET_ERROR_BAIL("Timeout on state transition\n", OMX_ErrorUndefined);
OMX_CONF_BAIL_IF_ERROR(OMX_GetState(pCtxt->hWComp[pCtxt->nInst], &eState));
if (eState != eToState)
OMX_CONF_SET_ERROR_BAIL("Incorrect transition\n", OMX_ErrorUndefined);
OMX_CONF_TEST_BAIL:
if (OMX_ErrorNone != eError && eToState == OMX_StateIdle && (eState == OMX_StateLoaded))
{
/* Add some delay before cleaning up */
OMX_OSAL_EventWait(pCtxt->hStateSetEvent, OMX_CONF_TIMEOUT_EXPECTING_FAILURE, &bTimeout);
/* Disable all ports to free buffers*/
OMX_SendCommand(pCtxt->hWComp[pCtxt->nInst], OMX_CommandPortDisable, OMX_ALL, 0x0);
/* Cleanup last instance */
ResourceExhaustionTest_DeInitBuffer(pCtxt);
}
return eError;
}
OMX_ERRORTYPE PortCommTest_TransitionWait(OMX_STATETYPE eToState,
PortCommTestCtxt* pContext)
{
OMX_ERRORTYPE eError = OMX_ErrorNone;
OMX_BOOL bTimeout = OMX_FALSE;
OMX_OSAL_EventReset(pContext->hStateSetEvent);
eError = OMX_SendCommand(pContext->hWComp, OMX_CommandStateSet, eToState, 0);
OMX_CONF_BAIL_IF_ERROR(eError);
if (eToState == OMX_StateIdle && (pContext->eState == OMX_StateLoaded))
{
OMX_CONF_BAIL_IF_ERROR(PortCommTest_OperateOnPorts(pContext, AllocBuf));
}
else if (eToState == OMX_StateLoaded && pContext->eState == OMX_StateIdle)
{
OMX_CONF_BAIL_IF_ERROR(PortCommTest_DeInitBuffer(pContext));
}
OMX_OSAL_EventWait(pContext->hStateSetEvent, OMX_CONF_TIMEOUT_EXPECTING_SUCCESS, &bTimeout);
if (bTimeout == OMX_TRUE)
OMX_CONF_SET_ERROR_BAIL("Transition timed out\n", OMX_ErrorUndefined);
if (pContext->eState != eToState)
OMX_CONF_SET_ERROR_BAIL("Incorrect transition\n", OMX_ErrorUndefined);
OMX_CONF_TEST_BAIL:
return eError;
}
int32_t ilctts_delete(TTSRENDER_STATE_T *st) {
int32_t ret;
OMX_ERRORTYPE omx_err;
ret = ilclient_change_component_state(st->audio_render, OMX_StateIdle);
if (ret < 0) {
ERROR("ilctts_change_component_state returned error in ilctts_delete: %d", ret);
return -1;
}
omx_err = OMX_SendCommand(ILC_GET_HANDLE(st->audio_render), OMX_CommandStateSet, OMX_StateLoaded, NULL);
if (omx_err != OMX_ErrorNone) {
ERROR("OMX_SendCommand returned error in ilctts_delete: %d", omx_err);
return -1;
}
ilclient_disable_port_buffers(st->audio_render, 100, st->user_buffer_list, NULL, NULL);
ilclient_change_component_state(st->audio_render, OMX_StateLoaded);
ilclient_cleanup_components(st->list);
ilclient_destroy(st->client);
//sem_destroy(&st->buffer_list_sema);
destroy_semaphores(st);
destroy_mutexes(st);
free(st);
return 0;
} // end ilctts_delete
static inline void _GoToState(int state) {
OMX_ERRORTYPE err;
err = OMX_SendCommand(decoderhandle, OMX_CommandStateSet, state, NULL);
OMXE(err);
};
static int portSettingsChanged(JPEG_DECODER *decoder, IMAGE *jpeg){
OMX_PARAM_PORTDEFINITIONTYPE portdef;
int ret;
portdef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
portdef.nVersion.nVersion = OMX_VERSION;
portdef.nPortIndex = decoder->outPort;
OMX_GetParameter(decoder->handle,OMX_IndexParamPortDefinition, &portdef);
jpeg->width = portdef.format.image.nFrameWidth;
jpeg->height = portdef.format.image.nFrameHeight;
jpeg->nData = portdef.nBufferSize;
jpeg->colorSpace = COLOR_SPACE_YUV420P;
OMX_SendCommand(decoder->handle, OMX_CommandPortEnable, decoder->outPort, NULL);
jpeg->pData=malloc(jpeg->nData);
if(jpeg->pData == NULL){
jpeg->nData=0;
return OMX_IMAGE_ERROR_MEMORY;
}
ret = OMX_UseBuffer(decoder->handle, &decoder->pOutputBufferHeader,
decoder->outPort, NULL, portdef.nBufferSize, (OMX_U8 *) jpeg->pData);
if (ret != OMX_ErrorNone) {
return OMX_IMAGE_ERROR_MEMORY;
}
return OMX_IMAGE_OK;
}
status_t OMXNodeInstance::sendCommand(
OMX_COMMANDTYPE cmd, OMX_S32 param) {
Mutex::Autolock autoLock(mLock);
OMX_ERRORTYPE err = OMX_SendCommand(mHandle, cmd, param, NULL);
return StatusFromOMXError(err);
}
/**
* Disable unwanted ports, or we can't transition to Idle state
*/
void disablePort(OMX_INDEXTYPE paramType) {
OMX_PORT_PARAM_TYPE param;
int nPorts;
int startPortNumber;
int n;
setHeader(¶m, sizeof(OMX_PORT_PARAM_TYPE));
err = OMX_GetParameter(handle, paramType, ¶m);
if(err != OMX_ErrorNone){
fprintf(stderr, "Error in getting OMX_PORT_PARAM_TYPE parameter\n", 0);
exit(1);
}
startPortNumber = ((OMX_PORT_PARAM_TYPE)param).nStartPortNumber;
nPorts = ((OMX_PORT_PARAM_TYPE)param).nPorts;
if (nPorts > 0) {
fprintf(stderr, "Other has %d ports\n", nPorts);
/* and disable it */
for (n = 0; n < nPorts; n++) {
err = OMX_SendCommand(handle, OMX_CommandPortDisable, n + startPortNumber, NULL);
if (err != OMX_ErrorNone) {
fprintf(stderr, "Error on setting port to disabled\n");
exit(1);
}
}
}
}
static OMX_BUFFERHEADERTYPE *allocbufs(OMX_HANDLETYPE h, int port, int enable)
{
int i;
OMX_BUFFERHEADERTYPE *list = NULL, **end = &list;
OMX_PARAM_PORTDEFINITIONTYPE *portdef;
MAKEME(portdef, OMX_PARAM_PORTDEFINITIONTYPE);
portdef->nPortIndex = port;
OERRq(OMX_GetParameter(h, OMX_IndexParamPortDefinition, portdef));
if (enable)
OERRq(OMX_SendCommand(h, OMX_CommandPortEnable, port, NULL));
for (i = 0; i < portdef->nBufferCountActual; i++) {
OMX_U8 *buf;
buf = vcos_malloc_aligned(portdef->nBufferSize,
portdef->nBufferAlignment, "buffer");
// printf("Allocated a buffer of %d bytes\n", portdef->nBufferSize);
OERRq(OMX_UseBuffer(h, end, port, NULL, portdef->nBufferSize,
buf));
end = (OMX_BUFFERHEADERTYPE **) &((*end)->pAppPrivate);
}
free(portdef);
return list;
}
static inline void
change_state (GOmxCore *core,
OMX_STATETYPE state)
{
GST_DEBUG_OBJECT (core->object, "state=%d", state);
OMX_SendCommand (core->omx_handle, OMX_CommandStateSet, state, NULL);
}
void
omx_set_state(omx_component_t *oc, OMX_STATETYPE reqstate)
{
OMX_STATETYPE state;
int attempts = 20;
omxchk(OMX_GetState(oc->oc_handle, &state));
omxdbg("Telling component '%s' to go from state %d -> to state %d\n", oc->oc_name, state, reqstate);
while(1) {
oc->oc_cmd_done = 0;
int r = OMX_SendCommand(oc->oc_handle, OMX_CommandStateSet,
reqstate, NULL);
if(r == OMX_ErrorInsufficientResources && attempts) {
usleep(10000);
attempts--;
continue;
}
if(r != 0) {
panic("OMX Setstate %s from %d to %d error 0x%x",
oc->oc_name, state, reqstate, r);
}
if(reqstate == OMX_StateExecuting)
omx_wait_command(oc);
return;
}
}
OMX_ERRORTYPE removeComponent(OMX_COMPONENTTYPE *pOMXComponent)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
if (pExynosComponent->currentState == OMX_StateIdle) {
(*(pExynosComponent->pCallbacks->EventHandler))(pOMXComponent,
pExynosComponent->callbackData,
OMX_EventError,
OMX_ErrorResourcesLost,
0,
NULL);
ret = OMX_SendCommand(pOMXComponent, OMX_CommandStateSet, OMX_StateLoaded, NULL);
if (ret != OMX_ErrorNone) {
ret = OMX_ErrorUndefined;
goto EXIT;
}
} else if ((pExynosComponent->currentState == OMX_StateExecuting) ||
(pExynosComponent->currentState == OMX_StatePause)) {
/* Todo */
}
ret = OMX_ErrorNone;
EXIT:
return ret;
}
OMX_ERRORTYPE Exynos_OMX_Release_Resource(OMX_COMPONENTTYPE *pOMXComponent)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
EXYNOS_OMX_RM_COMPONENT_LIST *pRMComponentList = NULL;
EXYNOS_OMX_RM_COMPONENT_LIST *pRMComponentWaitList = NULL;
EXYNOS_OMX_RM_COMPONENT_LIST *pComponentTemp = NULL;
OMX_COMPONENTTYPE *pOMXWaitComponent = NULL;
int numElem = 0;
FunctionIn();
Exynos_OSAL_MutexLock(ghVideoRMComponentListMutex);
pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
pRMComponentList = getRMList(pExynosComponent, gpRMList, NULL);
if (pRMComponentList == NULL) {
ret = OMX_ErrorUndefined;
goto EXIT;
}
ret = removeElementList(&pRMComponentList, pOMXComponent);
if (ret != OMX_ErrorNone)
goto EXIT;
ret = setRMList(pExynosComponent, gpRMList, pRMComponentList);
if (ret != OMX_ErrorNone)
goto EXIT;
pRMComponentWaitList = getRMList(pExynosComponent, gpRMWaitList, NULL);
pComponentTemp = pRMComponentWaitList;
while (pComponentTemp) {
numElem++;
pComponentTemp = pComponentTemp->pNext;
}
if (numElem > 0) {
pOMXWaitComponent = pRMComponentWaitList->pOMXStandComp;
ret = removeElementList(&pRMComponentWaitList, pOMXWaitComponent);
if (ret != OMX_ErrorNone)
goto EXIT;
ret = setRMList(pExynosComponent, gpRMWaitList, pRMComponentWaitList);
if (ret != OMX_ErrorNone)
goto EXIT;
ret = OMX_SendCommand(pOMXWaitComponent, OMX_CommandStateSet, OMX_StateIdle, NULL);
if (ret != OMX_ErrorNone)
goto EXIT;
}
EXIT:
Exynos_OSAL_MutexUnlock(ghVideoRMComponentListMutex);
FunctionOut();
return ret;
}
OMX_ERRORTYPE COMXCoreComponent::DisableAllPorts()
{
if(!m_handle)
return OMX_ErrorUndefined;
Lock();
OMX_ERRORTYPE omx_err = OMX_ErrorNone;
OMX_INDEXTYPE idxTypes[] = {
OMX_IndexParamAudioInit,
OMX_IndexParamImageInit,
OMX_IndexParamVideoInit,
OMX_IndexParamOtherInit
};
OMX_PORT_PARAM_TYPE ports;
OMX_INIT_STRUCTURE(ports);
int i;
for(i=0; i < 4; i++)
{
omx_err = OMX_GetParameter(m_handle, idxTypes[i], &ports);
if(omx_err == OMX_ErrorNone) {
uint32_t j;
for(j=0; j<ports.nPorts; j++)
{
OMX_PARAM_PORTDEFINITIONTYPE portFormat;
OMX_INIT_STRUCTURE(portFormat);
portFormat.nPortIndex = ports.nStartPortNumber+j;
omx_err = OMX_GetParameter(m_handle, OMX_IndexParamPortDefinition, &portFormat);
if(omx_err != OMX_ErrorNone)
{
if(portFormat.bEnabled == OMX_FALSE)
continue;
}
omx_err = OMX_SendCommand(m_handle, OMX_CommandPortDisable, ports.nStartPortNumber+j, NULL);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXCoreComponent::DisableAllPorts - Error disable port %d on component %s omx_err(0x%08x)",
(int)(ports.nStartPortNumber) + j, m_componentName.c_str(), (int)omx_err);
}
omx_err = WaitForCommand(OMX_CommandPortDisable, ports.nStartPortNumber+j);
if(omx_err != OMX_ErrorNone && omx_err != OMX_ErrorSameState)
{
UnLock();
return omx_err;
}
}
}
}
UnLock();
return OMX_ErrorNone;
}
CommandHelper const& send() const {
print(__FUNCTION__);
if (Cmd < OMX_CommandMax) {
OMX_ERRORTYPE err = OMX_SendCommand(self->component, Cmd, nParam1, pCmdData);
ERR_EXIT_IF(err!=OMX_ErrorNone, "OMX_SendCommand");
}
return *this;
}
static int startupDecoder(JPEG_DECODER * decoder){
ilclient_change_component_state(decoder->component,OMX_StateIdle);
OMX_IMAGE_PARAM_PORTFORMATTYPE imagePortFormat;
memset(&imagePortFormat, 0, sizeof(OMX_IMAGE_PARAM_PORTFORMATTYPE));
imagePortFormat.nSize = sizeof(OMX_IMAGE_PARAM_PORTFORMATTYPE);
imagePortFormat.nVersion.nVersion = OMX_VERSION;
imagePortFormat.nPortIndex = decoder->inPort;
imagePortFormat.eCompressionFormat = OMX_IMAGE_CodingJPEG;
OMX_SetParameter(decoder->handle,OMX_IndexParamImagePortFormat, &imagePortFormat);
OMX_PARAM_PORTDEFINITIONTYPE portdef;
portdef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
portdef.nVersion.nVersion = OMX_VERSION;
portdef.nPortIndex = decoder->inPort;
OMX_GetParameter(decoder->handle,OMX_IndexParamPortDefinition, &portdef);
portdef.nBufferCountActual = DECODER_BUFFER_NUM;
OMX_SetParameter(decoder->handle,OMX_IndexParamPortDefinition, &portdef);
OMX_SendCommand(decoder->handle, OMX_CommandPortEnable, decoder->inPort, NULL);
int i;
for (i = 0; i < DECODER_BUFFER_NUM; i++) {
if (OMX_AllocateBuffer(decoder->handle,
&(decoder->ppInputBufferHeader[i]),
decoder->inPort,
NULL, portdef.nBufferSize) != OMX_ErrorNone) {
return OMX_IMAGE_ERROR_MEMORY;
}
}
int ret = ilclient_wait_for_event(decoder->component, OMX_EventCmdComplete,
OMX_CommandPortEnable, 0, decoder->inPort, 0, 0, TIMEOUT_MS);
if (ret != 0) {
return OMX_IMAGE_ERROR_PORTS;
}
ret = OMX_SendCommand(decoder->handle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
if (ret != OMX_ErrorNone) {
return OMX_IMAGE_ERROR_EXECUTING;
}
return OMX_IMAGE_OK;
}
/*========================================================*/
OMX_ERRORTYPE SampleTest_TransitionWait(OMX_STATETYPE eToState,
SampleCompTestCtxt * pContext)
{
OMX_ERRORTYPE eError = OMX_ErrorNone;
OMX_PARAM_PORTDEFINITIONTYPE tPortDef;
OMX_U32 i, j;
eError = OMX_SendCommand(pContext->hComp, OMX_CommandStateSet,
eToState, NULL);
OMX_TEST_BAIL_IF_ERROR(eError);
if ((eToState == OMX_StateIdle) &&
(pContext->eState == OMX_StateLoaded))
{
for (i = 0; i < NUM_DOMAINS; i++)
{
for (j = pContext->sPortParam[i].nStartPortNumber;
j < pContext->sPortParam[i].nStartPortNumber
+ pContext->sPortParam[i].nPorts; j++)
{
OMX_TEST_INIT_STRUCT(tPortDef,
OMX_PARAM_PORTDEFINITIONTYPE);
tPortDef.nPortIndex = j;
//printf("\nCalling GetParam before UseBuf on port %d\n",j);
eError = OMX_GetParameter(pContext->hComp,
OMX_IndexParamPortDefinition,
(OMX_PTR) & tPortDef);
OMX_TEST_BAIL_IF_ERROR(eError);
// if(tPortDef.bEnabled)//AD
eError =
SampleTest_AllocateBuffers(pContext,
&tPortDef);
OMX_TEST_BAIL_IF_ERROR(eError);
}
}
} else if ((eToState == OMX_StateLoaded) &&
(pContext->eState == OMX_StateIdle))
{
eError = SampleTest_DeInitBuffers(pContext);
OMX_TEST_BAIL_IF_ERROR(eError);
}
printf("\nWaiting for state set event\n");
TIMM_OSAL_SemaphoreObtain(pContext->hStateSetEvent,
TIMM_OSAL_SUSPEND);
printf("\nState set event recd.\n");
if (pContext->eState != eToState)
OMX_TEST_SET_ERROR_BAIL(OMX_ErrorUndefined,
" InComplete Transition \n");
OMX_TEST_BAIL:
return eError;
}
OMX_ERRORTYPE Component::disablePort(unsigned int port)//default: wait=false
{
lock();
#ifdef DEBUG_PORTS
ofLogVerbose(__func__) << componentName << " port: " << port;
#endif
OMX_ERRORTYPE error;
error = OMX_SendCommand(handle, OMX_CommandPortDisable, port, NULL);
OMX_TRACE(error);
unlock();
return error;
#if 0
if(error == OMX_ErrorNone)
{
unlock();
return error;
}
OMX_PARAM_PORTDEFINITIONTYPE portFormat;
OMX_INIT_STRUCTURE(portFormat);
portFormat.nPortIndex = port;
error = OMX_GetParameter(handle, OMX_IndexParamPortDefinition, &portFormat);
OMX_TRACE(error);
if(portFormat.bEnabled == OMX_TRUE)
{
error = OMX_SendCommand(handle, OMX_CommandPortDisable, port, NULL);
OMX_TRACE(error);
if(error != OMX_ErrorNone)
{
unlock();
return error;
}
}
unlock();
return error;
#endif
}
int32_t ilctts_flush(TTSRENDER_STATE_T *st) {
OMX_ERRORTYPE omx_err;
omx_err = OMX_SendCommand(ILC_GET_HANDLE(st->audio_render), OMX_CommandFlush, -1, NULL);
if (omx_err != OMX_ErrorNone) {
ERROR("OMX_SendCommand returned error in ilctts_flush: %d", omx_err);
return -1;
}
return 0;
} // end ilctts_flush
OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_GetHandle(
OMX_OUT OMX_HANDLETYPE* pHandle,
OMX_IN OMX_STRING cComponentName,
OMX_IN OMX_PTR pAppData,
OMX_IN OMX_CALLBACKTYPE* pCallBacks){
List_t *tmpNode;
Component_Entry_t *comp;
OMX_ERRORTYPE ret = OMX_ErrorNone;
if (!gOmxCore){
AGILE_LOGE("the OMX_Init() is not done yet! quit...");
return OMX_ErrorInsufficientResources;
}
Mag_AcquireMutex(gOmxCore->lock);
tmpNode = gOmxCore->LoadedCompListHead.next;
while (tmpNode != &gOmxCore->LoadedCompListHead){
comp = (Component_Entry_t *)list_entry(tmpNode, Component_Entry_t, node);
if (!strcmp(comp->regInfo->name, cComponentName)){
if (comp->initialized){
*pHandle = comp->compHandle;
Mag_ReleaseMutex(gOmxCore->lock);
AGILE_LOGI("Get component handle: %s [initialized] successfully!", cComponentName);
return ret;
}else{
if (comp->regInfo->init){
ret = comp->regInfo->init(pHandle, pAppData, pCallBacks);
if (ret == OMX_ErrorNone){
comp->initialized = OMX_TRUE;
comp->compHandle = *pHandle;
ret = OMX_SendCommand(*pHandle, OMX_CommandStateSet, OMX_StateLoaded, NULL);
if (ret == OMX_ErrorNone){
AGILE_LOGI("Get component handle: %s successfully!", cComponentName);
}else{
AGILE_LOGE("Failed to set the state to OMX_StateLoaded, ret = 0x%x", ret);
}
}else{
AGILE_LOGE("Failed to initialize the component(%s)", cComponentName);
}
Mag_ReleaseMutex(gOmxCore->lock);
return ret;
}
}
}
tmpNode = tmpNode->next;
}
AGILE_LOGE("Failed to find the component: %s", cComponentName);
Mag_ReleaseMutex(gOmxCore->lock);
return OMX_ErrorComponentNotFound;
}
static gboolean
activate_push (GstPad *pad,
gboolean active)
{
gboolean result = TRUE;
GstOmxBaseFilter *self;
self = GST_OMX_BASE_FILTER (gst_pad_get_parent (pad));
if (active)
{
GST_DEBUG_OBJECT (self, "activate");
/* task may carry on */
g_atomic_int_set (&self->last_pad_push_return, GST_FLOW_OK);
/* we do not start the task yet if the pad is not connected */
if (gst_pad_is_linked (pad))
{
if (self->ready)
{
/** @todo link callback function also needed */
g_omx_port_resume (self->in_port);
g_omx_port_resume (self->out_port);
result = gst_pad_start_task (pad, output_loop, pad);
}
}
}
else
{
GST_DEBUG_OBJECT (self, "deactivate");
/* persuade task to bail out */
g_atomic_int_set (&self->last_pad_push_return, GST_FLOW_WRONG_STATE);
if (self->ready)
{
/** @todo disable this until we properly reinitialize the buffers. */
#if 0
/* flush all buffers */
OMX_SendCommand (self->gomx->omx_handle, OMX_CommandFlush, OMX_ALL, NULL);
#endif
/* unlock loops */
g_omx_port_pause (self->in_port);
g_omx_port_pause (self->out_port);
}
/* make sure streaming finishes */
result = gst_pad_stop_task (pad);
}
gst_object_unref (self);
return result;
}
void signal_handler(int sig_id) {
/* Flush */
if (sig_id == SIGUSR1) {
DEBUG_PRINT("%s Initiate flushing\n", __FUNCTION__);
bFlushing = true;
OMX_SendCommand(evrc_enc_handle, OMX_CommandFlush, OMX_ALL, NULL);
} else if (sig_id == SIGUSR2) {
if (bPause == true) {
DEBUG_PRINT("%s resume record\n", __FUNCTION__);
bPause = false;
OMX_SendCommand(evrc_enc_handle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
} else {
DEBUG_PRINT("%s pause record\n", __FUNCTION__);
bPause = true;
OMX_SendCommand(evrc_enc_handle, OMX_CommandStateSet, OMX_StatePause, NULL);
}
}
}
OMX_ERRORTYPE Component::sendCommand(OMX_COMMANDTYPE cmd, OMX_U32 cmdParam, OMX_PTR cmdParamData)
{
lock();
OMX_ERRORTYPE error = OMX_SendCommand(handle, cmd, cmdParam, cmdParamData);
OMX_TRACE(error);
unlock();
return error;
}
static int resizePortSettingsChanged(OMX_RESIZER *resizer, IMAGE *outImage){
OMX_PARAM_PORTDEFINITIONTYPE portdef;
int ret;
portdef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
portdef.nVersion.nVersion = OMX_VERSION;
portdef.nPortIndex = resizer->outPort;
OMX_GetParameter(resizer->handle, OMX_IndexParamPortDefinition, &portdef);
portdef.format.image.eCompressionFormat = OMX_IMAGE_CodingUnused;
portdef.format.image.bFlagErrorConcealment = OMX_FALSE;
if(outImage->colorSpace == COLOR_SPACE_YUV420P)
portdef.format.image.eColorFormat = OMX_COLOR_FormatYUV420PackedPlanar;
else if(outImage->colorSpace == COLOR_SPACE_RGBA)
portdef.format.image.eColorFormat = OMX_COLOR_Format32bitABGR8888;
else if(outImage->colorSpace == COLOR_SPACE_RGB16)
portdef.format.image.eColorFormat = OMX_COLOR_Format16bitRGB565;
portdef.format.image.nFrameWidth = outImage->width;
portdef.format.image.nFrameHeight = outImage->height;
portdef.format.image.nStride = 0;
portdef.format.image.nSliceHeight = 0;
ret = OMX_SetParameter(resizer->handle, OMX_IndexParamPortDefinition, &portdef);
if(ret != OMX_ErrorNone){
return OMX_IMAGE_ERROR_PARAMETER;
}
ret = OMX_GetParameter(resizer->handle, OMX_IndexParamPortDefinition, &portdef);
if(ret != OMX_ErrorNone){
return OMX_IMAGE_ERROR_PARAMETER;
}
ret = OMX_SendCommand(resizer->handle, OMX_CommandPortEnable, resizer->outPort, NULL);
if(ret != OMX_ErrorNone){
return OMX_IMAGE_ERROR_PORTS;
}
outImage->nData = portdef.nBufferSize;
outImage->pData=malloc(outImage->nData);
if(outImage->pData == NULL){
outImage->nData=0;
return OMX_IMAGE_ERROR_MEMORY;
}
ret = OMX_UseBuffer(resizer->handle, &resizer->pOutputBufferHeader,
resizer->outPort, NULL, portdef.nBufferSize, (OMX_U8 *) outImage->pData);
if (ret != OMX_ErrorNone) {
return OMX_IMAGE_ERROR_MEMORY;
}
return OMX_IMAGE_OK;
}
static int startupResizer(OMX_RESIZER *resizer, IMAGE *inImage){
OMX_PARAM_PORTDEFINITIONTYPE portdef;
int ret;
ilclient_change_component_state(resizer->component, OMX_StateIdle);
portdef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
portdef.nVersion.nVersion = OMX_VERSION;
portdef.nPortIndex = resizer->inPort;
ret = OMX_GetParameter(resizer->handle, OMX_IndexParamPortDefinition, &portdef);
if (ret != OMX_ErrorNone) {
return OMX_IMAGE_ERROR_PARAMETER;
}
portdef.format.image.eCompressionFormat = OMX_IMAGE_CodingUnused;
portdef.format.image.bFlagErrorConcealment = OMX_FALSE;
portdef.format.image.nFrameWidth = inImage->width;
portdef.format.image.nFrameHeight = inImage->height;
portdef.format.image.nStride = 0;
portdef.format.image.nSliceHeight = 0;
if(inImage->colorSpace == COLOR_SPACE_YUV420P)
portdef.format.image.eColorFormat = OMX_COLOR_FormatYUV420PackedPlanar;
else if(inImage->colorSpace == COLOR_SPACE_RGBA)
portdef.format.image.eColorFormat = OMX_COLOR_Format32bitABGR8888;
else if(inImage->colorSpace == COLOR_SPACE_RGB16)
portdef.format.image.eColorFormat = OMX_COLOR_Format16bitRGB565;
portdef.nBufferSize=inImage->nData;
ret = OMX_SetParameter(resizer->handle, OMX_IndexParamPortDefinition, &portdef);
if (ret != OMX_ErrorNone) {
return OMX_IMAGE_ERROR_PARAMETER;
}
ret = OMX_SendCommand(resizer->handle, OMX_CommandPortEnable, resizer->inPort, NULL);
if(ret != OMX_ErrorNone){
return OMX_IMAGE_ERROR_PORTS;
}
ret = OMX_UseBuffer(resizer->handle,&resizer->pInputBufferHeader,resizer->inPort,
NULL, portdef.nBufferSize, (OMX_U8 *) inImage->pData);
if(ret != OMX_ErrorNone){
return OMX_IMAGE_ERROR_MEMORY;
}
ilclient_change_component_state(resizer->component, OMX_StateExecuting);
return OMX_IMAGE_OK;
}
