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