OpenMAXBellagio: omx_volume_component.c Source File

00001 
00030 #include <omxcore.h>
00031 #include <omx_base_audio_port.h>
00032 #include <omx_volume_component.h>
00033 #include<OMX_Audio.h>
00034 
00035 /* gain value */
00036 #define GAIN_VALUE 100.0f
00037 
00038 /* Max allowable volume component instance */
00039 #define MAX_COMPONENT_VOLUME 1
00040 
00042 static OMX_U32 noVolumeCompInstance = 0;
00043 
00044 
00045 OMX_ERRORTYPE omx_volume_component_Constructor(OMX_COMPONENTTYPE *openmaxStandComp, OMX_STRING cComponentName) {
00046   OMX_ERRORTYPE err = OMX_ErrorNone;  
00047   omx_volume_component_PrivateType* omx_volume_component_Private;
00048   /* omx_base_audio_PortType *inPort, *outPort;*/
00049   OMX_U32 i;
00050 
00051   if (!openmaxStandComp->pComponentPrivate) {
00052     DEBUG(DEB_LEV_FUNCTION_NAME, "In %s, allocating component\n",__func__);
00053     openmaxStandComp->pComponentPrivate = calloc(1, sizeof(omx_volume_component_PrivateType));
00054     if(openmaxStandComp->pComponentPrivate == NULL) {
00055       return OMX_ErrorInsufficientResources;
00056     }
00057   } else {
00058     DEBUG(DEB_LEV_FUNCTION_NAME, "In %s, Error Component %x Already Allocated\n", __func__, (int)openmaxStandComp->pComponentPrivate);
00059   }
00060 
00061   omx_volume_component_Private = openmaxStandComp->pComponentPrivate;
00062   omx_volume_component_Private->ports = NULL;
00063   
00065   err = omx_base_filter_Constructor(openmaxStandComp, cComponentName);
00066 
00068   if (omx_volume_component_Private->sPortTypesParam.nPorts && !omx_volume_component_Private->ports) {
00069     omx_volume_component_Private->ports = calloc(omx_volume_component_Private->sPortTypesParam.nPorts, sizeof(omx_base_PortType *));
00070     if (!omx_volume_component_Private->ports) {
00071       return OMX_ErrorInsufficientResources;
00072     }
00073     for (i=0; i < omx_volume_component_Private->sPortTypesParam.nPorts; i++) {
00074       omx_volume_component_Private->ports[i] = calloc(1, sizeof(omx_base_audio_PortType));
00075       if (!omx_volume_component_Private->ports[i]) {
00076         return OMX_ErrorInsufficientResources;
00077       }
00078     }
00079   }
00080 
00081   base_audio_port_Constructor(openmaxStandComp, &omx_volume_component_Private->ports[0], 0, OMX_TRUE);
00082   base_audio_port_Constructor(openmaxStandComp, &omx_volume_component_Private->ports[1], 1, OMX_FALSE);
00083   
00085   omx_volume_component_Private->ports[OMX_BASE_FILTER_INPUTPORT_INDEX]->sPortParam.nBufferSize = DEFAULT_OUT_BUFFER_SIZE;
00086   omx_volume_component_Private->ports[OMX_BASE_FILTER_OUTPUTPORT_INDEX]->sPortParam.nBufferSize = DEFAULT_OUT_BUFFER_SIZE;
00087 
00088   /*
00089   inPort = (omx_base_audio_PortType *) omx_volume_component_Private->ports[OMX_BASE_FILTER_INPUTPORT_INDEX];
00090   outPort = (omx_base_audio_PortType *) omx_volume_component_Private->ports[OMX_BASE_FILTER_OUTPUTPORT_INDEX];
00091   */
00092 
00093   omx_volume_component_Private->gain = GAIN_VALUE; //100.0f; // default gain
00094   omx_volume_component_Private->destructor = omx_volume_component_Destructor;
00095   openmaxStandComp->SetParameter = omx_volume_component_SetParameter;
00096   openmaxStandComp->GetParameter = omx_volume_component_GetParameter;
00097   openmaxStandComp->GetConfig = omx_volume_component_GetConfig;
00098   openmaxStandComp->SetConfig = omx_volume_component_SetConfig;
00099   omx_volume_component_Private->BufferMgmtCallback = omx_volume_component_BufferMgmtCallback;
00100 
00101   noVolumeCompInstance++;
00102   if(noVolumeCompInstance > MAX_COMPONENT_VOLUME) {
00103     return OMX_ErrorInsufficientResources;
00104   }
00105 
00106   return err;
00107 }
00108 
00109 
00112 OMX_ERRORTYPE omx_volume_component_Destructor(OMX_COMPONENTTYPE *openmaxStandComp) {
00113 
00114   omx_volume_component_PrivateType* omx_volume_component_Private = openmaxStandComp->pComponentPrivate;
00115   OMX_U32 i;
00116 
00117   /* frees port/s */
00118   if (omx_volume_component_Private->ports) {
00119     for (i=0; i < omx_volume_component_Private->sPortTypesParam.nPorts; i++) {
00120       if(omx_volume_component_Private->ports[i])
00121         omx_volume_component_Private->ports[i]->PortDestructor(omx_volume_component_Private->ports[i]);
00122     }
00123     free(omx_volume_component_Private->ports);
00124     omx_volume_component_Private->ports=NULL;
00125   }
00126 
00127   DEBUG(DEB_LEV_FUNCTION_NAME, "Destructor of audiodecoder component is called\n");
00128   omx_base_filter_Destructor(openmaxStandComp);
00129   noVolumeCompInstance--;
00130 
00131   return OMX_ErrorNone;
00132 }
00133 
00136 void omx_volume_component_BufferMgmtCallback(OMX_COMPONENTTYPE *openmaxStandComp, OMX_BUFFERHEADERTYPE* pInputBuffer, OMX_BUFFERHEADERTYPE* pOutputBuffer) {
00137   int i;
00138   int sampleCount = pInputBuffer->nFilledLen / 2; // signed 16 bit samples assumed
00139   omx_volume_component_PrivateType* omx_volume_component_Private = openmaxStandComp->pComponentPrivate;
00140 
00141   if(omx_volume_component_Private->gain != GAIN_VALUE) {
00142     for (i = 0; i < sampleCount; i++) {
00143       ((OMX_S16*) pOutputBuffer->pBuffer)[i] = (OMX_S16)
00144               (((OMX_S16*) pInputBuffer->pBuffer)[i] * (omx_volume_component_Private->gain / 100.0f));
00145     }
00146   } else {
00147     memcpy(pOutputBuffer->pBuffer,pInputBuffer->pBuffer,pInputBuffer->nFilledLen);
00148   }
00149   pOutputBuffer->nFilledLen = pInputBuffer->nFilledLen;
00150   pInputBuffer->nFilledLen=0;
00151 }
00152 
00154 OMX_ERRORTYPE omx_volume_component_SetConfig(
00155   OMX_IN  OMX_HANDLETYPE hComponent,
00156   OMX_IN  OMX_INDEXTYPE nIndex,
00157   OMX_IN  OMX_PTR pComponentConfigStructure) {
00158 
00159   OMX_AUDIO_CONFIG_VOLUMETYPE* pVolume;
00160   OMX_COMPONENTTYPE *openmaxStandComp = (OMX_COMPONENTTYPE *)hComponent;
00161   omx_volume_component_PrivateType* omx_volume_component_Private = openmaxStandComp->pComponentPrivate;
00162   OMX_ERRORTYPE err = OMX_ErrorNone;
00163 
00164   switch (nIndex) {
00165     case OMX_IndexConfigAudioVolume : 
00166       pVolume = (OMX_AUDIO_CONFIG_VOLUMETYPE*) pComponentConfigStructure;
00167       if(pVolume->sVolume.nValue > 100) {
00168         err = OMX_ErrorBadParameter;
00169         break;
00170       }
00171       omx_volume_component_Private->gain = pVolume->sVolume.nValue;
00172       err = OMX_ErrorNone;
00173       break;
00174     default: // delegate to superclass
00175       err = omx_base_component_SetConfig(hComponent, nIndex, pComponentConfigStructure);
00176   }
00177 
00178   return err;
00179 }
00180 
00181 OMX_ERRORTYPE omx_volume_component_GetConfig(
00182   OMX_IN  OMX_HANDLETYPE hComponent,
00183   OMX_IN  OMX_INDEXTYPE nIndex,
00184   OMX_INOUT OMX_PTR pComponentConfigStructure) {
00185   OMX_AUDIO_CONFIG_VOLUMETYPE* pVolume;
00186   OMX_COMPONENTTYPE *openmaxStandComp = (OMX_COMPONENTTYPE *)hComponent;
00187   omx_volume_component_PrivateType* omx_volume_component_Private = openmaxStandComp->pComponentPrivate;
00188   OMX_ERRORTYPE err = OMX_ErrorNone;
00189 
00190   switch (nIndex) {
00191     case OMX_IndexConfigAudioVolume : 
00192       pVolume = (OMX_AUDIO_CONFIG_VOLUMETYPE*) pComponentConfigStructure;
00193       setHeader(pVolume,sizeof(OMX_AUDIO_CONFIG_VOLUMETYPE));
00194       pVolume->sVolume.nValue = omx_volume_component_Private->gain;
00195       pVolume->sVolume.nMin = 0;
00196       pVolume->sVolume.nMax = 100;
00197       pVolume->bLinear = OMX_TRUE;
00198       err = OMX_ErrorNone;
00199       break;
00200     default :
00201       err = omx_base_component_GetConfig(hComponent, nIndex, pComponentConfigStructure);
00202   }
00203   return err;
00204 }
00205 
00206 OMX_ERRORTYPE omx_volume_component_SetParameter(
00207   OMX_IN  OMX_HANDLETYPE hComponent,
00208   OMX_IN  OMX_INDEXTYPE nParamIndex,
00209   OMX_IN  OMX_PTR ComponentParameterStructure) {
00210 
00211   OMX_ERRORTYPE err = OMX_ErrorNone;
00212   OMX_AUDIO_PARAM_PORTFORMATTYPE *pAudioPortFormat;
00213   OMX_U32 portIndex;
00214   omx_base_audio_PortType *port;
00215 
00216   /* Check which structure we are being fed and make control its header */
00217   OMX_COMPONENTTYPE *openmaxStandComp = (OMX_COMPONENTTYPE *)hComponent;
00218   omx_volume_component_PrivateType* omx_volume_component_Private = openmaxStandComp->pComponentPrivate;
00219   if (ComponentParameterStructure == NULL) {
00220     return OMX_ErrorBadParameter;
00221   }
00222 
00223   DEBUG(DEB_LEV_SIMPLE_SEQ, "   Setting parameter %i\n", nParamIndex);
00224   switch(nParamIndex) {
00225     case OMX_IndexParamAudioPortFormat:
00226       pAudioPortFormat = (OMX_AUDIO_PARAM_PORTFORMATTYPE*)ComponentParameterStructure;
00227       portIndex = pAudioPortFormat->nPortIndex;
00228       err = omx_base_component_ParameterSanityCheck(hComponent, portIndex, pAudioPortFormat, sizeof(OMX_AUDIO_PARAM_PORTFORMATTYPE));
00229       if(err!=OMX_ErrorNone) { 
00230         DEBUG(DEB_LEV_ERR, "In %s Parameter Check Error=%x\n",__func__,err); 
00231         break;
00232       }
00233       if (portIndex <= 1) {
00234         port= (omx_base_audio_PortType *)omx_volume_component_Private->ports[portIndex];
00235         memcpy(&port->sAudioParam, pAudioPortFormat, sizeof(OMX_AUDIO_PARAM_PORTFORMATTYPE));
00236       } else {
00237         err = OMX_ErrorBadPortIndex;
00238       }
00239       break;  
00240     default:
00241       err = omx_base_component_SetParameter(hComponent, nParamIndex, ComponentParameterStructure);
00242   }
00243   return err;
00244 }
00245 
00246 OMX_ERRORTYPE omx_volume_component_GetParameter(
00247   OMX_IN  OMX_HANDLETYPE hComponent,
00248   OMX_IN  OMX_INDEXTYPE nParamIndex,
00249   OMX_INOUT OMX_PTR ComponentParameterStructure) {
00250 
00251   OMX_AUDIO_PARAM_PORTFORMATTYPE *pAudioPortFormat;  
00252   OMX_AUDIO_PARAM_PCMMODETYPE *pAudioPcmMode;
00253   OMX_ERRORTYPE err = OMX_ErrorNone;
00254   omx_base_audio_PortType *port;
00255   OMX_COMPONENTTYPE *openmaxStandComp = (OMX_COMPONENTTYPE *)hComponent;
00256   omx_volume_component_PrivateType* omx_volume_component_Private = openmaxStandComp->pComponentPrivate;
00257   if (ComponentParameterStructure == NULL) {
00258     return OMX_ErrorBadParameter;
00259   }
00260   DEBUG(DEB_LEV_SIMPLE_SEQ, "   Getting parameter %i\n", nParamIndex);
00261   /* Check which structure we are being fed and fill its header */
00262   switch(nParamIndex) {
00263     case OMX_IndexParamAudioInit:
00264       if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_PORT_PARAM_TYPE))) != OMX_ErrorNone) { 
00265         break;
00266       }
00267       memcpy(ComponentParameterStructure, &omx_volume_component_Private->sPortTypesParam, sizeof(OMX_PORT_PARAM_TYPE));
00268       break;    
00269     case OMX_IndexParamAudioPortFormat:
00270       pAudioPortFormat = (OMX_AUDIO_PARAM_PORTFORMATTYPE*)ComponentParameterStructure;
00271       if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_AUDIO_PARAM_PORTFORMATTYPE))) != OMX_ErrorNone) { 
00272         break;
00273       }
00274       if (pAudioPortFormat->nPortIndex <= 1) {
00275         port= (omx_base_audio_PortType *)omx_volume_component_Private->ports[pAudioPortFormat->nPortIndex];
00276         memcpy(pAudioPortFormat, &port->sAudioParam, sizeof(OMX_AUDIO_PARAM_PORTFORMATTYPE));
00277       } else {
00278         err = OMX_ErrorBadPortIndex;
00279       }
00280     break;    
00281     case OMX_IndexParamAudioPcm:
00282       pAudioPcmMode = (OMX_AUDIO_PARAM_PCMMODETYPE*)ComponentParameterStructure;
00283       if ((err = checkHeader(ComponentParameterStructure, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE))) != OMX_ErrorNone) { 
00284         break;
00285       }
00286 
00287       if (pAudioPcmMode->nPortIndex > 1) {
00288         return OMX_ErrorBadPortIndex;
00289       }
00290       pAudioPcmMode->nChannels = 2;
00291       pAudioPcmMode->eNumData = OMX_NumericalDataSigned;
00292       pAudioPcmMode->eEndian = OMX_EndianBig;
00293       pAudioPcmMode->bInterleaved = OMX_TRUE;
00294       pAudioPcmMode->nBitPerSample = 16;
00295       pAudioPcmMode->nSamplingRate = 0;
00296       pAudioPcmMode->ePCMMode = OMX_AUDIO_PCMModeLinear;
00297       break;
00298     default:
00299       err = omx_base_component_GetParameter(hComponent, nParamIndex, ComponentParameterStructure);
00300   }
00301   return err;
00302 }