OMX_ERRORTYPE omx_volume_component_Constructor(OMX_COMPONENTTYPE *openmaxStandComp, OMX_STRING cComponentName) {
OMX_ERRORTYPE err = OMX_ErrorNone;
omx_volume_component_PrivateType* omx_volume_component_Private;
OMX_U32 i;
if (!openmaxStandComp->pComponentPrivate) {
DEBUG(DEB_LEV_FUNCTION_NAME, "In %s, allocating component\n",__func__);
openmaxStandComp->pComponentPrivate = calloc(1, sizeof(omx_volume_component_PrivateType));
if(openmaxStandComp->pComponentPrivate == NULL) {
return OMX_ErrorInsufficientResources;
}
} else {
DEBUG(DEB_LEV_FUNCTION_NAME, "In %s, Error Component %x Already Allocated\n", __func__, (int)openmaxStandComp->pComponentPrivate);
}
omx_volume_component_Private = openmaxStandComp->pComponentPrivate;
omx_volume_component_Private->ports = NULL;
/** Calling base filter constructor */
err = omx_base_filter_Constructor(openmaxStandComp, cComponentName);
omx_volume_component_Private->sPortTypesParam[OMX_PortDomainAudio].nStartPortNumber = 0;
omx_volume_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts = 2;
/** Allocate Ports and call port constructor. */
if (omx_volume_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts && !omx_volume_component_Private->ports) {
omx_volume_component_Private->ports = calloc(omx_volume_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts, sizeof(omx_base_PortType *));
if (!omx_volume_component_Private->ports) {
return OMX_ErrorInsufficientResources;
}
for (i=0; i < omx_volume_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts; i++) {
omx_volume_component_Private->ports[i] = calloc(1, sizeof(omx_base_audio_PortType));
if (!omx_volume_component_Private->ports[i]) {
return OMX_ErrorInsufficientResources;
}
}
}
base_audio_port_Constructor(openmaxStandComp, &omx_volume_component_Private->ports[0], 0, OMX_TRUE);
base_audio_port_Constructor(openmaxStandComp, &omx_volume_component_Private->ports[1], 1, OMX_FALSE);
/** Domain specific section for the ports. */
omx_volume_component_Private->ports[OMX_BASE_FILTER_INPUTPORT_INDEX]->sPortParam.nBufferSize = DEFAULT_OUT_BUFFER_SIZE;
omx_volume_component_Private->ports[OMX_BASE_FILTER_OUTPUTPORT_INDEX]->sPortParam.nBufferSize = DEFAULT_OUT_BUFFER_SIZE;
omx_volume_component_Private->gain = GAIN_VALUE; //100.0f; // default gain
omx_volume_component_Private->destructor = omx_volume_component_Destructor;
openmaxStandComp->SetParameter = omx_volume_component_SetParameter;
openmaxStandComp->GetParameter = omx_volume_component_GetParameter;
openmaxStandComp->GetConfig = omx_volume_component_GetConfig;
openmaxStandComp->SetConfig = omx_volume_component_SetConfig;
omx_volume_component_Private->BufferMgmtCallback = omx_volume_component_BufferMgmtCallback;
noVolumeCompInstance++;
if(noVolumeCompInstance > MAX_COMPONENT_VOLUME) {
return OMX_ErrorInsufficientResources;
}
return err;
}
/** The Constructor
*/
OMX_ERRORTYPE omx_alsasink_component_Constructor(OMX_COMPONENTTYPE *openmaxStandComp,OMX_STRING cComponentName) {
int err;
int omxErr;
omx_base_audio_PortType *pPort;
omx_alsasink_component_PrivateType* omx_alsasink_component_Private;
if (!openmaxStandComp->pComponentPrivate) {
openmaxStandComp->pComponentPrivate = calloc(1, sizeof(omx_alsasink_component_PrivateType));
if(openmaxStandComp->pComponentPrivate==NULL) {
return OMX_ErrorInsufficientResources;
}
}
omx_alsasink_component_Private = openmaxStandComp->pComponentPrivate;
omx_alsasink_component_Private->ports = NULL;
omxErr = omx_base_sink_Constructor(openmaxStandComp,cComponentName);
if (omxErr != OMX_ErrorNone) {
return OMX_ErrorInsufficientResources;
}
omx_alsasink_component_Private->sPortTypesParam[OMX_PortDomainAudio].nStartPortNumber = 0;
omx_alsasink_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts = 1;
omx_alsasink_component_Private->sPortTypesParam[OMX_PortDomainOther].nStartPortNumber = 1;
omx_alsasink_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts = 1;
/** Allocate Ports and call port constructor. */
if ((omx_alsasink_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
omx_alsasink_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts)
&& !omx_alsasink_component_Private->ports) {
omx_alsasink_component_Private->ports = calloc((omx_alsasink_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
omx_alsasink_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts), sizeof(omx_base_PortType *));
if (!omx_alsasink_component_Private->ports) {
return OMX_ErrorInsufficientResources;
}
omx_alsasink_component_Private->ports[0] = calloc(1, sizeof(omx_base_audio_PortType));
if (!omx_alsasink_component_Private->ports[0]) {
return OMX_ErrorInsufficientResources;
}
base_audio_port_Constructor(openmaxStandComp, &omx_alsasink_component_Private->ports[0], 0, OMX_TRUE);
omx_alsasink_component_Private->ports[1] = calloc(1, sizeof(omx_base_clock_PortType));
if (!omx_alsasink_component_Private->ports[1]) {
return OMX_ErrorInsufficientResources;
}
base_clock_port_Constructor(openmaxStandComp, &omx_alsasink_component_Private->ports[1], 1, OMX_TRUE);
omx_alsasink_component_Private->ports[1]->sPortParam.bEnabled = OMX_FALSE;
}
pPort = (omx_base_audio_PortType *) omx_alsasink_component_Private->ports[OMX_BASE_SINK_INPUTPORT_INDEX];
// set the pPort params, now that the ports exist
/** Domain specific section for the ports. */
pPort->sPortParam.format.audio.eEncoding = OMX_AUDIO_CodingPCM;
/*Input pPort buffer size is equal to the size of the output buffer of the previous component*/
pPort->sPortParam.nBufferSize = DEFAULT_OUT_BUFFER_SIZE;
/* Initializing the function pointers */
omx_alsasink_component_Private->BufferMgmtCallback = omx_alsasink_component_BufferMgmtCallback;
omx_alsasink_component_Private->destructor = omx_alsasink_component_Destructor;
pPort->Port_SendBufferFunction = omx_alsasink_component_port_SendBufferFunction;
pPort->FlushProcessingBuffers = omx_alsasink_component_port_FlushProcessingBuffers;
setHeader(&pPort->sAudioParam, sizeof(OMX_AUDIO_PARAM_PORTFORMATTYPE));
pPort->sAudioParam.nPortIndex = 0;
pPort->sAudioParam.nIndex = 0;
pPort->sAudioParam.eEncoding = OMX_AUDIO_CodingPCM;
/* OMX_AUDIO_PARAM_PCMMODETYPE */
setHeader(&omx_alsasink_component_Private->sPCMModeParam, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
omx_alsasink_component_Private->sPCMModeParam.nPortIndex = 0;
omx_alsasink_component_Private->sPCMModeParam.nChannels = 2;
omx_alsasink_component_Private->sPCMModeParam.eNumData = OMX_NumericalDataSigned;
omx_alsasink_component_Private->sPCMModeParam.eEndian = OMX_EndianLittle;
omx_alsasink_component_Private->sPCMModeParam.bInterleaved = OMX_TRUE;
omx_alsasink_component_Private->sPCMModeParam.nBitPerSample = 16;
omx_alsasink_component_Private->sPCMModeParam.nSamplingRate = 44100;
omx_alsasink_component_Private->sPCMModeParam.ePCMMode = OMX_AUDIO_PCMModeLinear;
omx_alsasink_component_Private->sPCMModeParam.eChannelMapping[0] = OMX_AUDIO_ChannelNone;
/* testing the A/V sync */
noAlsasinkInstance++;
if(noAlsasinkInstance > MAX_COMPONENT_ALSASINK) {
return OMX_ErrorInsufficientResources;
}
/* Allocate the playback handle and the hardware parameter structure */
if ((err = snd_pcm_open (&omx_alsasink_component_Private->playback_handle, "default", SND_PCM_STREAM_PLAYBACK, 0)) < 0) {
DEBUG(DEB_LEV_ERR, "cannot open audio device %s (%s)\n", "default", snd_strerror (err));
return OMX_ErrorHardware;
}
else
DEBUG(DEB_LEV_SIMPLE_SEQ, "Got playback handle at %p %p in %i\n", omx_alsasink_component_Private->playback_handle, &omx_alsasink_component_Private->playback_handle, getpid());
if (snd_pcm_hw_params_malloc(&omx_alsasink_component_Private->hw_params) < 0) {
DEBUG(DEB_LEV_ERR, "%s: failed allocating input pPort hw parameters\n", __func__);
return OMX_ErrorHardware;
}
else
DEBUG(DEB_LEV_SIMPLE_SEQ, "Got hw parameters at %p\n", omx_alsasink_component_Private->hw_params);
if ((err = snd_pcm_hw_params_any (omx_alsasink_component_Private->playback_handle, omx_alsasink_component_Private->hw_params)) < 0) {
DEBUG(DEB_LEV_ERR, "cannot initialize hardware parameter structure (%s)\n", snd_strerror (err));
return OMX_ErrorHardware;
}
openmaxStandComp->SetParameter = omx_alsasink_component_SetParameter;
openmaxStandComp->GetParameter = omx_alsasink_component_GetParameter;
/* Write in the default parameters */
omx_alsasink_component_Private->AudioPCMConfigured = 0;
omx_alsasink_component_Private->eState = OMX_TIME_ClockStateStopped;
omx_alsasink_component_Private->xScale = 1<<16;
if (!omx_alsasink_component_Private->AudioPCMConfigured) {
DEBUG(DEB_LEV_SIMPLE_SEQ, "Configuring the PCM interface in the Init function\n");
omxErr = omx_alsasink_component_SetParameter(openmaxStandComp, OMX_IndexParamAudioPcm, &omx_alsasink_component_Private->sPCMModeParam);
if(omxErr != OMX_ErrorNone){
DEBUG(DEB_LEV_ERR, "In %s Error %08x\n",__func__,omxErr);
}
}
return OMX_ErrorNone;
}
OMX_ERRORTYPE omx_audio_decoder_component_Constructor(
OMX_COMPONENTTYPE *pComponent,
OMX_STRING cComponentName)
{
OMX_ERRORTYPE err = OMX_ErrorNone;
omx_audio_decoder_component_PrivateType* pPrivate;
omx_audio_decoder_component_PortType* pPort;
OMX_U32 i, idx = 0;
if((MAX_COMPONENT_INSTANCES > 0) &&
(noAudioSplitterCompInstance > MAX_COMPONENT_INSTANCES))
err = OMX_ErrorInsufficientResources;
if(OMX_ErrorNone == err) {
if(NULL == pComponent->pComponentPrivate) {
DEBUG(DEB_LEV_FUNCTION_NAME, "In %s, allocating component\n", __func__);
pComponent->pComponentPrivate = calloc(1, sizeof(omx_audio_decoder_component_PrivateType));
if(pComponent->pComponentPrivate == NULL) {
return OMX_ErrorInsufficientResources;
}
} else {
DEBUG(DEB_LEV_FUNCTION_NAME, "In %s, Error Component %x Already Allocated\n", __func__, (int) pComponent->pComponentPrivate);
}
}
/** Calling base filter constructor */
err = omx_base_filter_Constructor(pComponent, cComponentName);
pPrivate = pComponent->pComponentPrivate;
pPrivate->sPortTypesParam[OMX_PortDomainAudio].nPorts = NUM_PORTS;
/** Allocate Ports and call port constructor. */
pPrivate->ports = calloc(pPrivate->sPortTypesParam[OMX_PortDomainAudio].nPorts, sizeof(omx_base_PortType *));
if (NULL == pPrivate->ports)
return OMX_ErrorInsufficientResources;
for (i=0; i < pPrivate->sPortTypesParam[OMX_PortDomainAudio].nPorts; i++) {
pPrivate->ports[i] = calloc(1, sizeof(omx_audio_decoder_component_PortType));
if (NULL == pPrivate->ports[i])
return OMX_ErrorInsufficientResources;
}
/* construct input ports */
for(i = 0; i < NUM_INPUT_PORTS; i++) {
base_audio_port_Constructor(pComponent, &pPrivate->ports[idx], idx, OMX_TRUE);
idx++;
}
/* construct output ports */
for(i = 0; i < NUM_OUTPUT_PORTS; i++) {
base_audio_port_Constructor(pComponent, &pPrivate->ports[idx], idx, OMX_FALSE);
idx++;
}
/** Domain specific section for the ports. */
for(i = 0; i < pPrivate->sPortTypesParam[OMX_PortDomainAudio].nPorts; i++) {
pPort = (omx_audio_decoder_component_PortType *) pPrivate->ports[i];
pPort->sPortParam.nBufferSize = DEFAULT_OUT_BUFFER_SIZE;
setHeader(&pPort->pAudioPcmMode,sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
pPort->pAudioPcmMode.nPortIndex = i;
pPort->pAudioPcmMode.nChannels = 2;
pPort->pAudioPcmMode.eNumData = OMX_NumericalDataSigned;
pPort->pAudioPcmMode.eEndian = OMX_EndianBig;
pPort->pAudioPcmMode.bInterleaved = OMX_TRUE;
pPort->pAudioPcmMode.nBitPerSample = 16;
pPort->pAudioPcmMode.nSamplingRate = 48000;
pPort->pAudioPcmMode.ePCMMode = OMX_AUDIO_PCMModeLinear;
}
pPrivate->BufferMgmtCallback = omx_audio_decoder_component_BufferMgmtCallback;
pPrivate->destructor = omx_audio_decoder_component_Destructor;
noAudioSplitterCompInstance++;
return err;
}
/** The Constructor
*/
OMX_ERRORTYPE omx_amr_audiodec_component_Constructor(OMX_COMPONENTTYPE *openmaxStandComp,OMX_STRING cComponentName) {
OMX_ERRORTYPE err = OMX_ErrorNone;
omx_amr_audiodec_component_PrivateType* omx_amr_audiodec_component_Private;
omx_base_audio_PortType *pPort;
OMX_U32 i;
if (!openmaxStandComp->pComponentPrivate) {
DEBUG(DEB_LEV_FUNCTION_NAME,"In %s, allocating component\n",__func__);
openmaxStandComp->pComponentPrivate = calloc(1, sizeof(omx_amr_audiodec_component_PrivateType));
if(openmaxStandComp->pComponentPrivate==NULL)
return OMX_ErrorInsufficientResources;
}
else
DEBUG(DEB_LEV_FUNCTION_NAME,"In %s, Error Component %x Already Allocated\n",__func__, (int)openmaxStandComp->pComponentPrivate);
omx_amr_audiodec_component_Private = openmaxStandComp->pComponentPrivate;
omx_amr_audiodec_component_Private->ports = NULL;
/** Calling base filter constructor */
err = omx_base_filter_Constructor(openmaxStandComp,cComponentName);
omx_amr_audiodec_component_Private->sPortTypesParam[OMX_PortDomainAudio].nStartPortNumber = 0;
omx_amr_audiodec_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts = 2;
/** Allocate Ports and call port constructor. */
if (omx_amr_audiodec_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts && !omx_amr_audiodec_component_Private->ports) {
omx_amr_audiodec_component_Private->ports = calloc(omx_amr_audiodec_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts, sizeof(omx_base_PortType *));
if (!omx_amr_audiodec_component_Private->ports) {
return OMX_ErrorInsufficientResources;
}
for (i=0; i < omx_amr_audiodec_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts; i++) {
omx_amr_audiodec_component_Private->ports[i] = calloc(1, sizeof(omx_base_audio_PortType));
if (!omx_amr_audiodec_component_Private->ports[i]) {
return OMX_ErrorInsufficientResources;
}
}
}
base_audio_port_Constructor(openmaxStandComp, &omx_amr_audiodec_component_Private->ports[0], 0, OMX_TRUE);
base_audio_port_Constructor(openmaxStandComp, &omx_amr_audiodec_component_Private->ports[1], 1, OMX_FALSE);
/** Domain specific section for the ports. */
// first we set the parameter common to both formats
//common parameters related to input port
omx_amr_audiodec_component_Private->ports[OMX_BASE_FILTER_INPUTPORT_INDEX]->sPortParam.nBufferSize = DEFAULT_IN_BUFFER_SIZE;
//common parameters related to output port
pPort = (omx_base_audio_PortType *) omx_amr_audiodec_component_Private->ports[OMX_BASE_FILTER_OUTPUTPORT_INDEX];
pPort->sAudioParam.nIndex = OMX_IndexParamAudioPcm;
pPort->sAudioParam.eEncoding = OMX_AUDIO_CodingPCM;
pPort->sPortParam.format.audio.eEncoding = OMX_AUDIO_CodingPCM;
pPort->sPortParam.nBufferSize = DEFAULT_OUT_BUFFER_SIZE;
// now it's time to know the audio coding type of the component
if(!strcmp(cComponentName, AUDIO_DEC_AMR_NAME)) // AMR format encoder
omx_amr_audiodec_component_Private->audio_coding_type = OMX_AUDIO_CodingAMR;
else // IL client specified an invalid component name
return OMX_ErrorInvalidComponentName;
//set internal port parameters
omx_amr_audiodec_component_SetInternalParameters(openmaxStandComp);
//general configuration irrespective of any audio formats
//setting other parameters of omx_amr_audiodec_component_private
omx_amr_audiodec_component_Private->avCodec = NULL;
omx_amr_audiodec_component_Private->avCodecContext = NULL;
omx_amr_audiodec_component_Private->avcodecReady = OMX_FALSE;
omx_amr_audiodec_component_Private->extradata = NULL;
omx_amr_audiodec_component_Private->extradata_size = 0;
omx_amr_audiodec_component_Private->isFirstBuffer = OMX_TRUE;
omx_amr_audiodec_component_Private->BufferMgmtCallback = omx_amr_audiodec_component_BufferMgmtCallback;
/** first initializing the codec context etc that was done earlier by ffmpeglibinit function */
avcodec_init();
av_register_all();
omx_amr_audiodec_component_Private->avCodecContext = avcodec_alloc_context();
omx_amr_audiodec_component_Private->messageHandler = omx_amr_audiodec_component_MessageHandler;
omx_amr_audiodec_component_Private->destructor = omx_amr_audiodec_component_Destructor;
openmaxStandComp->SetParameter = omx_amr_audiodec_component_SetParameter;
openmaxStandComp->GetParameter = omx_amr_audiodec_component_GetParameter;
openmaxStandComp->ComponentRoleEnum = omx_amr_audiodec_component_ComponentRoleEnum;
noAudioDecInstance++;
if(noAudioDecInstance>MAX_COMPONENT_AMR_AUDIODEC)
return OMX_ErrorInsufficientResources;
return err;
}
/** The Constructor
*/
OMX_ERRORTYPE omx_parser3gp_component_Constructor(OMX_COMPONENTTYPE *openmaxStandComp,OMX_STRING cComponentName) {
OMX_ERRORTYPE err = OMX_ErrorNone;
omx_base_video_PortType *pPortV;
omx_base_audio_PortType *pPortA;
omx_parser3gp_component_PrivateType* omx_parser3gp_component_Private;
DEBUG(DEB_LEV_FUNCTION_NAME,"In %s \n",__func__);
if (!openmaxStandComp->pComponentPrivate) {
openmaxStandComp->pComponentPrivate = calloc(1, sizeof(omx_parser3gp_component_PrivateType));
if(openmaxStandComp->pComponentPrivate == NULL) {
return OMX_ErrorInsufficientResources;
}
}
/*Assign size of the derived port class,so that proper memory for port class can be allocated*/
omx_parser3gp_component_Private = openmaxStandComp->pComponentPrivate;
omx_parser3gp_component_Private->ports = NULL;
err = omx_base_source_Constructor(openmaxStandComp, cComponentName);
omx_parser3gp_component_Private->sPortTypesParam[OMX_PortDomainVideo].nStartPortNumber = 0;
omx_parser3gp_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts = 1;
omx_parser3gp_component_Private->sPortTypesParam[OMX_PortDomainAudio].nStartPortNumber = 1;
omx_parser3gp_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts = 1;
omx_parser3gp_component_Private->sPortTypesParam[OMX_PortDomainOther].nStartPortNumber = 2;
omx_parser3gp_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts = 1;
/** Allocate Ports and call port constructor. */
if ((omx_parser3gp_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
omx_parser3gp_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts +
omx_parser3gp_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts ) && !omx_parser3gp_component_Private->ports) {
omx_parser3gp_component_Private->ports = calloc((omx_parser3gp_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts +
omx_parser3gp_component_Private->sPortTypesParam[OMX_PortDomainVideo].nPorts +
omx_parser3gp_component_Private->sPortTypesParam[OMX_PortDomainOther].nPorts ), sizeof(omx_base_PortType *));
if (!omx_parser3gp_component_Private->ports) {
return OMX_ErrorInsufficientResources;
}
/* allocate video port*/
omx_parser3gp_component_Private->ports[VIDEO_PORT_INDEX] = calloc(1, sizeof(omx_base_video_PortType));
if (!omx_parser3gp_component_Private->ports[VIDEO_PORT_INDEX])
return OMX_ErrorInsufficientResources;
/* allocate audio port*/
omx_parser3gp_component_Private->ports[AUDIO_PORT_INDEX] = calloc(1, sizeof(omx_base_audio_PortType));
if (!omx_parser3gp_component_Private->ports[AUDIO_PORT_INDEX])
return OMX_ErrorInsufficientResources;
/* allocate clock port*/
omx_parser3gp_component_Private->ports[CLOCK_PORT_INDEX] = calloc(1, sizeof(omx_base_clock_PortType));
if (!omx_parser3gp_component_Private->ports[CLOCK_PORT_INDEX])
return OMX_ErrorInsufficientResources;
}
base_video_port_Constructor(openmaxStandComp, &omx_parser3gp_component_Private->ports[VIDEO_PORT_INDEX], VIDEO_PORT_INDEX, OMX_FALSE);
base_audio_port_Constructor(openmaxStandComp, &omx_parser3gp_component_Private->ports[AUDIO_PORT_INDEX], AUDIO_PORT_INDEX, OMX_FALSE);
base_clock_port_Constructor(openmaxStandComp, &omx_parser3gp_component_Private->ports[CLOCK_PORT_INDEX], CLOCK_PORT_INDEX, OMX_TRUE);
omx_parser3gp_component_Private->ports[CLOCK_PORT_INDEX]->sPortParam.bEnabled = OMX_FALSE;
pPortV = (omx_base_video_PortType *) omx_parser3gp_component_Private->ports[VIDEO_PORT_INDEX];
pPortA = (omx_base_audio_PortType *) omx_parser3gp_component_Private->ports[AUDIO_PORT_INDEX];
/*Input pPort buffer size is equal to the size of the output buffer of the previous component*/
pPortV->sPortParam.nBufferSize = DEFAULT_OUT_BUFFER_SIZE;
pPortA->sPortParam.nBufferSize = DEFAULT_IN_BUFFER_SIZE;
omx_parser3gp_component_Private->BufferMgmtCallback = omx_parser3gp_component_BufferMgmtCallback;
omx_parser3gp_component_Private->BufferMgmtFunction = omx_base_source_twoport_BufferMgmtFunction;
setHeader(&omx_parser3gp_component_Private->sTimeStamp, sizeof(OMX_TIME_CONFIG_TIMESTAMPTYPE));
omx_parser3gp_component_Private->sTimeStamp.nPortIndex=0;
omx_parser3gp_component_Private->sTimeStamp.nTimestamp=0x0;
omx_parser3gp_component_Private->destructor = omx_parser3gp_component_Destructor;
omx_parser3gp_component_Private->messageHandler = omx_parser3gp_component_MessageHandler;
noParser3gpInstance++;
if(noParser3gpInstance > MAX_COMPONENT_PARSER_3GP) {
return OMX_ErrorInsufficientResources;
}
openmaxStandComp->SetParameter = omx_parser3gp_component_SetParameter;
openmaxStandComp->GetParameter = omx_parser3gp_component_GetParameter;
openmaxStandComp->SetConfig = omx_parser3gp_component_SetConfig;
openmaxStandComp->GetExtensionIndex = omx_parser3gp_component_GetExtensionIndex;
/* Write in the default paramenters */
omx_parser3gp_component_Private->pTmpOutputBuffer = calloc(1,sizeof(OMX_BUFFERHEADERTYPE));
omx_parser3gp_component_Private->pTmpOutputBuffer->pBuffer = calloc(1,DEFAULT_OUT_BUFFER_SIZE);
omx_parser3gp_component_Private->pTmpOutputBuffer->nFilledLen=0;
omx_parser3gp_component_Private->pTmpOutputBuffer->nAllocLen=DEFAULT_OUT_BUFFER_SIZE;
omx_parser3gp_component_Private->pTmpOutputBuffer->nOffset=0;
omx_parser3gp_component_Private->avformatReady = OMX_FALSE;
omx_parser3gp_component_Private->isFirstBufferAudio = OMX_TRUE;
omx_parser3gp_component_Private->isFirstBufferVideo = OMX_TRUE;
if(!omx_parser3gp_component_Private->avformatSyncSem) {
omx_parser3gp_component_Private->avformatSyncSem = calloc(1,sizeof(tsem_t));
if(omx_parser3gp_component_Private->avformatSyncSem == NULL) return OMX_ErrorInsufficientResources;
tsem_init(omx_parser3gp_component_Private->avformatSyncSem, 0);
}
omx_parser3gp_component_Private->sInputFileName = malloc(DEFAULT_FILENAME_LENGTH);
/*Default Coding type*/
omx_parser3gp_component_Private->video_coding_type = OMX_VIDEO_CodingAVC;
omx_parser3gp_component_Private->audio_coding_type = OMX_AUDIO_CodingMP3;
av_register_all(); /* without this file opening gives an error */
return err;
}
OMX_ERRORTYPE omx_flacdec_component_Constructor(OMX_COMPONENTTYPE *openmaxStandComp, OMX_STRING cComponentName)
{
OMX_ERRORTYPE err = OMX_ErrorNone;
omx_flacdec_component_PrivateType* omx_flacdec_component_Private;
omx_base_audio_PortType *inPort,*outPort;
OMX_U32 i;
#ifdef HAVE_ANDROID_OS
if (1)
#else
if (!openmaxStandComp->pComponentPrivate)
#endif
{
openmaxStandComp->pComponentPrivate = TCC_calloc(1, sizeof(omx_flacdec_component_PrivateType));
if(openmaxStandComp->pComponentPrivate==NULL)
{
return OMX_ErrorInsufficientResources;
}
}
else
{
DBUG_MSG("In %s, Error Component %x Already Allocated\n",
__func__, (int)openmaxStandComp->pComponentPrivate);
}
omx_flacdec_component_Private = openmaxStandComp->pComponentPrivate;
omx_flacdec_component_Private->ports = NULL;
/** we could create our own port structures here
* fixme maybe the base class could use a "port factory" function pointer?
*/
err = omx_base_filter_Constructor(openmaxStandComp, cComponentName);
DBUG_MSG("constructor of FLAC decoder component is called\n");
/* Domain specific section for the ports. */
/* first we set the parameter common to both formats */
/* parameters related to input port which does not depend upon input audio format */
/* Allocate Ports and call port constructor. */
omx_flacdec_component_Private->sPortTypesParam[OMX_PortDomainAudio].nStartPortNumber = 0;
omx_flacdec_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts = 2;
if (omx_flacdec_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts && !omx_flacdec_component_Private->ports)
{
omx_flacdec_component_Private->ports = TCC_calloc(omx_flacdec_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts, sizeof(omx_base_PortType *));
if (!omx_flacdec_component_Private->ports)
{
return OMX_ErrorInsufficientResources;
}
for (i=0; i < omx_flacdec_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts; i++)
{
omx_flacdec_component_Private->ports[i] = TCC_calloc(1, sizeof(omx_base_audio_PortType));
if (!omx_flacdec_component_Private->ports[i])
{
return OMX_ErrorInsufficientResources;
}
}
}
base_audio_port_Constructor(openmaxStandComp, &omx_flacdec_component_Private->ports[0], 0, OMX_TRUE); // input
base_audio_port_Constructor(openmaxStandComp, &omx_flacdec_component_Private->ports[1], 1, OMX_FALSE); // output
/** parameters related to input port */
inPort = (omx_base_audio_PortType *) omx_flacdec_component_Private->ports[OMX_BASE_FILTER_INPUTPORT_INDEX];
inPort->sPortParam.nBufferSize = DEFAULT_IN_BUFFER_SIZE*2;
strcpy(inPort->sPortParam.format.audio.cMIMEType, "audio/flac");
inPort->sPortParam.format.audio.eEncoding = OMX_AUDIO_CodingFLAC;
inPort->sAudioParam.eEncoding = OMX_AUDIO_CodingFLAC;
/** parameters related to output port */
outPort = (omx_base_audio_PortType *) omx_flacdec_component_Private->ports[OMX_BASE_FILTER_OUTPUTPORT_INDEX];
outPort->sPortParam.format.audio.eEncoding = OMX_AUDIO_CodingPCM;
outPort->sPortParam.nBufferSize = AUDIO_DEC_OUT_BUFFER_SIZE;
outPort->sAudioParam.eEncoding = OMX_AUDIO_CodingPCM;
//Default values for AAC audio param port
setHeader(&omx_flacdec_component_Private->pAudioFlac, sizeof(OMX_AUDIO_PARAM_FLACTYPE));
omx_flacdec_component_Private->pAudioFlac.nPortIndex = 0;
omx_flacdec_component_Private->pAudioFlac.nChannels = 2;
omx_flacdec_component_Private->pAudioFlac.nBitRate = 0;
omx_flacdec_component_Private->pAudioFlac.nSampleRate = 44100;
omx_flacdec_component_Private->pAudioFlac.eChannelMode = OMX_AUDIO_ChannelModeStereo;
/** settings of output port audio format - pcm */
setHeader(&omx_flacdec_component_Private->pAudioPcmMode, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
omx_flacdec_component_Private->pAudioPcmMode.nPortIndex = 1;
omx_flacdec_component_Private->pAudioPcmMode.nChannels = 2;
omx_flacdec_component_Private->pAudioPcmMode.eNumData = OMX_NumericalDataSigned;
omx_flacdec_component_Private->pAudioPcmMode.eEndian = OMX_EndianLittle;
omx_flacdec_component_Private->pAudioPcmMode.bInterleaved = OMX_TRUE;
omx_flacdec_component_Private->pAudioPcmMode.nBitPerSample = 16;
omx_flacdec_component_Private->pAudioPcmMode.nSamplingRate = 44100;
omx_flacdec_component_Private->pAudioPcmMode.ePCMMode = OMX_AUDIO_PCMModeLinear;
omx_flacdec_component_Private->pAudioPcmMode.eChannelMapping[0] = OMX_AUDIO_ChannelLF;
omx_flacdec_component_Private->pAudioPcmMode.eChannelMapping[1] = OMX_AUDIO_ChannelRF;
/** now it's time to know the audio coding type of the component */
if(!strcmp(cComponentName, AUDIO_DEC_FLAC_NAME))
{
omx_flacdec_component_Private->audio_coding_type = OMX_AUDIO_CodingFLAC;
}
else if (!strcmp(cComponentName, AUDIO_DEC_BASE_NAME))
{
omx_flacdec_component_Private->audio_coding_type = OMX_AUDIO_CodingUnused;
}
else
{
// IL client specified an invalid component name
LOGE("OMX_ErrorInvalidComponentName %s", cComponentName);
return OMX_ErrorInvalidComponentName;
}
/** general configuration irrespective of any audio formats */
/** setting values of other fields of omx_maddec_component_Private structure */
omx_flacdec_component_Private->BufferMgmtCallback = omx_audiodec_component_BufferMgmtCallback;
omx_flacdec_component_Private->messageHandler = omx_audiodec_component_MessageHandler;
omx_flacdec_component_Private->destructor = omx_audiodec_component_Destructor;
openmaxStandComp->SetParameter = omx_audiodec_component_SetParameter;
openmaxStandComp->GetParameter = omx_audiodec_component_GetParameter;
openmaxStandComp->GetExtensionIndex = omx_audiodec_component_GetExtensionIndex;
omx_flacdec_component_Private->decode_ready = OMX_FALSE;
memset(&omx_flacdec_component_Private->cdk_core, 0x00, sizeof(cdk_core_t));
memset(&omx_flacdec_component_Private->cdmx_info, 0x00, sizeof(cdmx_info_t));
memset(&omx_flacdec_component_Private->cdmx_out, 0x00, sizeof(cdmx_output_t));
omx_flacdec_component_Private->cdk_core.m_iAudioProcessMode = 2; /* decoded pcm mode */
omx_flacdec_component_Private->cdk_core.m_psCallback = &(omx_flacdec_component_Private->callback_func);
omx_flacdec_component_Private->cdk_core.m_psCallback->m_pfMalloc = (void* (*) ( unsigned int ))malloc;
omx_flacdec_component_Private->cdk_core.m_psCallback->m_pfRealloc = (void* (*) ( void*, unsigned int ))realloc;
omx_flacdec_component_Private->cdk_core.m_psCallback->m_pfFree = (void (*) ( void* ))free;
omx_flacdec_component_Private->cdk_core.m_psCallback->m_pfMemcpy = (void* (*) ( void*, const void*, unsigned int ))memcpy;
omx_flacdec_component_Private->cdk_core.m_psCallback->m_pfMemmove = (void* (*) ( void*, const void*, unsigned int ))memmove;
omx_flacdec_component_Private->cdk_core.m_psCallback->m_pfMemset = (void (*) ( void*, int, unsigned int ))memset;
omx_flacdec_component_Private->iAdecType = AUDIO_ID_FLAC;
omx_flacdec_component_Private->iCtype = CONTAINER_TYPE_AUDIO;
omx_flacdec_component_Private->cb_function = TCC_FLAC_DEC;
if (omx_flacdec_component_Private->pRest == NULL)
{
omx_flacdec_component_Private->pRest = (OMX_U8*)malloc(DEFAULT_OUT_BUFFER_SIZE);
}
DBUG_MSG("constructor of FLAC decoder component is completed ret = %d \n", err);
return err;
}
/** The Constructor
*/
OMX_ERRORTYPE omx_audioenc_component_Constructor(OMX_COMPONENTTYPE *openmaxStandComp,OMX_STRING cComponentName) {
OMX_ERRORTYPE err = OMX_ErrorNone;
omx_audioenc_component_PrivateType* omx_audioenc_component_Private;
OMX_U32 i;
if (!openmaxStandComp->pComponentPrivate) {
DEBUG(DEB_LEV_FUNCTION_NAME,"In %s, allocating component\n",__func__);
openmaxStandComp->pComponentPrivate = calloc(1, sizeof(omx_audioenc_component_PrivateType));
if(openmaxStandComp->pComponentPrivate==NULL)
return OMX_ErrorInsufficientResources;
}
else
DEBUG(DEB_LEV_FUNCTION_NAME,"In %s, Error Component %x Already Allocated\n",__func__, (int)openmaxStandComp->pComponentPrivate);
omx_audioenc_component_Private = openmaxStandComp->pComponentPrivate;
omx_audioenc_component_Private->ports = NULL;
/** Calling base filter constructor */
err = omx_base_filter_Constructor(openmaxStandComp,cComponentName);
omx_audioenc_component_Private->sPortTypesParam[OMX_PortDomainAudio].nStartPortNumber = 0;
omx_audioenc_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts = 2;
/** Allocate Ports and call port constructor. */
if (omx_audioenc_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts && !omx_audioenc_component_Private->ports) {
omx_audioenc_component_Private->ports = calloc(omx_audioenc_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts, sizeof(omx_base_PortType *));
if (!omx_audioenc_component_Private->ports) {
return OMX_ErrorInsufficientResources;
}
for (i=0; i < omx_audioenc_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts; i++) {
omx_audioenc_component_Private->ports[i] = calloc(1, sizeof(omx_base_audio_PortType));
if (!omx_audioenc_component_Private->ports[i]) {
return OMX_ErrorInsufficientResources;
}
}
}
base_audio_port_Constructor(openmaxStandComp, &omx_audioenc_component_Private->ports[0], 0, OMX_TRUE);
base_audio_port_Constructor(openmaxStandComp, &omx_audioenc_component_Private->ports[1], 1, OMX_FALSE);
/** Domain specific section for the ports. */
// first we set the parameter common to both formats
//common parameters related to input port
omx_audioenc_component_Private->ports[OMX_BASE_FILTER_INPUTPORT_INDEX]->sPortParam.nBufferSize = DEFAULT_OUT_BUFFER_SIZE;
//common parameters related to output port
omx_audioenc_component_Private->ports[OMX_BASE_FILTER_OUTPUTPORT_INDEX]->sPortParam.nBufferSize = DEFAULT_IN_BUFFER_SIZE;
// now it's time to know the audio coding type of the component
if(!strcmp(cComponentName, AUDIO_ENC_MP3_NAME)) // mp3 format encoder
omx_audioenc_component_Private->audio_coding_type = OMX_AUDIO_CodingMP3;
else if(!strcmp(cComponentName, AUDIO_ENC_AAC_NAME)) // AAC format encoder
omx_audioenc_component_Private->audio_coding_type = OMX_AUDIO_CodingAAC;
else if(!strcmp(cComponentName, AUDIO_ENC_G726_NAME)) // G726 format encoder
omx_audioenc_component_Private->audio_coding_type = OMX_AUDIO_CodingG726;
else if (!strcmp(cComponentName, AUDIO_ENC_BASE_NAME))// general audio encoder
omx_audioenc_component_Private->audio_coding_type = OMX_AUDIO_CodingUnused;
else // IL client specified an invalid component name
return OMX_ErrorInvalidComponentName;
omx_audioenc_component_SetInternalParameters(openmaxStandComp);
//settings of output port
//output is pcm mode for all encoders - so generalise it
setHeader(&omx_audioenc_component_Private->pAudioPcmMode,sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
omx_audioenc_component_Private->pAudioPcmMode.nPortIndex = 0;
omx_audioenc_component_Private->pAudioPcmMode.nChannels = 2;
omx_audioenc_component_Private->pAudioPcmMode.eNumData = OMX_NumericalDataSigned;
omx_audioenc_component_Private->pAudioPcmMode.eEndian = OMX_EndianLittle;
omx_audioenc_component_Private->pAudioPcmMode.bInterleaved = OMX_TRUE;
omx_audioenc_component_Private->pAudioPcmMode.nBitPerSample = 16;
omx_audioenc_component_Private->pAudioPcmMode.nSamplingRate = 44100;
omx_audioenc_component_Private->pAudioPcmMode.ePCMMode = OMX_AUDIO_PCMModeLinear;
omx_audioenc_component_Private->pAudioPcmMode.eChannelMapping[0] = OMX_AUDIO_ChannelLF;
omx_audioenc_component_Private->pAudioPcmMode.eChannelMapping[1] = OMX_AUDIO_ChannelRF;
//general configuration irrespective of any audio formats
//setting other parameters of omx_audioenc_component_private
omx_audioenc_component_Private->avCodec = NULL;
omx_audioenc_component_Private->avCodecContext= NULL;
omx_audioenc_component_Private->avcodecReady = OMX_FALSE;
omx_audioenc_component_Private->BufferMgmtCallback = omx_audioenc_component_BufferMgmtCallback;
/** first initializing the codec context etc that was done earlier by ffmpeglibinit function */
avcodec_init();
av_register_all();
omx_audioenc_component_Private->avCodecContext = avcodec_alloc_context();
omx_audioenc_component_Private->messageHandler = omx_audioenc_component_MessageHandler;
omx_audioenc_component_Private->destructor = omx_audioenc_component_Destructor;
openmaxStandComp->SetParameter = omx_audioenc_component_SetParameter;
openmaxStandComp->GetParameter = omx_audioenc_component_GetParameter;
openmaxStandComp->ComponentRoleEnum = omx_audioenc_component_ComponentRoleEnum;
noaudioencInstance++;
if(noaudioencInstance>MAX_COMPONENT_AUDIOENC)
return OMX_ErrorInsufficientResources;
return err;
}
OMX_ERRORTYPE omx_audio_capturer_component_Constructor(
OMX_COMPONENTTYPE *pComponent,
OMX_STRING cComponentName)
{
OMX_ERRORTYPE err = OMX_ErrorNone;
omx_audio_capturer_component_PrivateType* pPrivate;
omx_audio_capturer_component_PortType* pPort;
DEBUG(DEB_LEV_FUNCTION_NAME, "%s\n", __func__);
if(OMX_ErrorNone == err) {
if(NULL == pComponent->pComponentPrivate) {
pComponent->pComponentPrivate = calloc(1, sizeof(omx_audio_capturer_component_PrivateType));
if(pComponent->pComponentPrivate == NULL) {
return OMX_ErrorInsufficientResources;
}
} else {
DEBUG(DEB_LEV_FUNCTION_NAME, "In %s, Error Component %x Already Allocated\n", __func__, (int) pComponent->pComponentPrivate);
}
}
/** Calling base source constructor */
if(OMX_ErrorNone == err)
err = omx_base_source_Constructor(pComponent, cComponentName);
if(OMX_ErrorNone == err) {
pPrivate = pComponent->pComponentPrivate;
pPrivate->sPortTypesParam[OMX_PortDomainAudio].nPorts = NUM_PORTS;
/** Allocate Ports and call port constructor. */
pPrivate->ports = calloc(pPrivate->sPortTypesParam[OMX_PortDomainAudio].nPorts, sizeof(omx_base_PortType *));
if (NULL == pPrivate->ports)
return OMX_ErrorInsufficientResources;
pPrivate->ports[0] = calloc(1, sizeof(omx_audio_capturer_component_PortType));
if (NULL == pPrivate->ports[0])
return OMX_ErrorInsufficientResources;
/* construct output port */
base_audio_port_Constructor(pComponent, &pPrivate->ports[0], 0, OMX_FALSE);
/** Domain specific section for the ports. */
pPort = (omx_audio_capturer_component_PortType *) pPrivate->ports[0];
pPort->sPortParam.nBufferSize = DEFAULT_OUT_BUFFER_SIZE;
/* OMX_AUDIO_PARAM_PCMMODETYPE */
setHeader(&pPort->sPCMModeParam, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
pPort->sPCMModeParam.nPortIndex = 0;
pPort->sPCMModeParam.nChannels = 2;
pPort->sPCMModeParam.eNumData = OMX_NumericalDataSigned;
pPort->sPCMModeParam.eEndian = OMX_EndianLittle;
pPort->sPCMModeParam.bInterleaved = OMX_TRUE;
pPort->sPCMModeParam.nBitPerSample = 16;
pPort->sPCMModeParam.nSamplingRate = 8000;
pPort->sPCMModeParam.ePCMMode = OMX_AUDIO_PCMModeLinear;
pPort->sPCMModeParam.eChannelMapping[0] = OMX_AUDIO_ChannelNone;
pComponent->GetParameter = omx_audio_capturer_GetParameter;
pComponent->SetParameter = omx_audio_capturer_SetParameter;
pPrivate->BufferMgmtCallback = omx_audio_capturer_component_BufferMgmtCallback;
pPrivate->destructor = omx_audio_capturer_component_Destructor;
}
if((MAX_COMPONENT_INSTANCES > 0) &&
(nComponentInstances >= MAX_COMPONENT_INSTANCES)) {
return OMX_ErrorInsufficientResources;
} else nComponentInstances++;
return err;
}
OMX_ERRORTYPE omx_vorbisdec_component_Constructor( OMX_COMPONENTTYPE *openmaxStandComp, OMX_STRING cComponentName) {
OMX_ERRORTYPE err = OMX_ErrorNone;
omx_vorbisdec_component_PrivateType* omx_vorbisdec_component_Private;
omx_base_audio_PortType *inPort,*outPort;
OMX_U32 i;
if (!openmaxStandComp->pComponentPrivate) {
DEBUG(DEB_LEV_FUNCTION_NAME, "In %s, allocating component\n", __func__);
openmaxStandComp->pComponentPrivate = calloc(1, sizeof(omx_vorbisdec_component_PrivateType));
if(openmaxStandComp->pComponentPrivate == NULL) {
return OMX_ErrorInsufficientResources;
}
} else {
DEBUG(DEB_LEV_FUNCTION_NAME, "In %s, Error Component %x Already Allocated\n", __func__, (int)openmaxStandComp->pComponentPrivate);
}
omx_vorbisdec_component_Private = openmaxStandComp->pComponentPrivate;
omx_vorbisdec_component_Private->ports = NULL;
/** we could create our own port structures here
* fixme maybe the base class could use a "port factory" function pointer?
*/
err = omx_base_filter_Constructor(openmaxStandComp,cComponentName);
/** Domain specific section for the ports. */
/** first we set the parameter common to both formats
* common parameters related to input port
*/
omx_vorbisdec_component_Private->sPortTypesParam[OMX_PortDomainAudio].nStartPortNumber = 0;
omx_vorbisdec_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts = 2;
/** Allocate Ports and call port constructor. */
if (omx_vorbisdec_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts && !omx_vorbisdec_component_Private->ports) {
omx_vorbisdec_component_Private->ports = calloc(omx_vorbisdec_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts, sizeof(omx_base_PortType *));
if (!omx_vorbisdec_component_Private->ports) {
return OMX_ErrorInsufficientResources;
}
for (i=0; i < omx_vorbisdec_component_Private->sPortTypesParam[OMX_PortDomainAudio].nPorts; i++) {
omx_vorbisdec_component_Private->ports[i] = calloc(1, sizeof(omx_base_audio_PortType));
if (!omx_vorbisdec_component_Private->ports[i]) {
return OMX_ErrorInsufficientResources;
}
}
}
base_audio_port_Constructor(openmaxStandComp, &omx_vorbisdec_component_Private->ports[0], 0, OMX_TRUE);
base_audio_port_Constructor(openmaxStandComp, &omx_vorbisdec_component_Private->ports[1], 1, OMX_FALSE);
inPort = (omx_base_audio_PortType *) omx_vorbisdec_component_Private->ports[OMX_BASE_FILTER_INPUTPORT_INDEX];
inPort->sPortParam.nBufferSize = DEFAULT_IN_BUFFER_SIZE;
strcpy(inPort->sPortParam.format.audio.cMIMEType, "audio/vorbis");
inPort->sPortParam.format.audio.eEncoding = OMX_AUDIO_CodingVORBIS;
inPort->sAudioParam.eEncoding = OMX_AUDIO_CodingVORBIS;
setHeader(&omx_vorbisdec_component_Private->pAudioVorbis,sizeof(OMX_AUDIO_PARAM_VORBISTYPE));
omx_vorbisdec_component_Private->pAudioVorbis.nPortIndex = 0;
omx_vorbisdec_component_Private->pAudioVorbis.nChannels = 2;
omx_vorbisdec_component_Private->pAudioVorbis.nBitRate = 28000;
omx_vorbisdec_component_Private->pAudioVorbis.nSampleRate = 44100;
omx_vorbisdec_component_Private->pAudioVorbis.nAudioBandWidth = 0;
omx_vorbisdec_component_Private->pAudioVorbis.nQuality = 3;
/** common parameters related to output port */
outPort = (omx_base_audio_PortType *) omx_vorbisdec_component_Private->ports[OMX_BASE_FILTER_OUTPUTPORT_INDEX];
outPort->sPortParam.format.audio.eEncoding = OMX_AUDIO_CodingPCM;
outPort->sPortParam.nBufferSize = DEFAULT_OUT_BUFFER_SIZE;
outPort->sAudioParam.eEncoding = OMX_AUDIO_CodingPCM;
/** settings of output port
* output is pcm audo format - so set the pcm mode settings
*/
setHeader(&omx_vorbisdec_component_Private->pAudioPcmMode, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
omx_vorbisdec_component_Private->pAudioPcmMode.nPortIndex = 1;
omx_vorbisdec_component_Private->pAudioPcmMode.nChannels = 2;
omx_vorbisdec_component_Private->pAudioPcmMode.eNumData = OMX_NumericalDataSigned;
omx_vorbisdec_component_Private->pAudioPcmMode.eEndian = OMX_EndianLittle;
omx_vorbisdec_component_Private->pAudioPcmMode.bInterleaved = OMX_TRUE;
omx_vorbisdec_component_Private->pAudioPcmMode.nBitPerSample = 16;
omx_vorbisdec_component_Private->pAudioPcmMode.nSamplingRate = 44100;
omx_vorbisdec_component_Private->pAudioPcmMode.ePCMMode = OMX_AUDIO_PCMModeLinear;
omx_vorbisdec_component_Private->pAudioPcmMode.eChannelMapping[0] = OMX_AUDIO_ChannelLF;
omx_vorbisdec_component_Private->pAudioPcmMode.eChannelMapping[1] = OMX_AUDIO_ChannelRF;
/** some more component private structure initialization */
omx_vorbisdec_component_Private->BufferMgmtCallback = omx_vorbisdec_component_BufferMgmtCallbackVorbis;
omx_vorbisdec_component_Private->messageHandler = omx_vorbis_decoder_MessageHandler;
omx_vorbisdec_component_Private->destructor = omx_vorbisdec_component_Destructor;
openmaxStandComp->SetParameter = omx_vorbisdec_component_SetParameter;
openmaxStandComp->GetParameter = omx_vorbisdec_component_GetParameter;
/** increase the counter of initialized components and check against the maximum limit */
noVorbisDecInstance++;
/** now it's time to know the audio coding type of the component
* if audio coding type is set other than vorbis then error returned
*/
if(!strcmp(cComponentName, AUDIO_DEC_VORBIS_NAME)) {
omx_vorbisdec_component_Private->audio_coding_type = OMX_AUDIO_CodingVORBIS;
} else if (!strcmp(cComponentName, AUDIO_DEC_BASE_NAME)) {
omx_vorbisdec_component_Private->audio_coding_type = OMX_AUDIO_CodingUnused;
} else {
/** IL client specified an invalid component name */
return OMX_ErrorInvalidComponentName;
}
if(noVorbisDecInstance > MAX_COMPONENT_VORBISDEC) {
return OMX_ErrorInsufficientResources;
}
return err;
}
