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