00001
00031 #ifdef __cplusplus
00032 extern "C" {
00033 #endif
00034
00035 #include <stdlib.h>
00036 #include <stdio.h>
00037 #include <string.h>
00038 #include <unistd.h>
00039 #include <errno.h>
00040
00041 #include <OMX_Core.h>
00042 #include <OMX_Component.h>
00043
00044 #include "omxcore.h"
00045 #include "omx_base_component.h"
00046
00047 #include "tsemaphore.h"
00048 #include "queue.h"
00049
00066 OMX_ERRORTYPE omx_base_component_Constructor(OMX_COMPONENTTYPE *openmaxStandComp,OMX_STRING cComponentName) {
00067 omx_base_component_PrivateType* omx_base_component_Private;
00068 OMX_U32 i;
00069
00070 DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
00071
00072 if (openmaxStandComp->pComponentPrivate) {
00073 omx_base_component_Private = (omx_base_component_PrivateType*)openmaxStandComp->pComponentPrivate;
00074 } else {
00075 omx_base_component_Private = calloc(1,sizeof(omx_base_component_PrivateType));
00076 if (!omx_base_component_Private) {
00077 return OMX_ErrorInsufficientResources;
00078 }
00079 }
00080
00081 if(!omx_base_component_Private->messageQueue) {
00082 omx_base_component_Private->messageQueue = calloc(1,sizeof(queue_t));
00083 queue_init(omx_base_component_Private->messageQueue);
00084 }
00085
00086 if(!omx_base_component_Private->messageSem) {
00087 omx_base_component_Private->messageSem = calloc(1,sizeof(tsem_t));
00088 tsem_init(omx_base_component_Private->messageSem, 0);
00089 }
00090 if(!omx_base_component_Private->bMgmtSem) {
00091 omx_base_component_Private->bMgmtSem = calloc(1,sizeof(tsem_t));
00092 tsem_init(omx_base_component_Private->bMgmtSem, 0);
00093 }
00094
00095 if(!omx_base_component_Private->bStateSem) {
00096 omx_base_component_Private->bStateSem = calloc(1,sizeof(tsem_t));
00097 tsem_init(omx_base_component_Private->bStateSem, 0);
00098 }
00099
00100 openmaxStandComp->nSize = sizeof(OMX_COMPONENTTYPE);
00101 openmaxStandComp->pApplicationPrivate = NULL;
00102 openmaxStandComp->GetComponentVersion = omx_base_component_GetComponentVersion;
00103 openmaxStandComp->SendCommand = omx_base_component_SendCommand;
00104 openmaxStandComp->GetParameter = omx_base_component_GetParameter;
00105 openmaxStandComp->SetParameter = omx_base_component_SetParameter;
00106 openmaxStandComp->GetConfig = omx_base_component_GetConfig;
00107 openmaxStandComp->SetConfig = omx_base_component_SetConfig;
00108 openmaxStandComp->GetExtensionIndex = omx_base_component_GetExtensionIndex;
00109 openmaxStandComp->GetState = omx_base_component_GetState;
00110 openmaxStandComp->SetCallbacks = omx_base_component_SetCallbacks;
00111 openmaxStandComp->ComponentDeInit = omx_base_component_ComponentDeInit;
00112 openmaxStandComp->ComponentRoleEnum = omx_base_component_ComponentRoleEnum;
00113 openmaxStandComp->ComponentTunnelRequest =omx_base_component_ComponentTunnelRequest;
00114
00115
00116 openmaxStandComp->AllocateBuffer = omx_base_component_AllocateBuffer;
00117 openmaxStandComp->UseBuffer = omx_base_component_UseBuffer;
00118 openmaxStandComp->UseEGLImage = omx_base_component_UseEGLImage;
00119 openmaxStandComp->FreeBuffer = omx_base_component_FreeBuffer;
00120 openmaxStandComp->EmptyThisBuffer = omx_base_component_EmptyThisBuffer;
00121 openmaxStandComp->FillThisBuffer = omx_base_component_FillThisBuffer;
00122
00123 openmaxStandComp->nVersion.s.nVersionMajor = SPECVERSIONMAJOR;
00124 openmaxStandComp->nVersion.s.nVersionMinor = SPECVERSIONMINOR;
00125 openmaxStandComp->nVersion.s.nRevision = SPECREVISION;
00126 openmaxStandComp->nVersion.s.nStep = SPECSTEP;
00127
00128 omx_base_component_Private->name = calloc(1,OMX_MAX_STRINGNAME_SIZE);
00129 if (!omx_base_component_Private->name) {
00130 return OMX_ErrorInsufficientResources;
00131 }
00132 strcpy(omx_base_component_Private->name,cComponentName);
00133 omx_base_component_Private->state = OMX_StateLoaded;
00134 omx_base_component_Private->transientState = OMX_TransStateMax;
00135 omx_base_component_Private->callbacks = NULL;
00136 omx_base_component_Private->callbackData = NULL;
00137 omx_base_component_Private->nGroupPriority = 0;
00138 omx_base_component_Private->nGroupID = 0;
00139 omx_base_component_Private->pMark=NULL;
00140 omx_base_component_Private->openmaxStandComp=openmaxStandComp;
00141 omx_base_component_Private->DoStateSet = &omx_base_component_DoStateSet;
00142 omx_base_component_Private->messageHandler = omx_base_component_MessageHandler;
00143 omx_base_component_Private->destructor = omx_base_component_Destructor;
00144 omx_base_component_Private->bufferMgmtThreadID = -1;
00145
00146 pthread_mutex_init(&omx_base_component_Private->flush_mutex, NULL);
00147 pthread_cond_init(&omx_base_component_Private->flush_all_condition, NULL);
00148 pthread_cond_init(&omx_base_component_Private->flush_condition, NULL);
00149
00150 for(i=0;i<NUM_DOMAINS;i++) {
00151 memset(&omx_base_component_Private->sPortTypesParam[i], 0, sizeof(OMX_PORT_PARAM_TYPE));
00152 setHeader(&omx_base_component_Private->sPortTypesParam[i], sizeof(OMX_PORT_PARAM_TYPE));
00153 }
00154
00155 omx_base_component_Private->messageHandlerThreadID = pthread_create(&omx_base_component_Private->messageHandlerThread,
00156 NULL,
00157 compMessageHandlerFunction,
00158 openmaxStandComp);
00159
00160 DEBUG(DEB_LEV_FUNCTION_NAME,"Out of %s\n",__func__);
00161 return OMX_ErrorNone;
00162 }
00163
00171 OMX_ERRORTYPE omx_base_component_Destructor(OMX_COMPONENTTYPE *openmaxStandComp) {
00172 omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)openmaxStandComp->pComponentPrivate;
00173 int err;
00174
00175 DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
00176 omx_base_component_Private->state = OMX_StateInvalid;
00177 omx_base_component_Private->callbacks=NULL;
00178
00179
00180 tsem_up(omx_base_component_Private->messageSem);
00181
00182
00183 if(omx_base_component_Private->messageQueue) {
00184 queue_deinit(omx_base_component_Private->messageQueue);
00185 free(omx_base_component_Private->messageQueue);
00186 omx_base_component_Private->messageQueue=NULL;
00187 }
00188
00189 err = pthread_join(omx_base_component_Private->messageHandlerThread,NULL);
00190 if(err!=0) {
00191 DEBUG(DEB_LEV_FUNCTION_NAME,"In %s pthread_join returned err=%d\n", __func__, err);
00192 }
00193
00194
00195 if(omx_base_component_Private->bMgmtSem){
00196 tsem_deinit(omx_base_component_Private->bMgmtSem);
00197 free(omx_base_component_Private->bMgmtSem);
00198 omx_base_component_Private->bMgmtSem=NULL;
00199 }
00200
00201
00202 if(omx_base_component_Private->messageSem) {
00203 tsem_deinit(omx_base_component_Private->messageSem);
00204 free(omx_base_component_Private->messageSem);
00205 omx_base_component_Private->messageSem=NULL;
00206 }
00207
00208 if(omx_base_component_Private->bStateSem){
00209 tsem_deinit(omx_base_component_Private->bStateSem);
00210 free(omx_base_component_Private->bStateSem);
00211 omx_base_component_Private->bStateSem=NULL;
00212 }
00213
00214 if(omx_base_component_Private->name){
00215 free(omx_base_component_Private->name);
00216 omx_base_component_Private->name=NULL;
00217 }
00218
00219 pthread_mutex_destroy(&omx_base_component_Private->flush_mutex);
00220 pthread_cond_destroy(&omx_base_component_Private->flush_all_condition);
00221 pthread_cond_destroy(&omx_base_component_Private->flush_condition);
00222
00223 DEBUG(DEB_LEV_FUNCTION_NAME,"Out of %s\n",__func__);
00224 return OMX_ErrorNone;
00225 }
00226
00235 OMX_ERRORTYPE omx_base_component_ComponentDeInit(
00236 OMX_IN OMX_HANDLETYPE hComponent) {
00237 OMX_COMPONENTTYPE *openmaxStandComp = (OMX_COMPONENTTYPE *)hComponent;
00238 omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)openmaxStandComp->pComponentPrivate;
00239
00240 DEBUG(DEB_LEV_FUNCTION_NAME, "In %s pComponentPrivate =%x \n", __func__,(int)openmaxStandComp->pComponentPrivate);
00241 omx_base_component_Private->destructor(openmaxStandComp);
00242
00243 free(openmaxStandComp->pComponentPrivate);
00244 openmaxStandComp->pComponentPrivate=NULL;
00245 return OMX_ErrorNone;
00246 }
00247
00258 OMX_ERRORTYPE omx_base_component_DoStateSet(OMX_COMPONENTTYPE *openmaxStandComp, OMX_U32 destinationState) {
00259 omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)openmaxStandComp->pComponentPrivate;
00260 omx_base_PortType *pPort;
00261 OMX_U32 i,j,k;
00262 OMX_ERRORTYPE err=OMX_ErrorNone;
00263
00264 DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
00265 DEBUG(DEB_LEV_PARAMS, "Changing state from %i to %i\n", omx_base_component_Private->state, (int)destinationState);
00266
00267 if(destinationState == OMX_StateLoaded){
00268 switch(omx_base_component_Private->state){
00269 case OMX_StateInvalid:
00270 err = OMX_ErrorInvalidState;
00271 break;
00272 case OMX_StateWaitForResources:
00273
00274 omx_base_component_Private->state = OMX_StateLoaded;
00275 break;
00276 case OMX_StateLoaded:
00277 err = OMX_ErrorSameState;
00278 break;
00279 case OMX_StateIdle:
00280
00281 for(j = 0; j < NUM_DOMAINS; j++) {
00282 for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
00283 i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
00284 omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
00285
00286 pPort = omx_base_component_Private->ports[i];
00287 if (PORT_IS_TUNNELED(pPort) && PORT_IS_BUFFER_SUPPLIER(pPort)) {
00288 while(pPort->pBufferQueue->nelem > 0) {
00289 DEBUG(DEB_LEV_PARAMS, "In %s Buffer %d remained in the port %d queue of comp%s\n",
00290 __func__,(int)pPort->pBufferQueue->nelem,(int)i,omx_base_component_Private->name);
00291 dequeue(pPort->pBufferQueue);
00292 }
00293
00294 err = pPort->Port_FreeTunnelBuffer(pPort,i);
00295 if(err!=OMX_ErrorNone) {
00296 DEBUG(DEB_LEV_ERR, "In %s Freeing Tunnel Buffer Error=%x\n",__func__,err);
00297 return err;
00298 }
00299 } else {
00300 DEBUG(DEB_LEV_FULL_SEQ, "In %s nPortIndex=%d pAllocSem Semval=%x\n", __func__,(int)i,(int)pPort->pAllocSem->semval);
00301
00302
00303 if(PORT_IS_ENABLED(pPort)) {
00304 tsem_down(pPort->pAllocSem);
00305 }
00306 }
00307 pPort->sPortParam.bPopulated = OMX_FALSE;
00308
00309 if(pPort->pInternalBufferStorage != NULL) {
00310 free(pPort->pInternalBufferStorage);
00311 pPort->pInternalBufferStorage=NULL;
00312 }
00313
00314 if(pPort->bBufferStateAllocated != NULL) {
00315 free(pPort->bBufferStateAllocated);
00316 pPort->bBufferStateAllocated=NULL;
00317 }
00318 }
00319 }
00320 omx_base_component_Private->state = OMX_StateLoaded;
00321
00322 if(omx_base_component_Private->bufferMgmtThreadID == 0 ){
00323
00324 tsem_up(omx_base_component_Private->bMgmtSem);
00325 pthread_join(omx_base_component_Private->bufferMgmtThread,NULL);
00326 omx_base_component_Private->bufferMgmtThreadID = -1;
00327 if(err != 0) {
00328 DEBUG(DEB_LEV_FUNCTION_NAME,"In %s pthread_join returned err=%d\n",__func__,err);
00329 }
00330 }
00331
00332 break;
00333 default:
00334 DEBUG(DEB_LEV_ERR, "In %s: state transition not allowed\n", __func__);
00335 err = OMX_ErrorIncorrectStateTransition;
00336 break;
00337 }
00338 return err;
00339 }
00340
00341 if(destinationState == OMX_StateWaitForResources){
00342 switch(omx_base_component_Private->state){
00343 case OMX_StateInvalid:
00344 err = OMX_ErrorInvalidState;
00345 break;
00346 case OMX_StateLoaded:
00347 omx_base_component_Private->state = OMX_StateWaitForResources;
00348 break;
00349 case OMX_StateWaitForResources:
00350 err = OMX_ErrorSameState;
00351 break;
00352 default:
00353 DEBUG(DEB_LEV_ERR, "In %s: state transition not allowed\n", __func__);
00354 err = OMX_ErrorIncorrectStateTransition;
00355 break;
00356 }
00357 return err;
00358 }
00359
00360 if(destinationState == OMX_StateIdle){
00361 switch(omx_base_component_Private->state){
00362 case OMX_StateInvalid:
00363 err = OMX_ErrorInvalidState;
00364 break;
00365 case OMX_StateWaitForResources:
00366 omx_base_component_Private->state = OMX_StateIdle;
00367 break;
00368 case OMX_StateLoaded:
00369
00370 for(j = 0; j < NUM_DOMAINS; j++) {
00371 for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
00372 i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
00373 omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
00374 pPort = omx_base_component_Private->ports[i];
00375 if (PORT_IS_TUNNELED(pPort) && PORT_IS_BUFFER_SUPPLIER(pPort)) {
00376 if(PORT_IS_ENABLED(pPort)) {
00378 err= pPort->Port_AllocateTunnelBuffer(pPort, i, omx_base_component_Private->ports[i]->sPortParam.nBufferSize);
00379 if(err!=OMX_ErrorNone) {
00380 DEBUG(DEB_LEV_ERR, "In %s Allocating Tunnel Buffer Error=%x\n",__func__,err);
00381 return err;
00382 }
00383 }
00384 } else {
00385 if(PORT_IS_ENABLED(pPort)) {
00386 DEBUG(DEB_LEV_FULL_SEQ, "In %s: wait for buffers. port enabled %i, port populated %i\n",
00387 __func__, pPort->sPortParam.bEnabled,pPort->sPortParam.bPopulated);
00388 tsem_down(pPort->pAllocSem);
00389 pPort->sPortParam.bPopulated = OMX_TRUE;
00390 }
00391 else
00392 DEBUG(DEB_LEV_ERR, "In %s: Port %i Disabled So no wait\n",__func__,(int)i);
00393 }
00394 DEBUG(DEB_LEV_SIMPLE_SEQ, "---> Tunnel status : port %d flags 0x%x\n",(int)i, (int)pPort->nTunnelFlags);
00395 }
00396 }
00397 omx_base_component_Private->state = OMX_StateIdle;
00399 omx_base_component_Private->bufferMgmtThreadID = pthread_create(&omx_base_component_Private->bufferMgmtThread,
00400 NULL,
00401 omx_base_component_Private->BufferMgmtFunction,
00402 openmaxStandComp);
00403 if(omx_base_component_Private->bufferMgmtThreadID < 0){
00404 DEBUG(DEB_LEV_ERR, "Starting buffer management thread failed\n");
00405 return OMX_ErrorUndefined;
00406 }
00407 break;
00408 case OMX_StateIdle:
00409 err = OMX_ErrorSameState;
00410 break;
00411 case OMX_StateExecuting:
00412
00413
00414 for(j = 0; j < NUM_DOMAINS; j++) {
00415 for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
00416 i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
00417 omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
00418 DEBUG(DEB_LEV_FULL_SEQ, "Flushing Port %i\n",(int)i);
00419 pPort = omx_base_component_Private->ports[i];
00420 if(PORT_IS_ENABLED(pPort)) {
00421 pPort->FlushProcessingBuffers(pPort);
00422 }
00423 }
00424 }
00425 omx_base_component_Private->state = OMX_StateIdle;
00426 break;
00427 case OMX_StatePause:
00428 omx_base_component_Private->state = OMX_StateIdle;
00429
00430 tsem_signal(omx_base_component_Private->bStateSem);
00431 break;
00432 default:
00433 DEBUG(DEB_LEV_ERR, "In %s: state transition not allowed\n", __func__);
00434 err = OMX_ErrorIncorrectStateTransition;
00435 break;
00436 }
00437 return err;
00438 }
00439
00440 if(destinationState == OMX_StatePause) {
00441 switch(omx_base_component_Private->state) {
00442 case OMX_StateInvalid:
00443 err = OMX_ErrorInvalidState;
00444 break;
00445 case OMX_StatePause:
00446 err = OMX_ErrorSameState;
00447 break;
00448 case OMX_StateExecuting:
00449 case OMX_StateIdle:
00450 omx_base_component_Private->state = OMX_StatePause;
00451 break;
00452 default:
00453 DEBUG(DEB_LEV_ERR, "In %s: state transition not allowed\n", __func__);
00454 err = OMX_ErrorIncorrectStateTransition;
00455 break;
00456 }
00457 return err;
00458 }
00459
00460 if(destinationState == OMX_StateExecuting) {
00461 switch(omx_base_component_Private->state) {
00462 case OMX_StateInvalid:
00463 err = OMX_ErrorInvalidState;
00464 break;
00465 case OMX_StateIdle:
00466 omx_base_component_Private->state=OMX_StateExecuting;
00467
00468
00469 for(j = 0; j < NUM_DOMAINS; j++) {
00470 for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
00471 i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
00472 omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
00473 pPort = omx_base_component_Private->ports[i];
00474 if (PORT_IS_TUNNELED(pPort) && PORT_IS_BUFFER_SUPPLIER(pPort)) {
00475 for(k=0;k<pPort->nNumTunnelBuffer;k++) {
00476 tsem_up(pPort->pBufferSem);
00477
00478 tsem_up(omx_base_component_Private->bMgmtSem);
00479 }
00480 }
00481 }
00482 }
00483 omx_base_component_Private->transientState = OMX_TransStateMax;
00484 err = OMX_ErrorNone;
00485 break;
00486 case OMX_StatePause:
00487 omx_base_component_Private->state=OMX_StateExecuting;
00488
00489
00490
00491 for(j = 0; j < NUM_DOMAINS; j++) {
00492 for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
00493 i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
00494 omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
00495
00496 pPort=omx_base_component_Private->ports[i];
00497 DEBUG(DEB_LEV_PARAMS, "In %s: state transition Paused 2 Executing, nelem=%d,semval=%d,Buf Count Actual=%d\n", __func__,
00498 pPort->pBufferQueue->nelem,pPort->pBufferSem->semval,(int)pPort->sPortParam.nBufferCountActual);
00499
00500 if (PORT_IS_TUNNELED_N_BUFFER_SUPPLIER(pPort) &&
00501 (pPort->pBufferQueue->nelem == (pPort->pBufferSem->semval + pPort->sPortParam.nBufferCountActual))) {
00502 for(k=0; k < pPort->sPortParam.nBufferCountActual;k++) {
00503 tsem_up(pPort->pBufferSem);
00504 tsem_up(omx_base_component_Private->bMgmtSem);
00505 }
00506 }
00507 }
00508 }
00509
00510 tsem_signal(omx_base_component_Private->bStateSem);
00511 break;
00512 case OMX_StateExecuting:
00513 err = OMX_ErrorSameState;
00514 break;
00515 default:
00516 DEBUG(DEB_LEV_ERR, "In %s: state transition not allowed\n", __func__);
00517 err = OMX_ErrorIncorrectStateTransition;
00518 break;
00519 }
00520 return err;
00521 }
00522
00523 if(destinationState == OMX_StateInvalid) {
00524 switch(omx_base_component_Private->state) {
00525 case OMX_StateInvalid:
00526 err = OMX_ErrorInvalidState;
00527 break;
00528 default:
00529 omx_base_component_Private->state = OMX_StateInvalid;
00530
00531 if(omx_base_component_Private->bufferMgmtThreadID == 0 ){
00532
00533 tsem_up(omx_base_component_Private->bMgmtSem);
00534 pthread_join(omx_base_component_Private->bufferMgmtThread,NULL);
00535 omx_base_component_Private->bufferMgmtThreadID = -1;
00536 if(err!=0) {
00537 DEBUG(DEB_LEV_FUNCTION_NAME,"In %s pthread_join returned err=%d\n",__func__,err);
00538 }
00539 }
00540 err = OMX_ErrorInvalidState;
00541 break;
00542 }
00543 return err;
00544 }
00545 return OMX_ErrorNone;
00546 }
00547
00559 OMX_ERRORTYPE checkHeader(OMX_PTR header, OMX_U32 size) {
00560 OMX_VERSIONTYPE* ver;
00561 if (header == NULL) {
00562 DEBUG(DEB_LEV_ERR, "In %s the header is null\n",__func__);
00563 return OMX_ErrorBadParameter;
00564 }
00565 ver = (OMX_VERSIONTYPE*)((char*)header + sizeof(OMX_U32));
00566 if(*((OMX_U32*)header) != size) {
00567 DEBUG(DEB_LEV_ERR, "In %s the header has a wrong size %i should be %i\n",__func__,(int)*((OMX_U32*)header),(int)size);
00568 return OMX_ErrorBadParameter;
00569 }
00570 if(ver->s.nVersionMajor != SPECVERSIONMAJOR ||
00571 ver->s.nVersionMinor != SPECVERSIONMINOR) {
00572 DEBUG(DEB_LEV_ERR, "The version does not match\n");
00573 return OMX_ErrorVersionMismatch;
00574 }
00575 return OMX_ErrorNone;
00576 }
00577
00585 void setHeader(OMX_PTR header, OMX_U32 size) {
00586 OMX_VERSIONTYPE* ver = (OMX_VERSIONTYPE*)((char*)header + sizeof(OMX_U32));
00587 *((OMX_U32*)header) = size;
00588
00589 ver->s.nVersionMajor = SPECVERSIONMAJOR;
00590 ver->s.nVersionMinor = SPECVERSIONMINOR;
00591 ver->s.nRevision = SPECREVISION;
00592 ver->s.nStep = SPECSTEP;
00593 }
00594
00598 OMX_ERRORTYPE omx_base_component_ParameterSanityCheck(OMX_IN OMX_HANDLETYPE hComponent,
00599 OMX_IN OMX_U32 nPortIndex,
00600 OMX_IN OMX_PTR pStructure,
00601 OMX_IN size_t size) {
00602 omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)(((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate);
00603 omx_base_PortType *pPort;
00604 int nNumPorts;
00605
00606 nNumPorts = omx_base_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
00607 omx_base_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts +
00608 omx_base_component_Private->sPortTypesParam[OMX_PortDomainImage].nPorts +
00609 omx_base_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts;
00610
00611 if (nPortIndex >= nNumPorts) {
00612 DEBUG(DEB_LEV_ERR, "Bad Port index %i when the component has %i ports\n", (int)nPortIndex, (int)nNumPorts);
00613 return OMX_ErrorBadPortIndex;
00614 }
00615
00616 pPort = omx_base_component_Private->ports[nPortIndex];
00617
00618 if (omx_base_component_Private->state != OMX_StateLoaded && omx_base_component_Private->state != OMX_StateWaitForResources) {
00619 if(PORT_IS_ENABLED(pPort)) {
00620 DEBUG(DEB_LEV_ERR, "In %s Incorrect State=%x lineno=%d\n",__func__,omx_base_component_Private->state,__LINE__);
00621 return OMX_ErrorIncorrectStateOperation;
00622 }
00623 }
00624
00625 return checkHeader(pStructure , size);
00626 }
00627
00632 OMX_ERRORTYPE omx_base_component_GetComponentVersion(OMX_IN OMX_HANDLETYPE hComponent,
00633 OMX_OUT OMX_STRING pComponentName,
00634 OMX_OUT OMX_VERSIONTYPE* pComponentVersion,
00635 OMX_OUT OMX_VERSIONTYPE* pSpecVersion,
00636 OMX_OUT OMX_UUIDTYPE* pComponentUUID) {
00637
00638 OMX_COMPONENTTYPE* omx_component = (OMX_COMPONENTTYPE*)hComponent;
00639 omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)omx_component->pComponentPrivate;
00640
00641 OMX_U32 uuid[3];
00642
00643 DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
00644
00645 strcpy(pComponentName, omx_base_component_Private->name);
00646
00647
00648 pComponentVersion->s.nVersionMajor = SPECVERSIONMAJOR;
00649 pComponentVersion->s.nVersionMinor = SPECVERSIONMINOR;
00650 pComponentVersion->s.nRevision = SPECREVISION;
00651 pComponentVersion->s.nStep = SPECSTEP;
00652
00653
00654 memcpy(pSpecVersion, &omx_component->nVersion, sizeof(OMX_VERSIONTYPE));
00655
00656
00657
00658 uuid[0] = (OMX_U32)omx_component;
00659 uuid[1] = getpid();
00660 uuid[2] = getuid();
00661 memcpy(*pComponentUUID, uuid, 3*sizeof(uuid));
00662
00663 DEBUG(DEB_LEV_FUNCTION_NAME, "Out of %s\n", __func__);
00664 return OMX_ErrorNone;
00665 }
00666
00675 OMX_ERRORTYPE omx_base_component_ComponentRoleEnum(
00676 OMX_IN OMX_HANDLETYPE hComponent,
00677 OMX_OUT OMX_U8 *cRole,
00678 OMX_IN OMX_U32 nIndex) {
00679 strcat((char*)cRole, "\0");
00680 return OMX_ErrorNoMore;
00681 }
00682
00688 OMX_ERRORTYPE omx_base_component_SetCallbacks(
00689 OMX_IN OMX_HANDLETYPE hComponent,
00690 OMX_IN OMX_CALLBACKTYPE* pCallbacks,
00691 OMX_IN OMX_PTR pAppData) {
00692
00693 OMX_COMPONENTTYPE *omxcomponent = (OMX_COMPONENTTYPE*)hComponent;
00694 omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)omxcomponent->pComponentPrivate;
00695 omx_base_PortType *pPort;
00696 OMX_U32 i,j;
00697
00698 DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
00699 omx_base_component_Private->callbacks = pCallbacks;
00700 omx_base_component_Private->callbackData = pAppData;
00701
00702
00703 for(j = 0; j < NUM_DOMAINS; j++) {
00704 for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
00705 i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
00706 omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
00707 pPort = omx_base_component_Private->ports[i];
00708 if (pPort->sPortParam.eDir == OMX_DirInput) {
00709 pPort->BufferProcessedCallback = omx_base_component_Private->callbacks->EmptyBufferDone;
00710 } else {
00711 pPort->BufferProcessedCallback = omx_base_component_Private->callbacks->FillBufferDone;
00712 }
00713 }
00714 }
00715 return OMX_ErrorNone;
00716 }
00717
00726 OMX_ERRORTYPE omx_base_component_GetParameter(
00727 OMX_IN OMX_HANDLETYPE hComponent,
00728 OMX_IN OMX_INDEXTYPE nParamIndex,
00729 OMX_INOUT OMX_PTR ComponentParameterStructure) {
00730
00731 OMX_COMPONENTTYPE *omxcomponent = (OMX_COMPONENTTYPE*)hComponent;
00732 omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)omxcomponent->pComponentPrivate;
00733 OMX_PRIORITYMGMTTYPE* pPrioMgmt;
00734 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef;
00735 OMX_PARAM_BUFFERSUPPLIERTYPE *pBufferSupplier;
00736 omx_base_PortType *pPort;
00737 OMX_PORT_PARAM_TYPE* pPortDomains;
00738 OMX_ERRORTYPE err = OMX_ErrorNone;
00739
00740 DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
00741 DEBUG(DEB_LEV_PARAMS, "Getting parameter %i\n", nParamIndex);
00742 if (ComponentParameterStructure == NULL) {
00743 return OMX_ErrorBadParameter;
00744 }
00745 switch(nParamIndex) {
00746 case OMX_IndexParamAudioInit:
00747 case OMX_IndexParamVideoInit:
00748 case OMX_IndexParamImageInit:
00749 case OMX_IndexParamOtherInit:
00750 pPortDomains = (OMX_PORT_PARAM_TYPE*)ComponentParameterStructure;
00751 if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_PORT_PARAM_TYPE))) != OMX_ErrorNone) {
00752 break;
00753 }
00754 pPortDomains->nPorts = 0;
00755 pPortDomains->nStartPortNumber = 0;
00756 break;
00757 case OMX_IndexParamPortDefinition:
00758 pPortDef = (OMX_PARAM_PORTDEFINITIONTYPE*) ComponentParameterStructure;
00759 if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_PARAM_PORTDEFINITIONTYPE))) != OMX_ErrorNone) {
00760 break;
00761 }
00762 if (pPortDef->nPortIndex >= (omx_base_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
00763 omx_base_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts +
00764 omx_base_component_Private->sPortTypesParam[OMX_PortDomainImage].nPorts +
00765 omx_base_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts)) {
00766 return OMX_ErrorBadPortIndex;
00767 }
00768
00769 memcpy(pPortDef, &omx_base_component_Private->ports[pPortDef->nPortIndex]->sPortParam, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
00770 break;
00771 case OMX_IndexParamPriorityMgmt:
00772 pPrioMgmt = (OMX_PRIORITYMGMTTYPE*)ComponentParameterStructure;
00773 if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_PRIORITYMGMTTYPE))) != OMX_ErrorNone) {
00774 break;
00775 }
00776 pPrioMgmt->nGroupPriority = omx_base_component_Private->nGroupPriority;
00777 pPrioMgmt->nGroupID = omx_base_component_Private->nGroupID;
00778 break;
00779 case OMX_IndexParamCompBufferSupplier:
00780 pBufferSupplier = (OMX_PARAM_BUFFERSUPPLIERTYPE*)ComponentParameterStructure;
00781 if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_PARAM_BUFFERSUPPLIERTYPE))) != OMX_ErrorNone) {
00782 break;
00783 }
00784 if (pBufferSupplier->nPortIndex >= (omx_base_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
00785 omx_base_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts +
00786 omx_base_component_Private->sPortTypesParam[OMX_PortDomainImage].nPorts +
00787 omx_base_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts)) {
00788 return OMX_ErrorBadPortIndex;
00789 }
00790
00791 pPort = omx_base_component_Private->ports[pBufferSupplier->nPortIndex];
00792
00793 if (pPort->sPortParam.eDir == OMX_DirInput) {
00794 if (PORT_IS_BUFFER_SUPPLIER(pPort)) {
00795 pBufferSupplier->eBufferSupplier = OMX_BufferSupplyInput;
00796 } else if (PORT_IS_TUNNELED(pPort)) {
00797 pBufferSupplier->eBufferSupplier = OMX_BufferSupplyOutput;
00798 } else {
00799 pBufferSupplier->eBufferSupplier = OMX_BufferSupplyUnspecified;
00800 }
00801 } else {
00802 if (PORT_IS_BUFFER_SUPPLIER(pPort)) {
00803 pBufferSupplier->eBufferSupplier = OMX_BufferSupplyOutput;
00804 } else if (PORT_IS_TUNNELED(pPort)) {
00805 pBufferSupplier->eBufferSupplier = OMX_BufferSupplyInput;
00806 } else {
00807 pBufferSupplier->eBufferSupplier = OMX_BufferSupplyUnspecified;
00808 }
00809 }
00810 break;
00811 default:
00812 err = OMX_ErrorUnsupportedIndex;
00813 break;
00814 }
00815 return err;
00816 }
00817
00826 OMX_ERRORTYPE omx_base_component_SetParameter(
00827 OMX_IN OMX_HANDLETYPE hComponent,
00828 OMX_IN OMX_INDEXTYPE nParamIndex,
00829 OMX_IN OMX_PTR ComponentParameterStructure) {
00830
00831 OMX_PRIORITYMGMTTYPE* pPrioMgmt;
00832 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef;
00833 OMX_ERRORTYPE err = OMX_ErrorNone;
00834 OMX_COMPONENTTYPE *omxcomponent = (OMX_COMPONENTTYPE*)hComponent;
00835 omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)omxcomponent->pComponentPrivate;
00836 OMX_PARAM_BUFFERSUPPLIERTYPE *pBufferSupplier;
00837 omx_base_PortType *pPort;
00838
00839 DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
00840 DEBUG(DEB_LEV_PARAMS, "Setting parameter %x\n", nParamIndex);
00841 if (ComponentParameterStructure == NULL) {
00842 DEBUG(DEB_LEV_ERR, "In %s parameter provided is null! err = %x\n", __func__, err);
00843 return OMX_ErrorBadParameter;
00844 }
00845
00846 switch(nParamIndex) {
00847 case OMX_IndexParamAudioInit:
00848 case OMX_IndexParamVideoInit:
00849 case OMX_IndexParamImageInit:
00850 case OMX_IndexParamOtherInit:
00851
00852 if (omx_base_component_Private->state != OMX_StateLoaded &&
00853 omx_base_component_Private->state != OMX_StateWaitForResources) {
00854 return OMX_ErrorIncorrectStateOperation;
00855 }
00856 if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_PORT_PARAM_TYPE))) != OMX_ErrorNone) {
00857 break;
00858 }
00859 err = OMX_ErrorUndefined;
00860 break;
00861 case OMX_IndexParamPortDefinition:
00862 pPortDef = (OMX_PARAM_PORTDEFINITIONTYPE*) ComponentParameterStructure;
00863 err = omx_base_component_ParameterSanityCheck(hComponent, pPortDef->nPortIndex, pPortDef, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
00864 if(err!=OMX_ErrorNone) {
00865 DEBUG(DEB_LEV_ERR, "In %s Parameter Check Error=%x\n",__func__,err);
00866 break;
00867 }
00868 {
00869 OMX_PARAM_PORTDEFINITIONTYPE *pPortParam;
00870 OMX_U32 j,old_nBufferCountActual=0;
00871 pPortParam = &omx_base_component_Private->ports[pPortDef->nPortIndex]->sPortParam;
00872 if(pPortDef->nBufferCountActual < pPortParam->nBufferCountMin) {
00873 DEBUG(DEB_LEV_ERR, "In %s nBufferCountActual of param (%i) is < of nBufferCountMin of port(%i)\n",__func__, (int)pPortDef->nBufferCountActual, (int)pPortParam->nBufferCountMin);
00874 err = OMX_ErrorBadParameter;
00875 break;
00876 }
00877 old_nBufferCountActual = pPortParam->nBufferCountActual;
00878 pPortParam->nBufferCountActual = pPortDef->nBufferCountActual;
00879
00880 switch(pPortDef->eDomain) {
00881 case OMX_PortDomainAudio:
00882 memcpy(&pPortParam->format.audio, &pPortDef->format.audio, sizeof(OMX_AUDIO_PORTDEFINITIONTYPE));
00883 break;
00884 case OMX_PortDomainVideo:
00885 pPortParam->format.video.pNativeRender = pPortDef->format.video.pNativeRender;
00886 pPortParam->format.video.nFrameWidth = pPortDef->format.video.nFrameWidth;
00887 pPortParam->format.video.nFrameHeight = pPortDef->format.video.nFrameHeight;
00888 pPortParam->format.video.nStride = pPortDef->format.video.nStride;
00889 pPortParam->format.video.xFramerate = pPortDef->format.video.xFramerate;
00890 pPortParam->format.video.bFlagErrorConcealment = pPortDef->format.video.bFlagErrorConcealment;
00891 pPortParam->format.video.eCompressionFormat = pPortDef->format.video.eCompressionFormat;
00892 pPortParam->format.video.eColorFormat = pPortDef->format.video.eColorFormat;
00893 pPortParam->format.video.pNativeWindow = pPortDef->format.video.pNativeWindow;
00894 break;
00895 case OMX_PortDomainImage:
00896 pPortParam->format.image.nFrameWidth = pPortDef->format.image.nFrameWidth;
00897 pPortParam->format.image.nFrameHeight = pPortDef->format.image.nFrameHeight;
00898 pPortParam->format.image.nStride = pPortDef->format.image.nStride;
00899 pPortParam->format.image.bFlagErrorConcealment = pPortDef->format.image.bFlagErrorConcealment;
00900 pPortParam->format.image.eCompressionFormat = pPortDef->format.image.eCompressionFormat;
00901 pPortParam->format.image.eColorFormat = pPortDef->format.image.eColorFormat;
00902 pPortParam->format.image.pNativeWindow = pPortDef->format.image.pNativeWindow;
00903 break;
00904 case OMX_PortDomainOther:
00905 memcpy(&pPortParam->format.other, &pPortDef->format.other, sizeof(OMX_OTHER_PORTDEFINITIONTYPE));
00906 break;
00907 default:
00908 DEBUG(DEB_LEV_ERR, "In %s wrong port domain. Out of OpenMAX scope\n",__func__);
00909 err = OMX_ErrorBadParameter;
00910 break;
00911 }
00912
00913
00914 if ((omx_base_component_Private->state == OMX_StateIdle ||
00915 omx_base_component_Private->state == OMX_StatePause ||
00916 omx_base_component_Private->state == OMX_StateExecuting) &&
00917 (pPortParam->nBufferCountActual > old_nBufferCountActual)) {
00918
00919 pPort = omx_base_component_Private->ports[pPortDef->nPortIndex];
00920 if(pPort->pInternalBufferStorage) {
00921 pPort->pInternalBufferStorage = realloc(pPort->pInternalBufferStorage,pPort->sPortParam.nBufferCountActual*sizeof(OMX_BUFFERHEADERTYPE *));
00922 }
00923
00924 if(pPort->bBufferStateAllocated) {
00925 pPort->bBufferStateAllocated = realloc(pPort->bBufferStateAllocated,pPort->sPortParam.nBufferCountActual*sizeof(BUFFER_STATUS_FLAG));
00926 for(j=0; j < pPort->sPortParam.nBufferCountActual; j++) {
00927 pPort->bBufferStateAllocated[j] = BUFFER_FREE;
00928 }
00929 }
00930 }
00931 }
00932 break;
00933 case OMX_IndexParamPriorityMgmt:
00934 if (omx_base_component_Private->state != OMX_StateLoaded &&
00935 omx_base_component_Private->state != OMX_StateWaitForResources) {
00936 return OMX_ErrorIncorrectStateOperation;
00937 }
00938 pPrioMgmt = (OMX_PRIORITYMGMTTYPE*)ComponentParameterStructure;
00939 if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_PRIORITYMGMTTYPE))) != OMX_ErrorNone) {
00940 break;
00941 }
00942 omx_base_component_Private->nGroupPriority = pPrioMgmt->nGroupPriority;
00943 omx_base_component_Private->nGroupID = pPrioMgmt->nGroupID;
00944 break;
00945 case OMX_IndexParamCompBufferSupplier:
00946 pBufferSupplier = (OMX_PARAM_BUFFERSUPPLIERTYPE*)ComponentParameterStructure;
00947
00948 DEBUG(DEB_LEV_PARAMS, "In %s Buf Sup Port index=%d\n", __func__,(int)pBufferSupplier->nPortIndex);
00949
00950 if(pBufferSupplier == NULL) {
00951 DEBUG(DEB_LEV_ERR, "In %s pBufferSupplier is null!\n",__func__);
00952 return OMX_ErrorBadParameter;
00953 }
00954 if(pBufferSupplier->nPortIndex > (omx_base_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
00955 omx_base_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts +
00956 omx_base_component_Private->sPortTypesParam[OMX_PortDomainImage].nPorts +
00957 omx_base_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts)) {
00958 return OMX_ErrorBadPortIndex;
00959 }
00960 err = omx_base_component_ParameterSanityCheck(hComponent, pBufferSupplier->nPortIndex, pBufferSupplier, sizeof(OMX_PARAM_BUFFERSUPPLIERTYPE));
00961 if(err==OMX_ErrorIncorrectStateOperation) {
00962 if (PORT_IS_ENABLED(omx_base_component_Private->ports[pBufferSupplier->nPortIndex])) {
00963 DEBUG(DEB_LEV_ERR, "In %s Incorrect State=%x\n",__func__,omx_base_component_Private->state);
00964 return OMX_ErrorIncorrectStateOperation;
00965 }
00966 } else if (err != OMX_ErrorNone) {
00967 break;
00968 }
00969
00970 if (pBufferSupplier->eBufferSupplier == OMX_BufferSupplyUnspecified) {
00971 DEBUG(DEB_LEV_PARAMS, "In %s: port is already buffer supplier unspecified\n", __func__);
00972 return OMX_ErrorNone;
00973 }
00974 if ((PORT_IS_TUNNELED(omx_base_component_Private->ports[pBufferSupplier->nPortIndex])) == 0) {
00975 return OMX_ErrorNone;
00976 }
00977
00978 pPort = omx_base_component_Private->ports[pBufferSupplier->nPortIndex];
00979
00980 if ((pBufferSupplier->eBufferSupplier == OMX_BufferSupplyInput) &&
00981 (pPort->sPortParam.eDir == OMX_DirInput)) {
00983 if (PORT_IS_BUFFER_SUPPLIER(pPort)) {
00984 err = OMX_ErrorNone;
00985 }
00986 pPort->nTunnelFlags |= TUNNEL_IS_SUPPLIER;
00987 pBufferSupplier->nPortIndex = pPort->nTunneledPort;
00988 err = OMX_SetParameter(pPort->hTunneledComponent, OMX_IndexParamCompBufferSupplier, pBufferSupplier);
00989 } else if ((pBufferSupplier->eBufferSupplier == OMX_BufferSupplyOutput) &&
00990 (pPort->sPortParam.eDir == OMX_DirInput)) {
00991 if (PORT_IS_BUFFER_SUPPLIER(pPort)) {
00992 pPort->nTunnelFlags &= ~TUNNEL_IS_SUPPLIER;
00993 pBufferSupplier->nPortIndex = pPort->nTunneledPort;
00994 err = OMX_SetParameter(pPort->hTunneledComponent, OMX_IndexParamCompBufferSupplier, pBufferSupplier);
00995 }
00996 err = OMX_ErrorNone;
00997 } else if ((pBufferSupplier->eBufferSupplier == OMX_BufferSupplyOutput) &&
00998 (pPort->sPortParam.eDir == OMX_DirOutput)) {
01000 if (PORT_IS_BUFFER_SUPPLIER(pPort)) {
01001 err = OMX_ErrorNone;
01002 }
01003 pPort->nTunnelFlags |= TUNNEL_IS_SUPPLIER;
01004 } else {
01005 if (PORT_IS_BUFFER_SUPPLIER(pPort)) {
01006 pPort->nTunnelFlags &= ~TUNNEL_IS_SUPPLIER;
01007 err = OMX_ErrorNone;
01008 }
01009 err = OMX_ErrorNone;
01010 }
01011 DEBUG(DEB_LEV_PARAMS, "In %s port %d Tunnel flag=%x \n", __func__,(int)pBufferSupplier->nPortIndex, (int)pPort->nTunnelFlags);
01012 break;
01013 default:
01014 err = OMX_ErrorUnsupportedIndex;
01015 break;
01016 }
01017 return err;
01018 }
01019
01027 OMX_ERRORTYPE omx_base_component_GetConfig(
01028 OMX_IN OMX_HANDLETYPE hComponent,
01029 OMX_IN OMX_INDEXTYPE nIndex,
01030 OMX_INOUT OMX_PTR pComponentConfigStructure) {
01031 return OMX_ErrorNone;
01032 }
01033
01041 OMX_ERRORTYPE omx_base_component_SetConfig(
01042 OMX_IN OMX_HANDLETYPE hComponent,
01043 OMX_IN OMX_INDEXTYPE nIndex,
01044 OMX_IN OMX_PTR pComponentConfigStructure) {
01045 return OMX_ErrorNone;
01046 }
01047
01053 OMX_ERRORTYPE omx_base_component_GetExtensionIndex(
01054 OMX_IN OMX_HANDLETYPE hComponent,
01055 OMX_IN OMX_STRING cParameterName,
01056 OMX_OUT OMX_INDEXTYPE* pIndexType) {
01057
01058 DEBUG(DEB_LEV_FUNCTION_NAME,"In %s \n",__func__);
01059
01060 return OMX_ErrorBadParameter;
01061 }
01062
01067 OMX_ERRORTYPE omx_base_component_GetState(
01068 OMX_IN OMX_HANDLETYPE hComponent,
01069 OMX_OUT OMX_STATETYPE* pState) {
01070 OMX_COMPONENTTYPE *omxcomponent = (OMX_COMPONENTTYPE*)hComponent;
01071 omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)omxcomponent->pComponentPrivate;
01072 *pState = omx_base_component_Private->state;
01073 return OMX_ErrorNone;
01074 }
01075
01081 OMX_ERRORTYPE omx_base_component_SendCommand(
01082 OMX_IN OMX_HANDLETYPE hComponent,
01083 OMX_IN OMX_COMMANDTYPE Cmd,
01084 OMX_IN OMX_U32 nParam,
01085 OMX_IN OMX_PTR pCmdData) {
01086 OMX_COMPONENTTYPE* omxComponent = (OMX_COMPONENTTYPE*)hComponent;
01087 omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)omxComponent->pComponentPrivate;
01088 internalRequestMessageType *message;
01089 queue_t* messageQueue;
01090 tsem_t* messageSem;
01091 OMX_U32 i,j,k;
01092 omx_base_PortType *pPort;
01093 OMX_ERRORTYPE err = OMX_ErrorNone;
01094 DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
01095
01096 messageQueue = omx_base_component_Private->messageQueue;
01097 messageSem = omx_base_component_Private->messageSem;
01098
01099 if (omx_base_component_Private->state == OMX_StateInvalid) {
01100 return OMX_ErrorInvalidState;
01101 }
01102
01103 message = calloc(1,sizeof(internalRequestMessageType));
01104 message->messageParam = nParam;
01105 message->pCmdData=pCmdData;
01107 switch (Cmd) {
01108 case OMX_CommandStateSet:
01109 message->messageType = OMX_CommandStateSet;
01110 if ((nParam == OMX_StateIdle) && (omx_base_component_Private->state == OMX_StateLoaded)) {
01111
01112
01113 for(j = 0; j < NUM_DOMAINS; j++) {
01114 for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
01115 i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
01116 omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
01117
01118 pPort = omx_base_component_Private->ports[i];
01119
01120 if(pPort->pInternalBufferStorage == NULL) {
01121 pPort->pInternalBufferStorage = calloc(pPort->sPortParam.nBufferCountActual,sizeof(OMX_BUFFERHEADERTYPE *));
01122 }
01123
01124 if(pPort->bBufferStateAllocated == NULL) {
01125 pPort->bBufferStateAllocated = calloc(pPort->sPortParam.nBufferCountActual,sizeof(BUFFER_STATUS_FLAG));
01126 }
01127
01128 for(k=0; k < pPort->sPortParam.nBufferCountActual; k++) {
01129 pPort->bBufferStateAllocated[k] = BUFFER_FREE;
01130 }
01131 }
01132 }
01133
01134 omx_base_component_Private->transientState = OMX_TransStateLoadedToIdle;
01135 } else if ((nParam == OMX_StateLoaded) && (omx_base_component_Private->state == OMX_StateIdle)) {
01136 omx_base_component_Private->transientState = OMX_TransStateIdleToLoaded;
01137 } else if ((nParam == OMX_StateIdle) && (omx_base_component_Private->state == OMX_StateExecuting)) {
01138 omx_base_component_Private->transientState = OMX_TransStateExecutingToIdle;
01139 }
01140 break;
01141 case OMX_CommandFlush:
01142 if (nParam >= (omx_base_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
01143 omx_base_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts +
01144 omx_base_component_Private->sPortTypesParam[OMX_PortDomainImage].nPorts +
01145 omx_base_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts) && nParam != OMX_ALL) {
01146 return OMX_ErrorBadPortIndex;
01147 }
01148 message->messageType = OMX_CommandFlush;
01149 break;
01150 case OMX_CommandPortDisable:
01151 if (nParam >= (omx_base_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
01152 omx_base_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts +
01153 omx_base_component_Private->sPortTypesParam[OMX_PortDomainImage].nPorts +
01154 omx_base_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts) && nParam != OMX_ALL) {
01155 return OMX_ErrorBadPortIndex;
01156 }
01157 message->messageType = OMX_CommandPortDisable;
01158 if(message->messageParam == OMX_ALL) {
01159
01160 for(j = 0; j < NUM_DOMAINS; j++) {
01161 for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
01162 i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
01163 omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
01164 omx_base_component_Private->ports[i]->bIsTransientToDisabled = OMX_TRUE;
01165 }
01166 }
01167 } else {
01168 omx_base_component_Private->ports[message->messageParam]->bIsTransientToDisabled = OMX_TRUE;
01169 }
01170 break;
01171 case OMX_CommandPortEnable:
01172 if (nParam >= (omx_base_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
01173 omx_base_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts +
01174 omx_base_component_Private->sPortTypesParam[OMX_PortDomainImage].nPorts +
01175 omx_base_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts) && nParam != OMX_ALL) {
01176 return OMX_ErrorBadPortIndex;
01177 }
01178 message->messageType = OMX_CommandPortEnable;
01179 if(message->messageParam == OMX_ALL) {
01180
01181 for(j = 0; j < NUM_DOMAINS; j++) {
01182 for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
01183 i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
01184 omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
01185 omx_base_component_Private->ports[i]->bIsTransientToEnabled = OMX_TRUE;
01186 }
01187 }
01188 } else {
01189 omx_base_component_Private->ports[message->messageParam]->bIsTransientToEnabled = OMX_TRUE;
01190 }
01191 break;
01192 case OMX_CommandMarkBuffer:
01193 if (nParam >= (omx_base_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
01194 omx_base_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts +
01195 omx_base_component_Private->sPortTypesParam[OMX_PortDomainImage].nPorts +
01196 omx_base_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts) && nParam != OMX_ALL) {
01197 return OMX_ErrorBadPortIndex;
01198 }
01199 message->messageType = OMX_CommandMarkBuffer;
01200 break;
01201 default:
01202 err = OMX_ErrorUnsupportedIndex;
01203 break;
01204 }
01205
01206 if (err == OMX_ErrorNone)
01207 {
01208 queue(messageQueue, message);
01209 tsem_up(messageSem);
01210 }
01211
01212 DEBUG(DEB_LEV_FULL_SEQ, "In %s messageSem up param=%d\n", __func__,message->messageParam);
01213
01214 return err;
01215 }
01216
01223 void* compMessageHandlerFunction(void* param) {
01224 OMX_COMPONENTTYPE *openmaxStandComp = (OMX_COMPONENTTYPE *)param;
01225 omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)openmaxStandComp->pComponentPrivate;
01226 internalRequestMessageType *message;
01227
01228 while(1){
01229
01230 if (omx_base_component_Private == NULL) {
01231 break;
01232 }
01233 tsem_down(omx_base_component_Private->messageSem);
01234 DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
01235
01236 if(omx_base_component_Private->state == OMX_StateInvalid) {
01237 break;
01238 }
01239
01240 message = dequeue(omx_base_component_Private->messageQueue);
01241 if(message == NULL){
01242 DEBUG(DEB_LEV_ERR, "In %s: ouch!! had null message!\n", __func__);
01243 break;
01244 }
01245
01246 omx_base_component_Private->messageHandler(openmaxStandComp,message);
01247
01248
01249
01250 free(message);
01251 message = NULL;
01252 }
01253 DEBUG(DEB_LEV_FUNCTION_NAME,"Exiting Message Handler thread\n");
01254 return NULL;
01255 }
01256
01268 OMX_ERRORTYPE omx_base_component_MessageHandler(OMX_COMPONENTTYPE *openmaxStandComp,internalRequestMessageType* message) {
01269 omx_base_component_PrivateType* omx_base_component_Private=openmaxStandComp->pComponentPrivate;
01270 OMX_U32 i,j,k;
01271 OMX_ERRORTYPE err = OMX_ErrorNone;
01272 omx_base_PortType* pPort;
01273
01274 DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
01275
01276
01277
01278
01279
01280
01281 switch(message->messageType){
01282 case OMX_CommandStateSet: {
01283
01284 err = (*(omx_base_component_Private->DoStateSet))(openmaxStandComp, message->messageParam);
01285 if (err != OMX_ErrorNone) {
01286 (*(omx_base_component_Private->callbacks->EventHandler))
01287 (openmaxStandComp,
01288 omx_base_component_Private->callbackData,
01289 OMX_EventError,
01290 err,
01291 0,
01292 NULL);
01293 } else {
01294
01295 DEBUG(DEB_LEV_FULL_SEQ,"running callback in %s\n",__func__);
01296 (*(omx_base_component_Private->callbacks->EventHandler))
01297 (openmaxStandComp,
01298 omx_base_component_Private->callbackData,
01299 OMX_EventCmdComplete,
01300 OMX_CommandStateSet,
01301 message->messageParam,
01302 NULL);
01303 }
01304 }
01305 break;
01306 case OMX_CommandFlush: {
01307
01308 if(message->messageParam == OMX_ALL) {
01309
01310 for(j = 0; j < NUM_DOMAINS; j++) {
01311 for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
01312 i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
01313 omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
01314 omx_base_component_Private->ports[i]->bIsPortFlushed = OMX_TRUE;
01315 }
01316 }
01317
01318 for(j = 0; j < NUM_DOMAINS; j++) {
01319 for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
01320 i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
01321 omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
01322 pPort=omx_base_component_Private->ports[i];
01323 err = pPort->FlushProcessingBuffers(pPort);
01324 }
01325 }
01326 }
01327 else {
01328 pPort=omx_base_component_Private->ports[message->messageParam];
01329 err = pPort->FlushProcessingBuffers(pPort);
01330 }
01331 if (err != OMX_ErrorNone) {
01332 (*(omx_base_component_Private->callbacks->EventHandler))
01333 (openmaxStandComp,
01334 omx_base_component_Private->callbackData,
01335 OMX_EventError,
01336 err,
01337 0,
01338 NULL);
01339 } else {
01340 if(message->messageParam == OMX_ALL){
01341
01342 for(j = 0; j < NUM_DOMAINS; j++) {
01343 for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
01344 i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
01345 omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
01346 (*(omx_base_component_Private->callbacks->EventHandler))
01347 (openmaxStandComp,
01348 omx_base_component_Private->callbackData,
01349 OMX_EventCmdComplete,
01350 OMX_CommandFlush,
01351 i,
01352 NULL);
01353
01354 pPort=omx_base_component_Private->ports[i];
01355
01356 if (PORT_IS_TUNNELED(pPort) && PORT_IS_BUFFER_SUPPLIER(pPort)) {
01357 for(k=0;k<pPort->nNumTunnelBuffer;k++) {
01358 tsem_up(pPort->pBufferSem);
01359
01360 tsem_up(omx_base_component_Private->bMgmtSem);
01361 }
01362 }
01363 }
01364 }
01365 } else {
01366 (*(omx_base_component_Private->callbacks->EventHandler))
01367 (openmaxStandComp,
01368 omx_base_component_Private->callbackData,
01369 OMX_EventCmdComplete,
01370 OMX_CommandFlush,
01371 message->messageParam,
01372 NULL);
01373
01374 if (PORT_IS_TUNNELED(omx_base_component_Private->ports[message->messageParam])
01375 && PORT_IS_BUFFER_SUPPLIER(omx_base_component_Private->ports[message->messageParam])) {
01376 for(j=0;j<omx_base_component_Private->ports[message->messageParam]->nNumTunnelBuffer;j++) {
01377 tsem_up(omx_base_component_Private->ports[message->messageParam]->pBufferSem);
01378
01379 tsem_up(omx_base_component_Private->bMgmtSem);
01380 }
01381 }
01382 }
01383 }
01384 }
01385 break;
01386 case OMX_CommandPortDisable: {
01387
01388 if(message->messageParam == OMX_ALL) {
01389
01390 if(omx_base_component_Private->state!=OMX_StateLoaded) {
01391
01392 for(j = 0; j < NUM_DOMAINS; j++) {
01393 for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
01394 i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
01395 omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
01396 pPort=omx_base_component_Private->ports[i];
01397 err = pPort->FlushProcessingBuffers(pPort);
01398 }
01399 }
01400 }
01401
01402 for(j = 0; j < NUM_DOMAINS; j++) {
01403 for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
01404 i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
01405 omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
01406 pPort=omx_base_component_Private->ports[i];
01407 err = pPort->Port_DisablePort(pPort);
01408 }
01409 }
01410 }
01411 else {
01412 pPort=omx_base_component_Private->ports[message->messageParam];
01413 if(omx_base_component_Private->state!=OMX_StateLoaded) {
01414 err = pPort->FlushProcessingBuffers(pPort);
01415 DEBUG(DEB_LEV_FULL_SEQ, "In %s: Port Flush completed for Comp %s\n",__func__,omx_base_component_Private->name);
01416 }
01417 err = pPort->Port_DisablePort(pPort);
01418 }
01420 if (err != OMX_ErrorNone) {
01421 (*(omx_base_component_Private->callbacks->EventHandler))
01422 (openmaxStandComp,
01423 omx_base_component_Private->callbackData,
01424 OMX_EventError,
01425 err,
01426 0,
01427 NULL);
01428 } else {
01429 if(message->messageParam == OMX_ALL){
01430
01431 for(j = 0; j < NUM_DOMAINS; j++) {
01432 for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
01433 i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
01434 omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
01435 (*(omx_base_component_Private->callbacks->EventHandler))
01436 (openmaxStandComp,
01437 omx_base_component_Private->callbackData,
01438 OMX_EventCmdComplete,
01439 OMX_CommandPortDisable,
01440 i,
01441 NULL);
01442 }
01443 }
01444 } else {
01445 (*(omx_base_component_Private->callbacks->EventHandler))
01446 (openmaxStandComp,
01447 omx_base_component_Private->callbackData,
01448 OMX_EventCmdComplete,
01449 OMX_CommandPortDisable,
01450 message->messageParam,
01451 NULL);
01452 }
01453 }
01454 }
01455 break;
01456 case OMX_CommandPortEnable:{
01457
01458 if(message->messageParam == OMX_ALL) {
01459
01460 for(j = 0; j < NUM_DOMAINS; j++) {
01461 for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
01462 i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
01463 omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
01464 pPort=omx_base_component_Private->ports[i];
01465 err = pPort->Port_EnablePort(pPort);
01466 }
01467 }
01468 } else {
01469 pPort=omx_base_component_Private->ports[message->messageParam];
01470 err = pPort->Port_EnablePort(pPort);
01471 }
01472 if (err != OMX_ErrorNone) {
01473 (*(omx_base_component_Private->callbacks->EventHandler))
01474 (openmaxStandComp,
01475 omx_base_component_Private->callbackData,
01476 OMX_EventError,
01477 err,
01478 0,
01479 NULL);
01480 } else {
01481 if(message->messageParam != OMX_ALL) {
01482 (*(omx_base_component_Private->callbacks->EventHandler))
01483 (openmaxStandComp,
01484 omx_base_component_Private->callbackData,
01485 OMX_EventCmdComplete,
01486 OMX_CommandPortEnable,
01487 message->messageParam,
01488 NULL);
01489
01490 if (omx_base_component_Private->state==OMX_StateExecuting) {
01491 pPort=omx_base_component_Private->ports[message->messageParam];
01492 if (PORT_IS_BUFFER_SUPPLIER(pPort)) {
01493 for(i=0; i < pPort->sPortParam.nBufferCountActual;i++) {
01494 tsem_up(pPort->pBufferSem);
01495 tsem_up(omx_base_component_Private->bMgmtSem);
01496 }
01497 }
01498 }
01499
01500 } else {
01501
01502 for(j = 0; j < NUM_DOMAINS; j++) {
01503 for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
01504 i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
01505 omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
01506 (*(omx_base_component_Private->callbacks->EventHandler))
01507 (openmaxStandComp,
01508 omx_base_component_Private->callbackData,
01509 OMX_EventCmdComplete,
01510 OMX_CommandPortEnable,
01511 i,
01512 NULL);
01513 }
01514 }
01515
01516 if (omx_base_component_Private->state==OMX_StateExecuting) {
01517
01518 for(j = 0; j < NUM_DOMAINS; j++) {
01519 for(i = omx_base_component_Private->sPortTypesParam[j].nStartPortNumber;
01520 i < omx_base_component_Private->sPortTypesParam[j].nStartPortNumber +
01521 omx_base_component_Private->sPortTypesParam[j].nPorts; i++) {
01522 pPort=omx_base_component_Private->ports[i];
01523 if (PORT_IS_BUFFER_SUPPLIER(pPort)) {
01524 for(k=0; k < pPort->sPortParam.nBufferCountActual;k++) {
01525 tsem_up(pPort->pBufferSem);
01526 tsem_up(omx_base_component_Private->bMgmtSem);
01527 }
01528 }
01529 }
01530 }
01531 }
01532 }
01533 }
01534 }
01535 break;
01536 case OMX_CommandMarkBuffer: {
01537 omx_base_component_Private->pMark=(OMX_MARKTYPE *)message->pCmdData;
01538 }
01539 break;
01540 default:
01541 DEBUG(DEB_LEV_ERR, "In %s: Unrecognized command %i\n", __func__, message->messageType);
01542 break;
01543 }
01544 DEBUG(DEB_LEV_SIMPLE_SEQ, "Returning from %s: \n", __func__);
01545 return OMX_ErrorNone;
01546 }
01547
01548 OMX_ERRORTYPE omx_base_component_AllocateBuffer(
01549 OMX_IN OMX_HANDLETYPE hComponent,
01550 OMX_INOUT OMX_BUFFERHEADERTYPE** ppBuffer,
01551 OMX_IN OMX_U32 nPortIndex,
01552 OMX_IN OMX_PTR pAppPrivate,
01553 OMX_IN OMX_U32 nSizeBytes) {
01554 omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
01555 omx_base_PortType *pPort;
01556
01557 if (nPortIndex >= (omx_base_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
01558 omx_base_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts +
01559 omx_base_component_Private->sPortTypesParam[OMX_PortDomainImage].nPorts +
01560 omx_base_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts)) {
01561 DEBUG(DEB_LEV_ERR, "In %s: wrong port index\n", __func__);
01562 return OMX_ErrorBadPortIndex;
01563 }
01564 pPort = omx_base_component_Private->ports[nPortIndex];
01565
01566 return pPort->Port_AllocateBuffer(pPort,
01567 ppBuffer,
01568 nPortIndex,
01569 pAppPrivate,
01570 nSizeBytes);
01571 }
01572
01573 OMX_ERRORTYPE omx_base_component_UseBuffer(
01574 OMX_IN OMX_HANDLETYPE hComponent,
01575 OMX_INOUT OMX_BUFFERHEADERTYPE** ppBufferHdr,
01576 OMX_IN OMX_U32 nPortIndex,
01577 OMX_IN OMX_PTR pAppPrivate,
01578 OMX_IN OMX_U32 nSizeBytes,
01579 OMX_IN OMX_U8* pBuffer) {
01580 omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
01581 omx_base_PortType *pPort;
01582
01583 if (nPortIndex >= (omx_base_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
01584 omx_base_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts +
01585 omx_base_component_Private->sPortTypesParam[OMX_PortDomainImage].nPorts +
01586 omx_base_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts)) {
01587 DEBUG(DEB_LEV_ERR, "In %s: wrong port index\n", __func__);
01588 return OMX_ErrorBadPortIndex;
01589 }
01590 pPort = omx_base_component_Private->ports[nPortIndex];
01591
01592 return pPort->Port_UseBuffer(pPort,
01593 ppBufferHdr,
01594 nPortIndex,
01595 pAppPrivate,
01596 nSizeBytes,
01597 pBuffer);
01598 }
01599
01600 OMX_ERRORTYPE omx_base_component_UseEGLImage (
01601 OMX_HANDLETYPE hComponent,
01602 OMX_BUFFERHEADERTYPE** ppBufferHdr,
01603 OMX_U32 nPortIndex,
01604 OMX_PTR pAppPrivate,
01605 void* eglImage) {
01606 return OMX_ErrorNotImplemented;
01607 }
01608
01609 OMX_ERRORTYPE omx_base_component_FreeBuffer(
01610 OMX_IN OMX_HANDLETYPE hComponent,
01611 OMX_IN OMX_U32 nPortIndex,
01612 OMX_IN OMX_BUFFERHEADERTYPE* pBuffer) {
01613 omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
01614 omx_base_PortType *pPort;
01615
01616 if (nPortIndex >= (omx_base_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
01617 omx_base_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts +
01618 omx_base_component_Private->sPortTypesParam[OMX_PortDomainImage].nPorts +
01619 omx_base_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts)) {
01620 DEBUG(DEB_LEV_ERR, "In %s: wrong port index\n", __func__);
01621 return OMX_ErrorBadPortIndex;
01622 }
01623
01624 pPort = omx_base_component_Private->ports[nPortIndex];
01625
01626 return pPort->Port_FreeBuffer(pPort,
01627 nPortIndex,
01628 pBuffer);
01629 }
01630
01631 OMX_ERRORTYPE omx_base_component_EmptyThisBuffer(
01632 OMX_IN OMX_HANDLETYPE hComponent,
01633 OMX_IN OMX_BUFFERHEADERTYPE* pBuffer) {
01634 omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
01635 omx_base_PortType *pPort;
01636 DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
01637
01638 if (pBuffer->nInputPortIndex >= (omx_base_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
01639 omx_base_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts +
01640 omx_base_component_Private->sPortTypesParam[OMX_PortDomainImage].nPorts +
01641 omx_base_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts)) {
01642 DEBUG(DEB_LEV_ERR, "In %s: wrong port index\n", __func__);
01643 return OMX_ErrorBadPortIndex;
01644 }
01645 pPort = omx_base_component_Private->ports[pBuffer->nInputPortIndex];
01646 if (pPort->sPortParam.eDir != OMX_DirInput) {
01647 DEBUG(DEB_LEV_ERR, "In %s: wrong port direction in Component %s\n", __func__,omx_base_component_Private->name);
01648 return OMX_ErrorBadPortIndex;
01649 }
01650 return pPort->Port_SendBufferFunction(pPort, pBuffer);
01651 }
01652
01653 OMX_ERRORTYPE omx_base_component_FillThisBuffer(
01654 OMX_IN OMX_HANDLETYPE hComponent,
01655 OMX_IN OMX_BUFFERHEADERTYPE* pBuffer) {
01656
01657 omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
01658 omx_base_PortType *pPort;
01659 DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n", __func__);
01660 if (pBuffer->nOutputPortIndex >= (omx_base_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
01661 omx_base_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts +
01662 omx_base_component_Private->sPortTypesParam[OMX_PortDomainImage].nPorts +
01663 omx_base_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts)) {
01664 DEBUG(DEB_LEV_ERR, "In %s: wrong port index\n", __func__);
01665 return OMX_ErrorBadPortIndex;
01666 }
01667 pPort = omx_base_component_Private->ports[pBuffer->nOutputPortIndex];
01668 if (pPort->sPortParam.eDir != OMX_DirOutput) {
01669 DEBUG(DEB_LEV_ERR, "In %s: wrong port direction in Component %s\n", __func__,omx_base_component_Private->name);
01670 return OMX_ErrorBadPortIndex;
01671 }
01672 return pPort->Port_SendBufferFunction(pPort, pBuffer);
01673 }
01674
01675 OMX_ERRORTYPE omx_base_component_ComponentTunnelRequest(
01676 OMX_IN OMX_HANDLETYPE hComponent,
01677 OMX_IN OMX_U32 nPort,
01678 OMX_IN OMX_HANDLETYPE hTunneledComp,
01679 OMX_IN OMX_U32 nTunneledPort,
01680 OMX_INOUT OMX_TUNNELSETUPTYPE* pTunnelSetup) {
01681
01682 omx_base_component_PrivateType* omx_base_component_Private = (omx_base_component_PrivateType*)((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate;
01683 omx_base_PortType *pPort;
01684
01685 if (nPort >= (omx_base_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
01686 omx_base_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts +
01687 omx_base_component_Private->sPortTypesParam[OMX_PortDomainImage].nPorts +
01688 omx_base_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts)) {
01689 return OMX_ErrorBadPortIndex;
01690 }
01691
01692 pPort = omx_base_component_Private->ports[nPort];
01693
01694 return pPort->ComponentTunnelRequest(pPort, hTunneledComp, nTunneledPort, pTunnelSetup);
01695 }
01696 #ifdef __cplusplus
01697 }
01698 #endif
01699