component/video/enc/Exynos_OMX_VencControl.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_VencControl.c
  20  * @brief
  21  * @author      SeungBeom Kim (sbcrux.kim@samsung.com)
  22  * @version     2.0.0
  23  * @history
  24  *   2012.02.20 : Create
  25  */
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include "Exynos_OMX_Macros.h"
  31 #include "Exynos_OSAL_Event.h"
  32 #include "Exynos_OMX_Venc.h"
  33 #include "Exynos_OMX_VencControl.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 "Exynos_OSAL_SharedMemory.h"
  40
  41 #ifdef USE_ANB
  42 #include "Exynos_OSAL_Android.h"
  43 #endif
  44
  45 #undef  EXYNOS_LOG_TAG
  46 #define EXYNOS_LOG_TAG    "EXYNOS_VIDEO_ENCCONTROL"
  47 #define EXYNOS_LOG_OFF
  48 //#define EXYNOS_TRACE_ON
  49 #include "Exynos_OSAL_Log.h"
  50
  51
  52 OMX_ERRORTYPE Exynos_OMX_UseBuffer(
  53     OMX_IN OMX_HANDLETYPE            hComponent,
  54     OMX_INOUT OMX_BUFFERHEADERTYPE **ppBufferHdr,
  55     OMX_IN OMX_U32                   nPortIndex,
  56     OMX_IN OMX_PTR                   pAppPrivate,
  57     OMX_IN OMX_U32                   nSizeBytes,
  58     OMX_IN OMX_U8                   *pBuffer)
  59 {
  60     OMX_ERRORTYPE             ret               = OMX_ErrorNone;
  61     OMX_COMPONENTTYPE        *pOMXComponent     = NULL;
  62     EXYNOS_OMX_BASECOMPONENT *pExynosComponent  = NULL;
  63     EXYNOS_OMX_BASEPORT      *pExynosPort       = NULL;
  64     OMX_BUFFERHEADERTYPE     *pTempBufferHdr    = NULL;
  65     OMX_U32                   i                 = 0;
  66
  67     FunctionIn();
  68
  69     if (hComponent == NULL) {
  70         ret = OMX_ErrorBadParameter;
  71         goto EXIT;
  72     }
  73     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
  74
  75     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
  76     if (ret != OMX_ErrorNone) {
  77         goto EXIT;
  78     }
  79
  80     if (pOMXComponent->pComponentPrivate == NULL) {
  81         ret = OMX_ErrorBadParameter;
  82         goto EXIT;
  83     }
  84     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
  85
  86     if (nPortIndex >= pExynosComponent->portParam.nPorts) {
  87         ret = OMX_ErrorBadPortIndex;
  88         goto EXIT;
  89     }
  90     pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
  91
  92     if (pExynosPort->portState != OMX_StateIdle) {
  93         ret = OMX_ErrorIncorrectStateOperation;
  94         goto EXIT;
  95     }
  96
  97     if (CHECK_PORT_TUNNELED(pExynosPort) && CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)) {
  98         ret = OMX_ErrorBadPortIndex;
  99         goto EXIT;
 100     }
 101
 102     pTempBufferHdr = (OMX_BUFFERHEADERTYPE *)Exynos_OSAL_Malloc(sizeof(OMX_BUFFERHEADERTYPE));
 103     if (pTempBufferHdr == NULL) {
 104         ret = OMX_ErrorInsufficientResources;
 105         goto EXIT;
 106     }
 107     Exynos_OSAL_Memset(pTempBufferHdr, 0, sizeof(OMX_BUFFERHEADERTYPE));
 108
 109     for (i = 0; i < pExynosPort->portDefinition.nBufferCountActual; i++) {
 110         if (pExynosPort->bufferStateAllocate[i] == BUFFER_STATE_FREE) {
 111             pExynosPort->extendBufferHeader[i].OMXBufferHeader = pTempBufferHdr;
 112             pExynosPort->bufferStateAllocate[i] = (BUFFER_STATE_ASSIGNED | HEADER_STATE_ALLOCATED);
 113             INIT_SET_SIZE_VERSION(pTempBufferHdr, OMX_BUFFERHEADERTYPE);
 114             pTempBufferHdr->pBuffer        = pBuffer;
 115             pTempBufferHdr->nAllocLen      = nSizeBytes;
 116             pTempBufferHdr->pAppPrivate    = pAppPrivate;
 117             if (nPortIndex == INPUT_PORT_INDEX)
 118                 pTempBufferHdr->nInputPortIndex = INPUT_PORT_INDEX;
 119             else
 120                 pTempBufferHdr->nOutputPortIndex = OUTPUT_PORT_INDEX;
 121
 122             pExynosPort->assignedBufferNum++;
 123             if (pExynosPort->assignedBufferNum == pExynosPort->portDefinition.nBufferCountActual) {
 124                 pExynosPort->portDefinition.bPopulated = OMX_TRUE;
 125                 /* Exynos_OSAL_MutexLock(pExynosComponent->compMutex); */
 126                 Exynos_OSAL_SemaphorePost(pExynosPort->loadedResource);
 127                 /* Exynos_OSAL_MutexUnlock(pExynosComponent->compMutex); */
 128             }
 129             *ppBufferHdr = pTempBufferHdr;
 130             ret = OMX_ErrorNone;
 131             goto EXIT;
 132         }
 133     }
 134
 135     Exynos_OSAL_Free(pTempBufferHdr);
 136     ret = OMX_ErrorInsufficientResources;
 137
 138 EXIT:
 139     FunctionOut();
 140
 141     return ret;
 142 }
 143
 144 OMX_ERRORTYPE Exynos_OMX_AllocateBuffer(
 145     OMX_IN OMX_HANDLETYPE            hComponent,
 146     OMX_INOUT OMX_BUFFERHEADERTYPE **ppBufferHdr,
 147     OMX_IN OMX_U32                   nPortIndex,
 148     OMX_IN OMX_PTR                   pAppPrivate,
 149     OMX_IN OMX_U32                   nSizeBytes)
 150 {
 151     OMX_ERRORTYPE                    ret                = OMX_ErrorNone;
 152     OMX_COMPONENTTYPE               *pOMXComponent      = NULL;
 153     EXYNOS_OMX_BASECOMPONENT        *pExynosComponent   = NULL;
 154     EXYNOS_OMX_VIDEOENC_COMPONENT   *pVideoEnc          = NULL;
 155     EXYNOS_OMX_BASEPORT             *pExynosPort        = NULL;
 156     OMX_BUFFERHEADERTYPE            *pTempBufferHdr     = NULL;
 157     OMX_U8                          *pTempBuffer        = NULL;
 158     int                              fdTempBuffer       = -1;
 159     MEMORY_TYPE                      eMemType           = SYSTEM_MEMORY;
 160     OMX_U32                          i                  = 0;
 161
 162     FunctionIn();
 163
 164     if (hComponent == NULL) {
 165         ret = OMX_ErrorBadParameter;
 166         goto EXIT;
 167     }
 168     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
 169
 170     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
 171     if (ret != OMX_ErrorNone) {
 172         goto EXIT;
 173     }
 174
 175     if (pOMXComponent->pComponentPrivate == NULL) {
 176         ret = OMX_ErrorBadParameter;
 177         goto EXIT;
 178     }
 179     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 180
 181     if (pExynosComponent->hComponentHandle == NULL) {
 182         ret = OMX_ErrorBadParameter;
 183         goto EXIT;
 184     }
 185     pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
 186
 187     if (nPortIndex >= pExynosComponent->portParam.nPorts) {
 188         ret = OMX_ErrorBadPortIndex;
 189         goto EXIT;
 190     }
 191     pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
 192 /*
 193     if (pExynosPort->portState != OMX_StateIdle ) {
 194         ret = OMX_ErrorIncorrectStateOperation;
 195         goto EXIT;
 196     }
 197 */
 198     if (CHECK_PORT_TUNNELED(pExynosPort) && CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)) {
 199         ret = OMX_ErrorBadPortIndex;
 200         goto EXIT;
 201     }
 202
 203     if ((pVideoEnc->bDRMPlayerMode == OMX_TRUE) &&
 204         (nPortIndex == OUTPUT_PORT_INDEX)) {
 205         eMemType = SECURE_MEMORY;
 206     } else if (pExynosPort->bNeedContigMem == OMX_TRUE) {
 207         eMemType = CONTIG_MEMORY;
 208     } else if ((nPortIndex == INPUT_PORT_INDEX) &&
 209                (pExynosPort->bufferProcessType & BUFFER_SHARE)) {
 210         eMemType = NORMAL_MEMORY;
 211     }
 212
 213     pTempBuffer = Exynos_OSAL_SharedMemory_Alloc(pVideoEnc->hSharedMemory, nSizeBytes, eMemType);
 214     if (pTempBuffer == NULL) {
 215         ret = OMX_ErrorInsufficientResources;
 216         goto EXIT;
 217     }
 218     fdTempBuffer = Exynos_OSAL_SharedMemory_VirtToION(pVideoEnc->hSharedMemory, pTempBuffer);
 219
 220     pTempBufferHdr = (OMX_BUFFERHEADERTYPE *)Exynos_OSAL_Malloc(sizeof(OMX_BUFFERHEADERTYPE));
 221     if (pTempBufferHdr == NULL) {
 222         Exynos_OSAL_SharedMemory_Free(pVideoEnc->hSharedMemory, pTempBuffer);
 223         ret = OMX_ErrorInsufficientResources;
 224         goto EXIT;
 225     }
 226     Exynos_OSAL_Memset(pTempBufferHdr, 0, sizeof(OMX_BUFFERHEADERTYPE));
 227
 228     for (i = 0; i < pExynosPort->portDefinition.nBufferCountActual; i++) {
 229         if (pExynosPort->bufferStateAllocate[i] == BUFFER_STATE_FREE) {
 230             pExynosPort->extendBufferHeader[i].OMXBufferHeader = pTempBufferHdr;
 231             pExynosPort->extendBufferHeader[i].buf_fd[0] = fdTempBuffer;
 232             pExynosPort->bufferStateAllocate[i] = (BUFFER_STATE_ALLOCATED | HEADER_STATE_ALLOCATED);
 233             INIT_SET_SIZE_VERSION(pTempBufferHdr, OMX_BUFFERHEADERTYPE);
 234             if (eMemType == SECURE_MEMORY)
 235                 pTempBufferHdr->pBuffer = fdTempBuffer;
 236             else
 237                 pTempBufferHdr->pBuffer = pTempBuffer;
 238             pTempBufferHdr->nAllocLen      = nSizeBytes;
 239             pTempBufferHdr->pAppPrivate    = pAppPrivate;
 240             if (nPortIndex == INPUT_PORT_INDEX)
 241                 pTempBufferHdr->nInputPortIndex = INPUT_PORT_INDEX;
 242             else
 243                 pTempBufferHdr->nOutputPortIndex = OUTPUT_PORT_INDEX;
 244             pExynosPort->assignedBufferNum++;
 245             if (pExynosPort->assignedBufferNum == pExynosPort->portDefinition.nBufferCountActual) {
 246                 pExynosPort->portDefinition.bPopulated = OMX_TRUE;
 247                 /* Exynos_OSAL_MutexLock(pExynosComponent->compMutex); */
 248                 Exynos_OSAL_SemaphorePost(pExynosPort->loadedResource);
 249                 /* Exynos_OSAL_MutexUnlock(pExynosComponent->compMutex); */
 250             }
 251             *ppBufferHdr = pTempBufferHdr;
 252             ret = OMX_ErrorNone;
 253             goto EXIT;
 254         }
 255     }
 256
 257     Exynos_OSAL_Free(pTempBufferHdr);
 258     Exynos_OSAL_SharedMemory_Free(pVideoEnc->hSharedMemory, pTempBuffer);
 259
 260     ret = OMX_ErrorInsufficientResources;
 261
 262 EXIT:
 263     FunctionOut();
 264
 265     return ret;
 266 }
 267
 268 OMX_ERRORTYPE Exynos_OMX_FreeBuffer(
 269     OMX_IN OMX_HANDLETYPE        hComponent,
 270     OMX_IN OMX_U32               nPortIndex,
 271     OMX_IN OMX_BUFFERHEADERTYPE *pBufferHdr)
 272 {
 273     OMX_ERRORTYPE                    ret                = OMX_ErrorNone;
 274     OMX_COMPONENTTYPE               *pOMXComponent      = NULL;
 275     EXYNOS_OMX_BASECOMPONENT        *pExynosComponent   = NULL;
 276     EXYNOS_OMX_VIDEOENC_COMPONENT   *pVideoEnc          = NULL;
 277     EXYNOS_OMX_BASEPORT             *pExynosPort        = NULL;
 278     OMX_BUFFERHEADERTYPE            *pOMXBufferHdr      = NULL;
 279     OMX_U32                          i                  = 0;
 280
 281     FunctionIn();
 282
 283     if (hComponent == NULL) {
 284         ret = OMX_ErrorBadParameter;
 285         goto EXIT;
 286     }
 287     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
 288
 289     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
 290     if (ret != OMX_ErrorNone) {
 291         goto EXIT;
 292     }
 293
 294     if (pOMXComponent->pComponentPrivate == NULL) {
 295         ret = OMX_ErrorBadParameter;
 296         goto EXIT;
 297     }
 298     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 299
 300     if (pExynosComponent->hComponentHandle == NULL) {
 301         ret = OMX_ErrorBadParameter;
 302         goto EXIT;
 303     }
 304     pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
 305
 306     if (nPortIndex >= pExynosComponent->portParam.nPorts) {
 307         ret = OMX_ErrorBadPortIndex;
 308         goto EXIT;
 309     }
 310     pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
 311
 312     if (CHECK_PORT_TUNNELED(pExynosPort) && CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)) {
 313         ret = OMX_ErrorBadPortIndex;
 314         goto EXIT;
 315     }
 316
 317     if ((pExynosPort->portState != OMX_StateLoaded) &&
 318         (pExynosPort->portState != OMX_StateInvalid)) {
 319         (*(pExynosComponent->pCallbacks->EventHandler)) (pOMXComponent,
 320                         pExynosComponent->callbackData,
 321                         (OMX_U32)OMX_EventError,
 322                         (OMX_U32)OMX_ErrorPortUnpopulated,
 323                         nPortIndex, NULL);
 324     }
 325
 326     for (i = 0; i < /*pExynosPort->portDefinition.nBufferCountActual*/MAX_BUFFER_NUM; i++) {
 327         if ((pExynosPort->bufferStateAllocate[i] != BUFFER_STATE_FREE) &&
 328             (pExynosPort->extendBufferHeader[i].OMXBufferHeader != NULL)) {
 329             pOMXBufferHdr = pExynosPort->extendBufferHeader[i].OMXBufferHeader;
 330
 331             if (pOMXBufferHdr->pBuffer == pBufferHdr->pBuffer) {
 332                 if (pExynosPort->bufferStateAllocate[i] & BUFFER_STATE_ALLOCATED) {
 333                     if ((pVideoEnc->bDRMPlayerMode == OMX_TRUE) &&
 334                         (nPortIndex == OUTPUT_PORT_INDEX)) {
 335                         OMX_PTR mapBuffer = Exynos_OSAL_SharedMemory_IONToVirt(pVideoEnc->hSharedMemory, (int)pOMXBufferHdr->pBuffer);
 336                         Exynos_OSAL_SharedMemory_Free(pVideoEnc->hSharedMemory, mapBuffer);
 337                     } else {
 338                         Exynos_OSAL_SharedMemory_Free(pVideoEnc->hSharedMemory, pOMXBufferHdr->pBuffer);
 339                     }
 340                     pOMXBufferHdr->pBuffer = NULL;
 341                     pBufferHdr->pBuffer = NULL;
 342                 } else if (pExynosPort->bufferStateAllocate[i] & BUFFER_STATE_ASSIGNED) {
 343                     ; /* None*/
 344                 }
 345                 pExynosPort->assignedBufferNum--;
 346
 347                 if (pExynosPort->bufferStateAllocate[i] & HEADER_STATE_ALLOCATED) {
 348                     Exynos_OSAL_Free(pOMXBufferHdr);
 349                     pExynosPort->extendBufferHeader[i].OMXBufferHeader = NULL;
 350                     pBufferHdr = NULL;
 351                 }
 352
 353                 pExynosPort->bufferStateAllocate[i] = BUFFER_STATE_FREE;
 354                 ret = OMX_ErrorNone;
 355                 goto EXIT;
 356             }
 357         }
 358     }
 359
 360 EXIT:
 361     if ((ret == OMX_ErrorNone) &&
 362         (pExynosPort->assignedBufferNum == 0)) {
 363         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pExynosPort->unloadedResource signal set");
 364         /* Exynos_OSAL_MutexLock(pExynosComponent->compMutex); */
 365         Exynos_OSAL_SemaphorePost(pExynosPort->unloadedResource);
 366         /* Exynos_OSAL_MutexUnlock(pExynosComponent->compMutex); */
 367         pExynosPort->portDefinition.bPopulated = OMX_FALSE;
 368     }
 369
 370     FunctionOut();
 371
 372     return ret;
 373 }
 374
 375 OMX_ERRORTYPE Exynos_OMX_AllocateTunnelBuffer(
 376     EXYNOS_OMX_BASEPORT     *pOMXBasePort,
 377     OMX_U32                  nPortIndex)
 378 {
 379     OMX_ERRORTYPE                 ret               = OMX_ErrorNone;
 380     EXYNOS_OMX_BASEPORT          *pExynosPort       = NULL;
 381     OMX_BUFFERHEADERTYPE         *pTempBufferHdr    = NULL;
 382     OMX_U8                       *pTempBuffer       = NULL;
 383     OMX_U32                       nBufferSize       = 0;
 384     OMX_PARAM_PORTDEFINITIONTYPE  portDefinition;
 385
 386     ret = OMX_ErrorTunnelingUnsupported;
 387 EXIT:
 388     return ret;
 389 }
 390
 391 OMX_ERRORTYPE Exynos_OMX_FreeTunnelBuffer(
 392     EXYNOS_OMX_BASEPORT     *pOMXBasePort,
 393     OMX_U32                  nPortIndex)
 394 {
 395     OMX_ERRORTYPE            ret            = OMX_ErrorNone;
 396     EXYNOS_OMX_BASEPORT     *pExynosPort    = NULL;
 397     OMX_BUFFERHEADERTYPE    *pTempBufferHdr = NULL;
 398     OMX_U8                  *pTempBuffer    = NULL;
 399     OMX_U32                  nBufferSize    = 0;
 400
 401     ret = OMX_ErrorTunnelingUnsupported;
 402 EXIT:
 403     return ret;
 404 }
 405
 406 OMX_ERRORTYPE Exynos_OMX_ComponentTunnelRequest(
 407     OMX_IN OMX_HANDLETYPE hComp,
 408     OMX_IN OMX_U32        nPort,
 409     OMX_IN OMX_HANDLETYPE hTunneledComp,
 410     OMX_IN OMX_U32        nTunneledPort,
 411     OMX_INOUT OMX_TUNNELSETUPTYPE *pTunnelSetup)
 412 {
 413     OMX_ERRORTYPE ret = OMX_ErrorNone;
 414
 415     ret = OMX_ErrorTunnelingUnsupported;
 416 EXIT:
 417     return ret;
 418 }
 419
 420 OMX_ERRORTYPE Exynos_OMX_GetFlushBuffer(
 421     EXYNOS_OMX_BASEPORT     *pExynosPort,
 422     EXYNOS_OMX_DATABUFFER   *pDataBuffer[])
 423 {
 424     OMX_ERRORTYPE ret = OMX_ErrorNone;
 425
 426     FunctionIn();
 427
 428     *pDataBuffer = NULL;
 429
 430     if (pExynosPort->portWayType == WAY1_PORT) {
 431         *pDataBuffer = &pExynosPort->way.port1WayDataBuffer.dataBuffer;
 432     } else if (pExynosPort->portWayType == WAY2_PORT) {
 433         pDataBuffer[0] = &(pExynosPort->way.port2WayDataBuffer.inputDataBuffer);
 434         pDataBuffer[1] = &(pExynosPort->way.port2WayDataBuffer.outputDataBuffer);
 435     }
 436
 437 EXIT:
 438     FunctionOut();
 439
 440     return ret;
 441 }
 442
 443 OMX_ERRORTYPE Exynos_OMX_FlushPort(
 444     OMX_COMPONENTTYPE   *pOMXComponent,
 445     OMX_S32              nPortIndex)
 446 {
 447     OMX_ERRORTYPE             ret               = OMX_ErrorNone;
 448     EXYNOS_OMX_BASECOMPONENT *pExynosComponent  = NULL;
 449     EXYNOS_OMX_BASEPORT      *pExynosPort       = NULL;
 450     OMX_BUFFERHEADERTYPE     *pBufferHdr        = NULL;
 451     EXYNOS_OMX_DATABUFFER    *pDataBuffer[2]    = {NULL, NULL};
 452     EXYNOS_OMX_MESSAGE       *pMessage          = NULL;
 453     OMX_S32                   nSemaCnt          = 0;
 454     int                       i                 = 0;
 455
 456     FunctionIn();
 457
 458     if (pOMXComponent == NULL) {
 459         ret = OMX_ErrorBadParameter;
 460         goto EXIT;
 461     }
 462
 463     if (pOMXComponent->pComponentPrivate == NULL) {
 464         ret = OMX_ErrorBadParameter;
 465         goto EXIT;
 466     }
 467     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 468
 469     if ((nPortIndex < 0) ||
 470         (nPortIndex >= pExynosComponent->portParam.nPorts)) {
 471         ret = OMX_ErrorBadPortIndex;
 472         goto EXIT;
 473     }
 474     pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
 475
 476     while (Exynos_OSAL_GetElemNum(&pExynosPort->bufferQ) > 0) {
 477         Exynos_OSAL_Get_SemaphoreCount(pExynosPort->bufferSemID, &nSemaCnt);
 478         if (nSemaCnt == 0)
 479             Exynos_OSAL_SemaphorePost(pExynosPort->bufferSemID);
 480
 481         Exynos_OSAL_SemaphoreWait(pExynosPort->bufferSemID);
 482         pMessage = (EXYNOS_OMX_MESSAGE *)Exynos_OSAL_Dequeue(&pExynosPort->bufferQ);
 483         if ((pMessage != NULL) &&
 484             (pMessage->messageType != EXYNOS_OMX_CommandFakeBuffer)) {
 485             pBufferHdr = (OMX_BUFFERHEADERTYPE *)pMessage->pCmdData;
 486             pBufferHdr->nFilledLen = 0;
 487
 488             if (nPortIndex == OUTPUT_PORT_INDEX) {
 489                 Exynos_OMX_OutputBufferReturn(pOMXComponent, pBufferHdr);
 490             } else if (nPortIndex == INPUT_PORT_INDEX) {
 491                 Exynos_OMX_InputBufferReturn(pOMXComponent, pBufferHdr);
 492             }
 493         }
 494         Exynos_OSAL_Free(pMessage);
 495         pMessage = NULL;
 496     }
 497
 498     Exynos_OMX_GetFlushBuffer(pExynosPort, pDataBuffer);
 499     if ((pDataBuffer[0] != NULL) &&
 500         (pDataBuffer[0]->dataValid == OMX_TRUE)) {
 501         if (nPortIndex == INPUT_PORT_INDEX)
 502             Exynos_FlushInputBufferReturn(pOMXComponent, pDataBuffer[0]);
 503         else if (nPortIndex == OUTPUT_PORT_INDEX)
 504             Exynos_FlushOutputBufferReturn(pOMXComponent, pDataBuffer[0]);
 505     }
 506     if ((pDataBuffer[1] != NULL) &&
 507         (pDataBuffer[1]->dataValid == OMX_TRUE)) {
 508         if (nPortIndex == INPUT_PORT_INDEX)
 509             Exynos_FlushInputBufferReturn(pOMXComponent, pDataBuffer[1]);
 510         else if (nPortIndex == OUTPUT_PORT_INDEX)
 511             Exynos_FlushOutputBufferReturn(pOMXComponent, pDataBuffer[1]);
 512     }
 513
 514     if (pExynosComponent->bMultiThreadProcess == OMX_TRUE) {
 515         if (pExynosPort->bufferProcessType & BUFFER_SHARE) {
 516             if (pExynosPort->processData.bufferHeader != NULL) {
 517                 if (nPortIndex == INPUT_PORT_INDEX) {
 518 #ifdef USE_METADATABUFFERTYPE
 519                     if ((pExynosPort->bStoreMetaData == OMX_TRUE) &&
 520                         (pExynosPort->portDefinition.format.video.eColorFormat == OMX_COLOR_FormatAndroidOpaque)) {
 521                         OMX_PTR ppBuf[MAX_BUFFER_PLANE];
 522                         Exynos_OSAL_GetInfoFromMetaData((OMX_BYTE)pExynosPort->processData.bufferHeader->pBuffer, ppBuf);
 523                         Exynos_OSAL_UnlockANBHandle(ppBuf[0]);
 524                     }
 525 #endif
 526                     Exynos_OMX_InputBufferReturn(pOMXComponent, pExynosPort->processData.bufferHeader);
 527                 } else if (nPortIndex == OUTPUT_PORT_INDEX) {
 528                     Exynos_OMX_OutputBufferReturn(pOMXComponent, pExynosPort->processData.bufferHeader);
 529                 }
 530             }
 531             Exynos_ResetCodecData(&pExynosPort->processData);
 532
 533             for (i = 0; i < pExynosPort->portDefinition.nBufferCountActual; i++) {
 534                 if (pExynosPort->extendBufferHeader[i].bBufferInOMX == OMX_TRUE) {
 535                     if (nPortIndex == OUTPUT_PORT_INDEX) {
 536                         Exynos_OMX_OutputBufferReturn(pOMXComponent,
 537                                                       pExynosPort->extendBufferHeader[i].OMXBufferHeader);
 538                     } else if (nPortIndex == INPUT_PORT_INDEX) {
 539 #ifdef USE_METADATABUFFERTYPE
 540                         if ((pExynosPort->bStoreMetaData == OMX_TRUE) &&
 541                             (pExynosPort->portDefinition.format.video.eColorFormat == OMX_COLOR_FormatAndroidOpaque)) {
 542                             OMX_PTR ppBuf[MAX_BUFFER_PLANE];
 543                             Exynos_OSAL_GetInfoFromMetaData((OMX_BYTE)pExynosPort->extendBufferHeader[i].OMXBufferHeader->pBuffer, ppBuf);
 544                             Exynos_OSAL_UnlockANBHandle(ppBuf[0]);
 545                         }
 546 #endif
 547                         Exynos_OMX_InputBufferReturn(pOMXComponent,
 548                                                      pExynosPort->extendBufferHeader[i].OMXBufferHeader);
 549                     }
 550                 }
 551             }
 552         }
 553     } else {
 554         Exynos_ResetCodecData(&pExynosPort->processData);
 555     }
 556
 557     while (1) {
 558         OMX_S32 cnt = 0;
 559         Exynos_OSAL_Get_SemaphoreCount(pExynosPort->bufferSemID, &cnt);
 560         if (cnt <= 0)
 561             break;
 562         Exynos_OSAL_SemaphoreWait(pExynosPort->bufferSemID);
 563     }
 564     Exynos_OSAL_ResetQueue(&pExynosPort->bufferQ);
 565
 566 EXIT:
 567     FunctionOut();
 568
 569     return ret;
 570 }
 571
 572 OMX_ERRORTYPE Exynos_OMX_BufferFlush(
 573     OMX_COMPONENTTYPE   *pOMXComponent,
 574     OMX_S32              nPortIndex,
 575     OMX_BOOL             bEvent)
 576 {
 577     OMX_ERRORTYPE                    ret                = OMX_ErrorNone;
 578     EXYNOS_OMX_BASECOMPONENT        *pExynosComponent   = NULL;
 579     EXYNOS_OMX_VIDEOENC_COMPONENT   *pVideoEnc          = NULL;
 580     EXYNOS_OMX_BASEPORT             *pExynosPort        = NULL;
 581     EXYNOS_OMX_DATABUFFER           *pDataBuffer[2]     = {NULL, NULL};
 582     OMX_U32                          i                  = 0;
 583
 584     FunctionIn();
 585
 586     if (pOMXComponent == NULL) {
 587         ret = OMX_ErrorBadParameter;
 588         goto EXIT;
 589     }
 590
 591     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
 592     if (ret != OMX_ErrorNone) {
 593         goto EXIT;
 594     }
 595
 596     if (pOMXComponent->pComponentPrivate == NULL) {
 597         ret = OMX_ErrorBadParameter;
 598         goto EXIT;
 599     }
 600     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 601
 602     if (pExynosComponent->hComponentHandle == NULL) {
 603         ret = OMX_ErrorBadParameter;
 604         goto EXIT;
 605     }
 606     pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
 607
 608     if ((nPortIndex < 0) ||
 609         (nPortIndex >= pExynosComponent->portParam.nPorts)) {
 610         ret = OMX_ErrorBadPortIndex;
 611         goto EXIT;
 612     }
 613     pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
 614
 615     Exynos_OSAL_Log(EXYNOS_LOG_TRACE,"OMX_CommandFlush start, port:%d", nPortIndex);
 616
 617     pExynosPort->bIsPortFlushed = OMX_TRUE;
 618
 619     if (pExynosComponent->bMultiThreadProcess == OMX_FALSE) {
 620         Exynos_OSAL_SignalSet(pExynosComponent->pauseEvent);
 621     } else {
 622         Exynos_OSAL_SignalSet(pExynosPort->pauseEvent);
 623     }
 624
 625     Exynos_OMX_GetFlushBuffer(pExynosPort, pDataBuffer);
 626     if (pDataBuffer[0] == NULL) {
 627         ret = OMX_ErrorBadParameter;
 628         goto EXIT;
 629     }
 630
 631     if (pExynosPort->bufferProcessType & BUFFER_COPY)
 632         Exynos_OSAL_SemaphorePost(pExynosPort->codecSemID);
 633     Exynos_OSAL_SemaphorePost(pExynosPort->bufferSemID);
 634
 635     pVideoEnc->exynos_codec_bufferProcessRun(pOMXComponent, nPortIndex);
 636
 637     Exynos_OSAL_MutexLock(pDataBuffer[0]->bufferMutex);
 638     pVideoEnc->exynos_codec_stop(pOMXComponent, nPortIndex);
 639
 640     if (pDataBuffer[1] != NULL)
 641         Exynos_OSAL_MutexLock(pDataBuffer[1]->bufferMutex);
 642
 643     ret = Exynos_OMX_FlushPort(pOMXComponent, nPortIndex);
 644     if (ret != OMX_ErrorNone)
 645         goto EXIT;
 646
 647     if (pExynosPort->bufferProcessType & BUFFER_COPY)
 648         pVideoEnc->exynos_codec_enqueueAllBuffer(pOMXComponent, nPortIndex);
 649     Exynos_ResetCodecData(&pExynosPort->processData);
 650
 651     if (ret == OMX_ErrorNone) {
 652         if (nPortIndex == INPUT_PORT_INDEX) {
 653             pExynosComponent->checkTimeStamp.needSetStartTimeStamp = OMX_TRUE;
 654             pExynosComponent->checkTimeStamp.needCheckStartTimeStamp = OMX_FALSE;
 655             Exynos_OSAL_Memset(pExynosComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
 656             Exynos_OSAL_Memset(pExynosComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
 657             pExynosComponent->getAllDelayBuffer = OMX_FALSE;
 658             pExynosComponent->bSaveFlagEOS = OMX_FALSE;
 659             pExynosComponent->reInputData = OMX_FALSE;
 660         }
 661
 662         pExynosPort->bIsPortFlushed = OMX_FALSE;
 663         Exynos_OSAL_Log(EXYNOS_LOG_TRACE,"OMX_CommandFlush EventCmdComplete, port:%d", nPortIndex);
 664         if (bEvent == OMX_TRUE)
 665             pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
 666                             pExynosComponent->callbackData,
 667                             OMX_EventCmdComplete,
 668                             OMX_CommandFlush, nPortIndex, NULL);
 669     }
 670
 671     if (pDataBuffer[1] != NULL)
 672         Exynos_OSAL_MutexUnlock(pDataBuffer[1]->bufferMutex);
 673
 674     Exynos_OSAL_MutexUnlock(pDataBuffer[0]->bufferMutex);
 675
 676 EXIT:
 677     if ((ret != OMX_ErrorNone) && (pOMXComponent != NULL) && (pExynosComponent != NULL)) {
 678         Exynos_OSAL_Log(EXYNOS_LOG_ERROR,"%s : %d", __FUNCTION__, __LINE__);
 679         pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
 680                         pExynosComponent->callbackData,
 681                         OMX_EventError,
 682                         ret, 0, NULL);
 683     }
 684
 685     FunctionOut();
 686
 687     return ret;
 688 }
 689
 690 OMX_ERRORTYPE Exynos_InputBufferReturn(
 691     OMX_COMPONENTTYPE   *pOMXComponent)
 692 {
 693     OMX_ERRORTYPE                ret                = OMX_ErrorNone;
 694     EXYNOS_OMX_BASECOMPONENT    *pExynosComponent   = NULL;
 695     EXYNOS_OMX_BASEPORT         *pExynosPort        = NULL;
 696     EXYNOS_OMX_DATABUFFER       *pDataBuffer        = NULL;
 697     OMX_BUFFERHEADERTYPE        *pBufferHdr         = NULL;
 698
 699     FunctionIn();
 700
 701     if (pOMXComponent == NULL) {
 702         ret = OMX_ErrorBadParameter;
 703         goto EXIT;
 704     }
 705
 706     if (pOMXComponent->pComponentPrivate == NULL) {
 707         ret = OMX_ErrorBadParameter;
 708         goto EXIT;
 709     }
 710     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 711     pExynosPort = &(pExynosComponent->pExynosPort[INPUT_PORT_INDEX]);
 712
 713     if (pExynosPort->bufferProcessType & BUFFER_COPY) {
 714         pDataBuffer = &(pExynosPort->way.port2WayDataBuffer.inputDataBuffer);
 715     } else if (pExynosPort->bufferProcessType & BUFFER_SHARE) {
 716         pDataBuffer = &(pExynosPort->way.port2WayDataBuffer.outputDataBuffer);
 717     }
 718
 719     if (pDataBuffer != NULL)
 720         pBufferHdr = pDataBuffer->bufferHeader;
 721
 722     if (pBufferHdr != NULL) {
 723         if (pExynosPort->markType.hMarkTargetComponent != NULL) {
 724             pBufferHdr->hMarkTargetComponent = pExynosPort->markType.hMarkTargetComponent;
 725             pBufferHdr->pMarkData            = pExynosPort->markType.pMarkData;
 726             pExynosPort->markType.hMarkTargetComponent = NULL;
 727             pExynosPort->markType.pMarkData = NULL;
 728         }
 729
 730         if (pBufferHdr->hMarkTargetComponent != NULL) {
 731             if (pBufferHdr->hMarkTargetComponent == pOMXComponent) {
 732                 pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
 733                                 pExynosComponent->callbackData,
 734                                 OMX_EventMark,
 735                                 0, 0, pBufferHdr->pMarkData);
 736             } else {
 737                 pExynosComponent->propagateMarkType.hMarkTargetComponent = pBufferHdr->hMarkTargetComponent;
 738                 pExynosComponent->propagateMarkType.pMarkData = pBufferHdr->pMarkData;
 739             }
 740         }
 741
 742         pBufferHdr->nFilledLen = 0;
 743         pBufferHdr->nOffset = 0;
 744         Exynos_OMX_InputBufferReturn(pOMXComponent, pBufferHdr);
 745     }
 746
 747     /* reset dataBuffer */
 748     Exynos_ResetDataBuffer(pDataBuffer);
 749
 750 EXIT:
 751     FunctionOut();
 752
 753     return ret;
 754 }
 755
 756 OMX_ERRORTYPE Exynos_FlushInputBufferReturn(
 757     OMX_COMPONENTTYPE       *pOMXComponent,
 758     EXYNOS_OMX_DATABUFFER   *pDataBuffer)
 759 {
 760     OMX_ERRORTYPE                ret = OMX_ErrorNone;
 761     EXYNOS_OMX_BASECOMPONENT    *pExynosComponent   = NULL;
 762     EXYNOS_OMX_BASEPORT         *pExynosPort        = NULL;
 763     OMX_BUFFERHEADERTYPE        *pBufferHdr         = NULL;
 764
 765     FunctionIn();
 766
 767     if (pOMXComponent == NULL) {
 768         ret = OMX_ErrorBadParameter;
 769         goto EXIT;
 770     }
 771
 772     if (pOMXComponent->pComponentPrivate == NULL) {
 773         ret = OMX_ErrorBadParameter;
 774         goto EXIT;
 775     }
 776     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 777     pExynosPort = &(pExynosComponent->pExynosPort[INPUT_PORT_INDEX]);
 778
 779     pBufferHdr = pDataBuffer->bufferHeader;
 780
 781     if (pBufferHdr != NULL) {
 782         if (pExynosPort->markType.hMarkTargetComponent != NULL) {
 783             pBufferHdr->hMarkTargetComponent  = pExynosPort->markType.hMarkTargetComponent;
 784             pBufferHdr->pMarkData             = pExynosPort->markType.pMarkData;
 785             pExynosPort->markType.hMarkTargetComponent = NULL;
 786             pExynosPort->markType.pMarkData = NULL;
 787         }
 788
 789         if (pBufferHdr->hMarkTargetComponent != NULL) {
 790             if (pBufferHdr->hMarkTargetComponent == pOMXComponent) {
 791                 pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
 792                                 pExynosComponent->callbackData,
 793                                 OMX_EventMark,
 794                                 0, 0, pBufferHdr->pMarkData);
 795             } else {
 796                 pExynosComponent->propagateMarkType.hMarkTargetComponent = pBufferHdr->hMarkTargetComponent;
 797                 pExynosComponent->propagateMarkType.pMarkData = pBufferHdr->pMarkData;
 798             }
 799         }
 800
 801         pBufferHdr->nFilledLen = 0;
 802         pBufferHdr->nOffset = 0;
 803         Exynos_OMX_InputBufferReturn(pOMXComponent, pBufferHdr);
 804     }
 805
 806     /* reset dataBuffer */
 807     Exynos_ResetDataBuffer(pDataBuffer);
 808
 809 EXIT:
 810     FunctionOut();
 811
 812     return ret;
 813 }
 814
 815 OMX_ERRORTYPE Exynos_InputBufferGetQueue(
 816     EXYNOS_OMX_BASECOMPONENT    *pExynosComponent)
 817 {
 818     OMX_ERRORTYPE          ret          = OMX_ErrorUndefined;
 819     EXYNOS_OMX_BASEPORT   *pExynosPort  = NULL;
 820     EXYNOS_OMX_MESSAGE    *pMessage     = NULL;
 821     EXYNOS_OMX_DATABUFFER *pDataBuffer  = NULL;
 822
 823     FunctionIn();
 824
 825     if (pExynosComponent == NULL) {
 826         ret = OMX_ErrorBadParameter;
 827         goto EXIT;
 828     }
 829     pExynosPort = &(pExynosComponent->pExynosPort[INPUT_PORT_INDEX]);
 830     pDataBuffer = &(pExynosPort->way.port2WayDataBuffer.inputDataBuffer);
 831
 832     if (pExynosComponent->currentState != OMX_StateExecuting) {
 833         ret = OMX_ErrorUndefined;
 834         goto EXIT;
 835     } else if ((pExynosComponent->transientState != EXYNOS_OMX_TransStateExecutingToIdle) &&
 836                (!CHECK_PORT_BEING_FLUSHED(pExynosPort))) {
 837         Exynos_OSAL_SemaphoreWait(pExynosPort->bufferSemID);
 838         if (pDataBuffer->dataValid != OMX_TRUE) {
 839             pMessage = (EXYNOS_OMX_MESSAGE *)Exynos_OSAL_Dequeue(&pExynosPort->bufferQ);
 840             if (pMessage == NULL) {
 841                 ret = OMX_ErrorUndefined;
 842                 goto EXIT;
 843             }
 844             if (pMessage->messageType == EXYNOS_OMX_CommandFakeBuffer) {
 845                 Exynos_OSAL_Free(pMessage);
 846                 ret = OMX_ErrorCodecFlush;
 847                 goto EXIT;
 848             }
 849
 850             pDataBuffer->bufferHeader  = (OMX_BUFFERHEADERTYPE *)(pMessage->pCmdData);
 851             pDataBuffer->allocSize     = pDataBuffer->bufferHeader->nAllocLen;
 852             pDataBuffer->dataLen       = pDataBuffer->bufferHeader->nFilledLen;
 853             pDataBuffer->remainDataLen = pDataBuffer->dataLen;
 854             pDataBuffer->usedDataLen   = 0;
 855             pDataBuffer->dataValid     = OMX_TRUE;
 856             pDataBuffer->nFlags        = pDataBuffer->bufferHeader->nFlags;
 857             pDataBuffer->timeStamp     = pDataBuffer->bufferHeader->nTimeStamp;
 858
 859             Exynos_OSAL_Free(pMessage);
 860
 861             if (pDataBuffer->allocSize <= pDataBuffer->dataLen)
 862                 Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "Input Buffer Full, Check input buffer size! allocSize:%d, dataLen:%d", pDataBuffer->allocSize, pDataBuffer->dataLen);
 863         }
 864         ret = OMX_ErrorNone;
 865     }
 866 EXIT:
 867     FunctionOut();
 868
 869     return ret;
 870 }
 871
 872 OMX_ERRORTYPE Exynos_OutputBufferReturn(
 873     OMX_COMPONENTTYPE   *pOMXComponent)
 874 {
 875     OMX_ERRORTYPE             ret               = OMX_ErrorNone;
 876     EXYNOS_OMX_BASECOMPONENT *pExynosComponent  = NULL;
 877     EXYNOS_OMX_BASEPORT      *pExynosPort       = NULL;
 878     EXYNOS_OMX_DATABUFFER    *pDataBuffer       = NULL;
 879     OMX_BUFFERHEADERTYPE     *pBufferHdr        = NULL;
 880
 881     FunctionIn();
 882
 883     if (pOMXComponent == NULL) {
 884         ret = OMX_ErrorBadParameter;
 885         goto EXIT;
 886     }
 887
 888     if (pOMXComponent->pComponentPrivate == NULL) {
 889         ret = OMX_ErrorBadParameter;
 890         goto EXIT;
 891     }
 892     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 893     pExynosPort = &(pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX]);
 894
 895     pDataBuffer = &(pExynosPort->way.port2WayDataBuffer.outputDataBuffer);
 896     pBufferHdr = pDataBuffer->bufferHeader;
 897
 898     if (pBufferHdr != NULL) {
 899         pBufferHdr->nFilledLen = pDataBuffer->remainDataLen;
 900         pBufferHdr->nOffset    = 0;
 901         pBufferHdr->nFlags     = pDataBuffer->nFlags;
 902         pBufferHdr->nTimeStamp = pDataBuffer->timeStamp;
 903
 904         if (pExynosComponent->propagateMarkType.hMarkTargetComponent != NULL) {
 905             pBufferHdr->hMarkTargetComponent = pExynosComponent->propagateMarkType.hMarkTargetComponent;
 906             pBufferHdr->pMarkData            = pExynosComponent->propagateMarkType.pMarkData;
 907             pExynosComponent->propagateMarkType.hMarkTargetComponent = NULL;
 908             pExynosComponent->propagateMarkType.pMarkData = NULL;
 909         }
 910
 911         if ((pBufferHdr->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
 912             pBufferHdr->nFilledLen = 0;
 913             Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "event OMX_BUFFERFLAG_EOS!!!");
 914             pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
 915                             pExynosComponent->callbackData,
 916                             OMX_EventBufferFlag,
 917                             OUTPUT_PORT_INDEX,
 918                             pBufferHdr->nFlags, NULL);
 919         }
 920
 921         Exynos_OMX_OutputBufferReturn(pOMXComponent, pBufferHdr);
 922     }
 923
 924     /* reset dataBuffer */
 925     Exynos_ResetDataBuffer(pDataBuffer);
 926
 927 EXIT:
 928     FunctionOut();
 929
 930     return ret;
 931 }
 932
 933 OMX_ERRORTYPE Exynos_FlushOutputBufferReturn(
 934     OMX_COMPONENTTYPE       *pOMXComponent,
 935     EXYNOS_OMX_DATABUFFER   *pDataBuffer)
 936 {
 937     OMX_ERRORTYPE             ret               = OMX_ErrorNone;
 938     EXYNOS_OMX_BASECOMPONENT *pExynosComponent  = NULL;
 939     OMX_BUFFERHEADERTYPE     *pBufferHdr        = NULL;
 940
 941     FunctionIn();
 942
 943     if (pOMXComponent == NULL) {
 944         ret = OMX_ErrorBadParameter;
 945         goto EXIT;
 946     }
 947
 948     if (pOMXComponent->pComponentPrivate == NULL) {
 949         ret = OMX_ErrorBadParameter;
 950         goto EXIT;
 951     }
 952     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 953     pBufferHdr = pDataBuffer->bufferHeader;
 954
 955     if (pBufferHdr != NULL) {
 956         pBufferHdr->nFilledLen = pDataBuffer->remainDataLen;
 957         pBufferHdr->nOffset    = 0;
 958         pBufferHdr->nFlags     = pDataBuffer->nFlags;
 959         pBufferHdr->nTimeStamp = pDataBuffer->timeStamp;
 960
 961         if (pExynosComponent->propagateMarkType.hMarkTargetComponent != NULL) {
 962             pBufferHdr->hMarkTargetComponent    = pExynosComponent->propagateMarkType.hMarkTargetComponent;
 963             pBufferHdr->pMarkData               = pExynosComponent->propagateMarkType.pMarkData;
 964             pExynosComponent->propagateMarkType.hMarkTargetComponent = NULL;
 965             pExynosComponent->propagateMarkType.pMarkData = NULL;
 966         }
 967
 968         if ((pBufferHdr->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
 969             pBufferHdr->nFilledLen = 0;
 970             Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "event OMX_BUFFERFLAG_EOS!!!");
 971             pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
 972                             pExynosComponent->callbackData,
 973                             OMX_EventBufferFlag,
 974                             OUTPUT_PORT_INDEX,
 975                             pBufferHdr->nFlags, NULL);
 976         }
 977         Exynos_OMX_OutputBufferReturn(pOMXComponent, pBufferHdr);
 978     }
 979
 980     /* reset dataBuffer */
 981     Exynos_ResetDataBuffer(pDataBuffer);
 982
 983 EXIT:
 984     FunctionOut();
 985
 986     return ret;
 987 }
 988
 989 OMX_ERRORTYPE Exynos_OutputBufferGetQueue(
 990     EXYNOS_OMX_BASECOMPONENT    *pExynosComponent)
 991 {
 992     OMX_ERRORTYPE          ret          = OMX_ErrorUndefined;
 993     EXYNOS_OMX_BASEPORT   *pExynosPort  = NULL;
 994     EXYNOS_OMX_MESSAGE    *pMessage     = NULL;
 995     EXYNOS_OMX_DATABUFFER *pDataBuffer  = NULL;
 996
 997     FunctionIn();
 998
 999     if (pExynosComponent == NULL) {
1000         ret = OMX_ErrorBadParameter;
1001         goto EXIT;
1002     }
1003     pExynosPort = &(pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX]);
1004
1005     if (pExynosPort->bufferProcessType & BUFFER_COPY) {
1006         pDataBuffer = &(pExynosPort->way.port2WayDataBuffer.outputDataBuffer);
1007     } else if (pExynosPort->bufferProcessType & BUFFER_SHARE) {
1008         pDataBuffer = &(pExynosPort->way.port2WayDataBuffer.inputDataBuffer);
1009     }
1010
1011     if (pExynosComponent->currentState != OMX_StateExecuting) {
1012         ret = OMX_ErrorUndefined;
1013         goto EXIT;
1014     } else if ((pExynosComponent->transientState != EXYNOS_OMX_TransStateExecutingToIdle) &&
1015                (!CHECK_PORT_BEING_FLUSHED(pExynosPort))) {
1016         Exynos_OSAL_SemaphoreWait(pExynosPort->bufferSemID);
1017         if ((pDataBuffer != NULL) &&
1018             (pDataBuffer->dataValid != OMX_TRUE)) {
1019             pMessage = (EXYNOS_OMX_MESSAGE *)Exynos_OSAL_Dequeue(&pExynosPort->bufferQ);
1020             if (pMessage == NULL) {
1021                 ret = OMX_ErrorUndefined;
1022                 goto EXIT;
1023             }
1024             if (pMessage->messageType == EXYNOS_OMX_CommandFakeBuffer) {
1025                 Exynos_OSAL_Free(pMessage);
1026                 ret = OMX_ErrorCodecFlush;
1027                 goto EXIT;
1028             }
1029
1030             pDataBuffer->bufferHeader  = (OMX_BUFFERHEADERTYPE *)(pMessage->pCmdData);
1031             pDataBuffer->allocSize     = pDataBuffer->bufferHeader->nAllocLen;
1032             pDataBuffer->dataLen       = 0; //dataBuffer->bufferHeader->nFilledLen;
1033             pDataBuffer->remainDataLen = pDataBuffer->dataLen;
1034             pDataBuffer->usedDataLen   = 0; //dataBuffer->bufferHeader->nOffset;
1035             pDataBuffer->dataValid     = OMX_TRUE;
1036             /* pDataBuffer->nFlags             = pDataBuffer->bufferHeader->nFlags; */
1037             /* pDtaBuffer->nTimeStamp         = pDataBuffer->bufferHeader->nTimeStamp; */
1038 /*
1039             if (pExynosPort->bufferProcessType & BUFFER_SHARE)
1040                 pDataBuffer->pPrivate      = pDataBuffer->bufferHeader->pOutputPortPrivate;
1041             else if (pExynosPort->bufferProcessType & BUFFER_COPY) {
1042                 pExynosPort->processData.dataBuffer = pDataBuffer->bufferHeader->pBuffer;
1043                 pExynosPort->processData.allocSize  = pDataBuffer->bufferHeader->nAllocLen;
1044             }
1045 */
1046             Exynos_OSAL_Free(pMessage);
1047         }
1048         ret = OMX_ErrorNone;
1049     }
1050 EXIT:
1051     FunctionOut();
1052
1053     return ret;
1054 }
1055
1056 OMX_BUFFERHEADERTYPE *Exynos_OutputBufferGetQueue_Direct(
1057     EXYNOS_OMX_BASECOMPONENT    *pExynosComponent)
1058 {
1059     OMX_BUFFERHEADERTYPE  *pBufferHdr   = NULL;
1060     EXYNOS_OMX_BASEPORT   *pExynosPort  = NULL;
1061     EXYNOS_OMX_MESSAGE    *pMessage     = NULL;
1062
1063     FunctionIn();
1064
1065     if (pExynosComponent == NULL) {
1066         pBufferHdr = NULL;
1067         goto EXIT;
1068     }
1069     pExynosPort = &(pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX]);
1070
1071     if (pExynosComponent->currentState != OMX_StateExecuting) {
1072         pBufferHdr = NULL;
1073         goto EXIT;
1074     } else if ((pExynosComponent->transientState != EXYNOS_OMX_TransStateExecutingToIdle) &&
1075                (!CHECK_PORT_BEING_FLUSHED(pExynosPort))) {
1076         Exynos_OSAL_SemaphoreWait(pExynosPort->bufferSemID);
1077
1078         pMessage = (EXYNOS_OMX_MESSAGE *)Exynos_OSAL_Dequeue(&pExynosPort->bufferQ);
1079         if (pMessage == NULL) {
1080             pBufferHdr = NULL;
1081             goto EXIT;
1082         }
1083         if (pMessage->messageType == EXYNOS_OMX_CommandFakeBuffer) {
1084             Exynos_OSAL_Free(pMessage);
1085             pBufferHdr = NULL;
1086             goto EXIT;
1087         }
1088
1089         pBufferHdr  = (OMX_BUFFERHEADERTYPE *)(pMessage->pCmdData);
1090         Exynos_OSAL_Free(pMessage);
1091     }
1092
1093 EXIT:
1094     FunctionOut();
1095
1096     return pBufferHdr;
1097 }
1098
1099 OMX_ERRORTYPE Exynos_CodecBufferEnqueue(
1100     EXYNOS_OMX_BASECOMPONENT    *pExynosComponent,
1101     OMX_U32                      nPortIndex,
1102     OMX_PTR                      pData)
1103 {
1104     OMX_ERRORTYPE          ret         = OMX_ErrorNone;
1105     EXYNOS_OMX_BASEPORT   *pExynosPort = NULL;
1106
1107     FunctionIn();
1108
1109     if (pExynosComponent == NULL) {
1110         ret = OMX_ErrorBadParameter;
1111         goto EXIT;
1112     }
1113
1114     if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1115         ret = OMX_ErrorBadPortIndex;
1116         goto EXIT;
1117     }
1118     pExynosPort = &(pExynosComponent->pExynosPort[nPortIndex]);
1119
1120     if (pData == NULL) {
1121         ret = OMX_ErrorInsufficientResources;
1122         goto EXIT;
1123     }
1124
1125     ret = Exynos_OSAL_Queue(&pExynosPort->codecBufferQ, (void *)pData);
1126     if (ret != 0) {
1127         ret = OMX_ErrorUndefined;
1128         goto EXIT;
1129     }
1130     Exynos_OSAL_SemaphorePost(pExynosPort->codecSemID);
1131
1132     ret = OMX_ErrorNone;
1133
1134 EXIT:
1135     FunctionOut();
1136
1137     return ret;
1138 }
1139
1140 OMX_ERRORTYPE Exynos_CodecBufferDequeue(
1141     EXYNOS_OMX_BASECOMPONENT    *pExynosComponent,
1142     OMX_U32                      nPortIndex,
1143     OMX_PTR                     *pData)
1144 {
1145     OMX_ERRORTYPE          ret         = OMX_ErrorNone;
1146     EXYNOS_OMX_BASEPORT   *pExynosPort = NULL;
1147     OMX_PTR                pTempData   = NULL;
1148
1149     FunctionIn();
1150
1151     if (pExynosComponent == NULL) {
1152         ret = OMX_ErrorBadParameter;
1153         goto EXIT;
1154     }
1155
1156     if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1157         ret = OMX_ErrorBadPortIndex;
1158         goto EXIT;
1159     }
1160     pExynosPort = &(pExynosComponent->pExynosPort[nPortIndex]);
1161
1162     Exynos_OSAL_SemaphoreWait(pExynosPort->codecSemID);
1163     pTempData = (OMX_PTR)Exynos_OSAL_Dequeue(&pExynosPort->codecBufferQ);
1164     if (pTempData != NULL) {
1165         *pData = (OMX_PTR)pTempData;
1166         ret = OMX_ErrorNone;
1167     } else {
1168         *pData = NULL;
1169         ret = OMX_ErrorUndefined;
1170     }
1171
1172 EXIT:
1173     FunctionOut();
1174
1175     return ret;
1176 }
1177
1178 OMX_ERRORTYPE Exynos_CodecBufferReset(
1179     EXYNOS_OMX_BASECOMPONENT    *pExynosComponent,
1180     OMX_U32                      nPortIndex)
1181 {
1182     OMX_ERRORTYPE          ret          = OMX_ErrorNone;
1183     EXYNOS_OMX_BASEPORT   *pExynosPort  = NULL;
1184
1185     FunctionIn();
1186
1187     if (pExynosComponent == NULL) {
1188         ret = OMX_ErrorBadParameter;
1189         goto EXIT;
1190     }
1191
1192     if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1193         ret = OMX_ErrorBadPortIndex;
1194         goto EXIT;
1195     }
1196     pExynosPort = &(pExynosComponent->pExynosPort[nPortIndex]);
1197
1198     ret = Exynos_OSAL_ResetQueue(&pExynosPort->codecBufferQ);
1199     if (ret != 0) {
1200         ret = OMX_ErrorUndefined;
1201         goto EXIT;
1202     }
1203
1204     while (1) {
1205         int cnt = 0;
1206         Exynos_OSAL_Get_SemaphoreCount(pExynosPort->codecSemID, &cnt);
1207         if (cnt > 0)
1208             Exynos_OSAL_SemaphoreWait(pExynosPort->codecSemID);
1209         else
1210             break;
1211     }
1212     ret = OMX_ErrorNone;
1213
1214 EXIT:
1215     FunctionOut();
1216
1217     return ret;
1218 }
1219
1220 OMX_ERRORTYPE Exynos_OMX_VideoEncodeGetParameter(
1221     OMX_IN OMX_HANDLETYPE hComponent,
1222     OMX_IN OMX_INDEXTYPE  nParamIndex,
1223     OMX_INOUT OMX_PTR     pComponentParameterStructure)
1224 {
1225     OMX_ERRORTYPE             ret               = OMX_ErrorNone;
1226     OMX_COMPONENTTYPE        *pOMXComponent     = NULL;
1227     EXYNOS_OMX_BASECOMPONENT *pExynosComponent  = NULL;
1228     EXYNOS_OMX_BASEPORT      *pExynosPort       = NULL;
1229
1230     FunctionIn();
1231
1232     if (hComponent == NULL) {
1233         ret = OMX_ErrorBadParameter;
1234         goto EXIT;
1235     }
1236     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1237
1238     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1239     if (ret != OMX_ErrorNone) {
1240         goto EXIT;
1241     }
1242
1243     if (pOMXComponent->pComponentPrivate == NULL) {
1244         ret = OMX_ErrorBadParameter;
1245         goto EXIT;
1246     }
1247     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1248
1249     if (pExynosComponent->currentState == OMX_StateInvalid) {
1250         ret = OMX_ErrorInvalidState;
1251         goto EXIT;
1252     }
1253
1254     if (pComponentParameterStructure == NULL) {
1255         ret = OMX_ErrorBadParameter;
1256         goto EXIT;
1257     }
1258
1259     switch (nParamIndex) {
1260     case OMX_IndexParamVideoInit:
1261     {
1262         OMX_PORT_PARAM_TYPE *pPortParam = (OMX_PORT_PARAM_TYPE *)pComponentParameterStructure;
1263         ret = Exynos_OMX_Check_SizeVersion(pPortParam, sizeof(OMX_PORT_PARAM_TYPE));
1264         if (ret != OMX_ErrorNone) {
1265             goto EXIT;
1266         }
1267
1268         pPortParam->nPorts           = pExynosComponent->portParam.nPorts;
1269         pPortParam->nStartPortNumber = pExynosComponent->portParam.nStartPortNumber;
1270         ret = OMX_ErrorNone;
1271     }
1272         break;
1273     case OMX_IndexParamVideoPortFormat:
1274     {
1275         OMX_VIDEO_PARAM_PORTFORMATTYPE *pPortFormat     = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)pComponentParameterStructure;
1276         OMX_U32                         nPortIndex      = pPortFormat->nPortIndex;
1277         OMX_U32                         nIndex          = pPortFormat->nIndex;
1278         EXYNOS_OMX_BASEPORT            *pExynosPort     = NULL;
1279         OMX_PARAM_PORTDEFINITIONTYPE   *pPortDef        = NULL;
1280         OMX_U32                         nSupportFormat  = 0;
1281
1282         ret = Exynos_OMX_Check_SizeVersion(pPortFormat, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
1283         if (ret != OMX_ErrorNone) {
1284             goto EXIT;
1285         }
1286
1287         if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1288             ret = OMX_ErrorBadPortIndex;
1289             goto EXIT;
1290         }
1291
1292         if (nPortIndex == INPUT_PORT_INDEX) {
1293             pExynosPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1294             pPortDef = &pExynosPort->portDefinition;
1295
1296             switch (nIndex) {
1297             case supportFormat_0:
1298                 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1299                 pPortFormat->eColorFormat       = OMX_COLOR_FormatYUV420Planar;
1300                 pPortFormat->xFramerate         = pPortDef->format.video.xFramerate;
1301                 break;
1302             case supportFormat_1:
1303                 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1304                 pPortFormat->eColorFormat       = OMX_COLOR_FormatYUV420SemiPlanar;
1305                 pPortFormat->xFramerate         = pPortDef->format.video.xFramerate;
1306                 break;
1307             case supportFormat_2:
1308                 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1309                 pPortFormat->eColorFormat       = OMX_SEC_COLOR_FormatNV12Tiled;
1310                 pPortFormat->xFramerate         = pPortDef->format.video.xFramerate;
1311                 break;
1312             case supportFormat_3:
1313                 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1314                 pPortFormat->eColorFormat       = OMX_SEC_COLOR_FormatNV21Linear;
1315                 pPortFormat->xFramerate         = pPortDef->format.video.xFramerate;
1316                 break;
1317             case supportFormat_4:
1318                 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1319                 pPortFormat->eColorFormat       = OMX_COLOR_FormatAndroidOpaque;
1320                 pPortFormat->xFramerate         = pPortDef->format.video.xFramerate;
1321                 break;
1322             default:
1323                 if (nIndex > supportFormat_0) {
1324                     ret = OMX_ErrorNoMore;
1325                     goto EXIT;
1326                 }
1327                 break;
1328             }
1329         } else if (nPortIndex == OUTPUT_PORT_INDEX) {
1330             nSupportFormat = OUTPUT_PORT_SUPPORTFORMAT_NUM_MAX - 1;
1331             if (nIndex > nSupportFormat) {
1332                 ret = OMX_ErrorNoMore;
1333                 goto EXIT;
1334             }
1335
1336             pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1337             pPortDef = &pExynosPort->portDefinition;
1338
1339             pPortFormat->eCompressionFormat = pPortDef->format.video.eCompressionFormat;
1340             pPortFormat->eColorFormat       = pPortDef->format.video.eColorFormat;
1341             pPortFormat->xFramerate         = pPortDef->format.video.xFramerate;
1342         }
1343         ret = OMX_ErrorNone;
1344     }
1345         break;
1346     case OMX_IndexParamVideoBitrate:
1347     {
1348         OMX_VIDEO_PARAM_BITRATETYPE     *pVideoBitrate  = (OMX_VIDEO_PARAM_BITRATETYPE *)pComponentParameterStructure;
1349         OMX_U32                          nPortIndex     = pVideoBitrate->nPortIndex;
1350         EXYNOS_OMX_BASEPORT             *pExynosPort    = NULL;
1351         EXYNOS_OMX_VIDEOENC_COMPONENT   *pVideoEnc      = NULL;
1352         OMX_PARAM_PORTDEFINITIONTYPE    *pPortDef       = NULL;
1353
1354         if (nPortIndex != OUTPUT_PORT_INDEX) {
1355             ret = OMX_ErrorBadPortIndex;
1356             goto EXIT;
1357         } else {
1358             pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1359             if (pVideoEnc == NULL) {
1360                 ret = OMX_ErrorBadParameter;
1361                 goto EXIT;
1362             }
1363             pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1364             pPortDef = &pExynosPort->portDefinition;
1365
1366             pVideoBitrate->eControlRate = pVideoEnc->eControlRate[nPortIndex];
1367             pVideoBitrate->nTargetBitrate = pPortDef->format.video.nBitrate;
1368         }
1369         ret = OMX_ErrorNone;
1370     }
1371         break;
1372     case OMX_IndexParamVideoQuantization:
1373     {
1374         OMX_VIDEO_PARAM_QUANTIZATIONTYPE  *pVideoQuantization = (OMX_VIDEO_PARAM_QUANTIZATIONTYPE *)pComponentParameterStructure;
1375         OMX_U32                            nPortIndex         = pVideoQuantization->nPortIndex;
1376         EXYNOS_OMX_BASEPORT               *pExynosPort        = NULL;
1377         EXYNOS_OMX_VIDEOENC_COMPONENT     *pVideoEnc          = NULL;
1378         OMX_PARAM_PORTDEFINITIONTYPE      *pPortDef           = NULL;
1379
1380         if (nPortIndex != OUTPUT_PORT_INDEX) {
1381             ret = OMX_ErrorBadPortIndex;
1382             goto EXIT;
1383         } else {
1384             pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1385             if (pVideoEnc == NULL) {
1386                 ret = OMX_ErrorBadParameter;
1387                 goto EXIT;
1388             }
1389             pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1390             pPortDef = &pExynosPort->portDefinition;
1391
1392             pVideoQuantization->nQpI = pVideoEnc->quantization.nQpI;
1393             pVideoQuantization->nQpP = pVideoEnc->quantization.nQpP;
1394             pVideoQuantization->nQpB = pVideoEnc->quantization.nQpB;
1395         }
1396         ret = OMX_ErrorNone;
1397     }
1398         break;
1399     case OMX_IndexParamPortDefinition:
1400     {
1401         OMX_PARAM_PORTDEFINITIONTYPE *pPortDef      = (OMX_PARAM_PORTDEFINITIONTYPE *)pComponentParameterStructure;
1402         OMX_U32                       nPortIndex    = pPortDef->nPortIndex;
1403         EXYNOS_OMX_BASEPORT          *pExynosPort   = NULL;
1404
1405         if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1406             ret = OMX_ErrorBadPortIndex;
1407             goto EXIT;
1408         }
1409
1410         ret = Exynos_OMX_Check_SizeVersion(pPortDef, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1411         if (ret != OMX_ErrorNone) {
1412             goto EXIT;
1413         }
1414
1415         pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1416         Exynos_OSAL_Memcpy(pPortDef, &pExynosPort->portDefinition, pPortDef->nSize);
1417
1418 #ifdef USE_STOREMETADATA
1419         if ((nPortIndex == 0) &&
1420             (pExynosPort->bStoreMetaData == OMX_TRUE)) {
1421             pPortDef->nBufferSize = MAX_INPUT_METADATA_BUFFER_SIZE;
1422         }
1423 #endif
1424     }
1425         break;
1426     case OMX_IndexVendorNeedContigMemory:
1427     {
1428         EXYNOS_OMX_VIDEO_PARAM_PORTMEMTYPE  *pPortMemType    = (EXYNOS_OMX_VIDEO_PARAM_PORTMEMTYPE *)pComponentParameterStructure;
1429         OMX_U32                              nPortIndex      = pPortMemType->nPortIndex;
1430         EXYNOS_OMX_BASEPORT                 *pExynosPort;
1431
1432         if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1433             ret = OMX_ErrorBadPortIndex;
1434             goto EXIT;
1435         }
1436
1437         ret = Exynos_OMX_Check_SizeVersion(pPortMemType, sizeof(EXYNOS_OMX_VIDEO_PARAM_PORTMEMTYPE));
1438         if (ret != OMX_ErrorNone)
1439             goto EXIT;
1440
1441         pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1442
1443         pPortMemType->bNeedContigMem = pExynosPort->bNeedContigMem;
1444     }
1445         break;
1446     default:
1447     {
1448         ret = Exynos_OMX_GetParameter(hComponent, nParamIndex, pComponentParameterStructure);
1449     }
1450         break;
1451     }
1452 EXIT:
1453     FunctionOut();
1454
1455     return ret;
1456 }
1457
1458 OMX_ERRORTYPE Exynos_OMX_VideoEncodeSetParameter(
1459     OMX_IN OMX_HANDLETYPE hComponent,
1460     OMX_IN OMX_INDEXTYPE  nParamIndex,
1461     OMX_IN OMX_PTR        pComponentParameterStructure)
1462 {
1463     OMX_ERRORTYPE             ret               = OMX_ErrorNone;
1464     OMX_COMPONENTTYPE        *pOMXComponent     = NULL;
1465     EXYNOS_OMX_BASECOMPONENT *pExynosComponent  = NULL;
1466     EXYNOS_OMX_BASEPORT      *pExynosPort       = NULL;
1467
1468     FunctionIn();
1469
1470     if (hComponent == NULL) {
1471         ret = OMX_ErrorBadParameter;
1472         goto EXIT;
1473     }
1474     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1475
1476     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1477     if (ret != OMX_ErrorNone) {
1478         goto EXIT;
1479     }
1480
1481     if (pOMXComponent->pComponentPrivate == NULL) {
1482         ret = OMX_ErrorBadParameter;
1483         goto EXIT;
1484     }
1485     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1486
1487     if (pExynosComponent->currentState == OMX_StateInvalid) {
1488         ret = OMX_ErrorInvalidState;
1489         goto EXIT;
1490     }
1491
1492     if (pComponentParameterStructure == NULL) {
1493         ret = OMX_ErrorBadParameter;
1494         goto EXIT;
1495     }
1496
1497     switch (nParamIndex) {
1498     case OMX_IndexParamVideoPortFormat:
1499     {
1500         OMX_VIDEO_PARAM_PORTFORMATTYPE *pPortFormat     = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)pComponentParameterStructure;
1501         OMX_U32                         nPortIndex      = pPortFormat->nPortIndex;
1502         OMX_U32                         nIndex          = pPortFormat->nIndex;
1503         OMX_PARAM_PORTDEFINITIONTYPE   *pPortDef        = NULL;
1504         OMX_U32                         nSupportFormat  = 0;
1505
1506         ret = Exynos_OMX_Check_SizeVersion(pPortFormat, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
1507         if (ret != OMX_ErrorNone) {
1508             goto EXIT;
1509         }
1510
1511         if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1512             ret = OMX_ErrorBadPortIndex;
1513             goto EXIT;
1514         }
1515         pPortDef = &(pExynosComponent->pExynosPort[nPortIndex].portDefinition);
1516
1517         pPortDef->format.video.eColorFormat       = pPortFormat->eColorFormat;
1518         pPortDef->format.video.eCompressionFormat = pPortFormat->eCompressionFormat;
1519         pPortDef->format.video.xFramerate         = pPortFormat->xFramerate;
1520     }
1521         break;
1522     case OMX_IndexParamVideoBitrate:
1523     {
1524         OMX_VIDEO_PARAM_BITRATETYPE     *pVideoBitrate = (OMX_VIDEO_PARAM_BITRATETYPE *)pComponentParameterStructure;
1525         OMX_U32                          nPortIndex    = pVideoBitrate->nPortIndex;
1526         EXYNOS_OMX_BASEPORT             *pExynosPort   = NULL;
1527         EXYNOS_OMX_VIDEOENC_COMPONENT   *pVideoEnc     = NULL;
1528         OMX_PARAM_PORTDEFINITIONTYPE    *pPortDef      = NULL;
1529
1530         if (nPortIndex != OUTPUT_PORT_INDEX) {
1531             ret = OMX_ErrorBadPortIndex;
1532             goto EXIT;
1533         } else {
1534             pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1535             if (pVideoEnc == NULL) {
1536                 ret = OMX_ErrorBadParameter;
1537                 goto EXIT;
1538             }
1539             pPortDef = &(pExynosComponent->pExynosPort[nPortIndex].portDefinition);
1540
1541             pVideoEnc->eControlRate[nPortIndex] = pVideoBitrate->eControlRate;
1542             pPortDef->format.video.nBitrate = pVideoBitrate->nTargetBitrate;
1543         }
1544         ret = OMX_ErrorNone;
1545     }
1546         break;
1547     case OMX_IndexParamVideoQuantization:
1548     {
1549         OMX_VIDEO_PARAM_QUANTIZATIONTYPE *pVideoQuantization = (OMX_VIDEO_PARAM_QUANTIZATIONTYPE *)pComponentParameterStructure;
1550         OMX_U32                           nPortIndex         = pVideoQuantization->nPortIndex;
1551         EXYNOS_OMX_BASEPORT              *pExynosPort        = NULL;
1552         EXYNOS_OMX_VIDEOENC_COMPONENT    *pVideoEnc          = NULL;
1553         OMX_PARAM_PORTDEFINITIONTYPE     *pPortDef           = NULL;
1554
1555         if (nPortIndex != OUTPUT_PORT_INDEX) {
1556             ret = OMX_ErrorBadPortIndex;
1557             goto EXIT;
1558         } else {
1559             pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1560             if (pVideoEnc == NULL) {
1561                 ret = OMX_ErrorBadParameter;
1562                 goto EXIT;
1563             }
1564             pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1565             pPortDef = &pExynosPort->portDefinition;
1566
1567             pVideoEnc->quantization.nQpI = pVideoQuantization->nQpI;
1568             pVideoEnc->quantization.nQpP = pVideoQuantization->nQpP;
1569             pVideoEnc->quantization.nQpB = pVideoQuantization->nQpB;
1570         }
1571         ret = OMX_ErrorNone;
1572     }
1573         break;
1574     case OMX_IndexParamPortDefinition:
1575     {
1576         OMX_PARAM_PORTDEFINITIONTYPE *pPortDef      = (OMX_PARAM_PORTDEFINITIONTYPE *)pComponentParameterStructure;
1577         OMX_U32                       nPortIndex    = pPortDef->nPortIndex;
1578         EXYNOS_OMX_BASEPORT          *pExynosPort   = NULL;
1579         OMX_U32 width, height, size;
1580
1581         if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1582             ret = OMX_ErrorBadPortIndex;
1583             goto EXIT;
1584         }
1585
1586         ret = Exynos_OMX_Check_SizeVersion(pPortDef, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1587         if (ret != OMX_ErrorNone) {
1588             goto EXIT;
1589         }
1590
1591         pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1592
1593         if ((pExynosComponent->currentState != OMX_StateLoaded) &&
1594             (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1595             if (pExynosPort->portDefinition.bEnabled == OMX_TRUE) {
1596                 ret = OMX_ErrorIncorrectStateOperation;
1597                 goto EXIT;
1598             }
1599         }
1600
1601         if (pPortDef->nBufferCountActual < pExynosPort->portDefinition.nBufferCountMin) {
1602             ret = OMX_ErrorBadParameter;
1603             goto EXIT;
1604         }
1605
1606         Exynos_OSAL_Memcpy(&pExynosPort->portDefinition, pPortDef, pPortDef->nSize);
1607         if (nPortIndex == INPUT_PORT_INDEX) {
1608             pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1609             Exynos_UpdateFrameSize(pOMXComponent);
1610             Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pExynosOutputPort->portDefinition.nBufferSize: %d",
1611                             pExynosPort->portDefinition.nBufferSize);
1612         }
1613         ret = OMX_ErrorNone;
1614     }
1615         break;
1616 #ifdef USE_STOREMETADATA
1617     case OMX_IndexParamStoreMetaDataBuffer:
1618     {
1619         EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1620         if (pVideoEnc == NULL) {
1621             ret = OMX_ErrorBadParameter;
1622             goto EXIT;
1623         }
1624
1625         ret = Exynos_OSAL_SetANBParameter(hComponent, nParamIndex, pComponentParameterStructure);
1626         if (ret == OMX_ErrorNone)
1627             pVideoEnc->bFirstInput = OMX_TRUE;
1628     }
1629         break;
1630 #endif
1631     case OMX_IndexVendorNeedContigMemory:
1632     {
1633         EXYNOS_OMX_VIDEO_PARAM_PORTMEMTYPE  *pPortMemType    = (EXYNOS_OMX_VIDEO_PARAM_PORTMEMTYPE *)pComponentParameterStructure;
1634         OMX_U32                              nPortIndex      = pPortMemType->nPortIndex;
1635         EXYNOS_OMX_BASEPORT                 *pExynosPort;
1636
1637         if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1638             ret = OMX_ErrorBadPortIndex;
1639             goto EXIT;
1640         }
1641
1642         ret = Exynos_OMX_Check_SizeVersion(pPortMemType, sizeof(EXYNOS_OMX_VIDEO_PARAM_PORTMEMTYPE));
1643         if (ret != OMX_ErrorNone)
1644             goto EXIT;
1645
1646         pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1647
1648         if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1649             if (pExynosPort->portDefinition.bEnabled == OMX_TRUE) {
1650                 ret = OMX_ErrorIncorrectStateOperation;
1651                 goto EXIT;
1652             }
1653         }
1654
1655         pExynosPort->bNeedContigMem = pPortMemType->bNeedContigMem;
1656     }
1657         break;
1658     default:
1659     {
1660         ret = Exynos_OMX_SetParameter(hComponent, nParamIndex, pComponentParameterStructure);
1661     }
1662         break;
1663     }
1664 EXIT:
1665     FunctionOut();
1666
1667     return ret;
1668 }
1669
1670 OMX_ERRORTYPE Exynos_OMX_VideoEncodeGetConfig(
1671     OMX_HANDLETYPE  hComponent,
1672     OMX_INDEXTYPE   nParamIndex,
1673     OMX_PTR         pComponentConfigStructure)
1674 {
1675     OMX_ERRORTYPE             ret               = OMX_ErrorNone;
1676     OMX_COMPONENTTYPE        *pOMXComponent     = NULL;
1677     EXYNOS_OMX_BASECOMPONENT *pExynosComponent  = NULL;
1678
1679     FunctionIn();
1680
1681     if ((hComponent == NULL) ||
1682         (pComponentConfigStructure == NULL)) {
1683         ret = OMX_ErrorBadParameter;
1684         goto EXIT;
1685     }
1686     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1687
1688     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1689     if (ret != OMX_ErrorNone) {
1690         goto EXIT;
1691     }
1692
1693     if (pOMXComponent->pComponentPrivate == NULL) {
1694         ret = OMX_ErrorBadParameter;
1695         goto EXIT;
1696     }
1697     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1698
1699     if (pExynosComponent->currentState == OMX_StateInvalid) {
1700         ret = OMX_ErrorInvalidState;
1701         goto EXIT;
1702     }
1703
1704     switch (nParamIndex) {
1705     case OMX_IndexConfigVideoBitrate:
1706     {
1707         OMX_VIDEO_CONFIG_BITRATETYPE *pConfigBitrate = (OMX_VIDEO_CONFIG_BITRATETYPE *)pComponentConfigStructure;
1708         OMX_U32                       nPortIndex     = pConfigBitrate->nPortIndex;
1709         EXYNOS_OMX_BASEPORT          *pExynosPort    = NULL;
1710
1711         if (nPortIndex != OUTPUT_PORT_INDEX) {
1712             ret = OMX_ErrorBadPortIndex;
1713             goto EXIT;
1714         } else {
1715             pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1716             pConfigBitrate->nEncodeBitrate = pExynosPort->portDefinition.format.video.nBitrate;
1717         }
1718     }
1719         break;
1720     case OMX_IndexConfigVideoFramerate:
1721     {
1722         OMX_CONFIG_FRAMERATETYPE *pConfigFramerate = (OMX_CONFIG_FRAMERATETYPE *)pComponentConfigStructure;
1723         OMX_U32                   nPortIndex       = pConfigFramerate->nPortIndex;
1724         EXYNOS_OMX_BASEPORT      *pExynosPort      = NULL;
1725
1726         if (nPortIndex != OUTPUT_PORT_INDEX) {
1727             ret = OMX_ErrorBadPortIndex;
1728             goto EXIT;
1729         } else {
1730             pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1731             pConfigFramerate->xEncodeFramerate = pExynosPort->portDefinition.format.video.xFramerate;
1732         }
1733     }
1734         break;
1735     case OMX_IndexVendorGetBufferFD:
1736     {
1737         EXYNOS_OMX_VIDEOENC_COMPONENT       *pVideoEnc      = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1738         EXYNOS_OMX_VIDEO_CONFIG_BUFFERINFO  *pBufferInfo    = (EXYNOS_OMX_VIDEO_CONFIG_BUFFERINFO *)pComponentConfigStructure;
1739
1740         ret = Exynos_OMX_Check_SizeVersion(pBufferInfo, sizeof(EXYNOS_OMX_VIDEO_CONFIG_BUFFERINFO));
1741         if (ret != OMX_ErrorNone)
1742             goto EXIT;
1743
1744         pBufferInfo->fd = Exynos_OSAL_SharedMemory_VirtToION(pVideoEnc->hSharedMemory, pBufferInfo->pVirAddr);
1745     }
1746         break;
1747     default:
1748     {
1749         ret = Exynos_OMX_GetConfig(hComponent, nParamIndex, pComponentConfigStructure);
1750     }
1751         break;
1752     }
1753 EXIT:
1754     FunctionOut();
1755
1756     return ret;
1757 }
1758
1759 OMX_ERRORTYPE Exynos_OMX_VideoEncodeSetConfig(
1760     OMX_HANDLETYPE  hComponent,
1761     OMX_INDEXTYPE   nParamIndex,
1762     OMX_PTR         pComponentConfigStructure)
1763     {
1764     OMX_ERRORTYPE             ret               = OMX_ErrorNone;
1765     OMX_COMPONENTTYPE        *pOMXComponent     = NULL;
1766     EXYNOS_OMX_BASECOMPONENT *pExynosComponent  = NULL;
1767
1768     FunctionIn();
1769
1770     if ((hComponent == NULL) ||
1771         (pComponentConfigStructure == NULL)) {
1772         ret = OMX_ErrorBadParameter;
1773         goto EXIT;
1774     }
1775     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1776
1777     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1778     if (ret != OMX_ErrorNone) {
1779         goto EXIT;
1780     }
1781
1782     if (pOMXComponent->pComponentPrivate == NULL) {
1783         ret = OMX_ErrorBadParameter;
1784         goto EXIT;
1785     }
1786     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1787
1788     if (pExynosComponent->currentState == OMX_StateInvalid) {
1789         ret = OMX_ErrorInvalidState;
1790         goto EXIT;
1791     }
1792
1793     switch (nParamIndex) {
1794     case OMX_IndexConfigVideoBitrate:
1795     {
1796         OMX_VIDEO_CONFIG_BITRATETYPE *pConfigBitrate = (OMX_VIDEO_CONFIG_BITRATETYPE *)pComponentConfigStructure;
1797         OMX_U32                       nPortIndex     = pConfigBitrate->nPortIndex;
1798         EXYNOS_OMX_BASEPORT          *pExynosPort    = NULL;
1799
1800         if (nPortIndex != OUTPUT_PORT_INDEX) {
1801             ret = OMX_ErrorBadPortIndex;
1802             goto EXIT;
1803         } else {
1804             pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1805             pExynosPort->portDefinition.format.video.nBitrate = pConfigBitrate->nEncodeBitrate;
1806         }
1807     }
1808         break;
1809     case OMX_IndexConfigVideoFramerate:
1810     {
1811         OMX_CONFIG_FRAMERATETYPE *pConfigFramerate = (OMX_CONFIG_FRAMERATETYPE *)pComponentConfigStructure;
1812         OMX_U32                   nPortIndex       = pConfigFramerate->nPortIndex;
1813         EXYNOS_OMX_BASEPORT      *pExynosPort      = NULL;
1814
1815         if (nPortIndex != OUTPUT_PORT_INDEX) {
1816             ret = OMX_ErrorBadPortIndex;
1817             goto EXIT;
1818         } else {
1819             pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1820             pExynosPort->portDefinition.format.video.xFramerate = pConfigFramerate->xEncodeFramerate;
1821         }
1822     }
1823         break;
1824     case OMX_IndexConfigVideoIntraVOPRefresh:
1825     {
1826         OMX_CONFIG_INTRAREFRESHVOPTYPE *pIntraRefreshVOP = (OMX_CONFIG_INTRAREFRESHVOPTYPE *)pComponentConfigStructure;
1827         EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc         = NULL;
1828         OMX_U32                        nPortIndex        = pIntraRefreshVOP->nPortIndex;
1829
1830         if (pExynosComponent->hComponentHandle == NULL) {
1831             ret = OMX_ErrorBadParameter;
1832             goto EXIT;
1833         }
1834         pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1835
1836         if (nPortIndex != OUTPUT_PORT_INDEX) {
1837             ret = OMX_ErrorBadPortIndex;
1838             goto EXIT;
1839         } else {
1840             pVideoEnc->IntraRefreshVOP = pIntraRefreshVOP->IntraRefreshVOP;
1841         }
1842     }
1843         break;
1844     default:
1845     {
1846         ret = Exynos_OMX_SetConfig(hComponent, nParamIndex, pComponentConfigStructure);
1847     }
1848         break;
1849     }
1850 EXIT:
1851     FunctionOut();
1852
1853     return ret;
1854 }
1855
1856 OMX_ERRORTYPE Exynos_OMX_VideoEncodeGetExtensionIndex(
1857     OMX_IN OMX_HANDLETYPE  hComponent,
1858     OMX_IN OMX_STRING      szParamName,
1859     OMX_OUT OMX_INDEXTYPE *pIndexType)
1860 {
1861     OMX_ERRORTYPE             ret               = OMX_ErrorNone;
1862     OMX_COMPONENTTYPE        *pOMXComponent     = NULL;
1863     EXYNOS_OMX_BASECOMPONENT *pExynosComponent  = NULL;
1864
1865     FunctionIn();
1866
1867     if (hComponent == NULL) {
1868         ret = OMX_ErrorBadParameter;
1869         goto EXIT;
1870     }
1871     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1872
1873     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1874     if (ret != OMX_ErrorNone) {
1875         goto EXIT;
1876     }
1877
1878     if (pOMXComponent->pComponentPrivate == NULL) {
1879         ret = OMX_ErrorBadParameter;
1880         goto EXIT;
1881     }
1882     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1883
1884     if ((szParamName == NULL) || (pIndexType == NULL)) {
1885         ret = OMX_ErrorBadParameter;
1886         goto EXIT;
1887     }
1888
1889     if (pExynosComponent->currentState == OMX_StateInvalid) {
1890         ret = OMX_ErrorInvalidState;
1891         goto EXIT;
1892     }
1893
1894     if (Exynos_OSAL_Strcmp(szParamName, EXYNOS_INDEX_PARAM_NEED_CONTIG_MEMORY) == 0) {
1895         *pIndexType = (OMX_INDEXTYPE) OMX_IndexVendorNeedContigMemory;
1896         ret = OMX_ErrorNone;
1897         goto EXIT;
1898     } else if (Exynos_OSAL_Strcmp(szParamName, EXYNOS_INDEX_CONFIG_GET_BUFFER_FD) == 0) {
1899         *pIndexType = (OMX_INDEXTYPE) OMX_IndexVendorGetBufferFD;
1900         ret = OMX_ErrorNone;
1901         goto EXIT;
1902     }
1903
1904 #ifdef USE_STOREMETADATA
1905     if (Exynos_OSAL_Strcmp(szParamName, EXYNOS_INDEX_PARAM_STORE_METADATA_BUFFER) == 0) {
1906         *pIndexType = (OMX_INDEXTYPE)OMX_IndexParamStoreMetaDataBuffer;
1907     } else {
1908         ret = Exynos_OMX_GetExtensionIndex(hComponent, szParamName, pIndexType);
1909     }
1910 #else
1911     ret = Exynos_OMX_GetExtensionIndex(hComponent, szParamName, pIndexType);
1912 #endif
1913 EXIT:
1914     FunctionOut();
1915
1916     return ret;
1917 }
1918
1919 OMX_ERRORTYPE Exynos_Shared_DataToBuffer(EXYNOS_OMX_DATA *pData, EXYNOS_OMX_DATABUFFER *pUseBuffer, OMX_BOOL bNeedUnlock)
1920 {
1921     OMX_ERRORTYPE ret = OMX_ErrorNone;
1922
1923     pUseBuffer->bufferHeader          = pData->bufferHeader;
1924     pUseBuffer->allocSize             = pData->allocSize;
1925     pUseBuffer->dataLen               = pData->dataLen;
1926     pUseBuffer->usedDataLen           = pData->usedDataLen;
1927     pUseBuffer->remainDataLen         = pData->remainDataLen;
1928     pUseBuffer->timeStamp             = pData->timeStamp;
1929     pUseBuffer->nFlags                = pData->nFlags;
1930     pUseBuffer->pPrivate              = pData->pPrivate;
1931
1932     if ((bNeedUnlock == OMX_TRUE) && (pUseBuffer->bufferHeader != NULL)) {
1933         OMX_PTR ppBuf[MAX_BUFFER_PLANE];
1934         Exynos_OSAL_GetInfoFromMetaData((OMX_BYTE)pUseBuffer->bufferHeader->pBuffer, ppBuf);
1935         Exynos_OSAL_UnlockANBHandle(ppBuf[0]);
1936     }
1937
1938     return ret;
1939 }