openmax/component/audio/dec/Exynos_OMX_Adec.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_Adec.c
  20  * @brief
  21  * @author      Yunji Kim (yunji.kim@samsung.com)
  22  *
  23  * @version     1.1.0
  24  * @history
  25  *   2012.02.28 : Create
  26  */
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include "Exynos_OMX_Macros.h"
  32 #include "Exynos_OSAL_Event.h"
  33 #include "Exynos_OMX_Adec.h"
  34 #include "Exynos_OMX_Basecomponent.h"
  35 #include "Exynos_OSAL_Thread.h"
  36 #include "Exynos_OSAL_Semaphore.h"
  37 #include "Exynos_OSAL_Mutex.h"
  38 #include "Exynos_OSAL_ETC.h"
  39 #include "srp_api.h"
  40
  41 #undef  EXYNOS_LOG_TAG
  42 #define EXYNOS_LOG_TAG    "EXYNOS_AUDIO_DEC"
  43 #define EXYNOS_LOG_OFF
  44 #include "Exynos_OSAL_Log.h"
  45
  46 OMX_ERRORTYPE Exynos_OMX_UseBuffer(
  47     OMX_IN OMX_HANDLETYPE            hComponent,
  48     OMX_INOUT OMX_BUFFERHEADERTYPE **ppBufferHdr,
  49     OMX_IN OMX_U32                   nPortIndex,
  50     OMX_IN OMX_PTR                   pAppPrivate,
  51     OMX_IN OMX_U32                   nSizeBytes,
  52     OMX_IN OMX_U8                   *pBuffer)
  53 {
  54     OMX_ERRORTYPE             ret = OMX_ErrorNone;
  55     OMX_COMPONENTTYPE        *pOMXComponent = NULL;
  56     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
  57     EXYNOS_OMX_BASEPORT      *pExynosPort = NULL;
  58     OMX_BUFFERHEADERTYPE     *temp_bufferHeader = NULL;
  59     OMX_U32                   i = 0;
  60
  61     FunctionIn();
  62
  63     if (hComponent == NULL) {
  64         ret = OMX_ErrorBadParameter;
  65         goto EXIT;
  66     }
  67     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
  68     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
  69     if (ret != OMX_ErrorNone) {
  70         goto EXIT;
  71     }
  72
  73     if (pOMXComponent->pComponentPrivate == NULL) {
  74         ret = OMX_ErrorBadParameter;
  75         goto EXIT;
  76     }
  77     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
  78
  79     pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
  80     if (nPortIndex >= pExynosComponent->portParam.nPorts) {
  81         ret = OMX_ErrorBadPortIndex;
  82         goto EXIT;
  83     }
  84     if (pExynosPort->portState != OMX_StateIdle) {
  85         ret = OMX_ErrorIncorrectStateOperation;
  86         goto EXIT;
  87     }
  88
  89     if (CHECK_PORT_TUNNELED(pExynosPort) && CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)) {
  90         ret = OMX_ErrorBadPortIndex;
  91         goto EXIT;
  92     }
  93
  94     temp_bufferHeader = (OMX_BUFFERHEADERTYPE *)Exynos_OSAL_Malloc(sizeof(OMX_BUFFERHEADERTYPE));
  95     if (temp_bufferHeader == NULL) {
  96         ret = OMX_ErrorInsufficientResources;
  97         goto EXIT;
  98     }
  99     Exynos_OSAL_Memset(temp_bufferHeader, 0, sizeof(OMX_BUFFERHEADERTYPE));
 100
 101     for (i = 0; i < pExynosPort->portDefinition.nBufferCountActual; i++) {
 102         if (pExynosPort->bufferStateAllocate[i] == BUFFER_STATE_FREE) {
 103             pExynosPort->extendBufferHeader[i].OMXBufferHeader = temp_bufferHeader;
 104             pExynosPort->bufferStateAllocate[i] = (BUFFER_STATE_ASSIGNED | HEADER_STATE_ALLOCATED);
 105             INIT_SET_SIZE_VERSION(temp_bufferHeader, OMX_BUFFERHEADERTYPE);
 106             temp_bufferHeader->pBuffer        = pBuffer;
 107             temp_bufferHeader->nAllocLen      = nSizeBytes;
 108             temp_bufferHeader->pAppPrivate    = pAppPrivate;
 109             if (nPortIndex == INPUT_PORT_INDEX)
 110                 temp_bufferHeader->nInputPortIndex = INPUT_PORT_INDEX;
 111             else
 112                 temp_bufferHeader->nOutputPortIndex = OUTPUT_PORT_INDEX;
 113
 114             pExynosPort->assignedBufferNum++;
 115             if (pExynosPort->assignedBufferNum == pExynosPort->portDefinition.nBufferCountActual) {
 116                 pExynosPort->portDefinition.bPopulated = OMX_TRUE;
 117                 /* Exynos_OSAL_MutexLock(pExynosComponent->compMutex); */
 118                 Exynos_OSAL_SemaphorePost(pExynosPort->loadedResource);
 119                 /* Exynos_OSAL_MutexUnlock(pExynosComponent->compMutex); */
 120             }
 121             *ppBufferHdr = temp_bufferHeader;
 122             ret = OMX_ErrorNone;
 123             goto EXIT;
 124         }
 125     }
 126
 127     Exynos_OSAL_Free(temp_bufferHeader);
 128     ret = OMX_ErrorInsufficientResources;
 129
 130 EXIT:
 131     FunctionOut();
 132
 133     return ret;
 134 }
 135
 136 OMX_ERRORTYPE Exynos_OMX_AllocateBuffer(
 137     OMX_IN OMX_HANDLETYPE            hComponent,
 138     OMX_INOUT OMX_BUFFERHEADERTYPE **ppBuffer,
 139     OMX_IN OMX_U32                   nPortIndex,
 140     OMX_IN OMX_PTR                   pAppPrivate,
 141     OMX_IN OMX_U32                   nSizeBytes)
 142 {
 143     OMX_ERRORTYPE             ret = OMX_ErrorNone;
 144     OMX_COMPONENTTYPE        *pOMXComponent = NULL;
 145     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
 146     EXYNOS_OMX_BASEPORT      *pExynosPort = NULL;
 147     OMX_BUFFERHEADERTYPE     *temp_bufferHeader = NULL;
 148     OMX_U8                   *temp_buffer = NULL;
 149     OMX_U32                   i = 0;
 150
 151     FunctionIn();
 152
 153     if (hComponent == NULL) {
 154         ret = OMX_ErrorBadParameter;
 155         goto EXIT;
 156     }
 157     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
 158     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
 159     if (ret != OMX_ErrorNone) {
 160         goto EXIT;
 161     }
 162
 163     if (pOMXComponent->pComponentPrivate == NULL) {
 164         ret = OMX_ErrorBadParameter;
 165         goto EXIT;
 166     }
 167     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 168
 169     pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
 170     if (nPortIndex >= pExynosComponent->portParam.nPorts) {
 171         ret = OMX_ErrorBadPortIndex;
 172         goto EXIT;
 173     }
 174 /*
 175     if (pExynosPort->portState != OMX_StateIdle ) {
 176         ret = OMX_ErrorIncorrectStateOperation;
 177         goto EXIT;
 178     }
 179 */
 180     if (CHECK_PORT_TUNNELED(pExynosPort) && CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)) {
 181         ret = OMX_ErrorBadPortIndex;
 182         goto EXIT;
 183     }
 184
 185     temp_buffer = Exynos_OSAL_Malloc(sizeof(OMX_U8) * nSizeBytes);
 186     if (temp_buffer == NULL) {
 187         ret = OMX_ErrorInsufficientResources;
 188         goto EXIT;
 189     }
 190
 191     temp_bufferHeader = (OMX_BUFFERHEADERTYPE *)Exynos_OSAL_Malloc(sizeof(OMX_BUFFERHEADERTYPE));
 192     if (temp_bufferHeader == NULL) {
 193         Exynos_OSAL_Free(temp_buffer);
 194         temp_buffer = NULL;
 195         ret = OMX_ErrorInsufficientResources;
 196         goto EXIT;
 197     }
 198     Exynos_OSAL_Memset(temp_bufferHeader, 0, sizeof(OMX_BUFFERHEADERTYPE));
 199
 200     for (i = 0; i < pExynosPort->portDefinition.nBufferCountActual; i++) {
 201         if (pExynosPort->bufferStateAllocate[i] == BUFFER_STATE_FREE) {
 202             pExynosPort->extendBufferHeader[i].OMXBufferHeader = temp_bufferHeader;
 203             pExynosPort->bufferStateAllocate[i] = (BUFFER_STATE_ALLOCATED | HEADER_STATE_ALLOCATED);
 204             INIT_SET_SIZE_VERSION(temp_bufferHeader, OMX_BUFFERHEADERTYPE);
 205             temp_bufferHeader->pBuffer        = temp_buffer;
 206             temp_bufferHeader->nAllocLen      = nSizeBytes;
 207             temp_bufferHeader->pAppPrivate    = pAppPrivate;
 208             if (nPortIndex == INPUT_PORT_INDEX)
 209                 temp_bufferHeader->nInputPortIndex = INPUT_PORT_INDEX;
 210             else
 211                 temp_bufferHeader->nOutputPortIndex = OUTPUT_PORT_INDEX;
 212             pExynosPort->assignedBufferNum++;
 213             if (pExynosPort->assignedBufferNum == pExynosPort->portDefinition.nBufferCountActual) {
 214                 pExynosPort->portDefinition.bPopulated = OMX_TRUE;
 215                 /* Exynos_OSAL_MutexLock(pExynosComponent->compMutex); */
 216                 Exynos_OSAL_SemaphorePost(pExynosPort->loadedResource);
 217                 /* Exynos_OSAL_MutexUnlock(pExynosComponent->compMutex); */
 218             }
 219             *ppBuffer = temp_bufferHeader;
 220             ret = OMX_ErrorNone;
 221             goto EXIT;
 222         }
 223     }
 224
 225     Exynos_OSAL_Free(temp_bufferHeader);
 226     Exynos_OSAL_Free(temp_buffer);
 227     ret = OMX_ErrorInsufficientResources;
 228
 229 EXIT:
 230     FunctionOut();
 231
 232     return ret;
 233 }
 234
 235 OMX_ERRORTYPE Exynos_OMX_FreeBuffer(
 236     OMX_IN OMX_HANDLETYPE hComponent,
 237     OMX_IN OMX_U32        nPortIndex,
 238     OMX_IN OMX_BUFFERHEADERTYPE *pBufferHdr)
 239 {
 240     OMX_ERRORTYPE             ret = OMX_ErrorNone;
 241     OMX_COMPONENTTYPE        *pOMXComponent = NULL;
 242     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
 243     EXYNOS_OMX_BASEPORT      *pExynosPort = NULL;
 244     OMX_BUFFERHEADERTYPE     *temp_bufferHeader = NULL;
 245     OMX_U8                   *temp_buffer = NULL;
 246     OMX_U32                   i = 0;
 247
 248     FunctionIn();
 249
 250     if (hComponent == NULL) {
 251         ret = OMX_ErrorBadParameter;
 252         goto EXIT;
 253     }
 254     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
 255     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
 256     if (ret != OMX_ErrorNone) {
 257         goto EXIT;
 258     }
 259
 260     if (pOMXComponent->pComponentPrivate == NULL) {
 261         ret = OMX_ErrorBadParameter;
 262         goto EXIT;
 263     }
 264     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 265     pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
 266
 267     if (CHECK_PORT_TUNNELED(pExynosPort) && CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)) {
 268         ret = OMX_ErrorBadPortIndex;
 269         goto EXIT;
 270     }
 271
 272     if ((pExynosPort->portState != OMX_StateLoaded) && (pExynosPort->portState != OMX_StateInvalid)) {
 273         (*(pExynosComponent->pCallbacks->EventHandler)) (pOMXComponent,
 274                         pExynosComponent->callbackData,
 275                         (OMX_U32)OMX_EventError,
 276                         (OMX_U32)OMX_ErrorPortUnpopulated,
 277                         nPortIndex, NULL);
 278     }
 279
 280     for (i = 0; i < pExynosPort->portDefinition.nBufferCountActual; i++) {
 281         if (((pExynosPort->bufferStateAllocate[i] | BUFFER_STATE_FREE) != 0) && (pExynosPort->extendBufferHeader[i].OMXBufferHeader != NULL)) {
 282             if (pExynosPort->extendBufferHeader[i].OMXBufferHeader->pBuffer == pBufferHdr->pBuffer) {
 283                 if (pExynosPort->bufferStateAllocate[i] & BUFFER_STATE_ALLOCATED) {
 284                     Exynos_OSAL_Free(pExynosPort->extendBufferHeader[i].OMXBufferHeader->pBuffer);
 285                     pExynosPort->extendBufferHeader[i].OMXBufferHeader->pBuffer = NULL;
 286                     pBufferHdr->pBuffer = NULL;
 287                 } else if (pExynosPort->bufferStateAllocate[i] & BUFFER_STATE_ASSIGNED) {
 288                     ; /* None*/
 289                 }
 290                 pExynosPort->assignedBufferNum--;
 291                 if (pExynosPort->bufferStateAllocate[i] & HEADER_STATE_ALLOCATED) {
 292                     Exynos_OSAL_Free(pExynosPort->extendBufferHeader[i].OMXBufferHeader);
 293                     pExynosPort->extendBufferHeader[i].OMXBufferHeader = NULL;
 294                     pBufferHdr = NULL;
 295                 }
 296                 pExynosPort->bufferStateAllocate[i] = BUFFER_STATE_FREE;
 297                 ret = OMX_ErrorNone;
 298                 goto EXIT;
 299             }
 300         }
 301     }
 302
 303 EXIT:
 304     if (ret == OMX_ErrorNone) {
 305         if (pExynosPort->assignedBufferNum == 0) {
 306             Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pExynosPort->unloadedResource signal set");
 307             /* Exynos_OSAL_MutexLock(pExynosComponent->compMutex); */
 308             Exynos_OSAL_SemaphorePost(pExynosPort->unloadedResource);
 309             /* Exynos_OSAL_MutexUnlock(pExynosComponent->compMutex); */
 310             pExynosPort->portDefinition.bPopulated = OMX_FALSE;
 311         }
 312     }
 313
 314     FunctionOut();
 315
 316     return ret;
 317 }
 318
 319 OMX_ERRORTYPE Exynos_OMX_AllocateTunnelBuffer(EXYNOS_OMX_BASEPORT *pOMXBasePort, OMX_U32 nPortIndex)
 320 {
 321     OMX_ERRORTYPE                 ret = OMX_ErrorNone;
 322     EXYNOS_OMX_BASEPORT          *pExynosPort = NULL;
 323     OMX_BUFFERHEADERTYPE         *temp_bufferHeader = NULL;
 324     OMX_U8                       *temp_buffer = NULL;
 325     OMX_U32                       bufferSize = 0;
 326     OMX_PARAM_PORTDEFINITIONTYPE  portDefinition;
 327
 328     ret = OMX_ErrorTunnelingUnsupported;
 329 EXIT:
 330     return ret;
 331 }
 332
 333 OMX_ERRORTYPE Exynos_OMX_FreeTunnelBuffer(EXYNOS_OMX_BASEPORT *pOMXBasePort, OMX_U32 nPortIndex)
 334 {
 335     OMX_ERRORTYPE ret = OMX_ErrorNone;
 336     EXYNOS_OMX_BASEPORT* pExynosPort = NULL;
 337     OMX_BUFFERHEADERTYPE* temp_bufferHeader = NULL;
 338     OMX_U8 *temp_buffer = NULL;
 339     OMX_U32 bufferSize = 0;
 340
 341     ret = OMX_ErrorTunnelingUnsupported;
 342 EXIT:
 343     return ret;
 344 }
 345
 346 OMX_ERRORTYPE Exynos_OMX_ComponentTunnelRequest(
 347     OMX_IN OMX_HANDLETYPE hComp,
 348     OMX_IN OMX_U32        nPort,
 349     OMX_IN OMX_HANDLETYPE hTunneledComp,
 350     OMX_IN OMX_U32        nTunneledPort,
 351     OMX_INOUT OMX_TUNNELSETUPTYPE *pTunnelSetup)
 352 {
 353     OMX_ERRORTYPE ret = OMX_ErrorNone;
 354
 355     ret = OMX_ErrorTunnelingUnsupported;
 356 EXIT:
 357     return ret;
 358 }
 359
 360 OMX_BOOL Exynos_Check_BufferProcess_State(EXYNOS_OMX_BASECOMPONENT *pExynosComponent)
 361 {
 362     if ((pExynosComponent->currentState == OMX_StateExecuting) &&
 363         (pExynosComponent->pExynosPort[INPUT_PORT_INDEX].portState == OMX_StateIdle) &&
 364         (pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX].portState == OMX_StateIdle) &&
 365         (pExynosComponent->transientState != EXYNOS_OMX_TransStateExecutingToIdle) &&
 366         (pExynosComponent->transientState != EXYNOS_OMX_TransStateIdleToExecuting)) {
 367         return OMX_TRUE;
 368     } else {
 369         return OMX_FALSE;
 370     }
 371 }
 372
 373 OMX_ERRORTYPE Exynos_InputBufferReturn(OMX_COMPONENTTYPE *pOMXComponent)
 374 {
 375     OMX_ERRORTYPE             ret = OMX_ErrorNone;
 376     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 377     EXYNOS_OMX_BASEPORT      *exynosOMXInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
 378     EXYNOS_OMX_BASEPORT      *exynosOMXOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
 379     EXYNOS_OMX_DATABUFFER    *dataBuffer = &exynosOMXInputPort->way.port1WayDataBuffer.dataBuffer;
 380     OMX_BUFFERHEADERTYPE     *bufferHeader = dataBuffer->bufferHeader;
 381
 382     FunctionIn();
 383
 384     if (bufferHeader != NULL) {
 385         if (exynosOMXInputPort->markType.hMarkTargetComponent != NULL ) {
 386             bufferHeader->hMarkTargetComponent      = exynosOMXInputPort->markType.hMarkTargetComponent;
 387             bufferHeader->pMarkData                 = exynosOMXInputPort->markType.pMarkData;
 388             exynosOMXInputPort->markType.hMarkTargetComponent = NULL;
 389             exynosOMXInputPort->markType.pMarkData = NULL;
 390         }
 391
 392         if (bufferHeader->hMarkTargetComponent != NULL) {
 393             if (bufferHeader->hMarkTargetComponent == pOMXComponent) {
 394                 pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
 395                                 pExynosComponent->callbackData,
 396                                 OMX_EventMark,
 397                                 0, 0, bufferHeader->pMarkData);
 398             } else {
 399                 pExynosComponent->propagateMarkType.hMarkTargetComponent = bufferHeader->hMarkTargetComponent;
 400                 pExynosComponent->propagateMarkType.pMarkData = bufferHeader->pMarkData;
 401             }
 402         }
 403
 404         bufferHeader->nFilledLen = 0;
 405         pExynosComponent->pCallbacks->EmptyBufferDone(pOMXComponent, pExynosComponent->callbackData, bufferHeader);
 406     }
 407
 408     if ((pExynosComponent->currentState == OMX_StatePause) &&
 409         ((!CHECK_PORT_BEING_FLUSHED(exynosOMXInputPort) && !CHECK_PORT_BEING_FLUSHED(exynosOMXOutputPort)))) {
 410         Exynos_OSAL_SignalWait(pExynosComponent->pauseEvent, DEF_MAX_WAIT_TIME);
 411         Exynos_OSAL_SignalReset(pExynosComponent->pauseEvent);
 412     }
 413
 414     dataBuffer->dataValid     = OMX_FALSE;
 415     dataBuffer->dataLen       = 0;
 416     dataBuffer->remainDataLen = 0;
 417     dataBuffer->usedDataLen   = 0;
 418     dataBuffer->bufferHeader  = NULL;
 419     dataBuffer->nFlags        = 0;
 420     dataBuffer->timeStamp     = 0;
 421
 422 EXIT:
 423     FunctionOut();
 424
 425     return ret;
 426 }
 427
 428 OMX_ERRORTYPE Exynos_InputBufferGetQueue(EXYNOS_OMX_BASECOMPONENT *pExynosComponent)
 429 {
 430     OMX_ERRORTYPE          ret = OMX_ErrorNone;
 431     EXYNOS_OMX_BASEPORT   *pExynosPort = NULL;
 432     EXYNOS_OMX_DATABUFFER *dataBuffer = NULL;
 433     EXYNOS_OMX_MESSAGE    *message = NULL;
 434
 435     FunctionIn();
 436
 437     pExynosPort= &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
 438     dataBuffer = &pExynosPort->way.port1WayDataBuffer.dataBuffer;
 439
 440     if (pExynosComponent->currentState != OMX_StateExecuting) {
 441         ret = OMX_ErrorUndefined;
 442         goto EXIT;
 443     } else {
 444         Exynos_OSAL_SemaphoreWait(pExynosPort->bufferSemID);
 445         Exynos_OSAL_MutexLock(dataBuffer->bufferMutex);
 446         if (dataBuffer->dataValid != OMX_TRUE) {
 447             message = (EXYNOS_OMX_MESSAGE *)Exynos_OSAL_Dequeue(&pExynosPort->bufferQ);
 448             if (message == NULL) {
 449                 ret = OMX_ErrorUndefined;
 450                 Exynos_OSAL_MutexUnlock(dataBuffer->bufferMutex);
 451                 goto EXIT;
 452             }
 453
 454             dataBuffer->bufferHeader = (OMX_BUFFERHEADERTYPE *)(message->pCmdData);
 455             dataBuffer->allocSize = dataBuffer->bufferHeader->nAllocLen;
 456             dataBuffer->dataLen = dataBuffer->bufferHeader->nFilledLen;
 457             dataBuffer->remainDataLen = dataBuffer->dataLen;
 458             dataBuffer->usedDataLen = 0;
 459             dataBuffer->dataValid = OMX_TRUE;
 460             dataBuffer->nFlags = dataBuffer->bufferHeader->nFlags;
 461             dataBuffer->timeStamp = dataBuffer->bufferHeader->nTimeStamp;
 462
 463             Exynos_OSAL_Free(message);
 464
 465 #ifndef TIZEN_FEATURE_E3250
 466             if (dataBuffer->allocSize <= dataBuffer->dataLen)
 467                 Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "Input Buffer Full, Check input buffer size! allocSize:%d, dataLen:%d", dataBuffer->allocSize, dataBuffer->dataLen);
 468 #endif
 469         }
 470         Exynos_OSAL_MutexUnlock(dataBuffer->bufferMutex);
 471         ret = OMX_ErrorNone;
 472     }
 473 EXIT:
 474     FunctionOut();
 475
 476     return ret;
 477 }
 478
 479 OMX_ERRORTYPE Exynos_OutputBufferReturn(OMX_COMPONENTTYPE *pOMXComponent)
 480 {
 481     OMX_ERRORTYPE             ret = OMX_ErrorNone;
 482     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 483     EXYNOS_OMX_BASEPORT      *exynosOMXInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
 484     EXYNOS_OMX_BASEPORT      *exynosOMXOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
 485     EXYNOS_OMX_DATABUFFER    *dataBuffer = &exynosOMXOutputPort->way.port1WayDataBuffer.dataBuffer;
 486     OMX_BUFFERHEADERTYPE     *bufferHeader = dataBuffer->bufferHeader;
 487
 488     FunctionIn();
 489
 490     if (bufferHeader != NULL) {
 491         bufferHeader->nFilledLen = dataBuffer->remainDataLen;
 492         bufferHeader->nOffset    = 0;
 493         bufferHeader->nFlags     = dataBuffer->nFlags;
 494         bufferHeader->nTimeStamp = dataBuffer->timeStamp;
 495
 496         if (pExynosComponent->propagateMarkType.hMarkTargetComponent != NULL) {
 497             bufferHeader->hMarkTargetComponent = pExynosComponent->propagateMarkType.hMarkTargetComponent;
 498             bufferHeader->pMarkData = pExynosComponent->propagateMarkType.pMarkData;
 499             pExynosComponent->propagateMarkType.hMarkTargetComponent = NULL;
 500             pExynosComponent->propagateMarkType.pMarkData = NULL;
 501         }
 502
 503         if (bufferHeader->nFlags & OMX_BUFFERFLAG_EOS) {
 504             pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
 505                             pExynosComponent->callbackData,
 506                             OMX_EventBufferFlag,
 507                             OUTPUT_PORT_INDEX,
 508                             bufferHeader->nFlags, NULL);
 509         }
 510
 511         pExynosComponent->pCallbacks->FillBufferDone(pOMXComponent, pExynosComponent->callbackData, bufferHeader);
 512     }
 513
 514     if ((pExynosComponent->currentState == OMX_StatePause) &&
 515         ((!CHECK_PORT_BEING_FLUSHED(exynosOMXInputPort) && !CHECK_PORT_BEING_FLUSHED(exynosOMXOutputPort)))) {
 516         Exynos_OSAL_SignalWait(pExynosComponent->pauseEvent, DEF_MAX_WAIT_TIME);
 517         Exynos_OSAL_SignalReset(pExynosComponent->pauseEvent);
 518     }
 519
 520     /* reset dataBuffer */
 521     dataBuffer->dataValid     = OMX_FALSE;
 522     dataBuffer->dataLen       = 0;
 523     dataBuffer->remainDataLen = 0;
 524     dataBuffer->usedDataLen   = 0;
 525     dataBuffer->bufferHeader  = NULL;
 526     dataBuffer->nFlags        = 0;
 527     dataBuffer->timeStamp     = 0;
 528
 529 EXIT:
 530     FunctionOut();
 531
 532     return ret;
 533 }
 534
 535 OMX_ERRORTYPE Exynos_OutputBufferGetQueue(EXYNOS_OMX_BASECOMPONENT *pExynosComponent)
 536 {
 537     OMX_ERRORTYPE          ret = OMX_ErrorNone;
 538     EXYNOS_OMX_BASEPORT   *pExynosPort = NULL;
 539     EXYNOS_OMX_DATABUFFER *dataBuffer = NULL;
 540     EXYNOS_OMX_MESSAGE    *message = NULL;
 541
 542     FunctionIn();
 543
 544     pExynosPort= &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
 545     dataBuffer = &pExynosPort->way.port1WayDataBuffer.dataBuffer;
 546
 547     if (pExynosComponent->currentState != OMX_StateExecuting) {
 548         ret = OMX_ErrorUndefined;
 549         goto EXIT;
 550     } else {
 551         Exynos_OSAL_SemaphoreWait(pExynosPort->bufferSemID);
 552         Exynos_OSAL_MutexLock(dataBuffer->bufferMutex);
 553         if (dataBuffer->dataValid != OMX_TRUE) {
 554             message = (EXYNOS_OMX_MESSAGE *)Exynos_OSAL_Dequeue(&pExynosPort->bufferQ);
 555             if (message == NULL) {
 556                 ret = OMX_ErrorUndefined;
 557                 Exynos_OSAL_MutexUnlock(dataBuffer->bufferMutex);
 558                 goto EXIT;
 559             }
 560
 561             dataBuffer->bufferHeader = (OMX_BUFFERHEADERTYPE *)(message->pCmdData);
 562             dataBuffer->allocSize = dataBuffer->bufferHeader->nAllocLen;
 563             dataBuffer->dataLen = 0; //dataBuffer->bufferHeader->nFilledLen;
 564             dataBuffer->remainDataLen = dataBuffer->dataLen;
 565             dataBuffer->usedDataLen = 0; //dataBuffer->bufferHeader->nOffset;
 566             dataBuffer->dataValid = OMX_TRUE;
 567             /* dataBuffer->nFlags = dataBuffer->bufferHeader->nFlags; */
 568             /* dataBuffer->nTimeStamp = dataBuffer->bufferHeader->nTimeStamp; */
 569             pExynosPort->processData.buffer.singlePlaneBuffer.dataBuffer = dataBuffer->bufferHeader->pBuffer;
 570             pExynosPort->processData.allocSize = dataBuffer->bufferHeader->nAllocLen;
 571
 572             Exynos_OSAL_Free(message);
 573         }
 574         Exynos_OSAL_MutexUnlock(dataBuffer->bufferMutex);
 575         ret = OMX_ErrorNone;
 576     }
 577 EXIT:
 578     FunctionOut();
 579
 580     return ret;
 581
 582 }
 583
 584 OMX_BOOL Exynos_Preprocessor_InputData(OMX_COMPONENTTYPE *pOMXComponent)
 585 {
 586     OMX_BOOL                  ret = OMX_FALSE;
 587     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 588     EXYNOS_OMX_BASEPORT      *exynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
 589     EXYNOS_OMX_DATABUFFER    *inputUseBuffer = &exynosInputPort->way.port1WayDataBuffer.dataBuffer;
 590     EXYNOS_OMX_DATA          *inputData = &exynosInputPort->processData;
 591     OMX_U32                   copySize = 0;
 592     OMX_BYTE                  checkInputStream = NULL;
 593     OMX_U32                   checkInputStreamLen = 0;
 594     OMX_U32                   checkedSize = 0;
 595     OMX_BOOL                  flagEOF = OMX_FALSE;
 596     OMX_BOOL                  previousFrameEOF = OMX_FALSE;
 597
 598     FunctionIn();
 599
 600     if (inputUseBuffer->dataValid == OMX_TRUE) {
 601         checkInputStream = inputUseBuffer->bufferHeader->pBuffer + inputUseBuffer->usedDataLen;
 602         checkInputStreamLen = inputUseBuffer->remainDataLen;
 603
 604         if (inputData->dataLen == 0) {
 605             previousFrameEOF = OMX_TRUE;
 606         } else {
 607             previousFrameEOF = OMX_FALSE;
 608         }
 609
 610         /* Audio extractor should parse into frame units. */
 611         flagEOF = OMX_TRUE;
 612         checkedSize = checkInputStreamLen;
 613         copySize = checkedSize;
 614
 615         if (inputUseBuffer->nFlags & OMX_BUFFERFLAG_EOS)
 616             pExynosComponent->bSaveFlagEOS = OMX_TRUE;
 617
 618         if (((inputData->allocSize) - (inputData->dataLen)) >= copySize) {
 619             if (copySize > 0)
 620                 Exynos_OSAL_Memcpy(inputData->buffer.singlePlaneBuffer.dataBuffer + inputData->dataLen, checkInputStream, copySize);
 621
 622             inputUseBuffer->dataLen -= copySize;
 623             inputUseBuffer->remainDataLen -= copySize;
 624             inputUseBuffer->usedDataLen += copySize;
 625
 626             inputData->dataLen += copySize;
 627             inputData->remainDataLen += copySize;
 628
 629             if (previousFrameEOF == OMX_TRUE) {
 630                 inputData->timeStamp = inputUseBuffer->timeStamp;
 631                 inputData->nFlags = inputUseBuffer->nFlags;
 632             }
 633
 634             if (pExynosComponent->bUseFlagEOF == OMX_TRUE) {
 635                 if (pExynosComponent->bSaveFlagEOS == OMX_TRUE) {
 636                     inputData->nFlags |= OMX_BUFFERFLAG_EOS;
 637                     flagEOF = OMX_TRUE;
 638                     pExynosComponent->bSaveFlagEOS = OMX_FALSE;
 639                 } else {
 640                     inputData->nFlags = (inputData->nFlags & (~OMX_BUFFERFLAG_EOS));
 641                 }
 642             } else {
 643                 if ((checkedSize == checkInputStreamLen) && (pExynosComponent->bSaveFlagEOS == OMX_TRUE)) {
 644                     if ((inputUseBuffer->nFlags & OMX_BUFFERFLAG_EOS) &&
 645                         ((inputData->nFlags & OMX_BUFFERFLAG_CODECCONFIG) ||
 646                         (inputData->dataLen == 0))) {
 647                         inputData->nFlags |= OMX_BUFFERFLAG_EOS;
 648                         flagEOF = OMX_TRUE;
 649                         pExynosComponent->bSaveFlagEOS = OMX_FALSE;
 650                     } else if ((inputUseBuffer->nFlags & OMX_BUFFERFLAG_EOS) &&
 651                                (!(inputData->nFlags & OMX_BUFFERFLAG_CODECCONFIG)) &&
 652                                (inputData->dataLen != 0)) {
 653                         inputData->nFlags = (inputData->nFlags & (~OMX_BUFFERFLAG_EOS));
 654                         flagEOF = OMX_TRUE;
 655                         pExynosComponent->bSaveFlagEOS = OMX_TRUE;
 656                     }
 657                 } else {
 658                     inputData->nFlags = (inputUseBuffer->nFlags & (~OMX_BUFFERFLAG_EOS));
 659                 }
 660             }
 661         } else {
 662             /*????????????????????????????????? Error ?????????????????????????????????*/
 663             Exynos_ResetCodecData(inputData);
 664             flagEOF = OMX_FALSE;
 665         }
 666
 667         if ((inputUseBuffer->remainDataLen == 0) ||
 668             (CHECK_PORT_BEING_FLUSHED(exynosInputPort)))
 669             Exynos_InputBufferReturn(pOMXComponent);
 670         else
 671             inputUseBuffer->dataValid = OMX_TRUE;
 672     }
 673
 674     if (flagEOF == OMX_TRUE) {
 675         if (pExynosComponent->checkTimeStamp.needSetStartTimeStamp == OMX_TRUE) {
 676             /* Flush SRP buffers */
 677             SRP_Flush();
 678
 679             pExynosComponent->checkTimeStamp.needCheckStartTimeStamp = OMX_TRUE;
 680             pExynosComponent->checkTimeStamp.startTimeStamp = inputData->timeStamp;
 681             pExynosComponent->checkTimeStamp.nStartFlags = inputData->nFlags;
 682             pExynosComponent->checkTimeStamp.needSetStartTimeStamp = OMX_FALSE;
 683             Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "first frame timestamp after seeking %lld us (%.2f secs)",
 684                 inputData->timeStamp, inputData->timeStamp / 1E6);
 685         }
 686
 687         ret = OMX_TRUE;
 688     } else {
 689         ret = OMX_FALSE;
 690     }
 691
 692     FunctionOut();
 693
 694     return ret;
 695 }
 696
 697 OMX_BOOL Exynos_Postprocess_OutputData(OMX_COMPONENTTYPE *pOMXComponent)
 698 {
 699     OMX_BOOL                  ret = OMX_FALSE;
 700     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 701     EXYNOS_OMX_BASEPORT      *exynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
 702     EXYNOS_OMX_DATABUFFER    *outputUseBuffer = &exynosOutputPort->way.port1WayDataBuffer.dataBuffer;
 703     EXYNOS_OMX_DATA          *outputData = &exynosOutputPort->processData;
 704     OMX_U32                   copySize = 0;
 705
 706     FunctionIn();
 707
 708     if (outputUseBuffer->dataValid == OMX_TRUE) {
 709         if (pExynosComponent->checkTimeStamp.needCheckStartTimeStamp == OMX_TRUE) {
 710             if (pExynosComponent->checkTimeStamp.startTimeStamp == outputData->timeStamp) {
 711                 pExynosComponent->checkTimeStamp.startTimeStamp = -19761123;
 712                 pExynosComponent->checkTimeStamp.nStartFlags = 0x0;
 713                 pExynosComponent->checkTimeStamp.needSetStartTimeStamp = OMX_FALSE;
 714                 pExynosComponent->checkTimeStamp.needCheckStartTimeStamp = OMX_FALSE;
 715             } else {
 716                 Exynos_ResetCodecData(outputData);
 717                 ret = OMX_TRUE;
 718                 goto EXIT;
 719             }
 720         } else if (pExynosComponent->checkTimeStamp.needSetStartTimeStamp == OMX_TRUE) {
 721             Exynos_ResetCodecData(outputData);
 722             ret = OMX_TRUE;
 723             goto EXIT;
 724         }
 725
 726         if (outputData->remainDataLen <= (outputUseBuffer->allocSize - outputUseBuffer->dataLen)) {
 727             copySize = outputData->remainDataLen;
 728
 729             outputUseBuffer->dataLen += copySize;
 730             outputUseBuffer->remainDataLen += copySize;
 731             outputUseBuffer->nFlags = outputData->nFlags;
 732             outputUseBuffer->timeStamp = outputData->timeStamp;
 733
 734             ret = OMX_TRUE;
 735
 736             /* reset outputData */
 737             Exynos_ResetCodecData(outputData);
 738
 739             if ((outputUseBuffer->remainDataLen > 0) ||
 740                 (outputUseBuffer->nFlags & OMX_BUFFERFLAG_EOS) ||
 741                 (CHECK_PORT_BEING_FLUSHED(exynosOutputPort)))
 742                 Exynos_OutputBufferReturn(pOMXComponent);
 743         } else {
 744             Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "output buffer is smaller than decoded data size Out Length");
 745
 746             ret = OMX_FALSE;
 747
 748             /* reset outputData */
 749             Exynos_ResetCodecData(outputData);
 750         }
 751     } else {
 752         ret = OMX_FALSE;
 753     }
 754
 755 EXIT:
 756     FunctionOut();
 757
 758     return ret;
 759 }
 760
 761 OMX_ERRORTYPE Exynos_OMX_BufferProcess(OMX_HANDLETYPE hComponent)
 762 {
 763     OMX_ERRORTYPE             ret = OMX_ErrorNone;
 764     OMX_COMPONENTTYPE        *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
 765     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 766     EXYNOS_OMX_AUDIODEC_COMPONENT *pAudioDec = (EXYNOS_OMX_AUDIODEC_COMPONENT *)pExynosComponent->hComponentHandle;
 767     EXYNOS_OMX_BASEPORT      *exynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
 768     EXYNOS_OMX_BASEPORT      *exynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
 769     EXYNOS_OMX_DATABUFFER    *inputUseBuffer = &exynosInputPort->way.port1WayDataBuffer.dataBuffer;
 770     EXYNOS_OMX_DATABUFFER    *outputUseBuffer = &exynosOutputPort->way.port1WayDataBuffer.dataBuffer;
 771     EXYNOS_OMX_DATA          *inputData = &exynosInputPort->processData;
 772     EXYNOS_OMX_DATA          *outputData = &exynosOutputPort->processData;
 773     OMX_U32                   copySize = 0;
 774
 775     pExynosComponent->reInputData = OMX_FALSE;
 776
 777     FunctionIn();
 778
 779     while (!pAudioDec->bExitBufferProcessThread) {
 780         Exynos_OSAL_SleepMillisec(0);
 781
 782         if (((pExynosComponent->currentState == OMX_StatePause) ||
 783             (pExynosComponent->currentState == OMX_StateIdle) ||
 784             (pExynosComponent->transientState == EXYNOS_OMX_TransStateLoadedToIdle) ||
 785             (pExynosComponent->transientState == EXYNOS_OMX_TransStateExecutingToIdle)) &&
 786             (pExynosComponent->transientState != EXYNOS_OMX_TransStateIdleToLoaded)&&
 787             ((!CHECK_PORT_BEING_FLUSHED(exynosInputPort) && !CHECK_PORT_BEING_FLUSHED(exynosOutputPort)))) {
 788             Exynos_OSAL_SignalWait(pExynosComponent->pauseEvent, DEF_MAX_WAIT_TIME);
 789             Exynos_OSAL_SignalReset(pExynosComponent->pauseEvent);
 790         }
 791
 792         while ((Exynos_Check_BufferProcess_State(pExynosComponent)) && (!pAudioDec->bExitBufferProcessThread)) {
 793             Exynos_OSAL_SleepMillisec(0);
 794
 795             Exynos_OSAL_MutexLock(outputUseBuffer->bufferMutex);
 796             if ((outputUseBuffer->dataValid != OMX_TRUE) &&
 797                 (!CHECK_PORT_BEING_FLUSHED(exynosOutputPort))) {
 798                 Exynos_OSAL_MutexUnlock(outputUseBuffer->bufferMutex);
 799                 ret = Exynos_OutputBufferGetQueue(pExynosComponent);
 800                 if ((ret == OMX_ErrorUndefined) ||
 801                     (exynosInputPort->portState != OMX_StateIdle) ||
 802                     (exynosOutputPort->portState != OMX_StateIdle)) {
 803                     break;
 804                 }
 805             } else {
 806                 Exynos_OSAL_MutexUnlock(outputUseBuffer->bufferMutex);
 807             }
 808
 809             if (pExynosComponent->reInputData == OMX_FALSE) {
 810                 Exynos_OSAL_MutexLock(inputUseBuffer->bufferMutex);
 811                 if ((Exynos_Preprocessor_InputData(pOMXComponent) == OMX_FALSE) &&
 812                     (!CHECK_PORT_BEING_FLUSHED(exynosInputPort))) {
 813                         Exynos_OSAL_MutexUnlock(inputUseBuffer->bufferMutex);
 814                         ret = Exynos_InputBufferGetQueue(pExynosComponent);
 815                         break;
 816                 }
 817
 818                 Exynos_OSAL_MutexUnlock(inputUseBuffer->bufferMutex);
 819             }
 820
 821             Exynos_OSAL_MutexLock(inputUseBuffer->bufferMutex);
 822             Exynos_OSAL_MutexLock(outputUseBuffer->bufferMutex);
 823             ret = pAudioDec->exynos_codec_bufferProcess(pOMXComponent, inputData, outputData);
 824             Exynos_OSAL_MutexUnlock(outputUseBuffer->bufferMutex);
 825             Exynos_OSAL_MutexUnlock(inputUseBuffer->bufferMutex);
 826
 827             if (ret == OMX_ErrorInputDataDecodeYet)
 828                 pExynosComponent->reInputData = OMX_TRUE;
 829             else
 830                 pExynosComponent->reInputData = OMX_FALSE;
 831
 832             Exynos_OSAL_MutexLock(outputUseBuffer->bufferMutex);
 833             Exynos_Postprocess_OutputData(pOMXComponent);
 834             Exynos_OSAL_MutexUnlock(outputUseBuffer->bufferMutex);
 835         }
 836     }
 837
 838 EXIT:
 839
 840     FunctionOut();
 841
 842     return ret;
 843 }
 844
 845 OMX_ERRORTYPE Exynos_OMX_GetFlushBuffer(EXYNOS_OMX_BASEPORT *pExynosPort, EXYNOS_OMX_DATABUFFER **pDataBuffer)
 846 {
 847     OMX_ERRORTYPE ret = OMX_ErrorNone;
 848
 849     FunctionIn();
 850
 851     if (pExynosPort->portWayType == WAY2_PORT) {
 852         *pDataBuffer = NULL;
 853         ret = OMX_ErrorBadParameter;
 854         goto EXIT;
 855     }
 856
 857     *pDataBuffer = &pExynosPort->way.port1WayDataBuffer.dataBuffer;
 858
 859 EXIT:
 860     FunctionOut();
 861
 862     return ret;
 863 }
 864
 865 OMX_ERRORTYPE Exynos_OMX_FlushPort(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 portIndex)
 866 {
 867     OMX_ERRORTYPE             ret = OMX_ErrorNone;
 868     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 869     EXYNOS_OMX_BASEPORT      *pExynosPort = NULL;
 870     EXYNOS_OMX_DATABUFFER    *flushPortBuffer = NULL;
 871     OMX_BUFFERHEADERTYPE     *bufferHeader = NULL;
 872     EXYNOS_OMX_MESSAGE       *message = NULL;
 873     OMX_U32                   flushNum = 0;
 874     OMX_S32                   semValue = 0;
 875
 876     FunctionIn();
 877 #ifdef TIZEN_FEATURE_E3250
 878     Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "flushPort idx:%d", portIndex);
 879 #endif
 880
 881     pExynosPort = &pExynosComponent->pExynosPort[portIndex];
 882     while (Exynos_OSAL_GetElemNum(&pExynosPort->bufferQ) > 0) {
 883         Exynos_OSAL_Get_SemaphoreCount(pExynosComponent->pExynosPort[portIndex].bufferSemID, &semValue);
 884         if (semValue == 0)
 885             Exynos_OSAL_SemaphorePost(pExynosComponent->pExynosPort[portIndex].bufferSemID);
 886         Exynos_OSAL_SemaphoreTryWait(pExynosComponent->pExynosPort[portIndex].bufferSemID);
 887
 888         message = (EXYNOS_OMX_MESSAGE *)Exynos_OSAL_Dequeue(&pExynosPort->bufferQ);
 889         if (message != NULL) {
 890             bufferHeader = (OMX_BUFFERHEADERTYPE *)message->pCmdData;
 891             bufferHeader->nFilledLen = 0;
 892
 893             if (portIndex == OUTPUT_PORT_INDEX) {
 894                 pExynosComponent->pCallbacks->FillBufferDone(pOMXComponent, pExynosComponent->callbackData, bufferHeader);
 895             } else {
 896                 pExynosComponent->pCallbacks->EmptyBufferDone(pOMXComponent, pExynosComponent->callbackData, bufferHeader);
 897             }
 898
 899             Exynos_OSAL_Free(message);
 900             message = NULL;
 901         }
 902     }
 903
 904     Exynos_OMX_GetFlushBuffer(pExynosPort, &flushPortBuffer);
 905     if (flushPortBuffer != NULL) {
 906         if (flushPortBuffer->dataValid == OMX_TRUE) {
 907             if (portIndex == INPUT_PORT_INDEX)
 908                 Exynos_InputBufferReturn(pOMXComponent);
 909             else if (portIndex == OUTPUT_PORT_INDEX)
 910                 Exynos_OutputBufferReturn(pOMXComponent);
 911         }
 912     }
 913
 914     while(1) {
 915         OMX_S32 cnt = 0;
 916         Exynos_OSAL_Get_SemaphoreCount(pExynosComponent->pExynosPort[portIndex].bufferSemID, &cnt);
 917         if (cnt <= 0)
 918             break;
 919         Exynos_OSAL_SemaphoreTryWait(pExynosComponent->pExynosPort[portIndex].bufferSemID);
 920     }
 921     Exynos_OSAL_SetElemNum(&pExynosPort->bufferQ, 0);
 922
 923     pExynosPort->processData.dataLen       = 0;
 924     pExynosPort->processData.nFlags        = 0;
 925     pExynosPort->processData.remainDataLen = 0;
 926     pExynosPort->processData.timeStamp     = 0;
 927     pExynosPort->processData.usedDataLen   = 0;
 928
 929 EXIT:
 930     FunctionOut();
 931
 932     return ret;
 933 }
 934
 935 OMX_ERRORTYPE Exynos_OMX_BufferFlush(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 nPortIndex, OMX_BOOL bEvent)
 936 {
 937     OMX_ERRORTYPE                  ret = OMX_ErrorNone;
 938     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = NULL;
 939     EXYNOS_OMX_AUDIODEC_COMPONENT *pAudioDec = NULL;
 940     EXYNOS_OMX_BASEPORT           *pExynosPort = NULL;
 941     EXYNOS_OMX_DATABUFFER         *flushPortBuffer = NULL;
 942     OMX_U32                        i = 0, cnt = 0;
 943
 944     FunctionIn();
 945 #ifdef TIZEN_FEATURE_E3250
 946     Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "bufferFlush idx:%d", nPortIndex);
 947 #endif
 948
 949     if (pOMXComponent == NULL) {
 950         ret = OMX_ErrorBadParameter;
 951         goto EXIT;
 952     }
 953     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
 954     if (ret != OMX_ErrorNone) {
 955         goto EXIT;
 956     }
 957
 958     if (pOMXComponent->pComponentPrivate == NULL) {
 959         ret = OMX_ErrorBadParameter;
 960         goto EXIT;
 961     }
 962     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 963     pAudioDec = (EXYNOS_OMX_AUDIODEC_COMPONENT *)pExynosComponent->hComponentHandle;
 964
 965     Exynos_OSAL_SignalSet(pExynosComponent->pauseEvent);
 966
 967     pExynosComponent->pExynosPort[nPortIndex].bIsPortFlushed = OMX_TRUE;
 968
 969     pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
 970     Exynos_OMX_GetFlushBuffer(pExynosPort, &flushPortBuffer);
 971
 972     Exynos_OSAL_MutexLock(flushPortBuffer->bufferMutex);
 973     ret = Exynos_OMX_FlushPort(pOMXComponent, nPortIndex);
 974     Exynos_OSAL_MutexUnlock(flushPortBuffer->bufferMutex);
 975
 976     pExynosComponent->pExynosPort[nPortIndex].bIsPortFlushed = OMX_FALSE;
 977
 978     if (bEvent == OMX_TRUE && ret == OMX_ErrorNone) {
 979         pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
 980                             pExynosComponent->callbackData,
 981                             OMX_EventCmdComplete,
 982                             OMX_CommandFlush, nPortIndex, NULL);
 983     }
 984
 985     if (nPortIndex == INPUT_PORT_INDEX) {
 986         pExynosComponent->checkTimeStamp.needSetStartTimeStamp = OMX_TRUE;
 987         pExynosComponent->checkTimeStamp.needCheckStartTimeStamp = OMX_FALSE;
 988         Exynos_OSAL_Memset(pExynosComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
 989         Exynos_OSAL_Memset(pExynosComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
 990         pExynosComponent->getAllDelayBuffer = OMX_FALSE;
 991         pExynosComponent->bSaveFlagEOS = OMX_FALSE;
 992         pExynosComponent->reInputData = OMX_FALSE;
 993     }
 994
 995 EXIT:
 996     if ((ret != OMX_ErrorNone) && (pOMXComponent != NULL) && (pExynosComponent != NULL)) {
 997         Exynos_OSAL_Log(EXYNOS_LOG_ERROR,"%s : %d", __FUNCTION__, __LINE__);
 998         pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
 999                         pExynosComponent->callbackData,
1000                         OMX_EventError,
1001                         ret, 0, NULL);
1002     }
1003
1004     FunctionOut();
1005
1006     return ret;
1007 }
1008
1009 OMX_ERRORTYPE Exynos_OMX_AudioDecodeGetParameter(
1010     OMX_IN OMX_HANDLETYPE hComponent,
1011     OMX_IN OMX_INDEXTYPE  nParamIndex,
1012     OMX_INOUT OMX_PTR     ComponentParameterStructure)
1013 {
1014     OMX_ERRORTYPE             ret = OMX_ErrorNone;
1015     OMX_COMPONENTTYPE        *pOMXComponent = NULL;
1016     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1017     EXYNOS_OMX_BASEPORT      *pExynosPort = NULL;
1018
1019     FunctionIn();
1020
1021     if (hComponent == NULL) {
1022         ret = OMX_ErrorBadParameter;
1023         goto EXIT;
1024     }
1025     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1026     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1027     if (ret != OMX_ErrorNone) {
1028         goto EXIT;
1029     }
1030
1031     if (pOMXComponent->pComponentPrivate == NULL) {
1032         ret = OMX_ErrorBadParameter;
1033         goto EXIT;
1034     }
1035     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1036
1037     if (pExynosComponent->currentState == OMX_StateInvalid ) {
1038         ret = OMX_ErrorInvalidState;
1039         goto EXIT;
1040     }
1041
1042     if (ComponentParameterStructure == NULL) {
1043         ret = OMX_ErrorBadParameter;
1044         goto EXIT;
1045     }
1046
1047     switch (nParamIndex) {
1048     case OMX_IndexParamAudioInit:
1049     {
1050         OMX_PORT_PARAM_TYPE *portParam = (OMX_PORT_PARAM_TYPE *)ComponentParameterStructure;
1051         ret = Exynos_OMX_Check_SizeVersion(portParam, sizeof(OMX_PORT_PARAM_TYPE));
1052         if (ret != OMX_ErrorNone) {
1053             goto EXIT;
1054         }
1055
1056         portParam->nPorts           = pExynosComponent->portParam.nPorts;
1057         portParam->nStartPortNumber = pExynosComponent->portParam.nStartPortNumber;
1058         ret = OMX_ErrorNone;
1059     }
1060         break;
1061     case OMX_IndexParamAudioPortFormat:
1062     {
1063         OMX_AUDIO_PARAM_PORTFORMATTYPE *portFormat = (OMX_AUDIO_PARAM_PORTFORMATTYPE *)ComponentParameterStructure;
1064         OMX_U32                         portIndex = portFormat->nPortIndex;
1065         OMX_U32                         index    = portFormat->nIndex;
1066         EXYNOS_OMX_BASEPORT            *pExynosPort = NULL;
1067         OMX_PARAM_PORTDEFINITIONTYPE   *portDefinition = NULL;
1068         OMX_U32                         supportFormatNum = 0; /* supportFormatNum = N-1 */
1069
1070         ret = Exynos_OMX_Check_SizeVersion(portFormat, sizeof(OMX_AUDIO_PARAM_PORTFORMATTYPE));
1071         if (ret != OMX_ErrorNone) {
1072             goto EXIT;
1073         }
1074
1075         if ((portIndex >= pExynosComponent->portParam.nPorts)) {
1076             ret = OMX_ErrorBadPortIndex;
1077             goto EXIT;
1078         }
1079
1080
1081         if (portIndex == INPUT_PORT_INDEX) {
1082             supportFormatNum = INPUT_PORT_SUPPORTFORMAT_NUM_MAX - 1;
1083             if (index > supportFormatNum) {
1084                 ret = OMX_ErrorNoMore;
1085                 goto EXIT;
1086             }
1087
1088             pExynosPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1089             portDefinition = &pExynosPort->portDefinition;
1090
1091             portFormat->eEncoding = portDefinition->format.audio.eEncoding;
1092         } else if (portIndex == OUTPUT_PORT_INDEX) {
1093             supportFormatNum = OUTPUT_PORT_SUPPORTFORMAT_NUM_MAX - 1;
1094             if (index > supportFormatNum) {
1095                 ret = OMX_ErrorNoMore;
1096                 goto EXIT;
1097             }
1098
1099             pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1100             portDefinition = &pExynosPort->portDefinition;
1101
1102             portFormat->eEncoding = portDefinition->format.audio.eEncoding;
1103         }
1104         ret = OMX_ErrorNone;
1105     }
1106         break;
1107     default:
1108     {
1109         ret = Exynos_OMX_GetParameter(hComponent, nParamIndex, ComponentParameterStructure);
1110     }
1111         break;
1112     }
1113
1114 EXIT:
1115     FunctionOut();
1116
1117     return ret;
1118 }
1119 OMX_ERRORTYPE Exynos_OMX_AudioDecodeSetParameter(
1120     OMX_IN OMX_HANDLETYPE hComponent,
1121     OMX_IN OMX_INDEXTYPE  nIndex,
1122     OMX_IN OMX_PTR        ComponentParameterStructure)
1123 {
1124     OMX_ERRORTYPE             ret = OMX_ErrorNone;
1125     OMX_COMPONENTTYPE        *pOMXComponent = NULL;
1126     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1127     EXYNOS_OMX_BASEPORT      *pExynosPort = NULL;
1128
1129     FunctionIn();
1130
1131     if (hComponent == NULL) {
1132         ret = OMX_ErrorBadParameter;
1133         goto EXIT;
1134     }
1135     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1136     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1137     if (ret != OMX_ErrorNone) {
1138         goto EXIT;
1139     }
1140
1141     if (pOMXComponent->pComponentPrivate == NULL) {
1142         ret = OMX_ErrorBadParameter;
1143         goto EXIT;
1144     }
1145     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1146
1147     if (pExynosComponent->currentState == OMX_StateInvalid ) {
1148         ret = OMX_ErrorInvalidState;
1149         goto EXIT;
1150     }
1151
1152     if (ComponentParameterStructure == NULL) {
1153         ret = OMX_ErrorBadParameter;
1154         goto EXIT;
1155     }
1156
1157     switch (nIndex) {
1158     case OMX_IndexParamAudioPortFormat:
1159     {
1160         OMX_AUDIO_PARAM_PORTFORMATTYPE *portFormat = (OMX_AUDIO_PARAM_PORTFORMATTYPE *)ComponentParameterStructure;
1161         OMX_U32                         portIndex = portFormat->nPortIndex;
1162         OMX_U32                         index    = portFormat->nIndex;
1163         EXYNOS_OMX_BASEPORT            *pExynosPort = NULL;
1164         OMX_PARAM_PORTDEFINITIONTYPE   *portDefinition = NULL;
1165         OMX_U32                         supportFormatNum = 0; /* supportFormatNum = N-1 */
1166
1167         ret = Exynos_OMX_Check_SizeVersion(portFormat, sizeof(OMX_AUDIO_PARAM_PORTFORMATTYPE));
1168         if (ret != OMX_ErrorNone) {
1169             goto EXIT;
1170         }
1171
1172         if ((portIndex >= pExynosComponent->portParam.nPorts)) {
1173             ret = OMX_ErrorBadPortIndex;
1174             goto EXIT;
1175         }
1176
1177         pExynosPort = &pExynosComponent->pExynosPort[portIndex];
1178         portDefinition = &pExynosPort->portDefinition;
1179
1180         portDefinition->format.audio.eEncoding = portFormat->eEncoding;
1181         ret = OMX_ErrorNone;
1182     }
1183         break;
1184     default:
1185     {
1186         ret = Exynos_OMX_SetParameter(hComponent, nIndex, ComponentParameterStructure);
1187     }
1188         break;
1189     }
1190
1191 EXIT:
1192     FunctionOut();
1193
1194     return ret;
1195 }
1196
1197 OMX_ERRORTYPE Exynos_OMX_AudioDecodeGetConfig(
1198     OMX_HANDLETYPE hComponent,
1199     OMX_INDEXTYPE nIndex,
1200     OMX_PTR pComponentConfigStructure)
1201 {
1202     OMX_ERRORTYPE             ret = OMX_ErrorNone;
1203     OMX_COMPONENTTYPE        *pOMXComponent = NULL;
1204     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1205
1206     FunctionIn();
1207
1208     if (hComponent == NULL) {
1209         ret = OMX_ErrorBadParameter;
1210         goto EXIT;
1211     }
1212     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1213     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1214     if (ret != OMX_ErrorNone) {
1215         goto EXIT;
1216     }
1217
1218     if (pOMXComponent->pComponentPrivate == NULL) {
1219         ret = OMX_ErrorBadParameter;
1220         goto EXIT;
1221     }
1222     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1223
1224     if (pComponentConfigStructure == NULL) {
1225         ret = OMX_ErrorBadParameter;
1226         goto EXIT;
1227     }
1228     if (pExynosComponent->currentState == OMX_StateInvalid) {
1229         ret = OMX_ErrorInvalidState;
1230         goto EXIT;
1231     }
1232
1233     switch (nIndex) {
1234     default:
1235         ret = Exynos_OMX_GetConfig(hComponent, nIndex, pComponentConfigStructure);
1236         break;
1237     }
1238
1239 EXIT:
1240     FunctionOut();
1241
1242     return ret;
1243 }
1244
1245 OMX_ERRORTYPE Exynos_OMX_AudioDecodeSetConfig(
1246     OMX_HANDLETYPE hComponent,
1247     OMX_INDEXTYPE nIndex,
1248     OMX_PTR pComponentConfigStructure)
1249 {
1250     OMX_ERRORTYPE             ret = OMX_ErrorNone;
1251     OMX_COMPONENTTYPE        *pOMXComponent = NULL;
1252     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1253
1254     FunctionIn();
1255
1256     if (hComponent == NULL) {
1257         ret = OMX_ErrorBadParameter;
1258         goto EXIT;
1259     }
1260     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1261     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1262     if (ret != OMX_ErrorNone) {
1263         goto EXIT;
1264     }
1265
1266     if (pOMXComponent->pComponentPrivate == NULL) {
1267         ret = OMX_ErrorBadParameter;
1268         goto EXIT;
1269     }
1270     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1271
1272     if (pComponentConfigStructure == NULL) {
1273         ret = OMX_ErrorBadParameter;
1274         goto EXIT;
1275     }
1276     if (pExynosComponent->currentState == OMX_StateInvalid) {
1277         ret = OMX_ErrorInvalidState;
1278         goto EXIT;
1279     }
1280
1281     switch (nIndex) {
1282     case OMX_IndexConfigAudioMute:
1283     {
1284         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "OMX_IndexConfigAudioMute");
1285         ret = OMX_ErrorUnsupportedIndex;
1286     }
1287         break;
1288     case OMX_IndexConfigAudioVolume:
1289     {
1290         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "OMX_IndexConfigAudioVolume");
1291         ret = OMX_ErrorUnsupportedIndex;
1292     }
1293         break;
1294     default:
1295         ret = Exynos_OMX_SetConfig(hComponent, nIndex, pComponentConfigStructure);
1296         break;
1297     }
1298
1299 EXIT:
1300     FunctionOut();
1301
1302     return ret;
1303 }
1304
1305 OMX_ERRORTYPE Exynos_OMX_AudioDecodeGetExtensionIndex(
1306     OMX_IN OMX_HANDLETYPE  hComponent,
1307     OMX_IN OMX_STRING      cParameterName,
1308     OMX_OUT OMX_INDEXTYPE *pIndexType)
1309 {
1310     OMX_ERRORTYPE             ret = OMX_ErrorNone;
1311     OMX_COMPONENTTYPE        *pOMXComponent = NULL;
1312     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1313
1314     FunctionIn();
1315
1316     if (hComponent == NULL) {
1317         ret = OMX_ErrorBadParameter;
1318         goto EXIT;
1319     }
1320     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1321     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1322     if (ret != OMX_ErrorNone) {
1323         goto EXIT;
1324     }
1325
1326     if (pOMXComponent->pComponentPrivate == NULL) {
1327         ret = OMX_ErrorBadParameter;
1328         goto EXIT;
1329     }
1330     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1331
1332     if ((cParameterName == NULL) || (pIndexType == NULL)) {
1333         ret = OMX_ErrorBadParameter;
1334         goto EXIT;
1335     }
1336     if (pExynosComponent->currentState == OMX_StateInvalid) {
1337         ret = OMX_ErrorInvalidState;
1338         goto EXIT;
1339     }
1340
1341     ret = Exynos_OMX_GetExtensionIndex(hComponent, cParameterName, pIndexType);
1342
1343 EXIT:
1344     FunctionOut();
1345
1346     return ret;
1347 }
1348
1349 static OMX_ERRORTYPE Exynos_OMX_BufferProcessThread(OMX_PTR threadData)
1350 {
1351     OMX_ERRORTYPE          ret = OMX_ErrorNone;
1352     OMX_COMPONENTTYPE     *pOMXComponent = NULL;
1353     EXYNOS_OMX_BASECOMPONENT *pSECComponent = NULL;
1354     EXYNOS_OMX_MESSAGE       *message = NULL;
1355
1356     FunctionIn();
1357
1358     if (threadData == NULL) {
1359         ret = OMX_ErrorBadParameter;
1360         goto EXIT;
1361     }
1362     pOMXComponent = (OMX_COMPONENTTYPE *)threadData;
1363     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1364     if (ret != OMX_ErrorNone) {
1365         goto EXIT;
1366     }
1367     pSECComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1368     Exynos_OMX_BufferProcess(pOMXComponent);
1369
1370     Exynos_OSAL_ThreadExit(NULL);
1371
1372 EXIT:
1373     FunctionOut();
1374
1375     return ret;
1376 }
1377
1378 OMX_ERRORTYPE Exynos_OMX_BufferProcess_Create(OMX_HANDLETYPE hComponent)
1379 {
1380     OMX_ERRORTYPE          ret = OMX_ErrorNone;
1381     OMX_COMPONENTTYPE     *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1382     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1383     EXYNOS_OMX_AUDIODEC_COMPONENT *pAudioDec = (EXYNOS_OMX_AUDIODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1384
1385     FunctionIn();
1386
1387     pAudioDec->bExitBufferProcessThread = OMX_FALSE;
1388
1389     ret = Exynos_OSAL_ThreadCreate(&pAudioDec->hBufferProcessThread,
1390                  Exynos_OMX_BufferProcessThread,
1391                  pOMXComponent);
1392
1393 EXIT:
1394     FunctionOut();
1395
1396     return ret;
1397 }
1398
1399 OMX_ERRORTYPE Exynos_OMX_BufferProcess_Terminate(OMX_HANDLETYPE hComponent)
1400 {
1401     OMX_ERRORTYPE          ret = OMX_ErrorNone;
1402     OMX_COMPONENTTYPE     *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1403     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1404     EXYNOS_OMX_AUDIODEC_COMPONENT *pAudioDec = (EXYNOS_OMX_AUDIODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1405     OMX_S32                countValue = 0;
1406     unsigned int           i = 0;
1407
1408     FunctionIn();
1409
1410     pAudioDec->bExitBufferProcessThread = OMX_TRUE;
1411
1412     for (i = 0; i < ALL_PORT_NUM; i++) {
1413         Exynos_OSAL_Get_SemaphoreCount(pExynosComponent->pExynosPort[i].bufferSemID, &countValue);
1414         if (countValue == 0)
1415             Exynos_OSAL_SemaphorePost(pExynosComponent->pExynosPort[i].bufferSemID);
1416     }
1417
1418     Exynos_OSAL_SignalSet(pExynosComponent->pauseEvent);
1419     Exynos_OSAL_ThreadTerminate(pAudioDec->hBufferProcessThread);
1420     pAudioDec->hBufferProcessThread = NULL;
1421
1422 EXIT:
1423     FunctionOut();
1424
1425     return ret;
1426 }
1427
1428 OMX_ERRORTYPE Exynos_OMX_AudioDecodeComponentInit(OMX_IN OMX_HANDLETYPE hComponent)
1429 {
1430     OMX_ERRORTYPE                  ret = OMX_ErrorNone;
1431     OMX_COMPONENTTYPE             *pOMXComponent = NULL;
1432     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = NULL;
1433     EXYNOS_OMX_BASEPORT           *pExynosPort = NULL;
1434     EXYNOS_OMX_AUDIODEC_COMPONENT *pAudioDec = NULL;
1435
1436     FunctionIn();
1437
1438     if (hComponent == NULL) {
1439         ret = OMX_ErrorBadParameter;
1440         goto EXIT;
1441     }
1442     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1443     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1444     if (ret != OMX_ErrorNone) {
1445         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_Error, Line:%d", __LINE__);
1446         goto EXIT;
1447     }
1448
1449     ret = Exynos_OMX_BaseComponent_Constructor(pOMXComponent);
1450     if (ret != OMX_ErrorNone) {
1451         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_Error, Line:%d", __LINE__);
1452         goto EXIT;
1453     }
1454
1455     ret = Exynos_OMX_Port_Constructor(pOMXComponent);
1456     if (ret != OMX_ErrorNone) {
1457         Exynos_OMX_BaseComponent_Destructor(pOMXComponent);
1458         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_Error, Line:%d", __LINE__);
1459         goto EXIT;
1460     }
1461
1462     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1463
1464     pAudioDec = Exynos_OSAL_Malloc(sizeof(EXYNOS_OMX_AUDIODEC_COMPONENT));
1465     if (pAudioDec == NULL) {
1466         Exynos_OMX_BaseComponent_Destructor(pOMXComponent);
1467         ret = OMX_ErrorInsufficientResources;
1468         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
1469         goto EXIT;
1470     }
1471
1472     Exynos_OSAL_Memset(pAudioDec, 0, sizeof(EXYNOS_OMX_AUDIODEC_COMPONENT));
1473     pExynosComponent->hComponentHandle = (OMX_HANDLETYPE)pAudioDec;
1474     pExynosComponent->bSaveFlagEOS = OMX_FALSE;
1475     pExynosComponent->bMultiThreadProcess = OMX_FALSE;
1476
1477     /* Input port */
1478     pExynosPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1479     pExynosPort->portDefinition.nBufferCountActual = MAX_AUDIO_INPUTBUFFER_NUM;
1480     pExynosPort->portDefinition.nBufferCountMin = MAX_AUDIO_INPUTBUFFER_NUM;
1481     pExynosPort->portDefinition.nBufferSize = DEFAULT_AUDIO_INPUT_BUFFER_SIZE;
1482     pExynosPort->portDefinition.eDomain = OMX_PortDomainAudio;
1483
1484     pExynosPort->portDefinition.format.audio.cMIMEType = Exynos_OSAL_Malloc(MAX_OMX_MIMETYPE_SIZE);
1485     Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.audio.cMIMEType, "audio/raw");
1486     pExynosPort->portDefinition.format.audio.pNativeRender = 0;
1487     pExynosPort->portDefinition.format.audio.bFlagErrorConcealment = OMX_FALSE;
1488     pExynosPort->portDefinition.format.audio.eEncoding = OMX_AUDIO_CodingUnused;
1489
1490     /* Output port */
1491     pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1492     pExynosPort->portDefinition.nBufferCountActual = MAX_AUDIO_OUTPUTBUFFER_NUM;
1493     pExynosPort->portDefinition.nBufferCountMin = MAX_AUDIO_OUTPUTBUFFER_NUM;
1494     pExynosPort->portDefinition.nBufferSize = DEFAULT_AUDIO_OUTPUT_BUFFER_SIZE;
1495     pExynosPort->portDefinition.eDomain = OMX_PortDomainAudio;
1496
1497     pExynosPort->portDefinition.format.audio.cMIMEType = Exynos_OSAL_Malloc(MAX_OMX_MIMETYPE_SIZE);
1498     Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.audio.cMIMEType, "audio/raw");
1499     pExynosPort->portDefinition.format.audio.pNativeRender = 0;
1500     pExynosPort->portDefinition.format.audio.bFlagErrorConcealment = OMX_FALSE;
1501     pExynosPort->portDefinition.format.audio.eEncoding = OMX_AUDIO_CodingUnused;
1502
1503
1504     pOMXComponent->UseBuffer              = &Exynos_OMX_UseBuffer;
1505     pOMXComponent->AllocateBuffer         = &Exynos_OMX_AllocateBuffer;
1506     pOMXComponent->FreeBuffer             = &Exynos_OMX_FreeBuffer;
1507     pOMXComponent->ComponentTunnelRequest = &Exynos_OMX_ComponentTunnelRequest;
1508
1509     pExynosComponent->exynos_AllocateTunnelBuffer = &Exynos_OMX_AllocateTunnelBuffer;
1510     pExynosComponent->exynos_FreeTunnelBuffer     = &Exynos_OMX_FreeTunnelBuffer;
1511     pExynosComponent->exynos_BufferProcessCreate    = &Exynos_OMX_BufferProcess_Create;
1512     pExynosComponent->exynos_BufferProcessTerminate = &Exynos_OMX_BufferProcess_Terminate;
1513     pExynosComponent->exynos_BufferFlush          = &Exynos_OMX_BufferFlush;
1514
1515 EXIT:
1516     FunctionOut();
1517
1518     return ret;
1519 }
1520
1521 OMX_ERRORTYPE Exynos_OMX_AudioDecodeComponentDeinit(OMX_IN OMX_HANDLETYPE hComponent)
1522 {
1523     OMX_ERRORTYPE                  ret = OMX_ErrorNone;
1524     OMX_COMPONENTTYPE             *pOMXComponent = NULL;
1525     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = NULL;
1526     EXYNOS_OMX_BASEPORT           *pExynosPort = NULL;
1527     EXYNOS_OMX_AUDIODEC_COMPONENT *pAudioDec = NULL;
1528     int                            i = 0;
1529
1530     FunctionIn();
1531
1532     if (hComponent == NULL) {
1533         ret = OMX_ErrorBadParameter;
1534         goto EXIT;
1535     }
1536     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1537     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1538     if (ret != OMX_ErrorNone) {
1539         goto EXIT;
1540     }
1541
1542     if (pOMXComponent->pComponentPrivate == NULL) {
1543         ret = OMX_ErrorBadParameter;
1544         goto EXIT;
1545     }
1546     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1547
1548     pAudioDec = (EXYNOS_OMX_AUDIODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1549     Exynos_OSAL_Free(pAudioDec);
1550     pExynosComponent->hComponentHandle = pAudioDec = NULL;
1551
1552     for(i = 0; i < ALL_PORT_NUM; i++) {
1553         pExynosPort = &pExynosComponent->pExynosPort[i];
1554         Exynos_OSAL_Free(pExynosPort->portDefinition.format.audio.cMIMEType);
1555         pExynosPort->portDefinition.format.audio.cMIMEType = NULL;
1556     }
1557
1558     ret = Exynos_OMX_Port_Destructor(pOMXComponent);
1559
1560     ret = Exynos_OMX_BaseComponent_Destructor(hComponent);
1561
1562 EXIT:
1563     FunctionOut();
1564
1565     return ret;
1566 }