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         if (pDataBuffer[1] != NULL)
 637             Exynos_OSAL_MutexUnlock(pDataBuffer[1]->bufferMutex);
 638
 639         Exynos_OSAL_MutexUnlock(pDataBuffer[0]->bufferMutex);
 640
 641         goto EXIT;
 642     }
 643
 644     if (pExynosPort->bufferProcessType & BUFFER_COPY)
 645         pVideoEnc->exynos_codec_enqueueAllBuffer(pOMXComponent, nPortIndex);
 646     Exynos_ResetCodecData(&pExynosPort->processData);
 647
 648     if (ret == OMX_ErrorNone) {
 649         if (nPortIndex == INPUT_PORT_INDEX) {
 650             pExynosComponent->checkTimeStamp.needSetStartTimeStamp = OMX_TRUE;
 651             pExynosComponent->checkTimeStamp.needCheckStartTimeStamp = OMX_FALSE;
 652             Exynos_OSAL_Memset(pExynosComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
 653             Exynos_OSAL_Memset(pExynosComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
 654             pExynosComponent->getAllDelayBuffer = OMX_FALSE;
 655             pExynosComponent->bSaveFlagEOS = OMX_FALSE;
 656             pExynosComponent->reInputData = OMX_FALSE;
 657         }
 658
 659         pExynosPort->bIsPortFlushed = OMX_FALSE;
 660         Exynos_OSAL_Log(EXYNOS_LOG_TRACE,"OMX_CommandFlush EventCmdComplete, port:%d", nPortIndex);
 661         if (bEvent == OMX_TRUE)
 662             pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
 663                             pExynosComponent->callbackData,
 664                             OMX_EventCmdComplete,
 665                             OMX_CommandFlush, nPortIndex, NULL);
 666     }
 667
 668     if (pDataBuffer[1] != NULL)
 669         Exynos_OSAL_MutexUnlock(pDataBuffer[1]->bufferMutex);
 670
 671     Exynos_OSAL_MutexUnlock(pDataBuffer[0]->bufferMutex);
 672
 673 EXIT:
 674     if ((ret != OMX_ErrorNone) && (pOMXComponent != NULL) && (pExynosComponent != NULL)) {
 675         Exynos_OSAL_Log(EXYNOS_LOG_ERROR,"%s : %d", __FUNCTION__, __LINE__);
 676         pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
 677                         pExynosComponent->callbackData,
 678                         OMX_EventError,
 679                         ret, 0, NULL);
 680     }
 681
 682     FunctionOut();
 683
 684     return ret;
 685 }
 686
 687 OMX_ERRORTYPE Exynos_InputBufferReturn(
 688     OMX_COMPONENTTYPE   *pOMXComponent)
 689 {
 690     OMX_ERRORTYPE                ret                = OMX_ErrorNone;
 691     EXYNOS_OMX_BASECOMPONENT    *pExynosComponent   = NULL;
 692     EXYNOS_OMX_BASEPORT         *pExynosPort        = NULL;
 693     EXYNOS_OMX_DATABUFFER       *pDataBuffer        = NULL;
 694     OMX_BUFFERHEADERTYPE        *pBufferHdr         = NULL;
 695
 696     FunctionIn();
 697
 698     if (pOMXComponent == NULL) {
 699         ret = OMX_ErrorBadParameter;
 700         goto EXIT;
 701     }
 702
 703     if (pOMXComponent->pComponentPrivate == NULL) {
 704         ret = OMX_ErrorBadParameter;
 705         goto EXIT;
 706     }
 707     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 708     pExynosPort = &(pExynosComponent->pExynosPort[INPUT_PORT_INDEX]);
 709
 710     if (pExynosPort->bufferProcessType & BUFFER_COPY) {
 711         pDataBuffer = &(pExynosPort->way.port2WayDataBuffer.inputDataBuffer);
 712     } else if (pExynosPort->bufferProcessType & BUFFER_SHARE) {
 713         pDataBuffer = &(pExynosPort->way.port2WayDataBuffer.outputDataBuffer);
 714     }
 715
 716     pBufferHdr = pDataBuffer->bufferHeader;
 717
 718     if (pBufferHdr != NULL) {
 719         if (pExynosPort->markType.hMarkTargetComponent != NULL) {
 720             pBufferHdr->hMarkTargetComponent = pExynosPort->markType.hMarkTargetComponent;
 721             pBufferHdr->pMarkData            = pExynosPort->markType.pMarkData;
 722             pExynosPort->markType.hMarkTargetComponent = NULL;
 723             pExynosPort->markType.pMarkData = NULL;
 724         }
 725
 726         if (pBufferHdr->hMarkTargetComponent != NULL) {
 727             if (pBufferHdr->hMarkTargetComponent == pOMXComponent) {
 728                 pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
 729                                 pExynosComponent->callbackData,
 730                                 OMX_EventMark,
 731                                 0, 0, pBufferHdr->pMarkData);
 732             } else {
 733                 pExynosComponent->propagateMarkType.hMarkTargetComponent = pBufferHdr->hMarkTargetComponent;
 734                 pExynosComponent->propagateMarkType.pMarkData = pBufferHdr->pMarkData;
 735             }
 736         }
 737
 738         pBufferHdr->nFilledLen = 0;
 739         pBufferHdr->nOffset = 0;
 740         Exynos_OMX_InputBufferReturn(pOMXComponent, pBufferHdr);
 741     }
 742
 743     /* reset dataBuffer */
 744     Exynos_ResetDataBuffer(pDataBuffer);
 745
 746 EXIT:
 747     FunctionOut();
 748
 749     return ret;
 750 }
 751
 752 OMX_ERRORTYPE Exynos_FlushInputBufferReturn(
 753     OMX_COMPONENTTYPE       *pOMXComponent,
 754     EXYNOS_OMX_DATABUFFER   *pDataBuffer)
 755 {
 756     OMX_ERRORTYPE                ret = OMX_ErrorNone;
 757     EXYNOS_OMX_BASECOMPONENT    *pExynosComponent   = NULL;
 758     EXYNOS_OMX_BASEPORT         *pExynosPort        = NULL;
 759     OMX_BUFFERHEADERTYPE        *pBufferHdr         = NULL;
 760
 761     FunctionIn();
 762
 763     if (pOMXComponent == NULL) {
 764         ret = OMX_ErrorBadParameter;
 765         goto EXIT;
 766     }
 767
 768     if (pOMXComponent->pComponentPrivate == NULL) {
 769         ret = OMX_ErrorBadParameter;
 770         goto EXIT;
 771     }
 772     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 773     pExynosPort = &(pExynosComponent->pExynosPort[INPUT_PORT_INDEX]);
 774
 775     pBufferHdr = pDataBuffer->bufferHeader;
 776
 777     if (pBufferHdr != NULL) {
 778         if (pExynosPort->markType.hMarkTargetComponent != NULL) {
 779             pBufferHdr->hMarkTargetComponent  = pExynosPort->markType.hMarkTargetComponent;
 780             pBufferHdr->pMarkData             = pExynosPort->markType.pMarkData;
 781             pExynosPort->markType.hMarkTargetComponent = NULL;
 782             pExynosPort->markType.pMarkData = NULL;
 783         }
 784
 785         if (pBufferHdr->hMarkTargetComponent != NULL) {
 786             if (pBufferHdr->hMarkTargetComponent == pOMXComponent) {
 787                 pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
 788                                 pExynosComponent->callbackData,
 789                                 OMX_EventMark,
 790                                 0, 0, pBufferHdr->pMarkData);
 791             } else {
 792                 pExynosComponent->propagateMarkType.hMarkTargetComponent = pBufferHdr->hMarkTargetComponent;
 793                 pExynosComponent->propagateMarkType.pMarkData = pBufferHdr->pMarkData;
 794             }
 795         }
 796
 797         pBufferHdr->nFilledLen = 0;
 798         pBufferHdr->nOffset = 0;
 799         Exynos_OMX_InputBufferReturn(pOMXComponent, pBufferHdr);
 800     }
 801
 802     /* reset dataBuffer */
 803     Exynos_ResetDataBuffer(pDataBuffer);
 804
 805 EXIT:
 806     FunctionOut();
 807
 808     return ret;
 809 }
 810
 811 OMX_ERRORTYPE Exynos_InputBufferGetQueue(
 812     EXYNOS_OMX_BASECOMPONENT    *pExynosComponent)
 813 {
 814     OMX_ERRORTYPE          ret          = OMX_ErrorUndefined;
 815     EXYNOS_OMX_BASEPORT   *pExynosPort  = NULL;
 816     EXYNOS_OMX_MESSAGE    *pMessage     = NULL;
 817     EXYNOS_OMX_DATABUFFER *pDataBuffer  = NULL;
 818
 819     FunctionIn();
 820
 821     if (pExynosComponent == NULL) {
 822         ret = OMX_ErrorBadParameter;
 823         goto EXIT;
 824     }
 825     pExynosPort = &(pExynosComponent->pExynosPort[INPUT_PORT_INDEX]);
 826     pDataBuffer = &(pExynosPort->way.port2WayDataBuffer.inputDataBuffer);
 827
 828     if (pExynosComponent->currentState != OMX_StateExecuting) {
 829         ret = OMX_ErrorUndefined;
 830         goto EXIT;
 831     } else if ((pExynosComponent->transientState != EXYNOS_OMX_TransStateExecutingToIdle) &&
 832                (!CHECK_PORT_BEING_FLUSHED(pExynosPort))) {
 833         Exynos_OSAL_SemaphoreWait(pExynosPort->bufferSemID);
 834         if (pDataBuffer->dataValid != OMX_TRUE) {
 835             pMessage = (EXYNOS_OMX_MESSAGE *)Exynos_OSAL_Dequeue(&pExynosPort->bufferQ);
 836             if (pMessage == NULL) {
 837                 ret = OMX_ErrorUndefined;
 838                 goto EXIT;
 839             }
 840             if (pMessage->messageType == EXYNOS_OMX_CommandFakeBuffer) {
 841                 Exynos_OSAL_Free(pMessage);
 842                 ret = OMX_ErrorCodecFlush;
 843                 goto EXIT;
 844             }
 845
 846             pDataBuffer->bufferHeader  = (OMX_BUFFERHEADERTYPE *)(pMessage->pCmdData);
 847             pDataBuffer->allocSize     = pDataBuffer->bufferHeader->nAllocLen;
 848             pDataBuffer->dataLen       = pDataBuffer->bufferHeader->nFilledLen;
 849             pDataBuffer->remainDataLen = pDataBuffer->dataLen;
 850             pDataBuffer->usedDataLen   = 0;
 851             pDataBuffer->dataValid     = OMX_TRUE;
 852             pDataBuffer->nFlags        = pDataBuffer->bufferHeader->nFlags;
 853             pDataBuffer->timeStamp     = pDataBuffer->bufferHeader->nTimeStamp;
 854
 855             Exynos_OSAL_Free(pMessage);
 856
 857 #ifndef TIZEN_FEATURE_E3250
 858             if (pDataBuffer->allocSize <= pDataBuffer->dataLen)
 859                 Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "Input Buffer Full, Check input buffer size! allocSize:%d, dataLen:%d", pDataBuffer->allocSize, pDataBuffer->dataLen);
 860 #endif
 861         }
 862         ret = OMX_ErrorNone;
 863     }
 864 EXIT:
 865     FunctionOut();
 866
 867     return ret;
 868 }
 869
 870 OMX_ERRORTYPE Exynos_OutputBufferReturn(
 871     OMX_COMPONENTTYPE   *pOMXComponent)
 872 {
 873     OMX_ERRORTYPE             ret               = OMX_ErrorNone;
 874     EXYNOS_OMX_BASECOMPONENT *pExynosComponent  = NULL;
 875     EXYNOS_OMX_BASEPORT      *pExynosPort       = NULL;
 876     EXYNOS_OMX_DATABUFFER    *pDataBuffer       = NULL;
 877     OMX_BUFFERHEADERTYPE     *pBufferHdr        = NULL;
 878
 879     FunctionIn();
 880
 881     if (pOMXComponent == NULL) {
 882         ret = OMX_ErrorBadParameter;
 883         goto EXIT;
 884     }
 885
 886     if (pOMXComponent->pComponentPrivate == NULL) {
 887         ret = OMX_ErrorBadParameter;
 888         goto EXIT;
 889     }
 890     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 891     pExynosPort = &(pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX]);
 892
 893     pDataBuffer = &(pExynosPort->way.port2WayDataBuffer.outputDataBuffer);
 894     pBufferHdr = pDataBuffer->bufferHeader;
 895
 896     if (pBufferHdr != NULL) {
 897         pBufferHdr->nFilledLen = pDataBuffer->remainDataLen;
 898         pBufferHdr->nOffset    = 0;
 899         pBufferHdr->nFlags     = pDataBuffer->nFlags;
 900         pBufferHdr->nTimeStamp = pDataBuffer->timeStamp;
 901
 902         if (pExynosComponent->propagateMarkType.hMarkTargetComponent != NULL) {
 903             pBufferHdr->hMarkTargetComponent = pExynosComponent->propagateMarkType.hMarkTargetComponent;
 904             pBufferHdr->pMarkData            = pExynosComponent->propagateMarkType.pMarkData;
 905             pExynosComponent->propagateMarkType.hMarkTargetComponent = NULL;
 906             pExynosComponent->propagateMarkType.pMarkData = NULL;
 907         }
 908
 909         if ((pBufferHdr->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
 910             pBufferHdr->nFilledLen = 0;
 911             Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "event OMX_BUFFERFLAG_EOS!!!");
 912             pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
 913                             pExynosComponent->callbackData,
 914                             OMX_EventBufferFlag,
 915                             OUTPUT_PORT_INDEX,
 916                             pBufferHdr->nFlags, NULL);
 917         }
 918
 919         Exynos_OMX_OutputBufferReturn(pOMXComponent, pBufferHdr);
 920     }
 921
 922     /* reset dataBuffer */
 923     Exynos_ResetDataBuffer(pDataBuffer);
 924
 925 EXIT:
 926     FunctionOut();
 927
 928     return ret;
 929 }
 930
 931 OMX_ERRORTYPE Exynos_FlushOutputBufferReturn(
 932     OMX_COMPONENTTYPE       *pOMXComponent,
 933     EXYNOS_OMX_DATABUFFER   *pDataBuffer)
 934 {
 935     OMX_ERRORTYPE             ret               = OMX_ErrorNone;
 936     EXYNOS_OMX_BASECOMPONENT *pExynosComponent  = NULL;
 937     OMX_BUFFERHEADERTYPE     *pBufferHdr        = NULL;
 938
 939     FunctionIn();
 940
 941     if (pOMXComponent == NULL) {
 942         ret = OMX_ErrorBadParameter;
 943         goto EXIT;
 944     }
 945
 946     if (pOMXComponent->pComponentPrivate == NULL) {
 947         ret = OMX_ErrorBadParameter;
 948         goto EXIT;
 949     }
 950     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 951     pBufferHdr = pDataBuffer->bufferHeader;
 952
 953     if (pBufferHdr != NULL) {
 954         pBufferHdr->nFilledLen = pDataBuffer->remainDataLen;
 955         pBufferHdr->nOffset    = 0;
 956         pBufferHdr->nFlags     = pDataBuffer->nFlags;
 957         pBufferHdr->nTimeStamp = pDataBuffer->timeStamp;
 958
 959         if (pExynosComponent->propagateMarkType.hMarkTargetComponent != NULL) {
 960             pBufferHdr->hMarkTargetComponent    = pExynosComponent->propagateMarkType.hMarkTargetComponent;
 961             pBufferHdr->pMarkData               = pExynosComponent->propagateMarkType.pMarkData;
 962             pExynosComponent->propagateMarkType.hMarkTargetComponent = NULL;
 963             pExynosComponent->propagateMarkType.pMarkData = NULL;
 964         }
 965
 966         if ((pBufferHdr->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
 967             pBufferHdr->nFilledLen = 0;
 968             Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "event OMX_BUFFERFLAG_EOS!!!");
 969             pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
 970                             pExynosComponent->callbackData,
 971                             OMX_EventBufferFlag,
 972                             OUTPUT_PORT_INDEX,
 973                             pBufferHdr->nFlags, NULL);
 974         }
 975         Exynos_OMX_OutputBufferReturn(pOMXComponent, pBufferHdr);
 976     }
 977
 978     /* reset dataBuffer */
 979     Exynos_ResetDataBuffer(pDataBuffer);
 980
 981 EXIT:
 982     FunctionOut();
 983
 984     return ret;
 985 }
 986
 987 OMX_ERRORTYPE Exynos_OutputBufferGetQueue(
 988     EXYNOS_OMX_BASECOMPONENT    *pExynosComponent)
 989 {
 990     OMX_ERRORTYPE          ret          = OMX_ErrorUndefined;
 991     EXYNOS_OMX_BASEPORT   *pExynosPort  = NULL;
 992     EXYNOS_OMX_MESSAGE    *pMessage     = NULL;
 993     EXYNOS_OMX_DATABUFFER *pDataBuffer  = NULL;
 994
 995     FunctionIn();
 996
 997     if (pExynosComponent == NULL) {
 998         ret = OMX_ErrorBadParameter;
 999         goto EXIT;
1000     }
1001     pExynosPort = &(pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX]);
1002
1003     if (pExynosPort->bufferProcessType & BUFFER_COPY) {
1004         pDataBuffer = &(pExynosPort->way.port2WayDataBuffer.outputDataBuffer);
1005     } else if (pExynosPort->bufferProcessType & BUFFER_SHARE) {
1006         pDataBuffer = &(pExynosPort->way.port2WayDataBuffer.inputDataBuffer);
1007     }
1008
1009     if (pExynosComponent->currentState != OMX_StateExecuting) {
1010         ret = OMX_ErrorUndefined;
1011         goto EXIT;
1012     } else if ((pExynosComponent->transientState != EXYNOS_OMX_TransStateExecutingToIdle) &&
1013                (!CHECK_PORT_BEING_FLUSHED(pExynosPort))) {
1014         Exynos_OSAL_SemaphoreWait(pExynosPort->bufferSemID);
1015         if (pDataBuffer->dataValid != OMX_TRUE) {
1016             pMessage = (EXYNOS_OMX_MESSAGE *)Exynos_OSAL_Dequeue(&pExynosPort->bufferQ);
1017             if (pMessage == NULL) {
1018                 ret = OMX_ErrorUndefined;
1019                 goto EXIT;
1020             }
1021             if (pMessage->messageType == EXYNOS_OMX_CommandFakeBuffer) {
1022                 Exynos_OSAL_Free(pMessage);
1023                 ret = OMX_ErrorCodecFlush;
1024                 goto EXIT;
1025             }
1026
1027             pDataBuffer->bufferHeader  = (OMX_BUFFERHEADERTYPE *)(pMessage->pCmdData);
1028             pDataBuffer->allocSize     = pDataBuffer->bufferHeader->nAllocLen;
1029             pDataBuffer->dataLen       = 0; //dataBuffer->bufferHeader->nFilledLen;
1030             pDataBuffer->remainDataLen = pDataBuffer->dataLen;
1031             pDataBuffer->usedDataLen   = 0; //dataBuffer->bufferHeader->nOffset;
1032             pDataBuffer->dataValid     = OMX_TRUE;
1033             /* pDataBuffer->nFlags             = pDataBuffer->bufferHeader->nFlags; */
1034             /* pDtaBuffer->nTimeStamp         = pDataBuffer->bufferHeader->nTimeStamp; */
1035 /*
1036             if (pExynosPort->bufferProcessType & BUFFER_SHARE)
1037                 pDataBuffer->pPrivate      = pDataBuffer->bufferHeader->pOutputPortPrivate;
1038             else if (pExynosPort->bufferProcessType & BUFFER_COPY) {
1039                 pExynosPort->processData.dataBuffer = pDataBuffer->bufferHeader->pBuffer;
1040                 pExynosPort->processData.allocSize  = pDataBuffer->bufferHeader->nAllocLen;
1041             }
1042 */
1043             Exynos_OSAL_Free(pMessage);
1044         }
1045         ret = OMX_ErrorNone;
1046     }
1047 EXIT:
1048     FunctionOut();
1049
1050     return ret;
1051 }
1052
1053 OMX_BUFFERHEADERTYPE *Exynos_OutputBufferGetQueue_Direct(
1054     EXYNOS_OMX_BASECOMPONENT    *pExynosComponent)
1055 {
1056     OMX_BUFFERHEADERTYPE  *pBufferHdr   = NULL;
1057     EXYNOS_OMX_BASEPORT   *pExynosPort  = NULL;
1058     EXYNOS_OMX_MESSAGE    *pMessage     = NULL;
1059
1060     FunctionIn();
1061
1062     if (pExynosComponent == NULL) {
1063         pBufferHdr = NULL;
1064         goto EXIT;
1065     }
1066     pExynosPort = &(pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX]);
1067
1068     if (pExynosComponent->currentState != OMX_StateExecuting) {
1069         pBufferHdr = NULL;
1070         goto EXIT;
1071     } else if ((pExynosComponent->transientState != EXYNOS_OMX_TransStateExecutingToIdle) &&
1072                (!CHECK_PORT_BEING_FLUSHED(pExynosPort))) {
1073         Exynos_OSAL_SemaphoreWait(pExynosPort->bufferSemID);
1074
1075         pMessage = (EXYNOS_OMX_MESSAGE *)Exynos_OSAL_Dequeue(&pExynosPort->bufferQ);
1076         if (pMessage == NULL) {
1077             pBufferHdr = NULL;
1078             goto EXIT;
1079         }
1080         if (pMessage->messageType == EXYNOS_OMX_CommandFakeBuffer) {
1081             Exynos_OSAL_Free(pMessage);
1082             pBufferHdr = NULL;
1083             goto EXIT;
1084         }
1085
1086         pBufferHdr  = (OMX_BUFFERHEADERTYPE *)(pMessage->pCmdData);
1087         Exynos_OSAL_Free(pMessage);
1088     }
1089
1090 EXIT:
1091     FunctionOut();
1092
1093     return pBufferHdr;
1094 }
1095
1096 OMX_ERRORTYPE Exynos_CodecBufferEnqueue(
1097     EXYNOS_OMX_BASECOMPONENT    *pExynosComponent,
1098     OMX_U32                      nPortIndex,
1099     OMX_PTR                      pData)
1100 {
1101     OMX_ERRORTYPE          ret         = OMX_ErrorNone;
1102     EXYNOS_OMX_BASEPORT   *pExynosPort = NULL;
1103
1104     FunctionIn();
1105
1106     if (pExynosComponent == NULL) {
1107         ret = OMX_ErrorBadParameter;
1108         goto EXIT;
1109     }
1110
1111     if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1112         ret = OMX_ErrorBadPortIndex;
1113         goto EXIT;
1114     }
1115     pExynosPort = &(pExynosComponent->pExynosPort[nPortIndex]);
1116
1117     if (pData == NULL) {
1118         ret = OMX_ErrorInsufficientResources;
1119         goto EXIT;
1120     }
1121
1122     ret = Exynos_OSAL_Queue(&pExynosPort->codecBufferQ, (void *)pData);
1123     if (ret != 0) {
1124         ret = OMX_ErrorUndefined;
1125         goto EXIT;
1126     }
1127     Exynos_OSAL_SemaphorePost(pExynosPort->codecSemID);
1128
1129     ret = OMX_ErrorNone;
1130
1131 EXIT:
1132     FunctionOut();
1133
1134     return ret;
1135 }
1136
1137 OMX_ERRORTYPE Exynos_CodecBufferDequeue(
1138     EXYNOS_OMX_BASECOMPONENT    *pExynosComponent,
1139     OMX_U32                      nPortIndex,
1140     OMX_PTR                     *pData)
1141 {
1142     OMX_ERRORTYPE          ret         = OMX_ErrorNone;
1143     EXYNOS_OMX_BASEPORT   *pExynosPort = NULL;
1144     OMX_PTR                pTempData   = NULL;
1145
1146     FunctionIn();
1147
1148     if (pExynosComponent == NULL) {
1149         ret = OMX_ErrorBadParameter;
1150         goto EXIT;
1151     }
1152
1153     if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1154         ret = OMX_ErrorBadPortIndex;
1155         goto EXIT;
1156     }
1157     pExynosPort = &(pExynosComponent->pExynosPort[nPortIndex]);
1158
1159     Exynos_OSAL_SemaphoreWait(pExynosPort->codecSemID);
1160     pTempData = (OMX_PTR)Exynos_OSAL_Dequeue(&pExynosPort->codecBufferQ);
1161     if (pTempData != NULL) {
1162         *pData = (OMX_PTR)pTempData;
1163         ret = OMX_ErrorNone;
1164     } else {
1165         *pData = NULL;
1166         ret = OMX_ErrorUndefined;
1167     }
1168
1169 EXIT:
1170     FunctionOut();
1171
1172     return ret;
1173 }
1174
1175 OMX_ERRORTYPE Exynos_CodecBufferReset(
1176     EXYNOS_OMX_BASECOMPONENT    *pExynosComponent,
1177     OMX_U32                      nPortIndex)
1178 {
1179     OMX_ERRORTYPE          ret          = OMX_ErrorNone;
1180     EXYNOS_OMX_BASEPORT   *pExynosPort  = NULL;
1181
1182     FunctionIn();
1183
1184     if (pExynosComponent == NULL) {
1185         ret = OMX_ErrorBadParameter;
1186         goto EXIT;
1187     }
1188
1189     if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1190         ret = OMX_ErrorBadPortIndex;
1191         goto EXIT;
1192     }
1193     pExynosPort = &(pExynosComponent->pExynosPort[nPortIndex]);
1194
1195     ret = Exynos_OSAL_ResetQueue(&pExynosPort->codecBufferQ);
1196     if (ret != 0) {
1197         ret = OMX_ErrorUndefined;
1198         goto EXIT;
1199     }
1200
1201     while (1) {
1202         OMX_S32 cnt = 0;
1203         Exynos_OSAL_Get_SemaphoreCount(pExynosPort->codecSemID, &cnt);
1204         if (cnt > 0)
1205             Exynos_OSAL_SemaphoreWait(pExynosPort->codecSemID);
1206         else
1207             break;
1208     }
1209     ret = OMX_ErrorNone;
1210
1211 EXIT:
1212     FunctionOut();
1213
1214     return ret;
1215 }
1216
1217 OMX_ERRORTYPE Exynos_OMX_VideoEncodeGetParameter(
1218     OMX_IN OMX_HANDLETYPE hComponent,
1219     OMX_IN OMX_INDEXTYPE  nParamIndex,
1220     OMX_INOUT OMX_PTR     pComponentParameterStructure)
1221 {
1222     OMX_ERRORTYPE             ret               = OMX_ErrorNone;
1223     OMX_COMPONENTTYPE        *pOMXComponent     = NULL;
1224     EXYNOS_OMX_BASECOMPONENT *pExynosComponent  = NULL;
1225
1226     FunctionIn();
1227
1228     if (hComponent == NULL) {
1229         ret = OMX_ErrorBadParameter;
1230         goto EXIT;
1231     }
1232     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1233
1234     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1235     if (ret != OMX_ErrorNone) {
1236         goto EXIT;
1237     }
1238
1239     if (pOMXComponent->pComponentPrivate == NULL) {
1240         ret = OMX_ErrorBadParameter;
1241         goto EXIT;
1242     }
1243     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1244
1245     if (pExynosComponent->currentState == OMX_StateInvalid) {
1246         ret = OMX_ErrorInvalidState;
1247         goto EXIT;
1248     }
1249
1250     if (pComponentParameterStructure == NULL) {
1251         ret = OMX_ErrorBadParameter;
1252         goto EXIT;
1253     }
1254
1255     switch (nParamIndex) {
1256     case OMX_IndexParamVideoInit:
1257     {
1258         OMX_PORT_PARAM_TYPE *pPortParam = (OMX_PORT_PARAM_TYPE *)pComponentParameterStructure;
1259         ret = Exynos_OMX_Check_SizeVersion(pPortParam, sizeof(OMX_PORT_PARAM_TYPE));
1260         if (ret != OMX_ErrorNone) {
1261             goto EXIT;
1262         }
1263
1264         pPortParam->nPorts           = pExynosComponent->portParam.nPorts;
1265         pPortParam->nStartPortNumber = pExynosComponent->portParam.nStartPortNumber;
1266         ret = OMX_ErrorNone;
1267     }
1268         break;
1269     case OMX_IndexParamVideoPortFormat:
1270     {
1271         OMX_VIDEO_PARAM_PORTFORMATTYPE *pPortFormat     = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)pComponentParameterStructure;
1272         OMX_U32                         nPortIndex      = pPortFormat->nPortIndex;
1273         OMX_U32                         nIndex          = pPortFormat->nIndex;
1274         EXYNOS_OMX_BASEPORT            *pExynosPort     = NULL;
1275         OMX_PARAM_PORTDEFINITIONTYPE   *pPortDef        = NULL;
1276         OMX_U32                         nSupportFormat  = 0;
1277
1278         ret = Exynos_OMX_Check_SizeVersion(pPortFormat, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
1279         if (ret != OMX_ErrorNone) {
1280             goto EXIT;
1281         }
1282
1283         if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1284             ret = OMX_ErrorBadPortIndex;
1285             goto EXIT;
1286         }
1287
1288         if (nPortIndex == INPUT_PORT_INDEX) {
1289             pExynosPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1290             pPortDef = &pExynosPort->portDefinition;
1291
1292             switch (nIndex) {
1293             case supportFormat_0:
1294                 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1295                 pPortFormat->eColorFormat       = OMX_COLOR_FormatYUV420Planar;
1296                 pPortFormat->xFramerate         = pPortDef->format.video.xFramerate;
1297                 break;
1298             case supportFormat_1:
1299                 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1300                 pPortFormat->eColorFormat       = OMX_COLOR_FormatYUV420SemiPlanar;
1301                 pPortFormat->xFramerate         = pPortDef->format.video.xFramerate;
1302                 break;
1303             case supportFormat_2:
1304                 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1305                 pPortFormat->eColorFormat       = OMX_SEC_COLOR_FormatNV12Tiled;
1306                 pPortFormat->xFramerate         = pPortDef->format.video.xFramerate;
1307                 break;
1308             case supportFormat_3:
1309                 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1310                 pPortFormat->eColorFormat       = OMX_SEC_COLOR_FormatNV21Linear;
1311                 pPortFormat->xFramerate         = pPortDef->format.video.xFramerate;
1312                 break;
1313             case supportFormat_4:
1314 #ifdef TIZEN_FEATURE_E3250
1315                 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "can not support this format");
1316 #else
1317                 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1318                 pPortFormat->eColorFormat       = OMX_COLOR_FormatAndroidOpaque;
1319                 pPortFormat->xFramerate         = pPortDef->format.video.xFramerate;
1320 #endif
1321                 break;
1322             case supportFormat_5:
1323                 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1324                 pPortFormat->eColorFormat       = OMX_SEC_COLOR_FormatNV12L_DmaBuf_Fd;
1325                 pPortFormat->xFramerate         = pPortDef->format.video.xFramerate;
1326                 break;
1327             case supportFormat_6:
1328                 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1329                 pPortFormat->eColorFormat       = OMX_SEC_COLOR_FormatNV12T_DmaBuf_Fd;
1330                 pPortFormat->xFramerate         = pPortDef->format.video.xFramerate;
1331                 break;
1332             default:
1333                 if (nIndex > supportFormat_0) {
1334                     ret = OMX_ErrorNoMore;
1335                     goto EXIT;
1336                 }
1337                 break;
1338             }
1339         } else if (nPortIndex == OUTPUT_PORT_INDEX) {
1340             nSupportFormat = OUTPUT_PORT_SUPPORTFORMAT_NUM_MAX - 1;
1341             if (nIndex > nSupportFormat) {
1342                 ret = OMX_ErrorNoMore;
1343                 goto EXIT;
1344             }
1345
1346             pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1347             pPortDef = &pExynosPort->portDefinition;
1348
1349             pPortFormat->eCompressionFormat = pPortDef->format.video.eCompressionFormat;
1350             pPortFormat->eColorFormat       = pPortDef->format.video.eColorFormat;
1351             pPortFormat->xFramerate         = pPortDef->format.video.xFramerate;
1352         }
1353         ret = OMX_ErrorNone;
1354     }
1355         break;
1356     case OMX_IndexParamVideoBitrate:
1357     {
1358         OMX_VIDEO_PARAM_BITRATETYPE     *pVideoBitrate  = (OMX_VIDEO_PARAM_BITRATETYPE *)pComponentParameterStructure;
1359         OMX_U32                          nPortIndex     = pVideoBitrate->nPortIndex;
1360         EXYNOS_OMX_BASEPORT             *pExynosPort    = NULL;
1361         EXYNOS_OMX_VIDEOENC_COMPONENT   *pVideoEnc      = NULL;
1362         OMX_PARAM_PORTDEFINITIONTYPE    *pPortDef       = NULL;
1363
1364         if (nPortIndex != OUTPUT_PORT_INDEX) {
1365             ret = OMX_ErrorBadPortIndex;
1366             goto EXIT;
1367         } else {
1368             pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1369             if (pVideoEnc == NULL) {
1370                 ret = OMX_ErrorBadParameter;
1371                 goto EXIT;
1372             }
1373             pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1374             pPortDef = &pExynosPort->portDefinition;
1375
1376             pVideoBitrate->eControlRate = pVideoEnc->eControlRate[nPortIndex];
1377             pVideoBitrate->nTargetBitrate = pPortDef->format.video.nBitrate;
1378         }
1379         ret = OMX_ErrorNone;
1380     }
1381         break;
1382     case OMX_IndexParamVideoQuantization:
1383     {
1384         OMX_VIDEO_PARAM_QUANTIZATIONTYPE  *pVideoQuantization = (OMX_VIDEO_PARAM_QUANTIZATIONTYPE *)pComponentParameterStructure;
1385         OMX_U32                            nPortIndex         = pVideoQuantization->nPortIndex;
1386         EXYNOS_OMX_VIDEOENC_COMPONENT     *pVideoEnc          = NULL;
1387
1388         if (nPortIndex != OUTPUT_PORT_INDEX) {
1389             ret = OMX_ErrorBadPortIndex;
1390             goto EXIT;
1391         } else {
1392             pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1393             if (pVideoEnc == NULL) {
1394                 ret = OMX_ErrorBadParameter;
1395                 goto EXIT;
1396             }
1397
1398             pVideoQuantization->nQpI = pVideoEnc->quantization.nQpI;
1399             pVideoQuantization->nQpP = pVideoEnc->quantization.nQpP;
1400             pVideoQuantization->nQpB = pVideoEnc->quantization.nQpB;
1401         }
1402         ret = OMX_ErrorNone;
1403     }
1404         break;
1405     case OMX_IndexParamPortDefinition:
1406     {
1407         OMX_PARAM_PORTDEFINITIONTYPE *pPortDef      = (OMX_PARAM_PORTDEFINITIONTYPE *)pComponentParameterStructure;
1408         OMX_U32                       nPortIndex    = pPortDef->nPortIndex;
1409         EXYNOS_OMX_BASEPORT          *pExynosPort   = NULL;
1410
1411         if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1412             ret = OMX_ErrorBadPortIndex;
1413             goto EXIT;
1414         }
1415
1416         ret = Exynos_OMX_Check_SizeVersion(pPortDef, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1417         if (ret != OMX_ErrorNone) {
1418             goto EXIT;
1419         }
1420
1421         pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1422         Exynos_OSAL_Memcpy(pPortDef, &pExynosPort->portDefinition, pPortDef->nSize);
1423
1424 #ifdef USE_STOREMETADATA
1425         if ((nPortIndex == 0) &&
1426             (pExynosPort->bStoreMetaData == OMX_TRUE)) {
1427             pPortDef->nBufferSize = MAX_INPUT_METADATA_BUFFER_SIZE;
1428         }
1429 #endif
1430     }
1431         break;
1432     default:
1433     {
1434         ret = Exynos_OMX_GetParameter(hComponent, nParamIndex, pComponentParameterStructure);
1435     }
1436         break;
1437     }
1438 EXIT:
1439     FunctionOut();
1440
1441     return ret;
1442 }
1443
1444 OMX_ERRORTYPE Exynos_OMX_VideoEncodeSetParameter(
1445     OMX_IN OMX_HANDLETYPE hComponent,
1446     OMX_IN OMX_INDEXTYPE  nParamIndex,
1447     OMX_IN OMX_PTR        pComponentParameterStructure)
1448 {
1449     OMX_ERRORTYPE             ret               = OMX_ErrorNone;
1450     OMX_COMPONENTTYPE        *pOMXComponent     = NULL;
1451     EXYNOS_OMX_BASECOMPONENT *pExynosComponent  = NULL;
1452
1453     FunctionIn();
1454
1455     if (hComponent == NULL) {
1456         ret = OMX_ErrorBadParameter;
1457         goto EXIT;
1458     }
1459     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1460
1461     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1462     if (ret != OMX_ErrorNone) {
1463         goto EXIT;
1464     }
1465
1466     if (pOMXComponent->pComponentPrivate == NULL) {
1467         ret = OMX_ErrorBadParameter;
1468         goto EXIT;
1469     }
1470     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1471
1472     if (pExynosComponent->currentState == OMX_StateInvalid) {
1473         ret = OMX_ErrorInvalidState;
1474         goto EXIT;
1475     }
1476
1477     if (pComponentParameterStructure == NULL) {
1478         ret = OMX_ErrorBadParameter;
1479         goto EXIT;
1480     }
1481
1482     switch (nParamIndex) {
1483     case OMX_IndexParamVideoPortFormat:
1484     {
1485         OMX_VIDEO_PARAM_PORTFORMATTYPE *pPortFormat     = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)pComponentParameterStructure;
1486         OMX_U32                         nPortIndex      = pPortFormat->nPortIndex;
1487         OMX_PARAM_PORTDEFINITIONTYPE   *pPortDef        = NULL;
1488
1489         ret = Exynos_OMX_Check_SizeVersion(pPortFormat, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
1490         if (ret != OMX_ErrorNone) {
1491             goto EXIT;
1492         }
1493
1494         if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1495             ret = OMX_ErrorBadPortIndex;
1496             goto EXIT;
1497         }
1498         pPortDef = &(pExynosComponent->pExynosPort[nPortIndex].portDefinition);
1499
1500         pPortDef->format.video.eColorFormat       = pPortFormat->eColorFormat;
1501         pPortDef->format.video.eCompressionFormat = pPortFormat->eCompressionFormat;
1502         pPortDef->format.video.xFramerate         = pPortFormat->xFramerate;
1503     }
1504         break;
1505     case OMX_IndexParamVideoBitrate:
1506     {
1507         OMX_VIDEO_PARAM_BITRATETYPE     *pVideoBitrate = (OMX_VIDEO_PARAM_BITRATETYPE *)pComponentParameterStructure;
1508         OMX_U32                          nPortIndex    = pVideoBitrate->nPortIndex;
1509         EXYNOS_OMX_VIDEOENC_COMPONENT   *pVideoEnc     = NULL;
1510         OMX_PARAM_PORTDEFINITIONTYPE    *pPortDef      = NULL;
1511
1512         if (nPortIndex != OUTPUT_PORT_INDEX) {
1513             ret = OMX_ErrorBadPortIndex;
1514             goto EXIT;
1515         } else {
1516             pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1517             if (pVideoEnc == NULL) {
1518                 ret = OMX_ErrorBadParameter;
1519                 goto EXIT;
1520             }
1521             pPortDef = &(pExynosComponent->pExynosPort[nPortIndex].portDefinition);
1522
1523             pVideoEnc->eControlRate[nPortIndex] = pVideoBitrate->eControlRate;
1524             pPortDef->format.video.nBitrate = pVideoBitrate->nTargetBitrate;
1525         }
1526         ret = OMX_ErrorNone;
1527     }
1528         break;
1529     case OMX_IndexParamVideoQuantization:
1530     {
1531         OMX_VIDEO_PARAM_QUANTIZATIONTYPE *pVideoQuantization = (OMX_VIDEO_PARAM_QUANTIZATIONTYPE *)pComponentParameterStructure;
1532         OMX_U32                           nPortIndex         = pVideoQuantization->nPortIndex;
1533         EXYNOS_OMX_VIDEOENC_COMPONENT    *pVideoEnc          = NULL;
1534
1535         if (nPortIndex != OUTPUT_PORT_INDEX) {
1536             ret = OMX_ErrorBadPortIndex;
1537             goto EXIT;
1538         } else {
1539             pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1540             if (pVideoEnc == NULL) {
1541                 ret = OMX_ErrorBadParameter;
1542                 goto EXIT;
1543             }
1544
1545             pVideoEnc->quantization.nQpI = pVideoQuantization->nQpI;
1546             pVideoEnc->quantization.nQpP = pVideoQuantization->nQpP;
1547             pVideoEnc->quantization.nQpB = pVideoQuantization->nQpB;
1548         }
1549         ret = OMX_ErrorNone;
1550     }
1551         break;
1552     case OMX_IndexParamPortDefinition:
1553     {
1554         OMX_PARAM_PORTDEFINITIONTYPE *pPortDef      = (OMX_PARAM_PORTDEFINITIONTYPE *)pComponentParameterStructure;
1555         OMX_U32                       nPortIndex    = pPortDef->nPortIndex;
1556         EXYNOS_OMX_BASEPORT          *pExynosPort   = NULL;
1557
1558         if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1559             ret = OMX_ErrorBadPortIndex;
1560             goto EXIT;
1561         }
1562
1563         ret = Exynos_OMX_Check_SizeVersion(pPortDef, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1564         if (ret != OMX_ErrorNone) {
1565             goto EXIT;
1566         }
1567
1568         pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1569
1570         if ((pExynosComponent->currentState != OMX_StateLoaded) &&
1571             (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1572             if (pExynosPort->portDefinition.bEnabled == OMX_TRUE) {
1573                 ret = OMX_ErrorIncorrectStateOperation;
1574                 goto EXIT;
1575             }
1576         }
1577
1578         if (pPortDef->nBufferCountActual < pExynosPort->portDefinition.nBufferCountMin) {
1579             ret = OMX_ErrorBadParameter;
1580             goto EXIT;
1581         }
1582
1583         Exynos_OSAL_Memcpy(&pExynosPort->portDefinition, pPortDef, pPortDef->nSize);
1584         if (nPortIndex == INPUT_PORT_INDEX) {
1585             pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1586             Exynos_UpdateFrameSize(pOMXComponent);
1587             Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pExynosOutputPort->portDefinition.nBufferSize: %d",
1588                             pExynosPort->portDefinition.nBufferSize);
1589         }
1590         ret = OMX_ErrorNone;
1591     }
1592         break;
1593 #ifdef USE_STOREMETADATA
1594     case OMX_IndexParamStoreMetaDataBuffer:
1595     {
1596         ret = Exynos_OSAL_SetANBParameter(hComponent, nParamIndex, pComponentParameterStructure);
1597     }
1598         break;
1599 #endif
1600     default:
1601     {
1602         ret = Exynos_OMX_SetParameter(hComponent, nParamIndex, pComponentParameterStructure);
1603     }
1604         break;
1605     }
1606 EXIT:
1607     FunctionOut();
1608
1609     return ret;
1610 }
1611
1612 OMX_ERRORTYPE Exynos_OMX_VideoEncodeGetConfig(
1613     OMX_HANDLETYPE  hComponent,
1614     OMX_INDEXTYPE   nParamIndex,
1615     OMX_PTR         pComponentConfigStructure)
1616 {
1617     OMX_ERRORTYPE             ret               = OMX_ErrorNone;
1618     OMX_COMPONENTTYPE        *pOMXComponent     = NULL;
1619     EXYNOS_OMX_BASECOMPONENT *pExynosComponent  = NULL;
1620
1621     FunctionIn();
1622
1623     if ((hComponent == NULL) ||
1624         (pComponentConfigStructure == NULL)) {
1625         ret = OMX_ErrorBadParameter;
1626         goto EXIT;
1627     }
1628     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1629
1630     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1631     if (ret != OMX_ErrorNone) {
1632         goto EXIT;
1633     }
1634
1635     if (pOMXComponent->pComponentPrivate == NULL) {
1636         ret = OMX_ErrorBadParameter;
1637         goto EXIT;
1638     }
1639     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1640
1641     if (pExynosComponent->currentState == OMX_StateInvalid) {
1642         ret = OMX_ErrorInvalidState;
1643         goto EXIT;
1644     }
1645
1646     switch (nParamIndex) {
1647     case OMX_IndexConfigVideoBitrate:
1648     {
1649         OMX_VIDEO_CONFIG_BITRATETYPE *pConfigBitrate = (OMX_VIDEO_CONFIG_BITRATETYPE *)pComponentConfigStructure;
1650         OMX_U32                       nPortIndex     = pConfigBitrate->nPortIndex;
1651         EXYNOS_OMX_BASEPORT          *pExynosPort    = NULL;
1652
1653         if (nPortIndex != OUTPUT_PORT_INDEX) {
1654             ret = OMX_ErrorBadPortIndex;
1655             goto EXIT;
1656         } else {
1657             pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1658             pConfigBitrate->nEncodeBitrate = pExynosPort->portDefinition.format.video.nBitrate;
1659         }
1660     }
1661         break;
1662     case OMX_IndexConfigVideoFramerate:
1663     {
1664         OMX_CONFIG_FRAMERATETYPE *pConfigFramerate = (OMX_CONFIG_FRAMERATETYPE *)pComponentConfigStructure;
1665         OMX_U32                   nPortIndex       = pConfigFramerate->nPortIndex;
1666         EXYNOS_OMX_BASEPORT      *pExynosPort      = NULL;
1667
1668         if (nPortIndex != OUTPUT_PORT_INDEX) {
1669             ret = OMX_ErrorBadPortIndex;
1670             goto EXIT;
1671         } else {
1672             pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1673             pConfigFramerate->xEncodeFramerate = pExynosPort->portDefinition.format.video.xFramerate;
1674         }
1675     }
1676         break;
1677     default:
1678     {
1679         ret = Exynos_OMX_GetConfig(hComponent, nParamIndex, pComponentConfigStructure);
1680     }
1681         break;
1682     }
1683 EXIT:
1684     FunctionOut();
1685
1686     return ret;
1687 }
1688
1689 OMX_ERRORTYPE Exynos_OMX_VideoEncodeSetConfig(
1690     OMX_HANDLETYPE  hComponent,
1691     OMX_INDEXTYPE   nParamIndex,
1692     OMX_PTR         pComponentConfigStructure)
1693     {
1694     OMX_ERRORTYPE             ret               = OMX_ErrorNone;
1695     OMX_COMPONENTTYPE        *pOMXComponent     = NULL;
1696     EXYNOS_OMX_BASECOMPONENT *pExynosComponent  = NULL;
1697
1698     FunctionIn();
1699
1700     if ((hComponent == NULL) ||
1701         (pComponentConfigStructure == NULL)) {
1702         ret = OMX_ErrorBadParameter;
1703         goto EXIT;
1704     }
1705     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1706
1707     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1708     if (ret != OMX_ErrorNone) {
1709         goto EXIT;
1710     }
1711
1712     if (pOMXComponent->pComponentPrivate == NULL) {
1713         ret = OMX_ErrorBadParameter;
1714         goto EXIT;
1715     }
1716     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1717
1718     if (pExynosComponent->currentState == OMX_StateInvalid) {
1719         ret = OMX_ErrorInvalidState;
1720         goto EXIT;
1721     }
1722
1723     switch (nParamIndex) {
1724     case OMX_IndexConfigVideoBitrate:
1725     {
1726         OMX_VIDEO_CONFIG_BITRATETYPE *pConfigBitrate = (OMX_VIDEO_CONFIG_BITRATETYPE *)pComponentConfigStructure;
1727         OMX_U32                       nPortIndex     = pConfigBitrate->nPortIndex;
1728         EXYNOS_OMX_BASEPORT          *pExynosPort    = NULL;
1729
1730         if (nPortIndex != OUTPUT_PORT_INDEX) {
1731             ret = OMX_ErrorBadPortIndex;
1732             goto EXIT;
1733         } else {
1734             pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1735             pExynosPort->portDefinition.format.video.nBitrate = pConfigBitrate->nEncodeBitrate;
1736         }
1737     }
1738         break;
1739     case OMX_IndexConfigVideoFramerate:
1740     {
1741         OMX_CONFIG_FRAMERATETYPE *pConfigFramerate = (OMX_CONFIG_FRAMERATETYPE *)pComponentConfigStructure;
1742         OMX_U32                   nPortIndex       = pConfigFramerate->nPortIndex;
1743         EXYNOS_OMX_BASEPORT      *pExynosPort      = NULL;
1744
1745         if (nPortIndex != OUTPUT_PORT_INDEX) {
1746             ret = OMX_ErrorBadPortIndex;
1747             goto EXIT;
1748         } else {
1749             pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1750             pExynosPort->portDefinition.format.video.xFramerate = pConfigFramerate->xEncodeFramerate;
1751         }
1752     }
1753         break;
1754     case OMX_IndexConfigVideoIntraVOPRefresh:
1755     {
1756         OMX_CONFIG_INTRAREFRESHVOPTYPE *pIntraRefreshVOP = (OMX_CONFIG_INTRAREFRESHVOPTYPE *)pComponentConfigStructure;
1757         EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc         = NULL;
1758         OMX_U32                        nPortIndex        = pIntraRefreshVOP->nPortIndex;
1759
1760         if (pExynosComponent->hComponentHandle == NULL) {
1761             ret = OMX_ErrorBadParameter;
1762             goto EXIT;
1763         }
1764         pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1765
1766         if (nPortIndex != OUTPUT_PORT_INDEX) {
1767             ret = OMX_ErrorBadPortIndex;
1768             goto EXIT;
1769         } else {
1770             pVideoEnc->IntraRefreshVOP = pIntraRefreshVOP->IntraRefreshVOP;
1771         }
1772     }
1773         break;
1774     default:
1775     {
1776         ret = Exynos_OMX_SetConfig(hComponent, nParamIndex, pComponentConfigStructure);
1777     }
1778         break;
1779     }
1780 EXIT:
1781     FunctionOut();
1782
1783     return ret;
1784 }
1785
1786 OMX_ERRORTYPE Exynos_OMX_VideoEncodeGetExtensionIndex(
1787     OMX_IN OMX_HANDLETYPE  hComponent,
1788     OMX_IN OMX_STRING      szParamName,
1789     OMX_OUT OMX_INDEXTYPE *pIndexType)
1790 {
1791     OMX_ERRORTYPE             ret               = OMX_ErrorNone;
1792     OMX_COMPONENTTYPE        *pOMXComponent     = NULL;
1793     EXYNOS_OMX_BASECOMPONENT *pExynosComponent  = NULL;
1794
1795     FunctionIn();
1796
1797     if (hComponent == NULL) {
1798         ret = OMX_ErrorBadParameter;
1799         goto EXIT;
1800     }
1801     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1802
1803     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1804     if (ret != OMX_ErrorNone) {
1805         goto EXIT;
1806     }
1807
1808     if (pOMXComponent->pComponentPrivate == NULL) {
1809         ret = OMX_ErrorBadParameter;
1810         goto EXIT;
1811     }
1812     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1813
1814     if ((szParamName == NULL) || (pIndexType == NULL)) {
1815         ret = OMX_ErrorBadParameter;
1816         goto EXIT;
1817     }
1818
1819     if (pExynosComponent->currentState == OMX_StateInvalid) {
1820         ret = OMX_ErrorInvalidState;
1821         goto EXIT;
1822     }
1823
1824 #ifdef USE_STOREMETADATA
1825     if (Exynos_OSAL_Strcmp(szParamName, EXYNOS_INDEX_PARAM_STORE_METADATA_BUFFER) == 0) {
1826         *pIndexType = (OMX_INDEXTYPE)OMX_IndexParamStoreMetaDataBuffer;
1827     } else {
1828         ret = Exynos_OMX_GetExtensionIndex(hComponent, szParamName, pIndexType);
1829     }
1830 #else
1831     ret = Exynos_OMX_GetExtensionIndex(hComponent, szParamName, pIndexType);
1832 #endif
1833 EXIT:
1834     FunctionOut();
1835
1836     return ret;
1837 }