omx_base_component.c

Go to the documentation of this file.
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   /*Will make Specific port Allocate buffer call*/
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   /*Send Dummy signal to Component Message handler to exit*/
00180   tsem_up(omx_base_component_Private->messageSem);
00181 
00182   /*Deinitialize and free message queue*/
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   /*Deinitialize and free buffer management semaphore*/
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   /*Deinitialize and free message semaphore*/
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       /* return back from wait for resources */
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       /* for all ports */
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             /* Freeing here the buffers allocated for the tunneling:*/
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             /*If ports are enabled then wait till all buffers are freed*/
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         /*Signal Buffer Management thread to exit*/
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       /* for all ports */
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       /*Flush Ports*/
00413       /* for all ports */
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       /*Signal buffer management thread if waiting at paused state*/
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       /*Send Tunneled Buffer to the Neighbouring Components*/
00468       /* for all ports */
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               /*signal buffer management thread availability of buffers*/
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       /* Tunneled Supplier Ports were enabled in paused state. So signal buffer managment thread*/
00490       /* for all ports */
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       /*Signal buffer management thread if waiting at paused state*/
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         /*Signal Buffer Management Thread to Exit*/
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   /* Fill component name */
00645   strcpy(pComponentName, omx_base_component_Private->name);
00646 
00647   /* Fill component version */
00648   pComponentVersion->s.nVersionMajor = SPECVERSIONMAJOR;
00649   pComponentVersion->s.nVersionMinor = SPECVERSIONMINOR;
00650   pComponentVersion->s.nRevision = SPECREVISION;
00651   pComponentVersion->s.nStep = SPECSTEP;
00652 
00653   /* Fill spec version (copy from component field) */
00654   memcpy(pSpecVersion, &omx_component->nVersion, sizeof(OMX_VERSIONTYPE));
00655 
00656   /* Fill UUID with handle address, PID and UID.
00657    * This should guarantee uiniqness */
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   /* for all ports */
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     /* pPortParam  = (OMX_PORT_PARAM_TYPE* ) ComponentParameterStructure;*/
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       /*If component state Idle/Pause/Executing and re-alloc the following private variables */
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       /*Allocate Internal Buffer Storage and Buffer Allocation State flags*/
01112        /* for all ports */
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        /* for all ports */
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        /* for all ports */
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     /* Wait for an incoming message */
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     /*Destructor has been called. So exit from the loop*/
01236     if(omx_base_component_Private->state == OMX_StateInvalid) {
01237       break;
01238     }
01239     /* Dequeue it */
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     /* Process it by calling component's message handler method */
01246     omx_base_component_Private->messageHandler(openmaxStandComp,message);
01247     /* Message ownership has been transferred to us
01248     * so we gonna free it when finished.
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   /* Dealing with a SendCommand call.
01277   * -messageType contains the command to execute
01278   * -messageParam contains the parameter of the command
01279   *  (destination state in case of a state change command).
01280   */
01281   switch(message->messageType){
01282   case OMX_CommandStateSet: {
01283     /* Do the actual state change */
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, /* The command was completed */
01290       err, /* The commands was a OMX_CommandStateSet */
01291       0, /* The state has been changed in message->messageParam */
01292       NULL);
01293     } else {
01294       /* And run the callback */
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, /* The command was completed */
01300       OMX_CommandStateSet, /* The commands was a OMX_CommandStateSet */
01301       message->messageParam, /* The state has been changed in message->messageParam */
01302       NULL);
01303     }
01304   }
01305   break;
01306   case OMX_CommandFlush: {
01307     /*Flush port/s*/
01308     if(message->messageParam == OMX_ALL) {
01309        /* for all ports */
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       /* for all ports */
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, /* The command was completed */
01336       err, /* The commands was a OMX_CommandStateSet */
01337       0, /* The state has been changed in message->messageParam */
01338       NULL);
01339     } else {
01340       if(message->messageParam == OMX_ALL){ /*Flush all port*/
01341         /* for all ports */
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, /* The command was completed */
01350             OMX_CommandFlush, /* The commands was a OMX_CommandStateSet */
01351             i, /* The state has been changed in message->messageParam */
01352             NULL);
01353 
01354             pPort=omx_base_component_Private->ports[i];
01355             /* Signal the buffer Semaphore and the buffer managment semaphore, to restart the exchange of buffers after flush */
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                 /*signal buffer management thread availability of buffers*/
01360                 tsem_up(omx_base_component_Private->bMgmtSem);
01361               }
01362             }
01363           }     
01364         }
01365       } else {/*Flush input/output port*/
01366         (*(omx_base_component_Private->callbacks->EventHandler))
01367         (openmaxStandComp,
01368         omx_base_component_Private->callbackData,
01369         OMX_EventCmdComplete, /* The command was completed */
01370         OMX_CommandFlush, /* The commands was a OMX_CommandStateSet */
01371         message->messageParam, /* The state has been changed in message->messageParam */
01372         NULL);
01373         /* Signal the buffer Semaphore and the buffer managment semaphore, to restart the exchange of buffers after flush */
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               /*signal buffer management thread availability of buffers*/
01379               tsem_up(omx_base_component_Private->bMgmtSem);
01380             }
01381           }
01382       }
01383     }
01384   }
01385   break;
01386   case OMX_CommandPortDisable: {
01387     /*Flush port/s*/
01388     if(message->messageParam == OMX_ALL) {
01389       /*If Component is not in loaded state,then First Flush all buffers then disable the port*/
01390       if(omx_base_component_Private->state!=OMX_StateLoaded) {
01391         /* for all ports */
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       /* for all ports */
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, /* The command was completed */
01425       err, /* The commands was a OMX_CommandStateSet */
01426       0, /* The state has been changed in message->messageParam */
01427       NULL);
01428     } else {
01429       if(message->messageParam == OMX_ALL){ /*Disable all ports*/
01430         /* for all ports */
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, /* The command was completed */
01439             OMX_CommandPortDisable, /* The commands was a OMX_CommandStateSet */
01440             i, /* The state has been changed in message->messageParam */
01441             NULL);
01442           }
01443         }
01444       } else {
01445         (*(omx_base_component_Private->callbacks->EventHandler))
01446         (openmaxStandComp,
01447         omx_base_component_Private->callbackData,
01448         OMX_EventCmdComplete, /* The command was completed */
01449         OMX_CommandPortDisable, /* The commands was a OMX_CommandStateSet */
01450         message->messageParam, /* The state has been changed in message->messageParam */
01451         NULL);
01452       }           
01453     }
01454   }
01455   break;
01456   case OMX_CommandPortEnable:{
01457     /*Flush port/s*/
01458     if(message->messageParam == OMX_ALL) {
01459       /* for all ports */
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, /* The command was completed */
01477       err, /* The commands was a OMX_CommandStateSet */
01478       0, /* The state has been changed in message->messageParam */
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, /* The command was completed */
01486         OMX_CommandPortEnable, /* The commands was a OMX_CommandStateSet */
01487         message->messageParam, /* The state has been changed in 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         /* for all ports */
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, /* The command was completed */
01510           OMX_CommandPortEnable, /* The commands was a OMX_CommandStateSet */
01511           i, /* The state has been changed in message->messageParam */
01512           NULL);
01513           }
01514         }
01515 
01516         if (omx_base_component_Private->state==OMX_StateExecuting) {
01517           /* for all ports */
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 

Generated for OpenMAX Bellagio rel. 0.9.0 by  doxygen 1.5.1
SourceForge.net Logo