openmax/component/common/Exynos_OMX_Baseport.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_Baseport.c
  20  * @brief
  21  * @author     SeungBeom Kim (sbcrux.kim@samsung.com)
  22  *             HyeYeon Chung (hyeon.chung@samsung.com)
  23  * @version    2.0.0
  24  * @history
  25  *    2012.02.20 : Create
  26  */
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31
  32 #include "Exynos_OMX_Macros.h"
  33 #include "Exynos_OSAL_Event.h"
  34 #include "Exynos_OSAL_Semaphore.h"
  35 #include "Exynos_OSAL_Mutex.h"
  36
  37 #include "Exynos_OMX_Baseport.h"
  38 #include "Exynos_OMX_Basecomponent.h"
  39
  40 #undef  EXYNOS_LOG_TAG
  41 #define EXYNOS_LOG_TAG    "EXYNOS_BASE_PORT"
  42 #define EXYNOS_LOG_OFF
  43 //#define EXYNOS_TRACE_ON
  44 #include "Exynos_OSAL_Log.h"
  45
  46
  47 OMX_ERRORTYPE Exynos_OMX_InputBufferReturn(OMX_COMPONENTTYPE *pOMXComponent, OMX_BUFFERHEADERTYPE* bufferHeader)
  48 {
  49     OMX_ERRORTYPE             ret = OMX_ErrorNone;
  50     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
  51     EXYNOS_OMX_BASEPORT      *pExynosPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
  52     OMX_U32                   i = 0;
  53
  54     Exynos_OSAL_MutexLock(pExynosPort->hPortMutex);
  55     for (i = 0; i < pExynosPort->portDefinition.nBufferCountActual; i++) {
  56         if (bufferHeader == pExynosPort->extendBufferHeader[i].OMXBufferHeader) {
  57             pExynosPort->extendBufferHeader[i].bBufferInOMX = OMX_FALSE;
  58             break;
  59         }
  60     }
  61     Exynos_OSAL_MutexUnlock(pExynosPort->hPortMutex);
  62
  63     if ((bufferHeader != NULL) && (bufferHeader->pBuffer != NULL))
  64     {
  65         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "%s : %d  EmptyBufferDone", __FUNCTION__, __LINE__);
  66         pExynosComponent->pCallbacks->EmptyBufferDone(pOMXComponent, pExynosComponent->callbackData, bufferHeader);
  67     }
  68
  69     return ret;
  70 }
  71
  72 OMX_ERRORTYPE Exynos_OMX_OutputBufferReturn(OMX_COMPONENTTYPE *pOMXComponent, OMX_BUFFERHEADERTYPE* bufferHeader)
  73 {
  74     OMX_ERRORTYPE             ret = OMX_ErrorNone;
  75     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
  76     EXYNOS_OMX_BASEPORT      *pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
  77     OMX_U32                   i = 0;
  78
  79     Exynos_OSAL_MutexLock(pExynosPort->hPortMutex);
  80     for (i = 0; i < pExynosPort->portDefinition.nBufferCountActual; i++) {
  81         if (bufferHeader == pExynosPort->extendBufferHeader[i].OMXBufferHeader) {
  82             pExynosPort->extendBufferHeader[i].bBufferInOMX = OMX_FALSE;
  83             break;
  84         }
  85     }
  86
  87     Exynos_OSAL_MutexUnlock(pExynosPort->hPortMutex);
  88
  89     if ((bufferHeader != NULL) && (bufferHeader->pBuffer != NULL))
  90     {
  91         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "%s : %d  FillBufferDone", __FUNCTION__, __LINE__);
  92         pExynosComponent->pCallbacks->FillBufferDone(pOMXComponent, pExynosComponent->callbackData, bufferHeader);
  93     }
  94
  95     return ret;
  96 }
  97
  98 OMX_ERRORTYPE Exynos_OMX_BufferFlushProcess(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 nPortIndex, OMX_BOOL bEvent)
  99 {
 100     OMX_ERRORTYPE             ret = OMX_ErrorNone;
 101     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
 102     OMX_S32                   portIndex = 0;
 103     OMX_U32                   i = 0, cnt = 0;
 104
 105     FunctionIn();
 106
 107     if (pOMXComponent == NULL) {
 108         ret = OMX_ErrorBadParameter;
 109         goto EXIT;
 110     }
 111     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
 112     if (ret != OMX_ErrorNone) {
 113         goto EXIT;
 114     }
 115
 116     if (pOMXComponent->pComponentPrivate == NULL) {
 117         ret = OMX_ErrorBadParameter;
 118         goto EXIT;
 119     }
 120     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 121
 122     cnt = (nPortIndex == ALL_PORT_INDEX ) ? ALL_PORT_NUM : 1;
 123
 124 #ifdef TIZEN_FEATURE_E3250
 125     Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "bufferFlushProcess cnt:%d port:%d", cnt, nPortIndex);
 126 #endif
 127
 128     for (i = 0; i < cnt; i++) {
 129         if (nPortIndex == ALL_PORT_INDEX)
 130             portIndex = i;
 131         else
 132             portIndex = nPortIndex;
 133
 134         pExynosComponent->exynos_BufferFlush(pOMXComponent, portIndex, bEvent);
 135     }
 136
 137 EXIT:
 138     if (ret != OMX_ErrorNone) {
 139         Exynos_OSAL_Log(EXYNOS_LOG_ERROR,"%s : %d", __FUNCTION__, __LINE__);
 140
 141         if ((pOMXComponent != NULL) && (pExynosComponent != NULL)) {
 142             pExynosComponent->pCallbacks->EventHandler(pOMXComponent, pExynosComponent->callbackData, OMX_EventError, ret, 0, NULL);
 143         }
 144     }
 145
 146     FunctionOut();
 147
 148     return ret;
 149 }
 150
 151 OMX_ERRORTYPE Exynos_OMX_EnablePort(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 portIndex)
 152 {
 153     OMX_ERRORTYPE          ret = OMX_ErrorNone;
 154     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 155     EXYNOS_OMX_BASEPORT      *pExynosPort = NULL;
 156
 157     FunctionIn();
 158 #ifdef TIZEN_FEATURE_E3250
 159     Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "enablePort idx:%d", portIndex);
 160 #endif
 161
 162     pExynosPort = &pExynosComponent->pExynosPort[portIndex];
 163
 164     if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
 165         Exynos_OSAL_SemaphoreWait(pExynosPort->loadedResource);
 166         pExynosPort->portDefinition.bPopulated = OMX_TRUE;
 167     }
 168     pExynosPort->exceptionFlag = GENERAL_STATE;
 169     pExynosPort->portDefinition.bEnabled = OMX_TRUE;
 170
 171     ret = OMX_ErrorNone;
 172
 173     FunctionOut();
 174
 175     return ret;
 176 }
 177
 178 OMX_ERRORTYPE Exynos_OMX_PortEnableProcess(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 nPortIndex)
 179 {
 180     OMX_ERRORTYPE          ret = OMX_ErrorNone;
 181     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
 182     OMX_S32                portIndex = 0;
 183     OMX_U32                i = 0, cnt = 0;
 184
 185     FunctionIn();
 186
 187     if (pOMXComponent == NULL) {
 188         ret = OMX_ErrorBadParameter;
 189         goto EXIT;
 190     }
 191     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
 192     if (ret != OMX_ErrorNone) {
 193         goto EXIT;
 194     }
 195
 196     if (pOMXComponent->pComponentPrivate == NULL) {
 197         ret = OMX_ErrorBadParameter;
 198         goto EXIT;
 199     }
 200     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 201
 202     cnt = (nPortIndex == ALL_PORT_INDEX) ? ALL_PORT_NUM : 1;
 203
 204 #ifdef TIZEN_FEATURE_E3250
 205     Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "portEnableProcess cnt:%d port:%d", cnt, nPortIndex);
 206 #endif
 207
 208     for (i = 0; i < cnt; i++) {
 209         if (nPortIndex == ALL_PORT_INDEX)
 210             portIndex = i;
 211         else
 212             portIndex = nPortIndex;
 213
 214         ret = Exynos_OMX_EnablePort(pOMXComponent, portIndex);
 215         if (ret == OMX_ErrorNone) {
 216             pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
 217                             pExynosComponent->callbackData,
 218                             OMX_EventCmdComplete,
 219                             OMX_CommandPortEnable, portIndex, NULL);
 220         }
 221     }
 222
 223 EXIT:
 224     if ((ret != OMX_ErrorNone) && (pOMXComponent != NULL) && (pExynosComponent != NULL)) {
 225             pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
 226                             pExynosComponent->callbackData,
 227                             OMX_EventError,
 228                             ret, 0, NULL);
 229         }
 230
 231     FunctionOut();
 232
 233     return ret;
 234 }
 235
 236 OMX_ERRORTYPE Exynos_OMX_DisablePort(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 portIndex)
 237 {
 238     OMX_ERRORTYPE          ret = OMX_ErrorNone;
 239     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 240     EXYNOS_OMX_BASEPORT      *pExynosPort = NULL;
 241     EXYNOS_OMX_MESSAGE       *message;
 242
 243     FunctionIn();
 244 #ifdef TIZEN_FEATURE_E3250
 245     Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "disablePort idx:%d", portIndex);
 246 #endif
 247
 248     pExynosPort = &pExynosComponent->pExynosPort[portIndex];
 249
 250     if (!CHECK_PORT_ENABLED(pExynosPort)) {
 251         ret = OMX_ErrorNone;
 252         goto EXIT;
 253     }
 254
 255     if (pExynosComponent->currentState != OMX_StateLoaded) {
 256         if (CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)) {
 257             while (Exynos_OSAL_GetElemNum(&pExynosPort->bufferQ) > 0) {
 258                 message = (EXYNOS_OMX_MESSAGE*)Exynos_OSAL_Dequeue(&pExynosPort->bufferQ);
 259                 Exynos_OSAL_Free(message);
 260             }
 261         }
 262         pExynosPort->portDefinition.bPopulated = OMX_FALSE;
 263         Exynos_OSAL_SemaphoreWait(pExynosPort->unloadedResource);
 264     }
 265     pExynosPort->portDefinition.bEnabled = OMX_FALSE;
 266     ret = OMX_ErrorNone;
 267
 268 EXIT:
 269     FunctionOut();
 270
 271     return ret;
 272 }
 273
 274 OMX_ERRORTYPE Exynos_OMX_PortDisableProcess(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 nPortIndex)
 275 {
 276     OMX_ERRORTYPE          ret = OMX_ErrorNone;
 277     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
 278     OMX_S32                portIndex = 0;
 279     OMX_U32                i = 0, cnt = 0;
 280
 281     FunctionIn();
 282
 283     if (pOMXComponent == NULL) {
 284         ret = OMX_ErrorBadParameter;
 285         goto EXIT;
 286     }
 287     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
 288     if (ret != OMX_ErrorNone) {
 289         goto EXIT;
 290     }
 291
 292     if (pOMXComponent->pComponentPrivate == NULL) {
 293         ret = OMX_ErrorBadParameter;
 294         goto EXIT;
 295     }
 296     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 297
 298     cnt = (nPortIndex == ALL_PORT_INDEX ) ? ALL_PORT_NUM : 1;
 299
 300 #ifdef TIZEN_FEATURE_E3250
 301     Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "portDisableProcess cnt:%d port:%d", cnt, nPortIndex);
 302 #endif
 303
 304     /* port flush*/
 305     for(i = 0; i < cnt; i++) {
 306         if (nPortIndex == ALL_PORT_INDEX)
 307             portIndex = i;
 308         else
 309             portIndex = nPortIndex;
 310
 311         Exynos_OMX_BufferFlushProcess(pOMXComponent, portIndex, OMX_FALSE);
 312     }
 313
 314     for(i = 0; i < cnt; i++) {
 315         if (nPortIndex == ALL_PORT_INDEX)
 316             portIndex = i;
 317         else
 318             portIndex = nPortIndex;
 319
 320         ret = Exynos_OMX_DisablePort(pOMXComponent, portIndex);
 321         pExynosComponent->pExynosPort[portIndex].bIsPortDisabled = OMX_FALSE;
 322         if (ret == OMX_ErrorNone) {
 323             pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
 324                             pExynosComponent->callbackData,
 325                             OMX_EventCmdComplete,
 326                             OMX_CommandPortDisable, portIndex, NULL);
 327         }
 328     }
 329
 330 EXIT:
 331     if ((ret != OMX_ErrorNone) && (pOMXComponent != NULL) && (pExynosComponent != NULL)) {
 332         pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
 333                         pExynosComponent->callbackData,
 334                         OMX_EventError,
 335                         ret, 0, NULL);
 336     }
 337
 338     FunctionOut();
 339
 340     return ret;
 341 }
 342
 343 OMX_ERRORTYPE Exynos_OMX_EmptyThisBuffer(
 344     OMX_IN OMX_HANDLETYPE        hComponent,
 345     OMX_IN OMX_BUFFERHEADERTYPE *pBuffer)
 346 {
 347     OMX_ERRORTYPE           ret = OMX_ErrorNone;
 348     OMX_COMPONENTTYPE     *pOMXComponent = NULL;
 349     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
 350     EXYNOS_OMX_BASEPORT      *pExynosPort = NULL;
 351     OMX_BOOL               findBuffer = OMX_FALSE;
 352     EXYNOS_OMX_MESSAGE       *message;
 353     OMX_U32                i = 0;
 354
 355     FunctionIn();
 356
 357     if (hComponent == NULL) {
 358         ret = OMX_ErrorBadParameter;
 359         goto EXIT;
 360     }
 361     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
 362     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
 363     if (ret != OMX_ErrorNone) {
 364         goto EXIT;
 365     }
 366
 367     if (pOMXComponent->pComponentPrivate == NULL) {
 368         ret = OMX_ErrorBadParameter;
 369         goto EXIT;
 370     }
 371     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 372     if (pExynosComponent->currentState == OMX_StateInvalid) {
 373         ret = OMX_ErrorInvalidState;
 374         goto EXIT;
 375     }
 376
 377     if (pBuffer == NULL) {
 378         ret = OMX_ErrorBadParameter;
 379         goto EXIT;
 380     }
 381     if (pBuffer->nInputPortIndex != INPUT_PORT_INDEX) {
 382         ret = OMX_ErrorBadPortIndex;
 383         goto EXIT;
 384     }
 385
 386     ret = Exynos_OMX_Check_SizeVersion(pBuffer, sizeof(OMX_BUFFERHEADERTYPE));
 387     if (ret != OMX_ErrorNone) {
 388         goto EXIT;
 389     }
 390
 391     if ((pExynosComponent->currentState != OMX_StateIdle) &&
 392         (pExynosComponent->currentState != OMX_StateExecuting) &&
 393         (pExynosComponent->currentState != OMX_StatePause)) {
 394         ret = OMX_ErrorIncorrectStateOperation;
 395         goto EXIT;
 396     }
 397
 398     pExynosPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
 399     if ((!CHECK_PORT_ENABLED(pExynosPort)) ||
 400         ((CHECK_PORT_BEING_FLUSHED(pExynosPort) || CHECK_PORT_BEING_DISABLED(pExynosPort)) &&
 401         (!CHECK_PORT_TUNNELED(pExynosPort) || !CHECK_PORT_BUFFER_SUPPLIER(pExynosPort))) ||
 402         ((pExynosComponent->transientState == EXYNOS_OMX_TransStateExecutingToIdle) &&
 403         (CHECK_PORT_TUNNELED(pExynosPort) && !CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)))) {
 404         ret = OMX_ErrorIncorrectStateOperation;
 405         goto EXIT;
 406     }
 407
 408     Exynos_OSAL_MutexLock(pExynosPort->hPortMutex);
 409     for (i = 0; i < pExynosPort->portDefinition.nBufferCountActual; i++) {
 410         if (pBuffer == pExynosPort->extendBufferHeader[i].OMXBufferHeader) {
 411             pExynosPort->extendBufferHeader[i].bBufferInOMX = OMX_TRUE;
 412             findBuffer = OMX_TRUE;
 413             break;
 414         }
 415     }
 416
 417     if (findBuffer == OMX_FALSE) {
 418         ret = OMX_ErrorBadParameter;
 419         Exynos_OSAL_MutexUnlock(pExynosPort->hPortMutex);
 420         goto EXIT;
 421     }
 422
 423     message = Exynos_OSAL_Malloc(sizeof(EXYNOS_OMX_MESSAGE));
 424     if (message == NULL) {
 425         ret = OMX_ErrorInsufficientResources;
 426         Exynos_OSAL_MutexUnlock(pExynosPort->hPortMutex);
 427         goto EXIT;
 428     }
 429     message->messageType = EXYNOS_OMX_CommandEmptyBuffer;
 430     message->messageParam = (OMX_U32) i;
 431     message->pCmdData = (OMX_PTR)pBuffer;
 432
 433     ret = Exynos_OSAL_Queue(&pExynosPort->bufferQ, (void *)message);
 434     if (ret != 0) {
 435         ret = OMX_ErrorUndefined;
 436         Exynos_OSAL_MutexUnlock(pExynosPort->hPortMutex);
 437         goto EXIT;
 438     }
 439     ret = Exynos_OSAL_SemaphorePost(pExynosPort->bufferSemID);
 440     Exynos_OSAL_MutexUnlock(pExynosPort->hPortMutex);
 441
 442 EXIT:
 443     FunctionOut();
 444
 445     return ret;
 446 }
 447
 448 OMX_ERRORTYPE Exynos_OMX_FillThisBuffer(
 449     OMX_IN OMX_HANDLETYPE        hComponent,
 450     OMX_IN OMX_BUFFERHEADERTYPE *pBuffer)
 451 {
 452     OMX_ERRORTYPE           ret = OMX_ErrorNone;
 453     OMX_COMPONENTTYPE     *pOMXComponent = NULL;
 454     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
 455     EXYNOS_OMX_BASEPORT      *pExynosPort = NULL;
 456     OMX_BOOL               findBuffer = OMX_FALSE;
 457     EXYNOS_OMX_MESSAGE       *message;
 458     OMX_U32                i = 0;
 459
 460     FunctionIn();
 461
 462     if (hComponent == NULL) {
 463         ret = OMX_ErrorBadParameter;
 464         goto EXIT;
 465     }
 466     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
 467     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
 468     if (ret != OMX_ErrorNone) {
 469         goto EXIT;
 470     }
 471
 472     if (pOMXComponent->pComponentPrivate == NULL) {
 473         ret = OMX_ErrorBadParameter;
 474         goto EXIT;
 475     }
 476     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 477     if (pExynosComponent->currentState == OMX_StateInvalid) {
 478         ret = OMX_ErrorInvalidState;
 479         goto EXIT;
 480     }
 481
 482     if (pBuffer == NULL) {
 483         ret = OMX_ErrorBadParameter;
 484         goto EXIT;
 485     }
 486     if (pBuffer->nOutputPortIndex != OUTPUT_PORT_INDEX) {
 487         ret = OMX_ErrorBadPortIndex;
 488         goto EXIT;
 489     }
 490
 491     ret = Exynos_OMX_Check_SizeVersion(pBuffer, sizeof(OMX_BUFFERHEADERTYPE));
 492     if (ret != OMX_ErrorNone) {
 493         goto EXIT;
 494     }
 495
 496     if ((pExynosComponent->currentState != OMX_StateIdle) &&
 497         (pExynosComponent->currentState != OMX_StateExecuting) &&
 498         (pExynosComponent->currentState != OMX_StatePause)) {
 499         ret = OMX_ErrorIncorrectStateOperation;
 500         goto EXIT;
 501     }
 502
 503     pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
 504     if ((!CHECK_PORT_ENABLED(pExynosPort)) ||
 505         ((CHECK_PORT_BEING_FLUSHED(pExynosPort) || CHECK_PORT_BEING_DISABLED(pExynosPort)) &&
 506         (!CHECK_PORT_TUNNELED(pExynosPort) || !CHECK_PORT_BUFFER_SUPPLIER(pExynosPort))) ||
 507         ((pExynosComponent->transientState == EXYNOS_OMX_TransStateExecutingToIdle) &&
 508         (CHECK_PORT_TUNNELED(pExynosPort) && !CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)))) {
 509         ret = OMX_ErrorIncorrectStateOperation;
 510         goto EXIT;
 511     }
 512
 513     Exynos_OSAL_MutexLock(pExynosPort->hPortMutex);
 514     for (i = 0; i < pExynosPort->portDefinition.nBufferCountActual; i++) {
 515         if (pBuffer == pExynosPort->extendBufferHeader[i].OMXBufferHeader) {
 516             pExynosPort->extendBufferHeader[i].bBufferInOMX = OMX_TRUE;
 517             findBuffer = OMX_TRUE;
 518             break;
 519         }
 520     }
 521
 522     if (findBuffer == OMX_FALSE) {
 523         ret = OMX_ErrorBadParameter;
 524         Exynos_OSAL_MutexUnlock(pExynosPort->hPortMutex);
 525         goto EXIT;
 526     }
 527
 528     message = Exynos_OSAL_Malloc(sizeof(EXYNOS_OMX_MESSAGE));
 529     if (message == NULL) {
 530         ret = OMX_ErrorInsufficientResources;
 531         Exynos_OSAL_MutexUnlock(pExynosPort->hPortMutex);
 532         goto EXIT;
 533     }
 534     message->messageType = EXYNOS_OMX_CommandFillBuffer;
 535     message->messageParam = (OMX_U32) i;
 536     message->pCmdData = (OMX_PTR)pBuffer;
 537
 538     ret = Exynos_OSAL_Queue(&pExynosPort->bufferQ, (void *)message);
 539     if (ret != 0) {
 540         ret = OMX_ErrorUndefined;
 541         Exynos_OSAL_MutexUnlock(pExynosPort->hPortMutex);
 542         goto EXIT;
 543     }
 544
 545     ret = Exynos_OSAL_SemaphorePost(pExynosPort->bufferSemID);
 546     Exynos_OSAL_MutexUnlock(pExynosPort->hPortMutex);
 547
 548 EXIT:
 549     FunctionOut();
 550
 551     return ret;
 552 }
 553
 554 OMX_ERRORTYPE Exynos_OMX_Port_Constructor(OMX_HANDLETYPE hComponent)
 555 {
 556     OMX_ERRORTYPE          ret = OMX_ErrorNone;
 557     OMX_COMPONENTTYPE     *pOMXComponent = NULL;
 558     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
 559     EXYNOS_OMX_BASEPORT      *pExynosPort = NULL;
 560     EXYNOS_OMX_BASEPORT      *pExynosInputPort = NULL;
 561     EXYNOS_OMX_BASEPORT      *pExynosOutputPort = NULL;
 562
 563     FunctionIn();
 564
 565     if (hComponent == NULL) {
 566         ret = OMX_ErrorBadParameter;
 567         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
 568         goto EXIT;
 569     }
 570     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
 571     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
 572     if (ret != OMX_ErrorNone) {
 573         goto EXIT;
 574     }
 575
 576     if (pOMXComponent->pComponentPrivate == NULL) {
 577         ret = OMX_ErrorBadParameter;
 578         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
 579         goto EXIT;
 580     }
 581     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 582
 583     INIT_SET_SIZE_VERSION(&pExynosComponent->portParam, OMX_PORT_PARAM_TYPE);
 584     pExynosComponent->portParam.nPorts = ALL_PORT_NUM;
 585     pExynosComponent->portParam.nStartPortNumber = INPUT_PORT_INDEX;
 586
 587     pExynosPort = Exynos_OSAL_Malloc(sizeof(EXYNOS_OMX_BASEPORT) * ALL_PORT_NUM);
 588     if (pExynosPort == NULL) {
 589         ret = OMX_ErrorInsufficientResources;
 590         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
 591         goto EXIT;
 592     }
 593     Exynos_OSAL_Memset(pExynosPort, 0, sizeof(EXYNOS_OMX_BASEPORT) * ALL_PORT_NUM);
 594     pExynosComponent->pExynosPort = pExynosPort;
 595
 596     /* Input Port */
 597     pExynosInputPort = &pExynosPort[INPUT_PORT_INDEX];
 598
 599     Exynos_OSAL_QueueCreate(&pExynosInputPort->bufferQ, MAX_QUEUE_ELEMENTS);
 600
 601     pExynosInputPort->extendBufferHeader = Exynos_OSAL_Malloc(sizeof(EXYNOS_OMX_BUFFERHEADERTYPE) * MAX_BUFFER_NUM);
 602     if (pExynosInputPort->extendBufferHeader == NULL) {
 603         Exynos_OSAL_Free(pExynosPort);
 604         pExynosPort = NULL;
 605         ret = OMX_ErrorInsufficientResources;
 606         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
 607         goto EXIT;
 608     }
 609     Exynos_OSAL_Memset(pExynosInputPort->extendBufferHeader, 0, sizeof(EXYNOS_OMX_BUFFERHEADERTYPE) * MAX_BUFFER_NUM);
 610
 611     pExynosInputPort->bufferStateAllocate = Exynos_OSAL_Malloc(sizeof(OMX_U32) * MAX_BUFFER_NUM);
 612     if (pExynosInputPort->bufferStateAllocate == NULL) {
 613         Exynos_OSAL_Free(pExynosInputPort->extendBufferHeader);
 614         pExynosInputPort->extendBufferHeader = NULL;
 615         Exynos_OSAL_Free(pExynosPort);
 616         pExynosPort = NULL;
 617         ret = OMX_ErrorInsufficientResources;
 618         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
 619         goto EXIT;
 620     }
 621     Exynos_OSAL_Memset(pExynosInputPort->bufferStateAllocate, 0, sizeof(OMX_U32) * MAX_BUFFER_NUM);
 622
 623     pExynosInputPort->bufferSemID = NULL;
 624     pExynosInputPort->assignedBufferNum = 0;
 625     pExynosInputPort->portState = OMX_StateMax;
 626     pExynosInputPort->bIsPortFlushed = OMX_FALSE;
 627     pExynosInputPort->bIsPortDisabled = OMX_FALSE;
 628     pExynosInputPort->tunneledComponent = NULL;
 629     pExynosInputPort->tunneledPort = 0;
 630     pExynosInputPort->tunnelBufferNum = 0;
 631     pExynosInputPort->bufferSupplier = OMX_BufferSupplyUnspecified;
 632     pExynosInputPort->tunnelFlags = 0;
 633     ret = Exynos_OSAL_SemaphoreCreate(&pExynosInputPort->loadedResource);
 634     if (ret != OMX_ErrorNone) {
 635         Exynos_OSAL_Free(pExynosInputPort->bufferStateAllocate);
 636         pExynosInputPort->bufferStateAllocate = NULL;
 637         Exynos_OSAL_Free(pExynosInputPort->extendBufferHeader);
 638         pExynosInputPort->extendBufferHeader = NULL;
 639         Exynos_OSAL_Free(pExynosPort);
 640         pExynosPort = NULL;
 641         goto EXIT;
 642     }
 643     ret = Exynos_OSAL_SemaphoreCreate(&pExynosInputPort->unloadedResource);
 644     if (ret != OMX_ErrorNone) {
 645         Exynos_OSAL_SemaphoreTerminate(pExynosInputPort->loadedResource);
 646         pExynosInputPort->loadedResource = NULL;
 647         Exynos_OSAL_Free(pExynosInputPort->bufferStateAllocate);
 648         pExynosInputPort->bufferStateAllocate = NULL;
 649         Exynos_OSAL_Free(pExynosInputPort->extendBufferHeader);
 650         pExynosInputPort->extendBufferHeader = NULL;
 651         Exynos_OSAL_Free(pExynosPort);
 652         pExynosPort = NULL;
 653         goto EXIT;
 654     }
 655
 656     INIT_SET_SIZE_VERSION(&pExynosInputPort->portDefinition, OMX_PARAM_PORTDEFINITIONTYPE);
 657     pExynosInputPort->portDefinition.nPortIndex = INPUT_PORT_INDEX;
 658     pExynosInputPort->portDefinition.eDir = OMX_DirInput;
 659     pExynosInputPort->portDefinition.nBufferCountActual = 0;
 660     pExynosInputPort->portDefinition.nBufferCountMin = 0;
 661     pExynosInputPort->portDefinition.nBufferSize = 0;
 662     pExynosInputPort->portDefinition.bEnabled = OMX_FALSE;
 663     pExynosInputPort->portDefinition.bPopulated = OMX_FALSE;
 664     pExynosInputPort->portDefinition.eDomain = OMX_PortDomainMax;
 665     pExynosInputPort->portDefinition.bBuffersContiguous = OMX_FALSE;
 666     pExynosInputPort->portDefinition.nBufferAlignment = 0;
 667     pExynosInputPort->markType.hMarkTargetComponent = NULL;
 668     pExynosInputPort->markType.pMarkData = NULL;
 669     pExynosInputPort->exceptionFlag = GENERAL_STATE;
 670
 671     /* Output Port */
 672     pExynosOutputPort = &pExynosPort[OUTPUT_PORT_INDEX];
 673
 674     Exynos_OSAL_QueueCreate(&pExynosOutputPort->bufferQ, MAX_QUEUE_ELEMENTS); /* For in case of "Output Buffer Share", MAX ELEMENTS(DPB + EDPB) */
 675
 676     pExynosOutputPort->extendBufferHeader = Exynos_OSAL_Malloc(sizeof(EXYNOS_OMX_BUFFERHEADERTYPE) * MAX_BUFFER_NUM);
 677     if (pExynosOutputPort->extendBufferHeader == NULL) {
 678         Exynos_OSAL_SemaphoreTerminate(pExynosInputPort->unloadedResource);
 679         pExynosInputPort->unloadedResource = NULL;
 680         Exynos_OSAL_SemaphoreTerminate(pExynosInputPort->loadedResource);
 681         pExynosInputPort->loadedResource = NULL;
 682         Exynos_OSAL_Free(pExynosInputPort->bufferStateAllocate);
 683         pExynosInputPort->bufferStateAllocate = NULL;
 684         Exynos_OSAL_Free(pExynosInputPort->extendBufferHeader);
 685         pExynosInputPort->extendBufferHeader = NULL;
 686         Exynos_OSAL_Free(pExynosPort);
 687         pExynosPort = NULL;
 688         ret = OMX_ErrorInsufficientResources;
 689         goto EXIT;
 690     }
 691     Exynos_OSAL_Memset(pExynosOutputPort->extendBufferHeader, 0, sizeof(EXYNOS_OMX_BUFFERHEADERTYPE) * MAX_BUFFER_NUM);
 692
 693     pExynosOutputPort->bufferStateAllocate = Exynos_OSAL_Malloc(sizeof(OMX_U32) * MAX_BUFFER_NUM);
 694     if (pExynosOutputPort->bufferStateAllocate == NULL) {
 695         Exynos_OSAL_Free(pExynosOutputPort->extendBufferHeader);
 696         pExynosOutputPort->extendBufferHeader = NULL;
 697
 698         Exynos_OSAL_SemaphoreTerminate(pExynosInputPort->unloadedResource);
 699         pExynosInputPort->unloadedResource = NULL;
 700         Exynos_OSAL_SemaphoreTerminate(pExynosInputPort->loadedResource);
 701         pExynosInputPort->loadedResource = NULL;
 702         Exynos_OSAL_Free(pExynosInputPort->bufferStateAllocate);
 703         pExynosInputPort->bufferStateAllocate = NULL;
 704         Exynos_OSAL_Free(pExynosInputPort->extendBufferHeader);
 705         pExynosInputPort->extendBufferHeader = NULL;
 706         Exynos_OSAL_Free(pExynosPort);
 707         pExynosPort = NULL;
 708         ret = OMX_ErrorInsufficientResources;
 709         goto EXIT;
 710     }
 711     Exynos_OSAL_Memset(pExynosOutputPort->bufferStateAllocate, 0, sizeof(OMX_U32) * MAX_BUFFER_NUM);
 712
 713     pExynosOutputPort->bufferSemID = NULL;
 714     pExynosOutputPort->assignedBufferNum = 0;
 715     pExynosOutputPort->portState = OMX_StateMax;
 716     pExynosOutputPort->bIsPortFlushed = OMX_FALSE;
 717     pExynosOutputPort->bIsPortDisabled = OMX_FALSE;
 718     pExynosOutputPort->tunneledComponent = NULL;
 719     pExynosOutputPort->tunneledPort = 0;
 720     pExynosOutputPort->tunnelBufferNum = 0;
 721     pExynosOutputPort->bufferSupplier = OMX_BufferSupplyUnspecified;
 722     pExynosOutputPort->tunnelFlags = 0;
 723     ret = Exynos_OSAL_SemaphoreCreate(&pExynosOutputPort->loadedResource);
 724     if (ret != OMX_ErrorNone) {
 725         Exynos_OSAL_Free(pExynosOutputPort->bufferStateAllocate);
 726         pExynosOutputPort->bufferStateAllocate = NULL;
 727         Exynos_OSAL_Free(pExynosOutputPort->extendBufferHeader);
 728         pExynosOutputPort->extendBufferHeader = NULL;
 729
 730         Exynos_OSAL_SemaphoreTerminate(pExynosInputPort->unloadedResource);
 731         pExynosInputPort->unloadedResource = NULL;
 732         Exynos_OSAL_SemaphoreTerminate(pExynosInputPort->loadedResource);
 733         pExynosInputPort->loadedResource = NULL;
 734         Exynos_OSAL_Free(pExynosInputPort->bufferStateAllocate);
 735         pExynosInputPort->bufferStateAllocate = NULL;
 736         Exynos_OSAL_Free(pExynosInputPort->extendBufferHeader);
 737         pExynosInputPort->extendBufferHeader = NULL;
 738         Exynos_OSAL_Free(pExynosPort);
 739         pExynosPort = NULL;
 740         goto EXIT;
 741     }
 742     ret = Exynos_OSAL_SemaphoreCreate(&pExynosOutputPort->unloadedResource);
 743     if (ret != OMX_ErrorNone) {
 744         Exynos_OSAL_SemaphoreTerminate(pExynosOutputPort->loadedResource);
 745         pExynosOutputPort->loadedResource = NULL;
 746         Exynos_OSAL_Free(pExynosOutputPort->bufferStateAllocate);
 747         pExynosOutputPort->bufferStateAllocate = NULL;
 748         Exynos_OSAL_Free(pExynosOutputPort->extendBufferHeader);
 749         pExynosOutputPort->extendBufferHeader = NULL;
 750
 751         Exynos_OSAL_SemaphoreTerminate(pExynosInputPort->unloadedResource);
 752         pExynosInputPort->unloadedResource = NULL;
 753         Exynos_OSAL_SemaphoreTerminate(pExynosInputPort->loadedResource);
 754         pExynosInputPort->loadedResource = NULL;
 755         Exynos_OSAL_Free(pExynosInputPort->bufferStateAllocate);
 756         pExynosInputPort->bufferStateAllocate = NULL;
 757         Exynos_OSAL_Free(pExynosInputPort->extendBufferHeader);
 758         pExynosInputPort->extendBufferHeader = NULL;
 759         Exynos_OSAL_Free(pExynosPort);
 760         pExynosPort = NULL;
 761         goto EXIT;
 762     }
 763
 764     INIT_SET_SIZE_VERSION(&pExynosOutputPort->portDefinition, OMX_PARAM_PORTDEFINITIONTYPE);
 765     pExynosOutputPort->portDefinition.nPortIndex = OUTPUT_PORT_INDEX;
 766     pExynosOutputPort->portDefinition.eDir = OMX_DirOutput;
 767     pExynosOutputPort->portDefinition.nBufferCountActual = 0;
 768     pExynosOutputPort->portDefinition.nBufferCountMin = 0;
 769     pExynosOutputPort->portDefinition.nBufferSize = 0;
 770     pExynosOutputPort->portDefinition.bEnabled = OMX_FALSE;
 771     pExynosOutputPort->portDefinition.bPopulated = OMX_FALSE;
 772     pExynosOutputPort->portDefinition.eDomain = OMX_PortDomainMax;
 773     pExynosOutputPort->portDefinition.bBuffersContiguous = OMX_FALSE;
 774     pExynosOutputPort->portDefinition.nBufferAlignment = 0;
 775     pExynosOutputPort->markType.hMarkTargetComponent = NULL;
 776     pExynosOutputPort->markType.pMarkData = NULL;
 777     pExynosOutputPort->exceptionFlag = GENERAL_STATE;
 778
 779     pExynosComponent->checkTimeStamp.needSetStartTimeStamp = OMX_FALSE;
 780     pExynosComponent->checkTimeStamp.needCheckStartTimeStamp = OMX_FALSE;
 781     pExynosComponent->checkTimeStamp.startTimeStamp = 0;
 782     pExynosComponent->checkTimeStamp.nStartFlags = 0x0;
 783
 784     pOMXComponent->EmptyThisBuffer = &Exynos_OMX_EmptyThisBuffer;
 785     pOMXComponent->FillThisBuffer  = &Exynos_OMX_FillThisBuffer;
 786
 787     ret = OMX_ErrorNone;
 788 EXIT:
 789     FunctionOut();
 790
 791     return ret;
 792 }
 793
 794 OMX_ERRORTYPE Exynos_OMX_Port_Destructor(OMX_HANDLETYPE hComponent)
 795 {
 796     OMX_ERRORTYPE          ret = OMX_ErrorNone;
 797     OMX_COMPONENTTYPE     *pOMXComponent = NULL;
 798     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
 799     EXYNOS_OMX_BASEPORT      *pExynosPort = NULL;
 800
 801     FunctionIn();
 802
 803     int i = 0;
 804
 805     if (hComponent == NULL) {
 806         ret = OMX_ErrorBadParameter;
 807         goto EXIT;
 808     }
 809     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
 810     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
 811     if (ret != OMX_ErrorNone) {
 812         goto EXIT;
 813     }
 814     if (pOMXComponent->pComponentPrivate == NULL) {
 815         ret = OMX_ErrorBadParameter;
 816         goto EXIT;
 817     }
 818     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 819     for (i = 0; i < ALL_PORT_NUM; i++) {
 820         pExynosPort = &pExynosComponent->pExynosPort[i];
 821
 822         Exynos_OSAL_SemaphoreTerminate(pExynosPort->loadedResource);
 823         pExynosPort->loadedResource = NULL;
 824         Exynos_OSAL_SemaphoreTerminate(pExynosPort->unloadedResource);
 825         pExynosPort->unloadedResource = NULL;
 826         Exynos_OSAL_Free(pExynosPort->bufferStateAllocate);
 827         pExynosPort->bufferStateAllocate = NULL;
 828         Exynos_OSAL_Free(pExynosPort->extendBufferHeader);
 829         pExynosPort->extendBufferHeader = NULL;
 830
 831         Exynos_OSAL_QueueTerminate(&pExynosPort->bufferQ);
 832     }
 833     Exynos_OSAL_Free(pExynosComponent->pExynosPort);
 834     pExynosComponent->pExynosPort = NULL;
 835     ret = OMX_ErrorNone;
 836 EXIT:
 837     FunctionOut();
 838
 839     return ret;
 840 }
 841
 842 OMX_ERRORTYPE Exynos_ResetDataBuffer(EXYNOS_OMX_DATABUFFER *pDataBuffer)
 843 {
 844     OMX_ERRORTYPE ret = OMX_ErrorNone;
 845
 846     if (pDataBuffer == NULL) {
 847         ret = OMX_ErrorBadParameter;
 848         goto EXIT;
 849     }
 850
 851     pDataBuffer->dataValid     = OMX_FALSE;
 852     pDataBuffer->dataLen       = 0;
 853     pDataBuffer->remainDataLen = 0;
 854     pDataBuffer->usedDataLen   = 0;
 855     pDataBuffer->bufferHeader  = NULL;
 856     pDataBuffer->nFlags        = 0;
 857     pDataBuffer->timeStamp     = 0;
 858     pDataBuffer->pPrivate      = NULL;
 859
 860 EXIT:
 861     return ret;
 862 }
 863
 864 OMX_ERRORTYPE Exynos_ResetCodecData(EXYNOS_OMX_DATA *pData)
 865 {
 866     OMX_ERRORTYPE ret = OMX_ErrorNone;
 867
 868     if (pData == NULL) {
 869         ret = OMX_ErrorBadParameter;
 870         goto EXIT;
 871     }
 872
 873     pData->dataLen       = 0;
 874     pData->usedDataLen   = 0;
 875     pData->remainDataLen = 0;
 876     pData->nFlags        = 0;
 877     pData->timeStamp     = 0;
 878     pData->pPrivate      = NULL;
 879     pData->bufferHeader  = NULL;
 880
 881 EXIT:
 882     return ret;
 883 }
 884
 885 OMX_ERRORTYPE Exynos_Shared_BufferToData(EXYNOS_OMX_DATABUFFER *pUseBuffer, EXYNOS_OMX_DATA *pData, EXYNOS_OMX_PLANE nPlane)
 886 {
 887     OMX_ERRORTYPE ret = OMX_ErrorNone;
 888
 889     if (nPlane == ONE_PLANE) {
 890         /* Case of Shared Buffer, Only support singlePlaneBuffer */
 891         pData->buffer.singlePlaneBuffer.dataBuffer = pUseBuffer->bufferHeader->pBuffer;
 892     } else {
 893         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Can not support plane");
 894         ret = OMX_ErrorNotImplemented;
 895         goto EXIT;
 896     }
 897
 898     pData->allocSize     = pUseBuffer->allocSize;
 899     pData->dataLen       = pUseBuffer->dataLen;
 900     pData->usedDataLen   = pUseBuffer->usedDataLen;
 901     pData->remainDataLen = pUseBuffer->remainDataLen;
 902     pData->timeStamp     = pUseBuffer->timeStamp;
 903     pData->nFlags        = pUseBuffer->nFlags;
 904     pData->pPrivate      = pUseBuffer->pPrivate;
 905     pData->bufferHeader  = pUseBuffer->bufferHeader;
 906
 907 EXIT:
 908     return ret;
 909 }
 910
 911 OMX_ERRORTYPE Exynos_Shared_DataToBuffer(EXYNOS_OMX_DATA *pData, EXYNOS_OMX_DATABUFFER *pUseBuffer)
 912 {
 913     OMX_ERRORTYPE ret = OMX_ErrorNone;
 914
 915     pUseBuffer->bufferHeader          = pData->bufferHeader;
 916     pUseBuffer->allocSize             = pData->allocSize;
 917     pUseBuffer->dataLen               = pData->dataLen;
 918     pUseBuffer->usedDataLen           = pData->usedDataLen;
 919     pUseBuffer->remainDataLen         = pData->remainDataLen;
 920     pUseBuffer->timeStamp             = pData->timeStamp;
 921     pUseBuffer->nFlags                = pData->nFlags;
 922     pUseBuffer->pPrivate              = pData->pPrivate;
 923
 924     return ret;
 925 }