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