omx_filereader_component.c

Go to the documentation of this file.
00001 
00031 #include <omxcore.h>
00032 #include <omx_base_audio_port.h>
00033 #include <omx_filereader_component.h>
00034 
00035 #define MAX_COMPONENT_FILEREADER 1
00036 
00038 static OMX_U32 noFilereaderInstance=0;
00039 
00040 #define DEFAULT_FILENAME_LENGTH 256
00041 
00044 OMX_ERRORTYPE omx_filereader_component_Constructor(OMX_COMPONENTTYPE *openmaxStandComp,OMX_STRING cComponentName) {
00045  
00046   OMX_ERRORTYPE err = OMX_ErrorNone;  
00047   omx_base_audio_PortType *pPort;
00048   omx_filereader_component_PrivateType* omx_filereader_component_Private;
00049   OMX_U32 i;
00050 
00051   DEBUG(DEB_LEV_FUNCTION_NAME,"In %s \n",__func__);
00052 
00053   if (!openmaxStandComp->pComponentPrivate) {
00054     openmaxStandComp->pComponentPrivate = calloc(1, sizeof(omx_filereader_component_PrivateType));
00055     if(openmaxStandComp->pComponentPrivate == NULL) {
00056       return OMX_ErrorInsufficientResources;
00057     }
00058   }
00059 
00060   omx_filereader_component_Private = openmaxStandComp->pComponentPrivate;
00061   omx_filereader_component_Private->ports = NULL;
00062   
00063   err = omx_base_source_Constructor(openmaxStandComp, cComponentName);
00064 
00065   omx_filereader_component_Private->sPortTypesParam[OMX_PortDomainAudio].nStartPortNumber = 0;
00066   omx_filereader_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts = 1;
00067 
00069   if (omx_filereader_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts && !omx_filereader_component_Private->ports) {
00070     omx_filereader_component_Private->ports = calloc(omx_filereader_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts, sizeof(omx_base_PortType *));
00071     if (!omx_filereader_component_Private->ports) {
00072       return OMX_ErrorInsufficientResources;
00073     }
00074     for (i=0; i < omx_filereader_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts; i++) {
00075       omx_filereader_component_Private->ports[i] = calloc(1, sizeof(omx_base_audio_PortType));
00076       if (!omx_filereader_component_Private->ports[i]) {
00077         return OMX_ErrorInsufficientResources;
00078       }
00079     }
00080   }
00081 
00082   base_audio_port_Constructor(openmaxStandComp, &omx_filereader_component_Private->ports[0], 0, OMX_FALSE);
00083   
00084   pPort = (omx_base_audio_PortType *) omx_filereader_component_Private->ports[OMX_BASE_SOURCE_OUTPUTPORT_INDEX];
00085   
00091   /*Input pPort buffer size is equal to the size of the output buffer of the previous component*/
00092   pPort->sPortParam.nBufferSize = DEFAULT_OUT_BUFFER_SIZE;
00093 
00094   omx_filereader_component_Private->BufferMgmtCallback = omx_filereader_component_BufferMgmtCallback;
00095 
00096   setHeader(&omx_filereader_component_Private->sTimeStamp, sizeof(OMX_TIME_CONFIG_TIMESTAMPTYPE));
00097   omx_filereader_component_Private->sTimeStamp.nPortIndex=0;
00098   omx_filereader_component_Private->sTimeStamp.nTimestamp=0x0;
00099 
00100   omx_filereader_component_Private->destructor = omx_filereader_component_Destructor;
00101   omx_filereader_component_Private->messageHandler = omx_filereader_component_MessageHandler;
00102 
00103   noFilereaderInstance++;
00104   if(noFilereaderInstance > MAX_COMPONENT_FILEREADER) {
00105     return OMX_ErrorInsufficientResources;
00106   }
00107 
00108   openmaxStandComp->SetParameter  = omx_filereader_component_SetParameter;
00109   openmaxStandComp->GetParameter  = omx_filereader_component_GetParameter;
00110   openmaxStandComp->SetConfig     = omx_filereader_component_SetConfig;
00111   openmaxStandComp->GetConfig     = omx_filereader_component_GetConfig;
00112   openmaxStandComp->GetExtensionIndex = omx_filereader_component_GetExtensionIndex;
00113 
00114   /* Write in the default paramenters */
00115 
00116   omx_filereader_component_Private->avformatReady = OMX_FALSE;
00117   if(!omx_filereader_component_Private->avformatSyncSem) {
00118     omx_filereader_component_Private->avformatSyncSem = calloc(1,sizeof(tsem_t));
00119     if(omx_filereader_component_Private->avformatSyncSem == NULL) return OMX_ErrorInsufficientResources;
00120     tsem_init(omx_filereader_component_Private->avformatSyncSem, 0);
00121   }
00122   omx_filereader_component_Private->sInputFileName = malloc(DEFAULT_FILENAME_LENGTH);
00123   memset(omx_filereader_component_Private->sInputFileName,0,DEFAULT_FILENAME_LENGTH);
00124   /*Default Coding type*/
00125   omx_filereader_component_Private->audio_coding_type = OMX_AUDIO_CodingMP3;
00126 
00127   return err;
00128 }
00129 
00132 OMX_ERRORTYPE omx_filereader_component_Destructor(OMX_COMPONENTTYPE *openmaxStandComp) {
00133   omx_filereader_component_PrivateType* omx_filereader_component_Private = openmaxStandComp->pComponentPrivate;
00134   OMX_U32 i;
00135   
00136   if(omx_filereader_component_Private->avformatSyncSem) {
00137     tsem_deinit(omx_filereader_component_Private->avformatSyncSem);
00138     free(omx_filereader_component_Private->avformatSyncSem);
00139     omx_filereader_component_Private->avformatSyncSem=NULL;
00140   }
00141 
00142   if(omx_filereader_component_Private->sInputFileName) {
00143     free(omx_filereader_component_Private->sInputFileName);
00144   }
00145   
00146   /* frees port/s */
00147   if (omx_filereader_component_Private->ports) {
00148     for (i=0; i < omx_filereader_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts; i++) {
00149       if(omx_filereader_component_Private->ports[i])
00150         omx_filereader_component_Private->ports[i]->PortDestructor(omx_filereader_component_Private->ports[i]);
00151     }
00152     free(omx_filereader_component_Private->ports);
00153     omx_filereader_component_Private->ports=NULL;
00154   }
00155 
00156   noFilereaderInstance--;
00157   DEBUG(DEB_LEV_FUNCTION_NAME,"In %s \n",__func__);
00158   return omx_base_source_Destructor(openmaxStandComp);
00159 }
00160 
00163 OMX_ERRORTYPE omx_filereader_component_Init(OMX_COMPONENTTYPE *openmaxStandComp) {
00164 
00165   omx_filereader_component_PrivateType* omx_filereader_component_Private = openmaxStandComp->pComponentPrivate;
00166   int error;
00167   OMX_VENDOR_EXTRADATATYPE *pExtraData;
00168 
00169   DEBUG(DEB_LEV_FUNCTION_NAME,"In %s \n",__func__);
00170 
00171   avcodec_init();
00172   av_register_all();
00173   
00176   error = av_open_input_file(&omx_filereader_component_Private->avformatcontext, 
00177                             (char*)omx_filereader_component_Private->sInputFileName,
00178                             omx_filereader_component_Private->avinputformat,
00179                             0,
00180                             omx_filereader_component_Private->avformatparameters);
00181 
00182   if(error != 0) {
00183     DEBUG(DEB_LEV_ERR,"Couldn't Open Input Stream error=%d File Name=%s--\n",
00184       error,(char*)omx_filereader_component_Private->sInputFileName);
00185   
00186     (*(omx_filereader_component_Private->callbacks->EventHandler))
00187       (openmaxStandComp,
00188       omx_filereader_component_Private->callbackData,
00189       OMX_EventError, /* The command was completed */
00190       OMX_ErrorFormatNotDetected, /* Format Not Detected */ 
00191       0, /* This is the output port index - only one port*/
00192       NULL);  
00193 
00194     return OMX_ErrorBadParameter;
00195   }
00196 
00197   av_find_stream_info(omx_filereader_component_Private->avformatcontext);
00198 
00199   if(omx_filereader_component_Private->audio_coding_type == OMX_AUDIO_CodingMP3) {
00200     DEBUG(DEB_LEV_SIMPLE_SEQ,"In %s Audio Coding Type Mp3\n",__func__);
00201   } else if(omx_filereader_component_Private->audio_coding_type == OMX_AUDIO_CodingVORBIS) {
00202     DEBUG(DEB_LEV_SIMPLE_SEQ,"In %s Audio Coding Type OGG\n",__func__);
00203   } else if(omx_filereader_component_Private->audio_coding_type == OMX_AUDIO_CodingAAC) {   
00204     DEBUG(DEB_LEV_SIMPLE_SEQ,"In %s Audio Coding Type AAC\n",__func__);
00205   } else {
00206     DEBUG(DEB_LEV_ERR,"In %s Ouch!! No Audio Coding Type Selected\n",__func__);
00207   }
00208   
00209   DEBUG(DEB_LEV_SIMPLE_SEQ,"In %s Extra data size=%d\n",__func__,omx_filereader_component_Private->avformatcontext->streams[0]->codec->extradata_size);
00210 
00212   omx_filereader_component_Private->bIsEOSSent = OMX_FALSE;
00213 
00217   /* filling up the OMX_VENDOR_EXTRADATATYPE structure */
00218   pExtraData = malloc(sizeof(OMX_VENDOR_EXTRADATATYPE));
00219   pExtraData->nPortIndex = 0; //output port index
00220   pExtraData->nDataSize = omx_filereader_component_Private->avformatcontext->streams[0]->codec->extradata_size;
00221   pExtraData->pData =  omx_filereader_component_Private->avformatcontext->streams[0]->codec->extradata;
00222 
00223   (*(omx_filereader_component_Private->callbacks->EventHandler))
00224     (openmaxStandComp,
00225     omx_filereader_component_Private->callbackData,
00226     OMX_EventPortFormatDetected, /* The command was completed */
00227     OMX_IndexParamAudioPortFormat, /* port Format Detected */ 
00228     0, /* This is the output port index - only one port*/
00229     NULL);  
00230 
00231   (*(omx_filereader_component_Private->callbacks->EventHandler))
00232     (openmaxStandComp,
00233     omx_filereader_component_Private->callbackData,
00234     OMX_EventPortSettingsChanged, /* The command was completed */
00235     OMX_IndexParamCommonExtraQuantData, /* port settings changed */ 
00236     0, /* This is the output port index - only one port*/
00237     pExtraData);  
00238 
00239   omx_filereader_component_Private->avformatReady = OMX_TRUE;
00240   /*Indicate that avformat is ready*/
00241   tsem_up(omx_filereader_component_Private->avformatSyncSem);
00242 
00243   free(pExtraData);
00244   return OMX_ErrorNone;
00245 }
00246 
00249 OMX_ERRORTYPE omx_filereader_component_Deinit(OMX_COMPONENTTYPE *openmaxStandComp) {
00250 
00251   omx_filereader_component_PrivateType* omx_filereader_component_Private = openmaxStandComp->pComponentPrivate;
00252 
00253   DEBUG(DEB_LEV_FUNCTION_NAME, "In %s \n",__func__);
00255   av_close_input_file(omx_filereader_component_Private->avformatcontext);
00256   
00257   omx_filereader_component_Private->avformatReady = OMX_FALSE;
00258   tsem_reset(omx_filereader_component_Private->avformatSyncSem);
00259 
00260   return OMX_ErrorNone;
00261 }
00262 
00263 
00268 void omx_filereader_component_BufferMgmtCallback(OMX_COMPONENTTYPE *openmaxStandComp, OMX_BUFFERHEADERTYPE* pOutputBuffer) {
00269 
00270   omx_filereader_component_PrivateType* omx_filereader_component_Private = openmaxStandComp->pComponentPrivate;
00271   int error;
00272 
00273   DEBUG(DEB_LEV_FUNCTION_NAME,"In %s \n",__func__);
00274 
00275   if (omx_filereader_component_Private->avformatReady == OMX_FALSE) {
00276     if(omx_filereader_component_Private->state == OMX_StateExecuting) {
00277       /*wait for avformat to be ready*/
00278       tsem_down(omx_filereader_component_Private->avformatSyncSem);
00279     } else {
00280       return;
00281     }
00282   }
00283 
00284   pOutputBuffer->nFilledLen = 0;
00285   pOutputBuffer->nOffset = 0;
00286 
00287   if(omx_filereader_component_Private->sTimeStamp.nTimestamp != 0x0) {
00288     av_seek_frame(omx_filereader_component_Private->avformatcontext, 0, omx_filereader_component_Private->sTimeStamp.nTimestamp, AVSEEK_FLAG_ANY);
00289     DEBUG(DEB_LEV_ERR, "Seek Timestamp %llx \n",omx_filereader_component_Private->sTimeStamp.nTimestamp);
00290     omx_filereader_component_Private->sTimeStamp.nTimestamp = 0x0;
00291   }
00292 
00293   error = av_read_frame(omx_filereader_component_Private->avformatcontext, &omx_filereader_component_Private->pkt);
00294   if(error < 0) {
00295     DEBUG(DEB_LEV_FULL_SEQ,"In %s EOS - no more packet,state=%x\n",__func__,
00296       omx_filereader_component_Private->state);
00297     if(omx_filereader_component_Private->bIsEOSSent == OMX_FALSE) {
00298       pOutputBuffer->nFlags = OMX_BUFFERFLAG_EOS;
00299       omx_filereader_component_Private->bIsEOSSent = OMX_TRUE;
00300     }
00301   } else {
00302     DEBUG(DEB_LEV_SIMPLE_SEQ,"\n packet size : %d \n",omx_filereader_component_Private->pkt.size);
00304     memcpy(pOutputBuffer->pBuffer, omx_filereader_component_Private->pkt.data, omx_filereader_component_Private->pkt.size);
00305     pOutputBuffer->nFilledLen = omx_filereader_component_Private->pkt.size;
00306     pOutputBuffer->nTimeStamp = omx_filereader_component_Private->pkt.dts;
00307 
00308     if(pOutputBuffer->nTimeStamp == 0x80000000) { //Skip -ve timestamp
00309       pOutputBuffer->nTimeStamp=0x0;
00310     }
00311   }
00312 
00313   av_free_packet(&omx_filereader_component_Private->pkt);
00314   
00316   DEBUG(DEB_LEV_FULL_SEQ, "One output buffer %x len=%d is full returning\n", (int)pOutputBuffer->pBuffer, (int)pOutputBuffer->nFilledLen);
00317 }
00318 
00319 OMX_ERRORTYPE omx_filereader_component_SetParameter(
00320   OMX_IN  OMX_HANDLETYPE hComponent,
00321   OMX_IN  OMX_INDEXTYPE nParamIndex,
00322   OMX_IN  OMX_PTR ComponentParameterStructure) {
00323 
00324   OMX_ERRORTYPE err = OMX_ErrorNone;
00325   OMX_AUDIO_PARAM_PORTFORMATTYPE *pAudioPortFormat;
00326   OMX_AUDIO_PARAM_MP3TYPE * pAudioMp3;
00327   OMX_U32 portIndex;
00328   OMX_U32 i;
00329   OMX_U32 nFileNameLength;
00330 
00331   /* Check which structure we are being fed and make control its header */
00332   OMX_COMPONENTTYPE *openmaxStandComp = (OMX_COMPONENTTYPE*)hComponent;
00333   omx_filereader_component_PrivateType* omx_filereader_component_Private = openmaxStandComp->pComponentPrivate;
00334   omx_base_audio_PortType* pPort = (omx_base_audio_PortType *) omx_filereader_component_Private->ports[OMX_BASE_SOURCE_OUTPUTPORT_INDEX];
00335 
00336   if(ComponentParameterStructure == NULL) {
00337     return OMX_ErrorBadParameter;
00338   }
00339 
00340   DEBUG(DEB_LEV_SIMPLE_SEQ, "   Setting parameter %i\n", nParamIndex);
00341 
00342   switch(nParamIndex) {
00343   case OMX_IndexParamAudioPortFormat:
00344     pAudioPortFormat = (OMX_AUDIO_PARAM_PORTFORMATTYPE*)ComponentParameterStructure;
00345     portIndex = pAudioPortFormat->nPortIndex;
00346     /*Check Structure Header and verify component state*/
00347     err = omx_base_component_ParameterSanityCheck(hComponent, portIndex, pAudioPortFormat, sizeof(OMX_AUDIO_PARAM_PORTFORMATTYPE));
00348     if(err!=OMX_ErrorNone) { 
00349       DEBUG(DEB_LEV_ERR, "In %s Parameter Check Error=%x\n",__func__,err); 
00350       break;
00351     }
00352     if (portIndex < 1) {
00353       memcpy(&pPort->sAudioParam,pAudioPortFormat,sizeof(OMX_AUDIO_PARAM_PORTFORMATTYPE));
00354     } else {
00355       return OMX_ErrorBadPortIndex;
00356     }
00357     break;
00358   case OMX_IndexParamAudioMp3:
00359     pAudioMp3 = (OMX_AUDIO_PARAM_MP3TYPE*)ComponentParameterStructure;
00360     /*Check Structure Header and verify component state*/
00361     err = omx_base_component_ParameterSanityCheck(hComponent, pAudioMp3->nPortIndex, pAudioMp3, sizeof(OMX_AUDIO_PARAM_MP3TYPE));
00362     if(err!=OMX_ErrorNone) { 
00363       DEBUG(DEB_LEV_ERR, "In %s Parameter Check Error=%x\n",__func__,err); 
00364       break;
00365     }
00366     break;
00367   case OMX_IndexVendorFileReadInputFilename : 
00368     nFileNameLength = strlen((char *)ComponentParameterStructure) + 1;
00369     if(nFileNameLength > DEFAULT_FILENAME_LENGTH) {
00370       free(omx_filereader_component_Private->sInputFileName);
00371       omx_filereader_component_Private->sInputFileName = malloc(nFileNameLength);
00372     }
00373     strcpy(omx_filereader_component_Private->sInputFileName, (char *)ComponentParameterStructure);
00374     omx_filereader_component_Private->bIsEOSSent = OMX_FALSE;
00376     for(i = 0; omx_filereader_component_Private->sInputFileName[i] != '\0'; i++);
00377     if(omx_filereader_component_Private->sInputFileName[i - 1] == '3') {
00378       omx_filereader_component_Private->audio_coding_type = OMX_AUDIO_CodingMP3;
00379     } else if(omx_filereader_component_Private->sInputFileName[i - 1] == 'g') {
00380       omx_filereader_component_Private->audio_coding_type = OMX_AUDIO_CodingVORBIS;
00381     } else if(omx_filereader_component_Private->sInputFileName[i - 1] == 'c') { 
00382       omx_filereader_component_Private->audio_coding_type = OMX_AUDIO_CodingAAC;
00383     } else {
00384       return OMX_ErrorBadParameter;  
00385     }
00387     if(omx_filereader_component_Private->audio_coding_type == OMX_AUDIO_CodingMP3) {
00388       strcpy(pPort->sPortParam.format.audio.cMIMEType, "audio/mpeg");
00389       pPort->sPortParam.format.audio.eEncoding = OMX_AUDIO_CodingMP3;
00390       pPort->sAudioParam.eEncoding = OMX_AUDIO_CodingMP3;
00391     } else if(omx_filereader_component_Private->audio_coding_type == OMX_AUDIO_CodingVORBIS) {
00392       strcpy(pPort->sPortParam.format.audio.cMIMEType, "audio/vorbis");
00393       pPort->sPortParam.format.audio.eEncoding = OMX_AUDIO_CodingVORBIS;
00394       pPort->sAudioParam.eEncoding = OMX_AUDIO_CodingVORBIS;
00395     } else if(omx_filereader_component_Private->audio_coding_type == OMX_AUDIO_CodingAAC) {   
00396       strcpy(pPort->sPortParam.format.audio.cMIMEType, "audio/aac");
00397       pPort->sPortParam.format.audio.eEncoding = OMX_AUDIO_CodingAAC;
00398       pPort->sAudioParam.eEncoding = OMX_AUDIO_CodingAAC;
00399     }
00400     break;
00401   default: /*Call the base component function*/
00402     return omx_base_component_SetParameter(hComponent, nParamIndex, ComponentParameterStructure);
00403   }
00404   return err;
00405 }
00406 
00407 OMX_ERRORTYPE omx_filereader_component_GetParameter(
00408   OMX_IN  OMX_HANDLETYPE hComponent,
00409   OMX_IN  OMX_INDEXTYPE nParamIndex,
00410   OMX_INOUT OMX_PTR ComponentParameterStructure) {
00411 
00412   OMX_ERRORTYPE err = OMX_ErrorNone;
00413   OMX_AUDIO_PARAM_PORTFORMATTYPE *pAudioPortFormat;  
00414   OMX_COMPONENTTYPE *openmaxStandComp = (OMX_COMPONENTTYPE*)hComponent;
00415   omx_filereader_component_PrivateType* omx_filereader_component_Private = openmaxStandComp->pComponentPrivate;
00416   omx_base_audio_PortType *pPort = (omx_base_audio_PortType *) omx_filereader_component_Private->ports[OMX_BASE_SOURCE_OUTPUTPORT_INDEX];  
00417   if (ComponentParameterStructure == NULL) {
00418     return OMX_ErrorBadParameter;
00419   }
00420 
00421   DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s Getting parameter %08x\n",__func__, nParamIndex);
00422   
00423   /* Check which structure we are being fed and fill its header */
00424   switch(nParamIndex) {
00425   case OMX_IndexParamAudioInit:
00426     if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_PORT_PARAM_TYPE))) != OMX_ErrorNone) { 
00427       break;
00428     }
00429     memcpy(ComponentParameterStructure, &omx_filereader_component_Private->sPortTypesParam[OMX_PortDomainAudio], sizeof(OMX_PORT_PARAM_TYPE));
00430     break;    
00431   case OMX_IndexParamAudioPortFormat:
00432     pAudioPortFormat = (OMX_AUDIO_PARAM_PORTFORMATTYPE*)ComponentParameterStructure;
00433     if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_AUDIO_PARAM_PORTFORMATTYPE))) != OMX_ErrorNone) { 
00434       break;
00435     }
00436     if (pAudioPortFormat->nPortIndex < 1) {
00437       memcpy(pAudioPortFormat, &pPort->sAudioParam, sizeof(OMX_AUDIO_PARAM_PORTFORMATTYPE));
00438     } else {
00439       return OMX_ErrorBadPortIndex;
00440     }
00441     break;  
00442   case OMX_IndexVendorFileReadInputFilename : 
00443     strcpy((char *)ComponentParameterStructure, "still no filename");
00444     break;
00445   default: /*Call the base component function*/
00446     return omx_base_component_GetParameter(hComponent, nParamIndex, ComponentParameterStructure);
00447   }
00448   return err;
00449 }
00450 
00454 OMX_ERRORTYPE omx_filereader_component_MessageHandler(OMX_COMPONENTTYPE* openmaxStandComp,internalRequestMessageType *message) {
00455   omx_filereader_component_PrivateType* omx_filereader_component_Private = (omx_filereader_component_PrivateType*)openmaxStandComp->pComponentPrivate;
00456   OMX_ERRORTYPE err = OMX_ErrorNone;
00457   OMX_STATETYPE oldState = omx_filereader_component_Private->state;
00458 
00459   DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s\n", __func__);
00460 
00461   /* Execute the base message handling */
00462   err = omx_base_component_MessageHandler(openmaxStandComp,message);
00463 
00464   if (message->messageType == OMX_CommandStateSet){ 
00465     if ((message->messageParam == OMX_StateExecuting) && (oldState == OMX_StateIdle)) {    
00466       err = omx_filereader_component_Init(openmaxStandComp);
00467       if(err!=OMX_ErrorNone) { 
00468         DEBUG(DEB_LEV_ERR, "In %s File Reader Init Failed Error=%x\n",__func__,err); 
00469         return err;
00470       }
00471     } else if ((message->messageParam == OMX_StateIdle) && (oldState == OMX_StateExecuting)) {
00472       err = omx_filereader_component_Deinit(openmaxStandComp);
00473       if(err!=OMX_ErrorNone) { 
00474         DEBUG(DEB_LEV_ERR, "In %s File Reader Deinit Failed Error=%x\n",__func__,err); 
00475         return err;
00476       }
00477     }
00478   }
00479 
00480   return err;
00481 }
00482 
00484 OMX_ERRORTYPE omx_filereader_component_SetConfig(
00485   OMX_IN  OMX_HANDLETYPE hComponent,
00486   OMX_IN  OMX_INDEXTYPE nIndex,
00487   OMX_IN  OMX_PTR pComponentConfigStructure) {
00488 
00489   OMX_TIME_CONFIG_TIMESTAMPTYPE* sTimeStamp;
00490   OMX_COMPONENTTYPE *openmaxStandComp = (OMX_COMPONENTTYPE *)hComponent;
00491   omx_filereader_component_PrivateType* omx_filereader_component_Private = openmaxStandComp->pComponentPrivate;
00492   OMX_ERRORTYPE err = OMX_ErrorNone;
00493   omx_base_audio_PortType *pPort;
00494 
00495   switch (nIndex) {
00496     case OMX_IndexConfigTimePosition : 
00497       sTimeStamp = (OMX_TIME_CONFIG_TIMESTAMPTYPE*)pComponentConfigStructure;
00498       /*Check Structure Header and verify component state*/
00499       if (sTimeStamp->nPortIndex >= (omx_filereader_component_Private->sPortTypesParam[OMX_PortDomainAudio].nStartPortNumber + omx_filereader_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts)) {
00500         DEBUG(DEB_LEV_ERR, "Bad Port index %i when the component has %i ports\n", (int)sTimeStamp->nPortIndex, (int)omx_filereader_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts);
00501         return OMX_ErrorBadPortIndex;
00502       }
00503 
00504       err= checkHeader(sTimeStamp , sizeof(OMX_TIME_CONFIG_TIMESTAMPTYPE));
00505       if(err != OMX_ErrorNone) {
00506         return err;
00507       }
00508 
00509       if (sTimeStamp->nPortIndex < 1) {
00510         pPort= (omx_base_audio_PortType *)omx_filereader_component_Private->ports[sTimeStamp->nPortIndex];
00511         memcpy(&omx_filereader_component_Private->sTimeStamp,sTimeStamp,sizeof(OMX_TIME_CONFIG_TIMESTAMPTYPE));
00512       } else {
00513         return OMX_ErrorBadPortIndex;
00514       }
00515       return OMX_ErrorNone;
00516     default: // delegate to superclass
00517       return omx_base_component_SetConfig(hComponent, nIndex, pComponentConfigStructure);
00518   }
00519   return OMX_ErrorNone;
00520 }
00521 
00523 OMX_ERRORTYPE omx_filereader_component_GetConfig(
00524   OMX_IN  OMX_HANDLETYPE hComponent,
00525   OMX_IN  OMX_INDEXTYPE nIndex,
00526   OMX_IN  OMX_PTR pComponentConfigStructure) {
00527 
00528   OMX_VENDOR_EXTRADATATYPE sExtraData;
00529   OMX_COMPONENTTYPE *openmaxStandComp = (OMX_COMPONENTTYPE *)hComponent;
00530   omx_filereader_component_PrivateType* omx_filereader_component_Private = openmaxStandComp->pComponentPrivate;
00531 
00532   switch (nIndex) {
00533     case OMX_IndexVendorAudioExtraData:
00534       sExtraData.nPortIndex = 0;
00535       sExtraData.nDataSize  = omx_filereader_component_Private->avformatcontext->streams[0]->codec->extradata_size;
00536       sExtraData.pData      = omx_filereader_component_Private->avformatcontext->streams[0]->codec->extradata;
00537       memcpy(pComponentConfigStructure, &sExtraData, sizeof(OMX_VENDOR_EXTRADATATYPE));
00538       break;
00539     default: // delegate to superclass
00540       return omx_base_component_GetConfig(hComponent, nIndex, pComponentConfigStructure);
00541   }
00542   return OMX_ErrorNone;
00543 }
00544 
00545 OMX_ERRORTYPE omx_filereader_component_GetExtensionIndex(
00546   OMX_IN  OMX_HANDLETYPE hComponent,
00547   OMX_IN  OMX_STRING cParameterName,
00548   OMX_OUT OMX_INDEXTYPE* pIndexType) {    
00549 
00550   DEBUG(DEB_LEV_FUNCTION_NAME,"In  %s \n",__func__);
00551 
00552   if(strcmp(cParameterName,"OMX.ST.index.param.filereader.inputfilename") == 0) {
00553     *pIndexType = OMX_IndexVendorFileReadInputFilename;  
00554   } else if(strcmp(cParameterName,"OMX.ST.index.config.audioextradata") == 0) {
00555     *pIndexType = OMX_IndexVendorAudioExtraData;  
00556   } else {
00557     return OMX_ErrorBadParameter;
00558   }
00559   return OMX_ErrorNone;  
00560 }

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