openmax/component/audio/dec/mp3/Exynos_OMX_Mp3dec.c

   1 /*
   2  *
   3  * Copyright 2012 Samsung Electronics S.LSI Co. LTD
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 /*
  19  * @file      Exynos_OMX_Mp3dec.c
  20  * @brief
  21  * @author    Yunji Kim (yunji.kim@samsung.com)
  22  * @version   1.1.0
  23  * @history
  24  *   2012.02.28 : Create
  25  */
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30
  31 #include "Exynos_OMX_Macros.h"
  32 #include "Exynos_OMX_Basecomponent.h"
  33 #include "Exynos_OMX_Baseport.h"
  34 #include "Exynos_OMX_Adec.h"
  35 #include "Exynos_OSAL_ETC.h"
  36 #include "Exynos_OSAL_Semaphore.h"
  37 #include "Exynos_OSAL_Thread.h"
  38 #include "library_register.h"
  39 #include "Exynos_OMX_Mp3dec.h"
  40 #include "srp_api.h"
  41
  42 #undef  EXYNOS_LOG_TAG
  43 #define EXYNOS_LOG_TAG    "EXYNOS_MP3_DEC"
  44 #define EXYNOS_LOG_OFF
  45 #include "Exynos_OSAL_Log.h"
  46
  47 //#define SRP_DUMP_TO_FILE
  48 #ifdef SRP_DUMP_TO_FILE
  49 #include "stdio.h"
  50
  51 FILE *inFile;
  52 FILE *outFile;
  53 #endif
  54
  55 OMX_ERRORTYPE Exynos_SRP_Mp3Dec_GetParameter(
  56     OMX_IN    OMX_HANDLETYPE hComponent,
  57     OMX_IN    OMX_INDEXTYPE  nParamIndex,
  58     OMX_INOUT OMX_PTR        pComponentParameterStructure)
  59 {
  60     OMX_ERRORTYPE             ret = OMX_ErrorNone;
  61     OMX_COMPONENTTYPE        *pOMXComponent = NULL;
  62     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
  63
  64     FunctionIn();
  65
  66     if (hComponent == NULL || pComponentParameterStructure == NULL) {
  67         ret = OMX_ErrorBadParameter;
  68         goto EXIT;
  69     }
  70     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
  71     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
  72     if (ret != OMX_ErrorNone) {
  73         goto EXIT;
  74     }
  75     if (pOMXComponent->pComponentPrivate == NULL) {
  76         ret = OMX_ErrorBadParameter;
  77         goto EXIT;
  78     }
  79
  80     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
  81     if (pExynosComponent->currentState == OMX_StateInvalid ) {
  82         ret = OMX_ErrorInvalidState;
  83         goto EXIT;
  84     }
  85
  86     switch (nParamIndex) {
  87     case OMX_IndexParamAudioMp3:
  88     {
  89         OMX_AUDIO_PARAM_MP3TYPE *pDstMp3Param = (OMX_AUDIO_PARAM_MP3TYPE *)pComponentParameterStructure;
  90         OMX_AUDIO_PARAM_MP3TYPE *pSrcMp3Param = NULL;
  91         EXYNOS_MP3_HANDLE       *pMp3Dec = NULL;
  92
  93         ret = Exynos_OMX_Check_SizeVersion(pDstMp3Param, sizeof(OMX_AUDIO_PARAM_MP3TYPE));
  94         if (ret != OMX_ErrorNone) {
  95             goto EXIT;
  96         }
  97
  98         if (pDstMp3Param->nPortIndex >= ALL_PORT_NUM) {
  99             ret = OMX_ErrorBadPortIndex;
 100             goto EXIT;
 101         }
 102
 103         pMp3Dec = (EXYNOS_MP3_HANDLE *)((EXYNOS_OMX_AUDIODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
 104         pSrcMp3Param = &pMp3Dec->mp3Param;
 105
 106         Exynos_OSAL_Memcpy(pDstMp3Param, pSrcMp3Param, sizeof(OMX_AUDIO_PARAM_MP3TYPE));
 107     }
 108         break;
 109     case OMX_IndexParamAudioPcm:
 110     {
 111         OMX_AUDIO_PARAM_PCMMODETYPE *pDstPcmParam = (OMX_AUDIO_PARAM_PCMMODETYPE *)pComponentParameterStructure;
 112         OMX_AUDIO_PARAM_PCMMODETYPE *pSrcPcmParam = NULL;
 113         EXYNOS_MP3_HANDLE           *pMp3Dec = NULL;
 114
 115         ret = Exynos_OMX_Check_SizeVersion(pDstPcmParam, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
 116         if (ret != OMX_ErrorNone) {
 117             goto EXIT;
 118         }
 119
 120         if (pDstPcmParam->nPortIndex >= ALL_PORT_NUM) {
 121             ret = OMX_ErrorBadPortIndex;
 122             goto EXIT;
 123         }
 124
 125         pMp3Dec = (EXYNOS_MP3_HANDLE *)((EXYNOS_OMX_AUDIODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
 126         pSrcPcmParam = &pMp3Dec->pcmParam;
 127
 128         Exynos_OSAL_Memcpy(pDstPcmParam, pSrcPcmParam, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
 129     }
 130         break;
 131     case OMX_IndexParamStandardComponentRole:
 132     {
 133         OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE *)pComponentParameterStructure;
 134
 135         ret = Exynos_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
 136         if (ret != OMX_ErrorNone) {
 137             goto EXIT;
 138         }
 139
 140         Exynos_OSAL_Strcpy((char *)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_MP3_DEC_ROLE);
 141     }
 142         break;
 143     default:
 144         ret = Exynos_OMX_AudioDecodeGetParameter(hComponent, nParamIndex, pComponentParameterStructure);
 145         break;
 146     }
 147 EXIT:
 148     FunctionOut();
 149
 150     return ret;
 151 }
 152
 153 OMX_ERRORTYPE Exynos_SRP_Mp3Dec_SetParameter(
 154     OMX_IN OMX_HANDLETYPE hComponent,
 155     OMX_IN OMX_INDEXTYPE  nIndex,
 156     OMX_IN OMX_PTR        pComponentParameterStructure)
 157 {
 158     OMX_ERRORTYPE             ret = OMX_ErrorNone;
 159     OMX_COMPONENTTYPE        *pOMXComponent = NULL;
 160     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
 161
 162     FunctionIn();
 163
 164     if (hComponent == NULL || pComponentParameterStructure == NULL) {
 165         ret = OMX_ErrorBadParameter;
 166         goto EXIT;
 167     }
 168     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
 169     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
 170     if (ret != OMX_ErrorNone) {
 171         goto EXIT;
 172     }
 173     if (pOMXComponent->pComponentPrivate == NULL) {
 174         ret = OMX_ErrorBadParameter;
 175         goto EXIT;
 176     }
 177
 178     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 179     if (pExynosComponent->currentState == OMX_StateInvalid ) {
 180         ret = OMX_ErrorInvalidState;
 181         goto EXIT;
 182     }
 183
 184     switch (nIndex) {
 185     case OMX_IndexParamAudioMp3:
 186     {
 187         OMX_AUDIO_PARAM_MP3TYPE *pDstMp3Param = NULL;
 188         OMX_AUDIO_PARAM_MP3TYPE *pSrcMp3Param = (OMX_AUDIO_PARAM_MP3TYPE *)pComponentParameterStructure;
 189         EXYNOS_MP3_HANDLE       *pMp3Dec = NULL;
 190
 191         ret = Exynos_OMX_Check_SizeVersion(pSrcMp3Param, sizeof(OMX_AUDIO_PARAM_MP3TYPE));
 192         if (ret != OMX_ErrorNone) {
 193             goto EXIT;
 194         }
 195
 196         if (pSrcMp3Param->nPortIndex >= ALL_PORT_NUM) {
 197             ret = OMX_ErrorBadPortIndex;
 198             goto EXIT;
 199         }
 200
 201         pMp3Dec = (EXYNOS_MP3_HANDLE *)((EXYNOS_OMX_AUDIODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
 202         pDstMp3Param = &pMp3Dec->mp3Param;
 203
 204         Exynos_OSAL_Memcpy(pDstMp3Param, pSrcMp3Param, sizeof(OMX_AUDIO_PARAM_MP3TYPE));
 205     }
 206         break;
 207     case OMX_IndexParamAudioPcm:
 208     {
 209         OMX_AUDIO_PARAM_PCMMODETYPE *pDstPcmParam = NULL;
 210         OMX_AUDIO_PARAM_PCMMODETYPE *pSrcPcmParam = (OMX_AUDIO_PARAM_PCMMODETYPE *)pComponentParameterStructure;
 211         EXYNOS_MP3_HANDLE           *pMp3Dec = NULL;
 212
 213         ret = Exynos_OMX_Check_SizeVersion(pSrcPcmParam, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
 214         if (ret != OMX_ErrorNone) {
 215             goto EXIT;
 216         }
 217
 218         if (pSrcPcmParam->nPortIndex >= ALL_PORT_NUM) {
 219             ret = OMX_ErrorBadPortIndex;
 220             goto EXIT;
 221         }
 222
 223         pMp3Dec = (EXYNOS_MP3_HANDLE *)((EXYNOS_OMX_AUDIODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
 224         pDstPcmParam = &pMp3Dec->pcmParam;
 225
 226         Exynos_OSAL_Memcpy(pDstPcmParam, pSrcPcmParam, sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
 227     }
 228         break;
 229     case OMX_IndexParamStandardComponentRole:
 230     {
 231         OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE*)pComponentParameterStructure;
 232
 233         ret = Exynos_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
 234         if (ret != OMX_ErrorNone) {
 235             goto EXIT;
 236         }
 237
 238         if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
 239             ret = OMX_ErrorIncorrectStateOperation;
 240             goto EXIT;
 241         }
 242
 243         if (!Exynos_OSAL_Strcmp((char*)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_MP3_DEC_ROLE)) {
 244             pExynosComponent->pExynosPort[INPUT_PORT_INDEX].portDefinition.format.audio.eEncoding = OMX_AUDIO_CodingMP3;
 245         } else {
 246             ret = OMX_ErrorBadParameter;
 247             goto EXIT;
 248         }
 249     }
 250         break;
 251     default:
 252         ret = Exynos_OMX_AudioDecodeSetParameter(hComponent, nIndex, pComponentParameterStructure);
 253         break;
 254     }
 255 EXIT:
 256     FunctionOut();
 257
 258     return ret;
 259 }
 260
 261 OMX_ERRORTYPE Exynos_SRP_Mp3Dec_GetConfig(
 262     OMX_IN OMX_HANDLETYPE hComponent,
 263     OMX_IN OMX_INDEXTYPE  nIndex,
 264     OMX_IN OMX_PTR        pComponentConfigStructure)
 265 {
 266     OMX_ERRORTYPE             ret = OMX_ErrorNone;
 267     OMX_COMPONENTTYPE        *pOMXComponent = NULL;
 268     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
 269
 270     FunctionIn();
 271
 272     if (hComponent == NULL || pComponentConfigStructure == NULL) {
 273         ret = OMX_ErrorBadParameter;
 274         goto EXIT;
 275     }
 276     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
 277     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
 278     if (ret != OMX_ErrorNone) {
 279         goto EXIT;
 280     }
 281     if (pOMXComponent->pComponentPrivate == NULL) {
 282         ret = OMX_ErrorBadParameter;
 283         goto EXIT;
 284     }
 285
 286     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 287     if (pExynosComponent->currentState == OMX_StateInvalid) {
 288         ret = OMX_ErrorInvalidState;
 289         goto EXIT;
 290     }
 291
 292     switch (nIndex) {
 293     default:
 294         ret = Exynos_OMX_AudioDecodeGetConfig(hComponent, nIndex, pComponentConfigStructure);
 295         break;
 296     }
 297
 298 EXIT:
 299     FunctionOut();
 300
 301     return ret;
 302 }
 303
 304 OMX_ERRORTYPE Exynos_SRP_Mp3Dec_SetConfig(
 305     OMX_IN OMX_HANDLETYPE hComponent,
 306     OMX_IN OMX_INDEXTYPE  nIndex,
 307     OMX_IN OMX_PTR        pComponentConfigStructure)
 308 {
 309     OMX_ERRORTYPE             ret = OMX_ErrorNone;
 310     OMX_COMPONENTTYPE        *pOMXComponent = NULL;
 311     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
 312
 313     FunctionIn();
 314
 315     if (hComponent == NULL || pComponentConfigStructure == NULL) {
 316         ret = OMX_ErrorBadParameter;
 317         goto EXIT;
 318     }
 319     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
 320     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
 321     if (ret != OMX_ErrorNone) {
 322         goto EXIT;
 323     }
 324     if (pOMXComponent->pComponentPrivate == NULL) {
 325         ret = OMX_ErrorBadParameter;
 326         goto EXIT;
 327     }
 328
 329     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 330     if (pExynosComponent->currentState == OMX_StateInvalid) {
 331         ret = OMX_ErrorInvalidState;
 332         goto EXIT;
 333     }
 334
 335     switch (nIndex) {
 336     default:
 337         ret = Exynos_OMX_AudioDecodeSetConfig(hComponent, nIndex, pComponentConfigStructure);
 338         break;
 339     }
 340
 341 EXIT:
 342     FunctionOut();
 343
 344     return ret;
 345 }
 346
 347 OMX_ERRORTYPE Exynos_SRP_Mp3Dec_GetExtensionIndex(
 348     OMX_IN OMX_HANDLETYPE  hComponent,
 349     OMX_IN OMX_STRING      cParameterName,
 350     OMX_OUT OMX_INDEXTYPE *pIndexType)
 351 {
 352     OMX_ERRORTYPE             ret = OMX_ErrorNone;
 353     OMX_COMPONENTTYPE        *pOMXComponent = NULL;
 354     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
 355
 356     FunctionIn();
 357
 358     if (hComponent == NULL) {
 359         ret = OMX_ErrorBadParameter;
 360         goto EXIT;
 361     }
 362     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
 363     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
 364     if (ret != OMX_ErrorNone) {
 365         goto EXIT;
 366     }
 367
 368     if (pOMXComponent->pComponentPrivate == NULL) {
 369         ret = OMX_ErrorBadParameter;
 370         goto EXIT;
 371     }
 372     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 373
 374     if ((cParameterName == NULL) || (pIndexType == NULL)) {
 375         ret = OMX_ErrorBadParameter;
 376         goto EXIT;
 377     }
 378     if (pExynosComponent->currentState == OMX_StateInvalid) {
 379         ret = OMX_ErrorInvalidState;
 380         goto EXIT;
 381     }
 382
 383     ret = Exynos_OMX_AudioDecodeGetExtensionIndex(hComponent, cParameterName, pIndexType);
 384
 385 EXIT:
 386     FunctionOut();
 387
 388     return ret;
 389 }
 390
 391 OMX_ERRORTYPE Exynos_SRP_Mp3Dec_ComponentRoleEnum(
 392     OMX_IN  OMX_HANDLETYPE hComponent,
 393     OMX_OUT OMX_U8        *cRole,
 394     OMX_IN  OMX_U32        nIndex)
 395 {
 396     OMX_ERRORTYPE               ret = OMX_ErrorNone;
 397     OMX_COMPONENTTYPE          *pOMXComponent = NULL;
 398     EXYNOS_OMX_BASECOMPONENT   *pExynosComponent = NULL;
 399
 400     FunctionIn();
 401
 402     if ((hComponent == NULL) || (cRole == NULL)) {
 403         ret = OMX_ErrorBadParameter;
 404         goto EXIT;
 405     }
 406     if (nIndex != (MAX_COMPONENT_ROLE_NUM - 1)) {
 407         ret = OMX_ErrorNoMore;
 408         goto EXIT;
 409     }
 410     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
 411     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
 412     if (ret != OMX_ErrorNone) {
 413         goto EXIT;
 414     }
 415     if (pOMXComponent->pComponentPrivate == NULL) {
 416         ret = OMX_ErrorBadParameter;
 417         goto EXIT;
 418     }
 419
 420     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 421     if (pExynosComponent->currentState == OMX_StateInvalid ) {
 422         ret = OMX_ErrorInvalidState;
 423         goto EXIT;
 424     }
 425
 426     Exynos_OSAL_Strcpy((char *)cRole, EXYNOS_OMX_COMPONENT_MP3_DEC_ROLE);
 427
 428 EXIT:
 429     FunctionOut();
 430
 431     return ret;
 432 }
 433
 434 OMX_ERRORTYPE Exynos_SRP_Mp3Dec_Init(OMX_COMPONENTTYPE *pOMXComponent)
 435 {
 436     OMX_ERRORTYPE                  ret = OMX_ErrorNone;
 437     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 438     EXYNOS_OMX_AUDIODEC_COMPONENT *pAudioDec = (EXYNOS_OMX_AUDIODEC_COMPONENT *)pExynosComponent->hComponentHandle;
 439     EXYNOS_MP3_HANDLE             *pMp3Dec = (EXYNOS_MP3_HANDLE *)pAudioDec->hCodecHandle;
 440
 441     FunctionIn();
 442
 443     Exynos_OSAL_Memset(pExynosComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
 444     Exynos_OSAL_Memset(pExynosComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
 445     pExynosComponent->bUseFlagEOF = OMX_TRUE; /* Mp3 extractor should parse into frame unit. */
 446     pExynosComponent->bSaveFlagEOS = OMX_FALSE;
 447     pMp3Dec->hSRPMp3Handle.bConfiguredSRP = OMX_FALSE;
 448     pMp3Dec->hSRPMp3Handle.bSRPSendEOS = OMX_FALSE;
 449 #ifdef TIZEN_FEATURE_E3250
 450     pMp3Dec->nPendingflags = 0;
 451 #endif
 452     pExynosComponent->getAllDelayBuffer = OMX_FALSE;
 453
 454 #ifdef SRP_DUMP_TO_FILE
 455     inFile = fopen("/data/InFile.mp3", "w+");
 456     outFile = fopen("/data/OutFile.pcm", "w+");
 457 #endif
 458
 459     FunctionOut();
 460
 461     return ret;
 462 }
 463
 464 OMX_ERRORTYPE Exynos_SRP_Mp3Dec_Terminate(OMX_COMPONENTTYPE *pOMXComponent)
 465 {
 466     OMX_ERRORTYPE                  ret = OMX_ErrorNone;
 467
 468     FunctionIn();
 469
 470 #ifdef SRP_DUMP_TO_FILE
 471     fclose(inFile);
 472     fclose(outFile);
 473 #endif
 474
 475     FunctionOut();
 476
 477     return ret;
 478 }
 479
 480 OMX_ERRORTYPE Exynos_SRP_Mp3_Decode_Block(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pInputData, EXYNOS_OMX_DATA *pOutputData)
 481 {
 482     OMX_ERRORTYPE                  ret = OMX_ErrorNone;
 483     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 484     EXYNOS_OMX_AUDIODEC_COMPONENT *pAudioDec = (EXYNOS_OMX_AUDIODEC_COMPONENT *)pExynosComponent->hComponentHandle;
 485     EXYNOS_MP3_HANDLE             *pMp3Dec = (EXYNOS_MP3_HANDLE *)pAudioDec->hCodecHandle;
 486     struct srp_dec_info            codecDecInfo;
 487     OMX_S32                        returnCodec = 0;
 488     unsigned long                  isSRPStopped = 0;
 489     OMX_PTR                        dataBuffer = NULL;
 490     unsigned int                   dataLen = 0;
 491     OMX_BOOL                       isSRPIbufOverflow = OMX_FALSE;
 492     char        dummy[2]={0xFF, 0xFF};
 493
 494     FunctionIn();
 495
 496 #ifdef SRP_DUMP_TO_FILE
 497     if (pExynosComponent->reInputData == OMX_FALSE) {
 498         fwrite(pInputData->buffer.singlePlaneBuffer.dataBuffer, pInputData->dataLen, 1, inFile);
 499     }
 500 #endif
 501
 502     /* Save timestamp and flags of input data */
 503 #ifndef TIZEN_FEATURE_E3250
 504     pOutputData->timeStamp = pInputData->timeStamp;
 505 #else
 506     if (pExynosComponent->checkTimeStamp.startTimeStamp == pInputData->timeStamp) {
 507         pMp3Dec->timeStamp = pInputData->timeStamp;
 508     }
 509 #endif
 510     pOutputData->nFlags = pInputData->nFlags & (~OMX_BUFFERFLAG_EOS);
 511
 512     /* Decoding mp3 frames by SRP */
 513     if (pExynosComponent->getAllDelayBuffer == OMX_FALSE) {
 514        if (pInputData->dataLen == 0)
 515             returnCodec = SRP_Decode(dummy, sizeof(dummy));
 516        else
 517             returnCodec = SRP_Decode(pInputData->buffer.singlePlaneBuffer.dataBuffer, pInputData->dataLen);
 518
 519         if (returnCodec >= 0) {
 520             if (pInputData->nFlags & OMX_BUFFERFLAG_EOS) {
 521                 SRP_Send_EOS();
 522                 pMp3Dec->hSRPMp3Handle.bSRPSendEOS = OMX_TRUE;
 523             }
 524         } else if (returnCodec == SRP_ERROR_IBUF_OVERFLOW) {
 525             isSRPIbufOverflow = OMX_TRUE;
 526             ret = OMX_ErrorInputDataDecodeYet;
 527         }
 528     }
 529
 530     if (pMp3Dec->hSRPMp3Handle.bConfiguredSRP == OMX_FALSE) {
 531         if ((pInputData->dataLen <= 0) && (pInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
 532             pOutputData->nFlags |= OMX_BUFFERFLAG_EOS;
 533             pMp3Dec->hSRPMp3Handle.bSRPSendEOS = OMX_FALSE;
 534             ret = OMX_ErrorNone;
 535             goto EXIT;
 536         }
 537
 538         returnCodec = SRP_Get_Dec_Info(&codecDecInfo);
 539         if (returnCodec < 0) {
 540             Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "SRP_Get_Dec_Info failed: %d", returnCodec);
 541             ret = OMX_ErrorHardware;
 542             goto EXIT;
 543         }
 544
 545         if (!codecDecInfo.sample_rate || !codecDecInfo.channels) {
 546             if (pMp3Dec->hSRPMp3Handle.bSRPSendEOS == OMX_TRUE) {
 547                 pOutputData->dataLen = 0;
 548                 pExynosComponent->getAllDelayBuffer = OMX_TRUE;
 549                 ret = OMX_ErrorInputDataDecodeYet;
 550             } else {
 551                 pExynosComponent->getAllDelayBuffer = OMX_FALSE;
 552                 if (isSRPIbufOverflow)
 553                     ret = OMX_ErrorInputDataDecodeYet;
 554                 else
 555                     ret = OMX_ErrorNone;
 556             }
 557             goto EXIT;
 558         }
 559
 560         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "numChannels(%d), samplingRate(%d)",
 561             codecDecInfo.channels, codecDecInfo.sample_rate);
 562
 563         if (pMp3Dec->pcmParam.nChannels != codecDecInfo.channels ||
 564             pMp3Dec->pcmParam.nSamplingRate != codecDecInfo.sample_rate) {
 565             /* Change channel count and sampling rate information */
 566             pMp3Dec->pcmParam.nChannels = codecDecInfo.channels;
 567             pMp3Dec->pcmParam.nSamplingRate = codecDecInfo.sample_rate;
 568
 569             /* Send Port Settings changed call back */
 570             (*(pExynosComponent->pCallbacks->EventHandler))
 571                   (pOMXComponent,
 572                    pExynosComponent->callbackData,
 573                    OMX_EventPortSettingsChanged, /* The command was completed */
 574                    OMX_DirOutput, /* This is the port index */
 575                    0,
 576                    NULL);
 577         }
 578
 579         pMp3Dec->hSRPMp3Handle.bConfiguredSRP = OMX_TRUE;
 580
 581         if (pMp3Dec->hSRPMp3Handle.bSRPSendEOS == OMX_TRUE) {
 582             pOutputData->dataLen = 0;
 583             pExynosComponent->getAllDelayBuffer = OMX_TRUE;
 584             ret = OMX_ErrorInputDataDecodeYet;
 585         } else {
 586             pExynosComponent->getAllDelayBuffer = OMX_FALSE;
 587             if (isSRPIbufOverflow)
 588                 ret = OMX_ErrorInputDataDecodeYet;
 589             else
 590                 ret = OMX_ErrorNone;
 591         }
 592         goto EXIT;
 593     }
 594
 595     /* Get decoded data from SRP */
 596     returnCodec = SRP_Get_PCM(&dataBuffer, &dataLen);
 597     if (dataLen > 0) {
 598         pOutputData->dataLen = dataLen;
 599         Exynos_OSAL_Memcpy(pOutputData->buffer.singlePlaneBuffer.dataBuffer, dataBuffer, dataLen);
 600 #ifdef TIZEN_FEATURE_E3250
 601         pOutputData->timeStamp = pMp3Dec->timeStamp;
 602         pMp3Dec->timeStamp += 1000000 * (OMX_TICKS)dataLen / (pMp3Dec->pcmParam.nSamplingRate * pMp3Dec->pcmParam.nChannels * pMp3Dec->pcmParam.nBitPerSample / 8);
 603         pOutputData->nFlags |= pMp3Dec->nPendingflags;
 604         pMp3Dec->nPendingflags = 0;
 605 #endif
 606     } else {
 607         pOutputData->dataLen = 0;
 608 #ifdef TIZEN_FEATURE_E3250
 609         pMp3Dec->nPendingflags = pOutputData->nFlags;
 610 #endif
 611     }
 612
 613 #ifdef SRP_DUMP_TO_FILE
 614     if (pOutputData->dataLen > 0)
 615         fwrite(pOutputData->buffer.singlePlaneBuffer.dataBuffer, pOutputData->dataLen, 1, outFile);
 616 #endif
 617
 618     /* Delay EOS signal until all the PCM is returned from the SRP driver. */
 619     if (pMp3Dec->hSRPMp3Handle.bSRPSendEOS == OMX_TRUE) {
 620         if (pInputData->nFlags & OMX_BUFFERFLAG_EOS) {
 621             returnCodec = SRP_GetParams(SRP_STOP_EOS_STATE, &isSRPStopped);
 622             if (returnCodec != 0)
 623                 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Fail SRP_STOP_EOS_STATE");
 624             if (isSRPStopped == 1) {
 625                 pOutputData->nFlags |= OMX_BUFFERFLAG_EOS;
 626                 pExynosComponent->getAllDelayBuffer = OMX_FALSE;
 627 #ifdef TIZEN_FEATURE_E3250
 628                 pOutputData->timeStamp = pInputData->timeStamp; /*For ALP EOS Timestamp*/
 629 #endif
 630                 pMp3Dec->hSRPMp3Handle.bSRPSendEOS = OMX_FALSE; /* for repeating one song */
 631                 ret = OMX_ErrorNone;
 632             } else {
 633                 pExynosComponent->getAllDelayBuffer = OMX_TRUE;
 634                 ret = OMX_ErrorInputDataDecodeYet;
 635             }
 636         } else { /* Flush after EOS */
 637             pMp3Dec->hSRPMp3Handle.bSRPSendEOS = OMX_FALSE;
 638         }
 639     }
 640 EXIT:
 641     FunctionOut();
 642
 643     return ret;
 644 }
 645
 646 OMX_ERRORTYPE Exynos_SRP_Mp3Dec_bufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pInputData, EXYNOS_OMX_DATA *pOutputData)
 647 {
 648     OMX_ERRORTYPE             ret = OMX_ErrorNone;
 649     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 650     EXYNOS_OMX_BASEPORT      *pInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
 651     EXYNOS_OMX_BASEPORT      *pOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
 652
 653     FunctionIn();
 654
 655     if ((!CHECK_PORT_ENABLED(pInputPort)) || (!CHECK_PORT_ENABLED(pOutputPort)) ||
 656             (!CHECK_PORT_POPULATED(pInputPort)) || (!CHECK_PORT_POPULATED(pOutputPort))) {
 657         if (pInputData->nFlags & OMX_BUFFERFLAG_EOS)
 658             ret = OMX_ErrorInputDataDecodeYet;
 659         else
 660             ret = OMX_ErrorNone;
 661
 662         goto EXIT;
 663     }
 664     if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent)) {
 665         if (pInputData->nFlags & OMX_BUFFERFLAG_EOS)
 666             ret = OMX_ErrorInputDataDecodeYet;
 667         else
 668             ret = OMX_ErrorNone;
 669
 670         goto EXIT;
 671     }
 672
 673     ret = Exynos_SRP_Mp3_Decode_Block(pOMXComponent, pInputData, pOutputData);
 674
 675     if (ret != OMX_ErrorNone) {
 676         if (ret == (OMX_ERRORTYPE)OMX_ErrorInputDataDecodeYet) {
 677             pOutputData->usedDataLen = 0;
 678             pOutputData->remainDataLen = pOutputData->dataLen;
 679         } else {
 680             pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
 681                                                     pExynosComponent->callbackData,
 682                                                     OMX_EventError, ret, 0, NULL);
 683         }
 684     } else {
 685         pInputData->usedDataLen += pInputData->dataLen;
 686         pInputData->remainDataLen = pInputData->dataLen - pInputData->usedDataLen;
 687         pInputData->dataLen -= pInputData->usedDataLen;
 688         pInputData->usedDataLen = 0;
 689
 690         pOutputData->usedDataLen = 0;
 691         pOutputData->remainDataLen = pOutputData->dataLen;
 692     }
 693
 694 EXIT:
 695     FunctionOut();
 696
 697     return ret;
 698 }
 699
 700 OSCL_EXPORT_REF OMX_ERRORTYPE Exynos_OMX_ComponentInit(OMX_HANDLETYPE hComponent, OMX_STRING componentName)
 701 {
 702     OMX_ERRORTYPE                  ret = OMX_ErrorNone;
 703     OMX_COMPONENTTYPE             *pOMXComponent = NULL;
 704     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = NULL;
 705     EXYNOS_OMX_BASEPORT           *pExynosPort = NULL;
 706     EXYNOS_OMX_AUDIODEC_COMPONENT *pAudioDec = NULL;
 707     EXYNOS_MP3_HANDLE             *pMp3Dec = NULL;
 708     OMX_PTR                        pInputBuffer = NULL;
 709     OMX_PTR                        pOutputBuffer = NULL;
 710     unsigned int                   inputBufferSize = 0;
 711     unsigned int                   inputBufferNum = 0;
 712     unsigned int                   outputBufferSize = 0;
 713     unsigned int                   outputBufferNum = 0;
 714     OMX_S32                        returnCodec;
 715
 716     FunctionIn();
 717
 718     if ((hComponent == NULL) || (componentName == NULL)) {
 719         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: parameters are null, ret: %X", __FUNCTION__, ret);
 720         ret = OMX_ErrorBadParameter;
 721         goto EXIT;
 722     }
 723     if (Exynos_OSAL_Strcmp(EXYNOS_OMX_COMPONENT_MP3_DEC, componentName) != 0) {
 724         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: componentName(%s) error, ret: %X", __FUNCTION__, componentName, ret);
 725         ret = OMX_ErrorBadParameter;
 726         goto EXIT;
 727     }
 728
 729     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
 730     ret = Exynos_OMX_AudioDecodeComponentInit(pOMXComponent);
 731     if (ret != OMX_ErrorNone) {
 732         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: Exynos_OMX_AudioDecodeComponentInit error, ret: %X", __FUNCTION__, ret);
 733         goto EXIT;
 734     }
 735     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 736     pExynosComponent->codecType = HW_AUDIO_DEC_CODEC;
 737
 738     pExynosComponent->componentName = (OMX_STRING)Exynos_OSAL_Malloc(MAX_OMX_COMPONENT_NAME_SIZE);
 739     if (pExynosComponent->componentName == NULL) {
 740         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: componentName alloc error, ret: %X", __FUNCTION__, ret);
 741         ret = OMX_ErrorInsufficientResources;
 742         goto EXIT_ERROR_1;
 743     }
 744     Exynos_OSAL_Memset(pExynosComponent->componentName, 0, MAX_OMX_COMPONENT_NAME_SIZE);
 745     Exynos_OSAL_Strcpy(pExynosComponent->componentName, EXYNOS_OMX_COMPONENT_MP3_DEC);
 746
 747     pMp3Dec = Exynos_OSAL_Malloc(sizeof(EXYNOS_MP3_HANDLE));
 748     if (pMp3Dec == NULL) {
 749         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: EXYNOS_MP3_HANDLE alloc error, ret: %X", __FUNCTION__, ret);
 750         ret = OMX_ErrorInsufficientResources;
 751         goto EXIT_ERROR_2;
 752     }
 753     Exynos_OSAL_Memset(pMp3Dec, 0, sizeof(EXYNOS_MP3_HANDLE));
 754     pAudioDec = (EXYNOS_OMX_AUDIODEC_COMPONENT *)pExynosComponent->hComponentHandle;
 755     pAudioDec->hCodecHandle = (OMX_HANDLETYPE)pMp3Dec;
 756
 757     /* Create and Init SRP */
 758     pMp3Dec->hSRPMp3Handle.bSRPLoaded = OMX_FALSE;
 759     returnCodec = SRP_Create(SRP_INIT_BLOCK_MODE);
 760     if (returnCodec < 0) {
 761         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "SRP_Create failed: %d", returnCodec);
 762         ret = OMX_ErrorHardware;
 763         goto EXIT_ERROR_3;
 764     }
 765     pMp3Dec->hSRPMp3Handle.hSRPHandle = (OMX_HANDLETYPE)returnCodec; /* SRP's fd */
 766     returnCodec = SRP_Init();
 767     if (returnCodec < 0) {
 768         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "SRP_Init failed: %d", returnCodec);
 769         ret = OMX_ErrorHardware;
 770         goto EXIT_ERROR_4;
 771     }
 772     pMp3Dec->hSRPMp3Handle.bSRPLoaded = OMX_TRUE;
 773
 774     /* Get input buffer info from SRP */
 775     returnCodec = SRP_Get_Ibuf_Info(&pInputBuffer, &inputBufferSize, &inputBufferNum);
 776     if (returnCodec < 0) {
 777         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "SRP_Get_Ibuf_Info failed: %d", returnCodec);
 778         ret = OMX_ErrorHardware;
 779         goto EXIT_ERROR_5;
 780     }
 781
 782     pExynosPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
 783     pExynosPort->processData.allocSize = inputBufferSize;
 784     pExynosPort->processData.buffer.singlePlaneBuffer.dataBuffer = Exynos_OSAL_Malloc(inputBufferSize);
 785     if (pExynosPort->processData.buffer.singlePlaneBuffer.dataBuffer == NULL) {
 786         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Input data buffer alloc failed");
 787         ret = OMX_ErrorInsufficientResources;
 788         goto EXIT_ERROR_5;
 789     }
 790
 791     /* Get output buffer info from SRP */
 792     returnCodec = SRP_Get_Obuf_Info(&pOutputBuffer, &outputBufferSize, &outputBufferNum);
 793     if (returnCodec < 0) {
 794         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "SRP_Get_Obuf_Info failed: %d", returnCodec);
 795         ret = OMX_ErrorHardware;
 796         goto EXIT_ERROR_6;
 797     }
 798
 799     /* Set componentVersion */
 800     pExynosComponent->componentVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
 801     pExynosComponent->componentVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
 802     pExynosComponent->componentVersion.s.nRevision     = REVISION_NUMBER;
 803     pExynosComponent->componentVersion.s.nStep         = STEP_NUMBER;
 804
 805     /* Set specVersion */
 806     pExynosComponent->specVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
 807     pExynosComponent->specVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
 808     pExynosComponent->specVersion.s.nRevision     = REVISION_NUMBER;
 809     pExynosComponent->specVersion.s.nStep         = STEP_NUMBER;
 810
 811     /* Input port */
 812     pExynosPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
 813     pExynosPort->portDefinition.nBufferCountActual = inputBufferNum;
 814     pExynosPort->portDefinition.nBufferCountMin = inputBufferNum;
 815     pExynosPort->portDefinition.nBufferSize = inputBufferSize;
 816     pExynosPort->portDefinition.bEnabled = OMX_TRUE;
 817     Exynos_OSAL_Memset(pExynosPort->portDefinition.format.audio.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
 818     Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.audio.cMIMEType, "audio/mpeg");
 819     pExynosPort->portDefinition.format.audio.pNativeRender = 0;
 820     pExynosPort->portDefinition.format.audio.bFlagErrorConcealment = OMX_FALSE;
 821     pExynosPort->portDefinition.format.audio.eEncoding = OMX_AUDIO_CodingMP3;
 822     pExynosPort->portWayType = WAY1_PORT;
 823
 824     /* Output port */
 825     pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
 826     pExynosPort->portDefinition.nBufferCountActual = outputBufferNum;
 827     pExynosPort->portDefinition.nBufferCountMin = outputBufferNum;
 828     pExynosPort->portDefinition.nBufferSize = outputBufferSize;
 829     pExynosPort->portDefinition.bEnabled = OMX_TRUE;
 830     Exynos_OSAL_Memset(pExynosPort->portDefinition.format.audio.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
 831     Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.audio.cMIMEType, "audio/raw");
 832     pExynosPort->portDefinition.format.audio.pNativeRender = 0;
 833     pExynosPort->portDefinition.format.audio.bFlagErrorConcealment = OMX_FALSE;
 834     pExynosPort->portDefinition.format.audio.eEncoding = OMX_AUDIO_CodingPCM;
 835     pExynosPort->portWayType = WAY1_PORT;
 836
 837     /* Default values for Mp3 audio param */
 838     INIT_SET_SIZE_VERSION(&pMp3Dec->mp3Param, OMX_AUDIO_PARAM_MP3TYPE);
 839     pMp3Dec->mp3Param.nPortIndex      = INPUT_PORT_INDEX;
 840     pMp3Dec->mp3Param.nChannels       = DEFAULT_AUDIO_CHANNELS_NUM;
 841     pMp3Dec->mp3Param.nBitRate        = 0;
 842     pMp3Dec->mp3Param.nSampleRate     = DEFAULT_AUDIO_SAMPLING_FREQ;
 843     pMp3Dec->mp3Param.nAudioBandWidth = 0;
 844     pMp3Dec->mp3Param.eChannelMode    = OMX_AUDIO_ChannelModeStereo;
 845     pMp3Dec->mp3Param.eFormat         = OMX_AUDIO_MP3StreamFormatMP1Layer3;
 846
 847     /* Default values for PCM audio param */
 848     INIT_SET_SIZE_VERSION(&pMp3Dec->pcmParam, OMX_AUDIO_PARAM_PCMMODETYPE);
 849     pMp3Dec->pcmParam.nPortIndex         = OUTPUT_PORT_INDEX;
 850     pMp3Dec->pcmParam.nChannels          = DEFAULT_AUDIO_CHANNELS_NUM;
 851     pMp3Dec->pcmParam.eNumData           = OMX_NumericalDataSigned;
 852     pMp3Dec->pcmParam.eEndian            = OMX_EndianLittle;
 853     pMp3Dec->pcmParam.bInterleaved       = OMX_TRUE;
 854     pMp3Dec->pcmParam.nBitPerSample      = DEFAULT_AUDIO_BIT_PER_SAMPLE;
 855     pMp3Dec->pcmParam.nSamplingRate      = DEFAULT_AUDIO_SAMPLING_FREQ;
 856     pMp3Dec->pcmParam.ePCMMode           = OMX_AUDIO_PCMModeLinear;
 857     pMp3Dec->pcmParam.eChannelMapping[0] = OMX_AUDIO_ChannelLF;
 858     pMp3Dec->pcmParam.eChannelMapping[1] = OMX_AUDIO_ChannelRF;
 859
 860     pOMXComponent->GetParameter      = &Exynos_SRP_Mp3Dec_GetParameter;
 861     pOMXComponent->SetParameter      = &Exynos_SRP_Mp3Dec_SetParameter;
 862     pOMXComponent->GetConfig         = &Exynos_SRP_Mp3Dec_GetConfig;
 863     pOMXComponent->SetConfig         = &Exynos_SRP_Mp3Dec_SetConfig;
 864     pOMXComponent->GetExtensionIndex = &Exynos_SRP_Mp3Dec_GetExtensionIndex;
 865     pOMXComponent->ComponentRoleEnum = &Exynos_SRP_Mp3Dec_ComponentRoleEnum;
 866     pOMXComponent->ComponentDeInit   = &Exynos_OMX_ComponentDeinit;
 867
 868     /* ToDo: Change the function name associated with a specific codec */
 869     pExynosComponent->exynos_codec_componentInit      = &Exynos_SRP_Mp3Dec_Init;
 870     pExynosComponent->exynos_codec_componentTerminate = &Exynos_SRP_Mp3Dec_Terminate;
 871     pAudioDec->exynos_codec_bufferProcess = &Exynos_SRP_Mp3Dec_bufferProcess;
 872     pAudioDec->exynos_checkInputFrame = NULL;
 873
 874     pExynosComponent->currentState = OMX_StateLoaded;
 875
 876     ret = OMX_ErrorNone;
 877     goto EXIT; /* This function is performed successfully. */
 878
 879 EXIT_ERROR_6:
 880     pExynosPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
 881     Exynos_OSAL_Free(pExynosPort->processData.buffer.singlePlaneBuffer.dataBuffer);
 882     pExynosPort->processData.buffer.singlePlaneBuffer.dataBuffer = NULL;
 883     pExynosPort->processData.allocSize = 0;
 884 EXIT_ERROR_5:
 885     SRP_Deinit();
 886 EXIT_ERROR_4:
 887     SRP_Terminate();
 888 EXIT_ERROR_3:
 889     Exynos_OSAL_Free(pMp3Dec);
 890     pAudioDec->hCodecHandle = NULL;
 891 EXIT_ERROR_2:
 892     Exynos_OSAL_Free(pExynosComponent->componentName);
 893     pExynosComponent->componentName = NULL;
 894 EXIT_ERROR_1:
 895     Exynos_OMX_AudioDecodeComponentDeinit(pOMXComponent);
 896 EXIT:
 897     FunctionOut();
 898
 899     return ret;
 900 }
 901
 902 OMX_ERRORTYPE Exynos_OMX_ComponentDeinit(OMX_HANDLETYPE hComponent)
 903 {
 904     OMX_ERRORTYPE             ret = OMX_ErrorNone;
 905     OMX_COMPONENTTYPE        *pOMXComponent = NULL;
 906     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
 907     EXYNOS_MP3_HANDLE        *pMp3Dec = NULL;
 908     EXYNOS_OMX_BASEPORT      *pExynosPort = NULL;
 909
 910     FunctionIn();
 911
 912     if (hComponent == NULL) {
 913         ret = OMX_ErrorBadParameter;
 914         goto EXIT;
 915     }
 916     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
 917     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 918
 919     Exynos_OSAL_Free(pExynosComponent->componentName);
 920     pExynosComponent->componentName = NULL;
 921     pExynosPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
 922     if (pExynosPort->processData.buffer.singlePlaneBuffer.dataBuffer) {
 923         Exynos_OSAL_Free(pExynosPort->processData.buffer.singlePlaneBuffer.dataBuffer);
 924         pExynosPort->processData.buffer.singlePlaneBuffer.dataBuffer = NULL;
 925         pExynosPort->processData.allocSize = 0;
 926     }
 927
 928     pMp3Dec = (EXYNOS_MP3_HANDLE *)((EXYNOS_OMX_AUDIODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
 929     if (pMp3Dec != NULL) {
 930         if (pMp3Dec->hSRPMp3Handle.bSRPLoaded == OMX_TRUE) {
 931             SRP_Deinit();
 932             SRP_Terminate();
 933         }
 934         Exynos_OSAL_Free(pMp3Dec);
 935         ((EXYNOS_OMX_AUDIODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle = NULL;
 936     }
 937
 938     ret = Exynos_OMX_AudioDecodeComponentDeinit(pOMXComponent);
 939     if (ret != OMX_ErrorNone) {
 940         goto EXIT;
 941     }
 942
 943     ret = OMX_ErrorNone;
 944
 945 EXIT:
 946     FunctionOut();
 947
 948     return ret;
 949 }