omx_audiodec_component.c

Go to the documentation of this file.
00001 
00030 #include <omxcore.h>
00031 #include <omx_base_audio_port.h>
00032 #include <omx_audiodec_component.h>
00034 #include<OMX_Audio.h>
00035 
00036 /* For FFMPEG_DECODER_VERSION */
00037 #include <config.h>
00038 
00039 #define MAX_COMPONENT_AUDIODEC 4
00040 
00042 #define OUTPUT_LEN_STANDARD_FFMPEG 192000
00043 
00045 static OMX_U32 noAudioDecInstance=0;
00046 
00049 OMX_ERRORTYPE omx_audiodec_component_Constructor(OMX_COMPONENTTYPE *openmaxStandComp,OMX_STRING cComponentName) {
00050 
00051   OMX_ERRORTYPE err = OMX_ErrorNone;  
00052   omx_audiodec_component_PrivateType* omx_audiodec_component_Private;
00053   OMX_U32 i;
00054 
00055   if (!openmaxStandComp->pComponentPrivate) {
00056     DEBUG(DEB_LEV_FUNCTION_NAME,"In %s, allocating component\n",__func__);
00057     openmaxStandComp->pComponentPrivate = calloc(1, sizeof(omx_audiodec_component_PrivateType));
00058     if(openmaxStandComp->pComponentPrivate==NULL)
00059       return OMX_ErrorInsufficientResources;
00060   }
00061   else 
00062     DEBUG(DEB_LEV_FUNCTION_NAME,"In %s, Error Component %x Already Allocated\n",__func__, (int)openmaxStandComp->pComponentPrivate);
00063   
00064   omx_audiodec_component_Private = openmaxStandComp->pComponentPrivate;
00065   omx_audiodec_component_Private->ports = NULL;
00066 
00068   err = omx_base_filter_Constructor(openmaxStandComp,cComponentName);
00069   
00070   omx_audiodec_component_Private->sPortTypesParam[OMX_PortDomainAudio].nStartPortNumber = 0;
00071   omx_audiodec_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts = 2;
00072 
00074   if (omx_audiodec_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts && !omx_audiodec_component_Private->ports) {
00075     omx_audiodec_component_Private->ports = calloc(omx_audiodec_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts, sizeof(omx_base_PortType *));
00076     if (!omx_audiodec_component_Private->ports) {
00077       return OMX_ErrorInsufficientResources;
00078     }
00079     for (i=0; i < omx_audiodec_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts; i++) {
00080       omx_audiodec_component_Private->ports[i] = calloc(1, sizeof(omx_base_audio_PortType));
00081       if (!omx_audiodec_component_Private->ports[i]) {
00082         return OMX_ErrorInsufficientResources;
00083       }
00084     }
00085   }
00086 
00087   base_audio_port_Constructor(openmaxStandComp, &omx_audiodec_component_Private->ports[0], 0, OMX_TRUE);
00088   base_audio_port_Constructor(openmaxStandComp, &omx_audiodec_component_Private->ports[1], 1, OMX_FALSE);
00089 
00091   // first we set the parameter common to both formats
00092   //common parameters related to input port
00093   omx_audiodec_component_Private->ports[OMX_BASE_FILTER_INPUTPORT_INDEX]->sPortParam.nBufferSize = DEFAULT_IN_BUFFER_SIZE;
00094   //common parameters related to output port
00095   omx_audiodec_component_Private->ports[OMX_BASE_FILTER_OUTPUTPORT_INDEX]->sPortParam.format.audio.eEncoding = OMX_AUDIO_CodingPCM;
00096   omx_audiodec_component_Private->ports[OMX_BASE_FILTER_OUTPUTPORT_INDEX]->sPortParam.nBufferSize = DEFAULT_OUT_BUFFER_SIZE;
00097 
00098   // now it's time to know the audio coding type of the component
00099   if(!strcmp(cComponentName, AUDIO_DEC_MP3_NAME))   // MP3 format decoder
00100     omx_audiodec_component_Private->audio_coding_type = OMX_AUDIO_CodingMP3;
00101 
00102   else if(!strcmp(cComponentName, AUDIO_DEC_VORBIS_NAME))   // VORBIS format decoder
00103     omx_audiodec_component_Private->audio_coding_type = OMX_AUDIO_CodingVORBIS;
00104     
00105   else if(!strcmp(cComponentName, AUDIO_DEC_AAC_NAME))   // AAC format decoder   
00106     omx_audiodec_component_Private->audio_coding_type = OMX_AUDIO_CodingAAC;
00107 
00108   else if(!strcmp(cComponentName, AUDIO_DEC_G726_NAME))  // G726 format decoder   
00109     omx_audiodec_component_Private->audio_coding_type = OMX_AUDIO_CodingG726;
00110     
00111   else if (!strcmp(cComponentName, AUDIO_DEC_BASE_NAME))// general audio decoder
00112     omx_audiodec_component_Private->audio_coding_type = OMX_AUDIO_CodingUnused;
00113 
00114   else  // IL client specified an invalid component name
00115     return OMX_ErrorInvalidComponentName;
00116 
00117   if(!omx_audiodec_component_Private->avCodecSyncSem) {
00118     omx_audiodec_component_Private->avCodecSyncSem = calloc(1,sizeof(tsem_t));
00119     if(omx_audiodec_component_Private->avCodecSyncSem == NULL) return OMX_ErrorInsufficientResources;
00120     tsem_init(omx_audiodec_component_Private->avCodecSyncSem, 0);
00121   }
00122 
00123   omx_audiodec_component_SetInternalParameters(openmaxStandComp);
00124 
00125   //settings of output port
00126   //output is pcm mode for all decoders - so generalise it 
00127   setHeader(&omx_audiodec_component_Private->pAudioPcmMode,sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
00128   omx_audiodec_component_Private->pAudioPcmMode.nPortIndex = 1;
00129   omx_audiodec_component_Private->pAudioPcmMode.nChannels = 2;
00130   omx_audiodec_component_Private->pAudioPcmMode.eNumData = OMX_NumericalDataSigned;
00131   omx_audiodec_component_Private->pAudioPcmMode.eEndian = OMX_EndianLittle;
00132   omx_audiodec_component_Private->pAudioPcmMode.bInterleaved = OMX_TRUE;
00133   omx_audiodec_component_Private->pAudioPcmMode.nBitPerSample = 16;
00134   omx_audiodec_component_Private->pAudioPcmMode.nSamplingRate = 44100;
00135   omx_audiodec_component_Private->pAudioPcmMode.ePCMMode = OMX_AUDIO_PCMModeLinear;
00136   omx_audiodec_component_Private->pAudioPcmMode.eChannelMapping[0] = OMX_AUDIO_ChannelLF;
00137   omx_audiodec_component_Private->pAudioPcmMode.eChannelMapping[1] = OMX_AUDIO_ChannelRF;
00138 
00139   //general configuration irrespective of any audio formats
00140   //setting other parameters of omx_audiodec_component_private  
00141   omx_audiodec_component_Private->avCodec = NULL;
00142   omx_audiodec_component_Private->avCodecContext= NULL;
00143   omx_audiodec_component_Private->avcodecReady = OMX_FALSE;
00144   omx_audiodec_component_Private->extradata = NULL;
00145   omx_audiodec_component_Private->extradata_size = 0;
00146 
00147   omx_audiodec_component_Private->BufferMgmtCallback = omx_audiodec_component_BufferMgmtCallback;
00148 
00150   avcodec_init();
00151   av_register_all();
00152   omx_audiodec_component_Private->avCodecContext = avcodec_alloc_context();
00153                                          
00154   omx_audiodec_component_Private->messageHandler = omx_audiodec_component_MessageHandler;
00155   omx_audiodec_component_Private->destructor = omx_audiodec_component_Destructor;
00156   openmaxStandComp->SetParameter = omx_audiodec_component_SetParameter;
00157   openmaxStandComp->GetParameter = omx_audiodec_component_GetParameter;
00158   openmaxStandComp->SetConfig    = omx_audiodec_component_SetConfig;
00159   openmaxStandComp->ComponentRoleEnum = omx_audiodec_component_ComponentRoleEnum;
00160   openmaxStandComp->GetExtensionIndex = omx_audiodec_component_GetExtensionIndex;
00161   
00162   noAudioDecInstance++;
00163 
00164   if(noAudioDecInstance>MAX_COMPONENT_AUDIODEC)
00165     return OMX_ErrorInsufficientResources;
00166 
00167   return err;
00168 }
00169 
00172 OMX_ERRORTYPE omx_audiodec_component_Destructor(OMX_COMPONENTTYPE *openmaxStandComp) 
00173 {
00174   omx_audiodec_component_PrivateType* omx_audiodec_component_Private = openmaxStandComp->pComponentPrivate;
00175   OMX_U32 i;
00176   
00177   if(omx_audiodec_component_Private->extradata) {
00178     free(omx_audiodec_component_Private->extradata);
00179   }
00180 
00181   /*Free Codec Context*/
00182   av_free (omx_audiodec_component_Private->avCodecContext);
00183 
00184   if(omx_audiodec_component_Private->avCodecSyncSem) {
00185     tsem_deinit(omx_audiodec_component_Private->avCodecSyncSem);
00186     free(omx_audiodec_component_Private->avCodecSyncSem);
00187     omx_audiodec_component_Private->avCodecSyncSem=NULL;
00188   }
00189 
00190   /* frees port/s */
00191   if (omx_audiodec_component_Private->ports) {
00192     for (i=0; i < omx_audiodec_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts; i++) {
00193       if(omx_audiodec_component_Private->ports[i])
00194         omx_audiodec_component_Private->ports[i]->PortDestructor(omx_audiodec_component_Private->ports[i]);
00195     }
00196     free(omx_audiodec_component_Private->ports);
00197     omx_audiodec_component_Private->ports=NULL;
00198   }
00199 
00200   DEBUG(DEB_LEV_FUNCTION_NAME, "Destructor of audiodecoder component is called\n");
00201 
00202   omx_base_filter_Destructor(openmaxStandComp);
00203 
00204   noAudioDecInstance--;
00205 
00206   return OMX_ErrorNone;
00207 }
00208 
00212 OMX_ERRORTYPE omx_audiodec_component_ffmpegLibInit(omx_audiodec_component_PrivateType* omx_audiodec_component_Private) {
00213   OMX_U32 target_codecID;  // id of FFmpeg codec to be used for different audio formats 
00214 
00215   DEBUG(DEB_LEV_SIMPLE_SEQ, "FFMpeg Library/codec iniited\n");
00216 
00217   switch(omx_audiodec_component_Private->audio_coding_type){
00218   case OMX_AUDIO_CodingMP3 :
00219     target_codecID = CODEC_ID_MP3;
00220     break;
00221   case OMX_AUDIO_CodingVORBIS :
00222     target_codecID = CODEC_ID_VORBIS;
00223     break;
00224   case OMX_AUDIO_CodingAAC :  
00225     target_codecID = CODEC_ID_AAC;
00226     break;
00227   case OMX_AUDIO_CodingG726 :
00228     target_codecID = CODEC_ID_ADPCM_G726;
00229     break;
00230   default :
00231     DEBUG(DEB_LEV_ERR, "Audio format other than not supported\nCodec not found\n");
00232     return OMX_ErrorComponentNotFound;
00233   }
00234   
00235   /*Find the  decoder corresponding to the audio type specified by IL client*/
00236   omx_audiodec_component_Private->avCodec = avcodec_find_decoder(target_codecID);
00237   if (omx_audiodec_component_Private->avCodec == NULL) {
00238     DEBUG(DEB_LEV_ERR, "Codec Not found\n");
00239     return OMX_ErrorInsufficientResources;
00240   }
00241 
00242   omx_audiodec_component_Private->avCodecContext->extradata = omx_audiodec_component_Private->extradata;
00243   omx_audiodec_component_Private->avCodecContext->extradata_size = (int)omx_audiodec_component_Private->extradata_size;
00244 
00245   omx_audiodec_component_Private->avCodecContext->channels = 1;
00246   omx_audiodec_component_Private->avCodecContext->bit_rate = 16000;
00247   omx_audiodec_component_Private->avCodecContext->sample_rate = 8000;
00248   //omx_audiodec_component_Private->avCodecContext->strict_std_compliance = FF_COMPLIANCE_INOFFICIAL;
00249 
00250   //DEBUG(DEB_LEV_ERR, "Extra Data Size=%d\n",(int)omx_audiodec_component_Private->extradata_size);
00251 
00252   /*open the avcodec if MP3,AAC,VORBIS format selected */
00253   if (avcodec_open(omx_audiodec_component_Private->avCodecContext, omx_audiodec_component_Private->avCodec) < 0) {
00254     DEBUG(DEB_LEV_ERR, "Could not open codec\n");
00255     return OMX_ErrorInsufficientResources;
00256   }
00257 
00258   /* apply flags */
00259   //omx_audiodec_component_Private->avCodecContext->flags |= CODEC_FLAG_TRUNCATED;
00260   omx_audiodec_component_Private->avCodecContext->flags |= CODEC_FLAG_EMU_EDGE;
00261   omx_audiodec_component_Private->avCodecContext->workaround_bugs |= FF_BUG_AUTODETECT;
00262  
00263   tsem_up(omx_audiodec_component_Private->avCodecSyncSem);
00264   DEBUG(DEB_LEV_SIMPLE_SEQ, "done\n");
00265   return OMX_ErrorNone;
00266 }
00267 
00271 void omx_audiodec_component_ffmpegLibDeInit(omx_audiodec_component_PrivateType* omx_audiodec_component_Private) {
00272   
00273   avcodec_close(omx_audiodec_component_Private->avCodecContext);
00274   omx_audiodec_component_Private->extradata_size = 0;
00275    
00276 }
00277 
00278 void omx_audiodec_component_SetInternalParameters(OMX_COMPONENTTYPE *openmaxStandComp) {
00279   omx_audiodec_component_PrivateType* omx_audiodec_component_Private;
00280   omx_base_audio_PortType *pPort;
00281 
00282   omx_audiodec_component_Private = openmaxStandComp->pComponentPrivate;
00283 
00284   pPort = (omx_base_audio_PortType *) omx_audiodec_component_Private->ports[OMX_BASE_FILTER_OUTPUTPORT_INDEX];
00285 
00286   pPort->sAudioParam.eEncoding = OMX_AUDIO_CodingPCM;
00287   
00288   if (omx_audiodec_component_Private->audio_coding_type == OMX_AUDIO_CodingMP3) {
00289     strcpy(omx_audiodec_component_Private->ports[OMX_BASE_FILTER_INPUTPORT_INDEX]->sPortParam.format.audio.cMIMEType, "audio/mpeg");
00290     omx_audiodec_component_Private->ports[OMX_BASE_FILTER_INPUTPORT_INDEX]->sPortParam.format.audio.eEncoding = OMX_AUDIO_CodingMP3;
00291 
00292     setHeader(&omx_audiodec_component_Private->pAudioMp3,sizeof(OMX_AUDIO_PARAM_MP3TYPE));    
00293     omx_audiodec_component_Private->pAudioMp3.nPortIndex = 0;                                                                    
00294     omx_audiodec_component_Private->pAudioMp3.nChannels = 2;                                                                    
00295     omx_audiodec_component_Private->pAudioMp3.nBitRate = 28000;                                                                  
00296     omx_audiodec_component_Private->pAudioMp3.nSampleRate = 44100;                                                               
00297     omx_audiodec_component_Private->pAudioMp3.nAudioBandWidth = 0;
00298     omx_audiodec_component_Private->pAudioMp3.eChannelMode = OMX_AUDIO_ChannelModeStereo;
00299 
00300     setHeader(&omx_audiodec_component_Private->pAudioMp3, sizeof(OMX_AUDIO_PARAM_MP3TYPE));
00301     omx_audiodec_component_Private->pAudioMp3.nPortIndex=0;
00302     omx_audiodec_component_Private->pAudioMp3.eFormat=OMX_AUDIO_MP3StreamFormatMP1Layer3;
00303 
00304     pPort = (omx_base_audio_PortType *) omx_audiodec_component_Private->ports[OMX_BASE_FILTER_INPUTPORT_INDEX];
00305 
00306     pPort->sAudioParam.nIndex = OMX_IndexParamAudioMp3;
00307     pPort->sAudioParam.eEncoding = OMX_AUDIO_CodingMP3;
00308   } else if(omx_audiodec_component_Private->audio_coding_type == OMX_AUDIO_CodingVORBIS) {
00309     strcpy(omx_audiodec_component_Private->ports[OMX_BASE_FILTER_INPUTPORT_INDEX]->sPortParam.format.audio.cMIMEType, "audio/vorbis");
00310     omx_audiodec_component_Private->ports[OMX_BASE_FILTER_INPUTPORT_INDEX]->sPortParam.format.audio.eEncoding = OMX_AUDIO_CodingVORBIS;
00311                                                                                                                              
00312     setHeader(&omx_audiodec_component_Private->pAudioVorbis,sizeof(OMX_AUDIO_PARAM_VORBISTYPE));
00313     omx_audiodec_component_Private->pAudioVorbis.nPortIndex = 0;
00314     omx_audiodec_component_Private->pAudioVorbis.nChannels = 2;                                                                                                                          
00315     omx_audiodec_component_Private->pAudioVorbis.nBitRate = 28000;
00316     omx_audiodec_component_Private->pAudioVorbis.nSampleRate = 44100;
00317     omx_audiodec_component_Private->pAudioVorbis.nAudioBandWidth = 0; //encoder decides the needed bandwidth
00318     omx_audiodec_component_Private->pAudioVorbis.nQuality = 3; //default quality
00319     
00320     pPort = (omx_base_audio_PortType *) omx_audiodec_component_Private->ports[OMX_BASE_FILTER_INPUTPORT_INDEX];
00321 
00322     pPort->sAudioParam.nIndex = OMX_IndexParamAudioVorbis;
00323     pPort->sAudioParam.eEncoding = OMX_AUDIO_CodingVORBIS;
00324 
00325   } else if(omx_audiodec_component_Private->audio_coding_type == OMX_AUDIO_CodingAAC) {
00326     strcpy(omx_audiodec_component_Private->ports[OMX_BASE_FILTER_INPUTPORT_INDEX]->sPortParam.format.audio.cMIMEType, "audio/aac");
00327     omx_audiodec_component_Private->ports[OMX_BASE_FILTER_INPUTPORT_INDEX]->sPortParam.format.audio.eEncoding = OMX_AUDIO_CodingAAC;
00328                                                                                                                              
00329     setHeader(&omx_audiodec_component_Private->pAudioAac,sizeof(OMX_AUDIO_PARAM_AACPROFILETYPE)); /* MONA -  comented */
00330     omx_audiodec_component_Private->pAudioAac.nPortIndex = 0;
00331     omx_audiodec_component_Private->pAudioAac.nChannels = 2;                                                                                                                          
00332     omx_audiodec_component_Private->pAudioAac.nBitRate = 28000;
00333     omx_audiodec_component_Private->pAudioAac.nSampleRate = 44100;
00334     omx_audiodec_component_Private->pAudioAac.nAudioBandWidth = 0; //encoder decides the needed bandwidth
00335     omx_audiodec_component_Private->pAudioAac.eChannelMode = OMX_AUDIO_ChannelModeStereo;
00336     omx_audiodec_component_Private->pAudioAac.nFrameLength = 0; //encoder decides the framelength
00337     
00338     pPort = (omx_base_audio_PortType *) omx_audiodec_component_Private->ports[OMX_BASE_FILTER_INPUTPORT_INDEX];
00339 
00340     pPort->sAudioParam.nIndex = OMX_IndexParamAudioAac;
00341     pPort->sAudioParam.eEncoding = OMX_AUDIO_CodingAAC;
00342 
00343   } else if(omx_audiodec_component_Private->audio_coding_type == OMX_AUDIO_CodingG726) {
00344     strcpy(omx_audiodec_component_Private->ports[OMX_BASE_FILTER_INPUTPORT_INDEX]->sPortParam.format.audio.cMIMEType, "audio/g726");
00345     omx_audiodec_component_Private->ports[OMX_BASE_FILTER_INPUTPORT_INDEX]->sPortParam.format.audio.eEncoding = OMX_AUDIO_CodingG726;
00346                                                                                                                              
00347     setHeader(&omx_audiodec_component_Private->pAudioG726,sizeof(OMX_AUDIO_PARAM_G726TYPE)); 
00348     omx_audiodec_component_Private->pAudioG726.nPortIndex = 0;
00349     omx_audiodec_component_Private->pAudioG726.nChannels = 1;                                                                                                                          
00350     omx_audiodec_component_Private->pAudioG726.eG726Mode = OMX_AUDIO_G726Mode16;
00351     
00352     pPort->sAudioParam.nIndex = OMX_IndexParamAudioG726;
00353     pPort->sAudioParam.eEncoding = OMX_AUDIO_CodingG726;
00354 
00355   } else {
00356     return;
00357     }
00358 }
00359 
00362 OMX_ERRORTYPE omx_audiodec_component_Init(OMX_COMPONENTTYPE *openmaxStandComp)
00363 {
00364   omx_audiodec_component_PrivateType* omx_audiodec_component_Private = openmaxStandComp->pComponentPrivate;
00365   OMX_ERRORTYPE err = OMX_ErrorNone;
00366   OMX_U32 nBufferSize;
00367 
00368   /*Temporary First Output buffer size*/
00369   omx_audiodec_component_Private->inputCurrBuffer=NULL;
00370   omx_audiodec_component_Private->inputCurrLength=0;
00371   nBufferSize=omx_audiodec_component_Private->ports[OMX_BASE_FILTER_OUTPUTPORT_INDEX]->sPortParam.nBufferSize * 2;
00372   omx_audiodec_component_Private->internalOutputBuffer = malloc(nBufferSize);
00373   memset(omx_audiodec_component_Private->internalOutputBuffer, 0, nBufferSize);
00374   omx_audiodec_component_Private->positionInOutBuf = 0;
00375   omx_audiodec_component_Private->isNewBuffer=1;
00376                                                                                                                              
00377   return err;
00378   
00379 };
00380 
00383 OMX_ERRORTYPE omx_audiodec_component_Deinit(OMX_COMPONENTTYPE *openmaxStandComp) {
00384   omx_audiodec_component_PrivateType* omx_audiodec_component_Private = openmaxStandComp->pComponentPrivate;
00385   OMX_ERRORTYPE err = OMX_ErrorNone;
00386 
00387   if (omx_audiodec_component_Private->avcodecReady) {
00388     omx_audiodec_component_ffmpegLibDeInit(omx_audiodec_component_Private);
00389     omx_audiodec_component_Private->avcodecReady = OMX_FALSE;
00390   }
00391 
00392   free(omx_audiodec_component_Private->internalOutputBuffer);
00393   omx_audiodec_component_Private->internalOutputBuffer = NULL;
00394 
00395   return err;
00396 }
00397 
00401 void omx_audiodec_component_BufferMgmtCallback(OMX_COMPONENTTYPE *openmaxStandComp, OMX_BUFFERHEADERTYPE* pInputBuffer, OMX_BUFFERHEADERTYPE* pOutputBuffer) 
00402 {
00403   omx_audiodec_component_PrivateType* omx_audiodec_component_Private = openmaxStandComp->pComponentPrivate;
00404   int output_length, len;
00405 
00406   DEBUG(DEB_LEV_FUNCTION_NAME, "In %s\n",__func__);
00407 
00408   if(omx_audiodec_component_Private->isNewBuffer) {
00409     omx_audiodec_component_Private->isNewBuffer = 0; 
00410   }
00411   pOutputBuffer->nFilledLen = 0;
00412   pOutputBuffer->nOffset=0;
00414   output_length = OUTPUT_LEN_STANDARD_FFMPEG;
00415 #if FFMPEG_DECODER_VERSION >= 2
00416   len  = avcodec_decode_audio2(omx_audiodec_component_Private->avCodecContext,
00417                               (short*)(pOutputBuffer->pBuffer),
00418                               &output_length,
00419                               pInputBuffer->pBuffer,
00420                               pInputBuffer->nFilledLen);
00421 #else
00422   len  = avcodec_decode_audio(omx_audiodec_component_Private->avCodecContext,
00423                               (short*)(pOutputBuffer->pBuffer),
00424                               &output_length,
00425                               pInputBuffer->pBuffer,
00426                               pInputBuffer->nFilledLen);
00427 #endif
00428   if((omx_audiodec_component_Private->pAudioPcmMode.nSamplingRate != omx_audiodec_component_Private->avCodecContext->sample_rate) ||
00429      ( omx_audiodec_component_Private->pAudioPcmMode.nChannels!=omx_audiodec_component_Private->avCodecContext->channels)) {
00430     DEBUG(DEB_LEV_FULL_SEQ, "---->Sending Port Settings Change Event\n");
00431     /* has MP3 dependency--requires modification */
00432     //switch for different audio formats---parameter settings accordingly
00433     switch(omx_audiodec_component_Private->audio_coding_type)  {
00434       /*Update Parameter which has changed from avCodecContext*/
00435     case OMX_AUDIO_CodingMP3 :
00436       /*pAudioMp3 is for input port MP3 data*/
00437       omx_audiodec_component_Private->pAudioMp3.nChannels = omx_audiodec_component_Private->avCodecContext->channels;
00438       omx_audiodec_component_Private->pAudioMp3.nBitRate = omx_audiodec_component_Private->avCodecContext->bit_rate;
00439       omx_audiodec_component_Private->pAudioMp3.nSampleRate = omx_audiodec_component_Private->avCodecContext->sample_rate;
00440             break;
00441     case OMX_AUDIO_CodingVORBIS:
00442       omx_audiodec_component_Private->pAudioVorbis.nChannels = omx_audiodec_component_Private->avCodecContext->channels; 
00443       omx_audiodec_component_Private->pAudioVorbis.nSampleRate = omx_audiodec_component_Private->avCodecContext->sample_rate;
00444       break;
00445     case OMX_AUDIO_CodingAAC :  
00446       /*pAudioAAC is for input port AAC data*/
00447       omx_audiodec_component_Private->pAudioAac.nChannels = omx_audiodec_component_Private->avCodecContext->channels;
00448       omx_audiodec_component_Private->pAudioAac.nBitRate = omx_audiodec_component_Private->avCodecContext->bit_rate;
00449       omx_audiodec_component_Private->pAudioAac.nSampleRate = omx_audiodec_component_Private->avCodecContext->sample_rate;
00450       omx_audiodec_component_Private->pAudioAac.eAACStreamFormat = OMX_AUDIO_AACStreamFormatRAW;
00451       switch(omx_audiodec_component_Private->avCodecContext->profile){   
00452       case  FF_PROFILE_AAC_MAIN:
00453         omx_audiodec_component_Private->pAudioAac.eAACProfile = OMX_AUDIO_AACObjectMain;
00454         break;
00455       case  FF_PROFILE_AAC_LOW:
00456         omx_audiodec_component_Private->pAudioAac.eAACProfile = OMX_AUDIO_AACObjectLC;
00457         break;
00458       case  FF_PROFILE_AAC_SSR:
00459         omx_audiodec_component_Private->pAudioAac.eAACProfile = OMX_AUDIO_AACObjectSSR;
00460         break;
00461       case  FF_PROFILE_AAC_LTP:
00462         omx_audiodec_component_Private->pAudioAac.eAACProfile = OMX_AUDIO_AACObjectLTP;
00463         break;
00464       case  FF_PROFILE_UNKNOWN:
00465         omx_audiodec_component_Private->pAudioAac.eAACProfile = OMX_AUDIO_AACObjectNull;
00466         break;
00467       }
00468       break;
00469     case OMX_AUDIO_CodingG726:
00470       omx_audiodec_component_Private->pAudioG726.nChannels = omx_audiodec_component_Private->avCodecContext->channels; 
00471       break;
00472     default :
00473       DEBUG(DEB_LEV_ERR, "Audio format other than MP3, VORBIS or AAC not supported\nCodec type %lu not found\n",omx_audiodec_component_Private->audio_coding_type);
00474       break;                       
00475     }//end of switch
00476 
00477     /*pAudioPcmMode is for output port PCM data*/
00478     omx_audiodec_component_Private->pAudioPcmMode.nChannels = omx_audiodec_component_Private->avCodecContext->channels;
00479     if(omx_audiodec_component_Private->avCodecContext->sample_fmt==SAMPLE_FMT_S16)
00480       omx_audiodec_component_Private->pAudioPcmMode.nBitPerSample = 16;
00481     else if(omx_audiodec_component_Private->avCodecContext->sample_fmt==SAMPLE_FMT_S32)
00482       omx_audiodec_component_Private->pAudioPcmMode.nBitPerSample = 32;
00483     omx_audiodec_component_Private->pAudioPcmMode.nSamplingRate = omx_audiodec_component_Private->avCodecContext->sample_rate;
00484 
00485     /*Send Port Settings changed call back*/
00486     (*(omx_audiodec_component_Private->callbacks->EventHandler))
00487       (openmaxStandComp,
00488       omx_audiodec_component_Private->callbackData,
00489       OMX_EventPortSettingsChanged, /* The command was completed */
00490       0, 
00491       1, /* This is the output port index */
00492       NULL);
00493   }
00494 
00495   if(len < 0) {
00496     DEBUG(DEB_LEV_ERR,"error in packet decoding in audio dcoder \n");
00497   } else {
00498     /*If output is max length it might be an error, so Don't send output buffer*/
00499     if((output_length != OUTPUT_LEN_STANDARD_FFMPEG) || (output_length <= pOutputBuffer->nAllocLen)) {
00500       pOutputBuffer->nFilledLen += output_length;
00501     }
00502     pInputBuffer->nFilledLen = 0;
00503     omx_audiodec_component_Private->isNewBuffer = 1;  
00504   }
00505 
00507 }
00508 
00509 OMX_ERRORTYPE omx_audiodec_component_SetParameter(
00510   OMX_IN  OMX_HANDLETYPE hComponent,
00511   OMX_IN  OMX_INDEXTYPE nParamIndex,
00512   OMX_IN  OMX_PTR ComponentParameterStructure)
00513 {
00514   OMX_ERRORTYPE err = OMX_ErrorNone;
00515   OMX_AUDIO_PARAM_PORTFORMATTYPE *pAudioPortFormat;
00516   OMX_AUDIO_PARAM_PCMMODETYPE* pAudioPcmMode;
00517   OMX_AUDIO_PARAM_MP3TYPE * pAudioMp3;
00518   OMX_AUDIO_PARAM_VORBISTYPE *pAudioVorbis; //support for Vorbis format
00519   OMX_AUDIO_PARAM_AACPROFILETYPE *pAudioAac; //support for AAC format
00520   OMX_PARAM_COMPONENTROLETYPE * pComponentRole;
00521   OMX_AUDIO_PARAM_G726TYPE *pAudioG726;
00522   OMX_U32 portIndex;
00523 
00524   /* Check which structure we are being fed and make control its header */
00525   OMX_COMPONENTTYPE *openmaxStandComp = (OMX_COMPONENTTYPE *)hComponent;
00526   omx_audiodec_component_PrivateType* omx_audiodec_component_Private = openmaxStandComp->pComponentPrivate;
00527   omx_base_audio_PortType *port;
00528   if (ComponentParameterStructure == NULL) {
00529     return OMX_ErrorBadParameter;
00530   }
00531 
00532   DEBUG(DEB_LEV_SIMPLE_SEQ, "   Setting parameter %i\n", nParamIndex);
00533   switch(nParamIndex) {
00534   case OMX_IndexParamAudioPortFormat:
00535     pAudioPortFormat = (OMX_AUDIO_PARAM_PORTFORMATTYPE*)ComponentParameterStructure;
00536     portIndex = pAudioPortFormat->nPortIndex;
00537     /*Check Structure Header and verify component state*/
00538     err = omx_base_component_ParameterSanityCheck(hComponent, portIndex, pAudioPortFormat, sizeof(OMX_AUDIO_PARAM_PORTFORMATTYPE));
00539     if(err!=OMX_ErrorNone) { 
00540       DEBUG(DEB_LEV_ERR, "In %s Parameter Check Error=%x\n",__func__,err); 
00541       break;
00542     } 
00543     if (portIndex <= 1) {
00544       port = (omx_base_audio_PortType *) omx_audiodec_component_Private->ports[portIndex];
00545       memcpy(&port->sAudioParam,pAudioPortFormat,sizeof(OMX_AUDIO_PARAM_PORTFORMATTYPE));
00546     } else {
00547       return OMX_ErrorBadPortIndex;
00548     }
00549     break;  
00550   case OMX_IndexParamAudioPcm:
00551     pAudioPcmMode = (OMX_AUDIO_PARAM_PCMMODETYPE*)ComponentParameterStructure;
00552     portIndex = pAudioPcmMode->nPortIndex;
00553     /*Check Structure Header and verify component state*/
00554     err = omx_base_component_ParameterSanityCheck(hComponent, portIndex, pAudioPcmMode, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
00555     if(err!=OMX_ErrorNone) { 
00556       DEBUG(DEB_LEV_ERR, "In %s Parameter Check Error=%x\n",__func__,err); 
00557       break;
00558     } 
00559     memcpy(&omx_audiodec_component_Private->pAudioPcmMode,pAudioPcmMode,sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));          
00560     break;
00561 
00562   case OMX_IndexParamAudioVorbis:
00563     pAudioVorbis = (OMX_AUDIO_PARAM_VORBISTYPE*)ComponentParameterStructure;
00564     portIndex = pAudioVorbis->nPortIndex;
00565     err = omx_base_component_ParameterSanityCheck(hComponent,portIndex,pAudioVorbis,sizeof(OMX_AUDIO_PARAM_VORBISTYPE));
00566     if(err!=OMX_ErrorNone) { 
00567       DEBUG(DEB_LEV_ERR, "In %s Parameter Check Error=%x\n",__func__,err); 
00568       break;
00569     } 
00570     if(pAudioVorbis->nPortIndex == 0)
00571       memcpy(&omx_audiodec_component_Private->pAudioVorbis,pAudioVorbis,sizeof(OMX_AUDIO_PARAM_VORBISTYPE));
00572     else
00573       return OMX_ErrorBadPortIndex;
00574     break;
00575   case OMX_IndexParamStandardComponentRole:
00576     pComponentRole = (OMX_PARAM_COMPONENTROLETYPE*)ComponentParameterStructure;
00577     if (!strcmp((char*)pComponentRole->cRole, AUDIO_DEC_MP3_ROLE)) {
00578       omx_audiodec_component_Private->audio_coding_type = OMX_AUDIO_CodingMP3;
00579     } else if (!strcmp((char*)pComponentRole->cRole, AUDIO_DEC_VORBIS_ROLE)) {
00580       omx_audiodec_component_Private->audio_coding_type = OMX_AUDIO_CodingVORBIS;
00581     } else if (!strcmp((char*)pComponentRole->cRole, AUDIO_DEC_AAC_ROLE)) {
00582       omx_audiodec_component_Private->audio_coding_type = OMX_AUDIO_CodingAAC;
00583     } else {
00584       return OMX_ErrorBadParameter;
00585     }
00586     omx_audiodec_component_SetInternalParameters(openmaxStandComp);
00587     break;
00588     
00589   case OMX_IndexParamAudioAac:  
00590     pAudioAac = (OMX_AUDIO_PARAM_AACPROFILETYPE*) ComponentParameterStructure;
00591     portIndex = pAudioAac->nPortIndex;
00592     err = omx_base_component_ParameterSanityCheck(hComponent,portIndex,pAudioAac,sizeof(OMX_AUDIO_PARAM_AACPROFILETYPE));
00593     if(err!=OMX_ErrorNone) { 
00594       DEBUG(DEB_LEV_ERR, "In %s Parameter Check Error=%x\n",__func__,err); 
00595       break;
00596     } 
00597     if (pAudioAac->nPortIndex == 0) {
00598       memcpy(&omx_audiodec_component_Private->pAudioAac,pAudioAac,sizeof(OMX_AUDIO_PARAM_AACPROFILETYPE));
00599     } else {
00600       return OMX_ErrorBadPortIndex;
00601     }
00602     break;
00603 
00604   case OMX_IndexParamAudioMp3:
00605     pAudioMp3 = (OMX_AUDIO_PARAM_MP3TYPE*) ComponentParameterStructure;
00606     portIndex = pAudioMp3->nPortIndex;
00607     err = omx_base_component_ParameterSanityCheck(hComponent,portIndex,pAudioMp3,sizeof(OMX_AUDIO_PARAM_MP3TYPE));
00608     if(err!=OMX_ErrorNone) { 
00609       DEBUG(DEB_LEV_ERR, "In %s Parameter Check Error=%x\n",__func__,err); 
00610       break;
00611     } 
00612     if (pAudioMp3->nPortIndex == 0) {
00613       memcpy(&omx_audiodec_component_Private->pAudioMp3,pAudioMp3,sizeof(OMX_AUDIO_PARAM_MP3TYPE));
00614     } else {
00615       return OMX_ErrorBadPortIndex;
00616     }
00617     break;
00618   case OMX_IndexParamAudioG726:
00619     pAudioG726 = (OMX_AUDIO_PARAM_G726TYPE*) ComponentParameterStructure;
00620     portIndex = pAudioG726->nPortIndex;
00621     err = omx_base_component_ParameterSanityCheck(hComponent,portIndex,pAudioG726,sizeof(OMX_AUDIO_PARAM_G726TYPE));
00622     if(err!=OMX_ErrorNone) { 
00623       DEBUG(DEB_LEV_ERR, "In %s Parameter Check Error=%x\n",__func__,err); 
00624       break;
00625     } 
00626     if (pAudioG726->nPortIndex == 0) {
00627       memcpy(&omx_audiodec_component_Private->pAudioG726,pAudioG726,sizeof(OMX_AUDIO_PARAM_G726TYPE));
00628     } else {
00629       return OMX_ErrorBadPortIndex;
00630     }
00631     break;
00632   default: /*Call the base component function*/
00633     return omx_base_component_SetParameter(hComponent, nParamIndex, ComponentParameterStructure);
00634   }
00635   return err;
00636 }
00637 
00638 OMX_ERRORTYPE omx_audiodec_component_GetParameter(
00639   OMX_IN  OMX_HANDLETYPE hComponent,
00640   OMX_IN  OMX_INDEXTYPE nParamIndex,
00641   OMX_INOUT OMX_PTR ComponentParameterStructure)
00642 {
00643   OMX_AUDIO_PARAM_PORTFORMATTYPE *pAudioPortFormat;  
00644   OMX_AUDIO_PARAM_PCMMODETYPE *pAudioPcmMode;
00645   OMX_AUDIO_PARAM_VORBISTYPE *pAudioVorbis; //support for Vorbis format  
00646   OMX_AUDIO_PARAM_AACPROFILETYPE *pAudioAac; //support for AAC format   
00647   OMX_PARAM_COMPONENTROLETYPE * pComponentRole;
00648   OMX_AUDIO_PARAM_MP3TYPE *pAudioMp3;
00649   OMX_AUDIO_PARAM_G726TYPE *pAudioG726;
00650   omx_base_audio_PortType *port;
00651   OMX_ERRORTYPE err = OMX_ErrorNone;
00652 
00653   OMX_COMPONENTTYPE *openmaxStandComp = (OMX_COMPONENTTYPE *)hComponent;
00654   omx_audiodec_component_PrivateType* omx_audiodec_component_Private = (omx_audiodec_component_PrivateType*)openmaxStandComp->pComponentPrivate;
00655   if (ComponentParameterStructure == NULL) {
00656     return OMX_ErrorBadParameter;
00657   }
00658   DEBUG(DEB_LEV_SIMPLE_SEQ, "   Getting parameter %i\n", nParamIndex);
00659   /* Check which structure we are being fed and fill its header */
00660   switch(nParamIndex) {
00661   case OMX_IndexParamAudioInit:
00662     if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_PORT_PARAM_TYPE))) != OMX_ErrorNone) { 
00663       break;
00664     }
00665     memcpy(ComponentParameterStructure, &omx_audiodec_component_Private->sPortTypesParam[OMX_PortDomainAudio], sizeof(OMX_PORT_PARAM_TYPE));
00666     break;    
00667   case OMX_IndexParamAudioPortFormat:
00668     pAudioPortFormat = (OMX_AUDIO_PARAM_PORTFORMATTYPE*)ComponentParameterStructure;
00669     if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_AUDIO_PARAM_PORTFORMATTYPE))) != OMX_ErrorNone) { 
00670       break;
00671     }
00672     if (pAudioPortFormat->nPortIndex <= 1) {
00673       port = (omx_base_audio_PortType *)omx_audiodec_component_Private->ports[pAudioPortFormat->nPortIndex];
00674       memcpy(pAudioPortFormat, &port->sAudioParam, sizeof(OMX_AUDIO_PARAM_PORTFORMATTYPE));
00675     } else {
00676       return OMX_ErrorBadPortIndex;
00677     }
00678     break;    
00679   case OMX_IndexParamAudioPcm:
00680     pAudioPcmMode = (OMX_AUDIO_PARAM_PCMMODETYPE*)ComponentParameterStructure;
00681     if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE))) != OMX_ErrorNone) { 
00682       break;
00683     }
00684     if (pAudioPcmMode->nPortIndex > 1) {
00685       return OMX_ErrorBadPortIndex;
00686     }
00687     memcpy(pAudioPcmMode,&omx_audiodec_component_Private->pAudioPcmMode,sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
00688     break;
00689   case OMX_IndexParamAudioMp3:
00690     pAudioMp3 = (OMX_AUDIO_PARAM_MP3TYPE*)ComponentParameterStructure;
00691     if (pAudioMp3->nPortIndex != 0) {
00692       return OMX_ErrorBadPortIndex;
00693     }
00694     if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_AUDIO_PARAM_MP3TYPE))) != OMX_ErrorNone) { 
00695       break;
00696     }
00697     memcpy(pAudioMp3,&omx_audiodec_component_Private->pAudioMp3,sizeof(OMX_AUDIO_PARAM_MP3TYPE));
00698     break;
00699     
00700   case OMX_IndexParamAudioAac:  
00701     pAudioAac = (OMX_AUDIO_PARAM_AACPROFILETYPE*)ComponentParameterStructure;
00702     if (pAudioAac->nPortIndex != 0) {
00703       return OMX_ErrorBadPortIndex;
00704     }
00705     if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_AUDIO_PARAM_AACPROFILETYPE))) != OMX_ErrorNone) { 
00706       break;
00707     }
00708     memcpy(pAudioAac,&omx_audiodec_component_Private->pAudioAac,sizeof(OMX_AUDIO_PARAM_AACPROFILETYPE));
00709     break;
00710     
00711   case OMX_IndexParamAudioVorbis:
00712     pAudioVorbis = (OMX_AUDIO_PARAM_VORBISTYPE*)ComponentParameterStructure;
00713     if (pAudioVorbis->nPortIndex != 0) {
00714        return OMX_ErrorBadPortIndex;
00715     }
00716     if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_AUDIO_PARAM_VORBISTYPE))) != OMX_ErrorNone) { 
00717       break;
00718     }
00719     memcpy(pAudioVorbis,&omx_audiodec_component_Private->pAudioVorbis,sizeof(OMX_AUDIO_PARAM_VORBISTYPE));
00720     break;
00721 
00722   case OMX_IndexParamAudioG726:
00723     pAudioG726 = (OMX_AUDIO_PARAM_G726TYPE*) ComponentParameterStructure;
00724     if (pAudioG726->nPortIndex != 0) {
00725        return OMX_ErrorBadPortIndex;
00726     }
00727     if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_AUDIO_PARAM_G726TYPE))) != OMX_ErrorNone) { 
00728       break;
00729     }
00730     memcpy(pAudioG726,&omx_audiodec_component_Private->pAudioG726,sizeof(OMX_AUDIO_PARAM_G726TYPE));
00731     break;
00732 
00733   case OMX_IndexParamStandardComponentRole:
00734     pComponentRole = (OMX_PARAM_COMPONENTROLETYPE*)ComponentParameterStructure;
00735     if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_PARAM_COMPONENTROLETYPE))) != OMX_ErrorNone) { 
00736       break;
00737     }
00738 
00739     if (omx_audiodec_component_Private->audio_coding_type == OMX_AUDIO_CodingMP3) {
00740       strcpy((char*)pComponentRole->cRole, AUDIO_DEC_MP3_ROLE);
00741     }  else if (omx_audiodec_component_Private->audio_coding_type == OMX_AUDIO_CodingVORBIS) {
00742       strcpy((char*)pComponentRole->cRole, AUDIO_DEC_VORBIS_ROLE);
00743     }  else if (omx_audiodec_component_Private->audio_coding_type == OMX_AUDIO_CodingAAC) {  
00744       strcpy((char*)pComponentRole->cRole, AUDIO_DEC_AAC_ROLE);
00745     } else {
00746       strcpy((char*)pComponentRole->cRole,"\0");;
00747     }
00748     break;
00749   default: /*Call the base component function*/
00750     return omx_base_component_GetParameter(hComponent, nParamIndex, ComponentParameterStructure);
00751   }
00752   return err;
00753 }
00754 
00755 OMX_ERRORTYPE omx_audiodec_component_MessageHandler(OMX_COMPONENTTYPE* openmaxStandComp,internalRequestMessageType *message)
00756 {
00757   omx_audiodec_component_PrivateType* omx_audiodec_component_Private = (omx_audiodec_component_PrivateType*)openmaxStandComp->pComponentPrivate;
00758   OMX_ERRORTYPE err;
00759   OMX_STATETYPE eCurrentState = omx_audiodec_component_Private->state;
00760 
00761   DEBUG(DEB_LEV_SIMPLE_SEQ, "In %s\n", __func__);
00762 
00763   if (message->messageType == OMX_CommandStateSet){
00764     if ((message->messageParam == OMX_StateExecuting ) && (omx_audiodec_component_Private->state == OMX_StateIdle)) {
00765       if (!omx_audiodec_component_Private->avcodecReady /* &&  omx_audiodec_component_Private->audio_coding_type == OMX_AUDIO_CodingMP3 */) {
00766         err = omx_audiodec_component_ffmpegLibInit(omx_audiodec_component_Private);
00767         if (err != OMX_ErrorNone) {
00768           return OMX_ErrorNotReady;
00769         }
00770         omx_audiodec_component_Private->avcodecReady = OMX_TRUE;
00771       }
00772     } 
00773     else if ((message->messageParam == OMX_StateIdle ) && (omx_audiodec_component_Private->state == OMX_StateLoaded)) {
00774       err = omx_audiodec_component_Init(openmaxStandComp);
00775       if(err!=OMX_ErrorNone) { 
00776         DEBUG(DEB_LEV_ERR, "In %s Audio Decoder Init Failed Error=%x\n",__func__,err); 
00777         return err;
00778       } 
00779     } else if ((message->messageParam == OMX_StateLoaded) && (omx_audiodec_component_Private->state == OMX_StateIdle)) {
00780       err = omx_audiodec_component_Deinit(openmaxStandComp);
00781       if(err!=OMX_ErrorNone) { 
00782         DEBUG(DEB_LEV_ERR, "In %s Audio Decoder Deinit Failed Error=%x\n",__func__,err); 
00783         return err;
00784       } 
00785     }
00786   }
00787   // Execute the base message handling
00788   err =  omx_base_component_MessageHandler(openmaxStandComp,message);
00789 
00790   if (message->messageType == OMX_CommandStateSet){
00791    if ((message->messageParam == OMX_StateIdle  ) && (eCurrentState == OMX_StateExecuting)) {
00792       if (omx_audiodec_component_Private->avcodecReady) {
00793         omx_audiodec_component_ffmpegLibDeInit(omx_audiodec_component_Private);
00794         omx_audiodec_component_Private->avcodecReady = OMX_FALSE;
00795       }
00796     }
00797   }
00798   return err;
00799 }
00800 
00801 OMX_ERRORTYPE omx_audiodec_component_ComponentRoleEnum(
00802   OMX_IN OMX_HANDLETYPE hComponent,
00803   OMX_OUT OMX_U8 *cRole,
00804   OMX_IN OMX_U32 nIndex)
00805 {
00806   if (nIndex == 0) {
00807     strcpy((char*)cRole, AUDIO_DEC_MP3_ROLE);
00808   } else if (nIndex == 1) {
00809     strcpy((char*)cRole, AUDIO_DEC_VORBIS_ROLE);
00810   } else if (nIndex == 2) {           
00811     strcpy((char*)cRole, AUDIO_DEC_AAC_ROLE);
00812   }else {
00813     return OMX_ErrorUnsupportedIndex;
00814   }
00815   return OMX_ErrorNone;
00816 }
00817 
00818 
00819 OMX_ERRORTYPE omx_audiodec_component_SetConfig(
00820   OMX_HANDLETYPE hComponent,
00821   OMX_INDEXTYPE nIndex,
00822   OMX_PTR pComponentConfigStructure) {
00823   
00824   OMX_ERRORTYPE err = OMX_ErrorNone;
00825   OMX_VENDOR_EXTRADATATYPE* pExtradata;
00826 
00827   OMX_COMPONENTTYPE *openmaxStandComp = (OMX_COMPONENTTYPE *)hComponent;
00828   omx_audiodec_component_PrivateType* omx_audiodec_component_Private = (omx_audiodec_component_PrivateType*)openmaxStandComp->pComponentPrivate;
00829   if (pComponentConfigStructure == NULL) {
00830     return OMX_ErrorBadParameter;
00831   }
00832   DEBUG(DEB_LEV_SIMPLE_SEQ, "   Getting configuration %i\n", nIndex);
00833   /* Check which structure we are being fed and fill its header */
00834   switch (nIndex) {
00835     case OMX_IndexVendorAudioExtraData :  
00836       pExtradata = (OMX_VENDOR_EXTRADATATYPE*)pComponentConfigStructure;
00837       if (pExtradata->nPortIndex <= 1) {
00839         omx_audiodec_component_Private->extradata_size = (OMX_U32)pExtradata->nDataSize;
00840         if(omx_audiodec_component_Private->extradata_size > 0) {
00841           if(omx_audiodec_component_Private->extradata) {
00842             free(omx_audiodec_component_Private->extradata);
00843           }
00844           omx_audiodec_component_Private->extradata = malloc((int)pExtradata->nDataSize);
00845           memcpy(omx_audiodec_component_Private->extradata, pExtradata->pData,pExtradata->nDataSize);
00846         } else {
00847             DEBUG(DEB_LEV_SIMPLE_SEQ,"extradata size is 0 !!!\n");
00848         }  
00849       } else {
00850           return OMX_ErrorBadPortIndex;
00851       }
00852       break;    
00853         
00854     default: // delegate to superclass
00855       return omx_base_component_SetConfig(hComponent, nIndex, pComponentConfigStructure);
00856   }
00857   return err;
00858 }
00859 
00860 OMX_ERRORTYPE omx_audiodec_component_GetExtensionIndex(
00861   OMX_IN  OMX_HANDLETYPE hComponent,
00862   OMX_IN  OMX_STRING cParameterName,
00863   OMX_OUT OMX_INDEXTYPE* pIndexType) {    
00864 
00865   DEBUG(DEB_LEV_FUNCTION_NAME,"In  %s \n",__func__);
00866 
00867   if(strcmp(cParameterName,"OMX.ST.index.config.audioextradata") == 0) {
00868     *pIndexType = OMX_IndexVendorAudioExtraData;  
00869   } else {
00870     return OMX_ErrorBadParameter;
00871   }
00872   return OMX_ErrorNone;  
00873 }
00874 
00875 
00876 

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