openmax/component/common/Exynos_OMX_Basecomponent.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_Basecomponent.c
  20  * @brief
  21  * @author     SeungBeom Kim (sbcrux.kim@samsung.com)
  22  *             Yunji Kim (yunji.kim@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 #include <unistd.h>
  32
  33 #include "Exynos_OSAL_Event.h"
  34 #include "Exynos_OSAL_Thread.h"
  35 #include "Exynos_OSAL_ETC.h"
  36 #include "Exynos_OSAL_Semaphore.h"
  37 #include "Exynos_OSAL_Mutex.h"
  38 #include "Exynos_OMX_Baseport.h"
  39 #include "Exynos_OMX_Basecomponent.h"
  40 #include "Exynos_OMX_Resourcemanager.h"
  41 #include "Exynos_OMX_Macros.h"
  42
  43 #undef  EXYNOS_LOG_TAG
  44 #define EXYNOS_LOG_TAG    "EXYNOS_BASE_COMP"
  45 #define EXYNOS_LOG_OFF
  46 //#define EXYNOS_TRACE_ON
  47 #include "Exynos_OSAL_Log.h"
  48
  49
  50 /* Change CHECK_SIZE_VERSION Macro */
  51 OMX_ERRORTYPE Exynos_OMX_Check_SizeVersion(OMX_PTR header, OMX_U32 size)
  52 {
  53     OMX_ERRORTYPE ret = OMX_ErrorNone;
  54
  55     OMX_VERSIONTYPE* version = NULL;
  56     if (header == NULL) {
  57         ret = OMX_ErrorBadParameter;
  58         goto EXIT;
  59     }
  60     version = (OMX_VERSIONTYPE*)((char*)header + sizeof(OMX_U32));
  61     if (*((OMX_U32*)header) != size) {
  62         ret = OMX_ErrorBadParameter;
  63         goto EXIT;
  64     }
  65     if (version->s.nVersionMajor != VERSIONMAJOR_NUMBER ||
  66         version->s.nVersionMinor != VERSIONMINOR_NUMBER) {
  67         ret = OMX_ErrorVersionMismatch;
  68         goto EXIT;
  69     }
  70     ret = OMX_ErrorNone;
  71 EXIT:
  72     return ret;
  73 }
  74
  75 OMX_ERRORTYPE Exynos_OMX_GetComponentVersion(
  76     OMX_IN  OMX_HANDLETYPE   hComponent,
  77     OMX_OUT OMX_STRING       pComponentName,
  78     OMX_OUT OMX_VERSIONTYPE *pComponentVersion,
  79     OMX_OUT OMX_VERSIONTYPE *pSpecVersion,
  80     OMX_OUT OMX_UUIDTYPE    *pComponentUUID)
  81 {
  82     OMX_ERRORTYPE             ret = OMX_ErrorNone;
  83     OMX_COMPONENTTYPE        *pOMXComponent = NULL;
  84     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
  85     OMX_U32                   compUUID[3];
  86
  87     FunctionIn();
  88
  89     /* check parameters */
  90     if (hComponent     == NULL ||
  91         pComponentName == NULL || pComponentVersion == NULL ||
  92         pSpecVersion   == NULL || pComponentUUID    == NULL) {
  93         ret = OMX_ErrorBadParameter;
  94         goto EXIT;
  95     }
  96     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
  97     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
  98     if (ret != OMX_ErrorNone) {
  99         goto EXIT;
 100     }
 101
 102     if (pOMXComponent->pComponentPrivate == NULL) {
 103         ret = OMX_ErrorBadParameter;
 104         goto EXIT;
 105     }
 106     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 107
 108     if (pExynosComponent->currentState == OMX_StateInvalid) {
 109         ret = OMX_ErrorInvalidState;
 110         goto EXIT;
 111     }
 112
 113     Exynos_OSAL_Strcpy(pComponentName, pExynosComponent->componentName);
 114     Exynos_OSAL_Memcpy(pComponentVersion, &(pExynosComponent->componentVersion), sizeof(OMX_VERSIONTYPE));
 115     Exynos_OSAL_Memcpy(pSpecVersion, &(pExynosComponent->specVersion), sizeof(OMX_VERSIONTYPE));
 116
 117     /* Fill UUID with handle address, PID and UID.
 118      * This should guarantee uiniqness */
 119     compUUID[0] = (OMX_U32)pOMXComponent;
 120     compUUID[1] = getpid();
 121     compUUID[2] = getuid();
 122     Exynos_OSAL_Memcpy(*pComponentUUID, compUUID, 3 * sizeof(*compUUID));
 123
 124     ret = OMX_ErrorNone;
 125
 126 EXIT:
 127     FunctionOut();
 128
 129     return ret;
 130 }
 131
 132 OMX_ERRORTYPE Exynos_OMX_GetState (
 133     OMX_IN OMX_HANDLETYPE  hComponent,
 134     OMX_OUT OMX_STATETYPE *pState)
 135 {
 136     OMX_ERRORTYPE             ret = OMX_ErrorNone;
 137     OMX_COMPONENTTYPE        *pOMXComponent = NULL;
 138     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
 139
 140     FunctionIn();
 141
 142     if (hComponent == NULL || pState == NULL) {
 143         ret = OMX_ErrorBadParameter;
 144         goto EXIT;
 145     }
 146     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
 147     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
 148     if (ret != OMX_ErrorNone) {
 149         goto EXIT;
 150     }
 151
 152     if (pOMXComponent->pComponentPrivate == NULL) {
 153         ret = OMX_ErrorBadParameter;
 154         goto EXIT;
 155     }
 156     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 157
 158     *pState = pExynosComponent->currentState;
 159     ret = OMX_ErrorNone;
 160
 161 EXIT:
 162     FunctionOut();
 163
 164     return ret;
 165 }
 166
 167 OMX_ERRORTYPE Exynos_OMX_ComponentStateSet(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 messageParam)
 168 {
 169     OMX_ERRORTYPE             ret = OMX_ErrorNone;
 170     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 171     EXYNOS_OMX_MESSAGE       *message;
 172     OMX_STATETYPE             destState = messageParam;
 173     OMX_STATETYPE             currentState = pExynosComponent->currentState;
 174     EXYNOS_OMX_BASEPORT      *pExynosPort = NULL;
 175     unsigned int              i = 0, j = 0;
 176     int                       k = 0;
 177
 178     FunctionIn();
 179
 180     /* check parameters */
 181     if (currentState == destState) {
 182          ret = OMX_ErrorSameState;
 183             goto EXIT;
 184     }
 185     if (currentState == OMX_StateInvalid) {
 186         ret = OMX_ErrorInvalidState;
 187         goto EXIT;
 188     }
 189
 190     if ((currentState == OMX_StateLoaded) && (destState == OMX_StateIdle)) {
 191         ret = Exynos_OMX_Get_Resource(pOMXComponent);
 192         if (ret != OMX_ErrorNone) {
 193             goto EXIT;
 194         }
 195     }
 196     if (((currentState == OMX_StateIdle) && (destState == OMX_StateLoaded))       ||
 197         ((currentState == OMX_StateIdle) && (destState == OMX_StateInvalid))      ||
 198         ((currentState == OMX_StateExecuting) && (destState == OMX_StateInvalid)) ||
 199         ((currentState == OMX_StatePause) && (destState == OMX_StateInvalid))) {
 200         Exynos_OMX_Release_Resource(pOMXComponent);
 201     }
 202
 203 #ifndef TIZEN_FEATURE_E3250
 204     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "destState: %d", destState);
 205 #else
 206     Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "destState: %d", destState);
 207 #endif
 208     switch (destState) {
 209     case OMX_StateInvalid:
 210         switch (currentState) {
 211         case OMX_StateWaitForResources:
 212             Exynos_OMX_Out_WaitForResource(pOMXComponent);
 213         case OMX_StateIdle:
 214         case OMX_StateExecuting:
 215         case OMX_StatePause:
 216         case OMX_StateLoaded:
 217             pExynosComponent->currentState = OMX_StateInvalid;
 218             ret = pExynosComponent->exynos_BufferProcessTerminate(pOMXComponent);
 219
 220             for (i = 0; i < ALL_PORT_NUM; i++) {
 221                 if (pExynosComponent->pExynosPort[i].portWayType == WAY1_PORT) {
 222                     Exynos_OSAL_MutexTerminate(pExynosComponent->pExynosPort[i].way.port1WayDataBuffer.dataBuffer.bufferMutex);
 223                     pExynosComponent->pExynosPort[i].way.port1WayDataBuffer.dataBuffer.bufferMutex = NULL;
 224                 } else if (pExynosComponent->pExynosPort[i].portWayType == WAY2_PORT) {
 225                     Exynos_OSAL_MutexTerminate(pExynosComponent->pExynosPort[i].way.port2WayDataBuffer.inputDataBuffer.bufferMutex);
 226                     pExynosComponent->pExynosPort[i].way.port2WayDataBuffer.inputDataBuffer.bufferMutex = NULL;
 227                     Exynos_OSAL_MutexTerminate(pExynosComponent->pExynosPort[i].way.port2WayDataBuffer.outputDataBuffer.bufferMutex);
 228                     pExynosComponent->pExynosPort[i].way.port2WayDataBuffer.outputDataBuffer.bufferMutex = NULL;
 229                 }
 230                 Exynos_OSAL_MutexTerminate(pExynosComponent->pExynosPort[i].hPortMutex);
 231                 pExynosComponent->pExynosPort[i].hPortMutex = NULL;
 232             }
 233
 234             if (pExynosComponent->bMultiThreadProcess == OMX_FALSE) {
 235                 Exynos_OSAL_SignalTerminate(pExynosComponent->pauseEvent);
 236                 pExynosComponent->pauseEvent = NULL;
 237             } else {
 238                 for (i = 0; i < ALL_PORT_NUM; i++) {
 239                     Exynos_OSAL_SignalTerminate(pExynosComponent->pExynosPort[i].pauseEvent);
 240                     pExynosComponent->pExynosPort[i].pauseEvent = NULL;
 241                     if (pExynosComponent->pExynosPort[i].bufferProcessType & BUFFER_SHARE) {
 242                         Exynos_OSAL_SignalTerminate(pExynosComponent->pExynosPort[i].hAllCodecBufferReturnEvent);
 243                         pExynosComponent->pExynosPort[i].hAllCodecBufferReturnEvent = NULL;
 244                     }
 245                 }
 246             }
 247             for (i = 0; i < ALL_PORT_NUM; i++) {
 248                 Exynos_OSAL_SemaphoreTerminate(pExynosComponent->pExynosPort[i].bufferSemID);
 249                 pExynosComponent->pExynosPort[i].bufferSemID = NULL;
 250             }
 251             if (pExynosComponent->exynos_codec_componentTerminate != NULL)
 252                 pExynosComponent->exynos_codec_componentTerminate(pOMXComponent);
 253
 254             ret = OMX_ErrorInvalidState;
 255             break;
 256         default:
 257             ret = OMX_ErrorInvalidState;
 258             break;
 259         }
 260         break;
 261     case OMX_StateLoaded:
 262         switch (currentState) {
 263         case OMX_StateIdle:
 264             ret = pExynosComponent->exynos_BufferProcessTerminate(pOMXComponent);
 265
 266             for (i = 0; i < ALL_PORT_NUM; i++) {
 267                 if (pExynosComponent->pExynosPort[i].portWayType == WAY1_PORT) {
 268                     Exynos_OSAL_MutexTerminate(pExynosComponent->pExynosPort[i].way.port1WayDataBuffer.dataBuffer.bufferMutex);
 269                     pExynosComponent->pExynosPort[i].way.port1WayDataBuffer.dataBuffer.bufferMutex = NULL;
 270                 } else if (pExynosComponent->pExynosPort[i].portWayType == WAY2_PORT) {
 271                     Exynos_OSAL_MutexTerminate(pExynosComponent->pExynosPort[i].way.port2WayDataBuffer.inputDataBuffer.bufferMutex);
 272                     pExynosComponent->pExynosPort[i].way.port2WayDataBuffer.inputDataBuffer.bufferMutex = NULL;
 273                     Exynos_OSAL_MutexTerminate(pExynosComponent->pExynosPort[i].way.port2WayDataBuffer.outputDataBuffer.bufferMutex);
 274                     pExynosComponent->pExynosPort[i].way.port2WayDataBuffer.outputDataBuffer.bufferMutex = NULL;
 275                 }
 276                 Exynos_OSAL_MutexTerminate(pExynosComponent->pExynosPort[i].hPortMutex);
 277                 pExynosComponent->pExynosPort[i].hPortMutex = NULL;
 278             }
 279             if (pExynosComponent->bMultiThreadProcess == OMX_FALSE) {
 280                 Exynos_OSAL_SignalTerminate(pExynosComponent->pauseEvent);
 281                 pExynosComponent->pauseEvent = NULL;
 282             } else {
 283                 for (i = 0; i < ALL_PORT_NUM; i++) {
 284                     Exynos_OSAL_SignalTerminate(pExynosComponent->pExynosPort[i].pauseEvent);
 285                     pExynosComponent->pExynosPort[i].pauseEvent = NULL;
 286                     if (pExynosComponent->pExynosPort[i].bufferProcessType & BUFFER_SHARE) {
 287                         Exynos_OSAL_SignalTerminate(pExynosComponent->pExynosPort[i].hAllCodecBufferReturnEvent);
 288                         pExynosComponent->pExynosPort[i].hAllCodecBufferReturnEvent = NULL;
 289                     }
 290                 }
 291             }
 292             for (i = 0; i < ALL_PORT_NUM; i++) {
 293                 Exynos_OSAL_SemaphoreTerminate(pExynosComponent->pExynosPort[i].bufferSemID);
 294                 pExynosComponent->pExynosPort[i].bufferSemID = NULL;
 295             }
 296
 297             pExynosComponent->exynos_codec_componentTerminate(pOMXComponent);
 298
 299             for (i = 0; i < (pExynosComponent->portParam.nPorts); i++) {
 300                 pExynosPort = (pExynosComponent->pExynosPort + i);
 301                 if (CHECK_PORT_TUNNELED(pExynosPort) && CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)) {
 302                     while (Exynos_OSAL_GetElemNum(&pExynosPort->bufferQ) > 0) {
 303                         message = (EXYNOS_OMX_MESSAGE*)Exynos_OSAL_Dequeue(&pExynosPort->bufferQ);
 304                         if (message != NULL)
 305                             Exynos_OSAL_Free(message);
 306                     }
 307                     ret = pExynosComponent->exynos_FreeTunnelBuffer(pExynosPort, i);
 308                     if (OMX_ErrorNone != ret) {
 309                         goto EXIT;
 310                     }
 311                 } else {
 312                     if (CHECK_PORT_ENABLED(pExynosPort)) {
 313                         Exynos_OSAL_SemaphoreWait(pExynosPort->unloadedResource);
 314                         while (Exynos_OSAL_GetElemNum(&pExynosPort->bufferQ) > 0) {
 315                             message = (EXYNOS_OMX_MESSAGE *)Exynos_OSAL_Dequeue(&pExynosPort->bufferQ);
 316                             if (message != NULL)
 317                                 Exynos_OSAL_Free(message);
 318                         }
 319                         pExynosPort->portDefinition.bPopulated = OMX_FALSE;
 320                     }
 321                 }
 322             }
 323             pExynosComponent->currentState = OMX_StateLoaded;
 324             break;
 325         case OMX_StateWaitForResources:
 326             ret = Exynos_OMX_Out_WaitForResource(pOMXComponent);
 327             pExynosComponent->currentState = OMX_StateLoaded;
 328             break;
 329         case OMX_StateExecuting:
 330         case OMX_StatePause:
 331         default:
 332             ret = OMX_ErrorIncorrectStateTransition;
 333             break;
 334         }
 335         break;
 336     case OMX_StateIdle:
 337         switch (currentState) {
 338         case OMX_StateLoaded:
 339             for (i = 0; i < pExynosComponent->portParam.nPorts; i++) {
 340                 pExynosPort = (pExynosComponent->pExynosPort + i);
 341                 if (CHECK_PORT_TUNNELED(pExynosPort) && CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)) {
 342                     if (CHECK_PORT_ENABLED(pExynosPort)) {
 343                         ret = pExynosComponent->exynos_AllocateTunnelBuffer(pExynosPort, i);
 344                         if (ret!=OMX_ErrorNone)
 345                             goto EXIT;
 346                     }
 347                 } else {
 348                     if (CHECK_PORT_ENABLED(pExynosPort)) {
 349                         Exynos_OSAL_SemaphoreWait(pExynosComponent->pExynosPort[i].loadedResource);
 350                         pExynosPort->portDefinition.bPopulated = OMX_TRUE;
 351                     }
 352                 }
 353             }
 354             ret = pExynosComponent->exynos_codec_componentInit(pOMXComponent);
 355             if (ret != OMX_ErrorNone) {
 356                 /*
 357                  * if (CHECK_PORT_TUNNELED == OMX_TRUE) thenTunnel Buffer Free
 358                  */
 359                 goto EXIT;
 360             }
 361             if (pExynosComponent->bMultiThreadProcess == OMX_FALSE) {
 362                 Exynos_OSAL_SignalCreate(&pExynosComponent->pauseEvent);
 363             } else {
 364                 for (i = 0; i < ALL_PORT_NUM; i++) {
 365                     Exynos_OSAL_SignalCreate(&pExynosComponent->pExynosPort[i].pauseEvent);
 366                     if (pExynosComponent->pExynosPort[i].bufferProcessType & BUFFER_SHARE)
 367                         Exynos_OSAL_SignalCreate(&pExynosComponent->pExynosPort[i].hAllCodecBufferReturnEvent);
 368                 }
 369             }
 370             for (i = 0; i < ALL_PORT_NUM; i++) {
 371                 ret = Exynos_OSAL_SemaphoreCreate(&pExynosComponent->pExynosPort[i].bufferSemID);
 372                 if (ret != OMX_ErrorNone) {
 373                     ret = OMX_ErrorInsufficientResources;
 374                     Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
 375                     goto EXIT;
 376                 }
 377             }
 378             for (i = 0; i < ALL_PORT_NUM; i++) {
 379                 if (pExynosComponent->pExynosPort[i].portWayType == WAY1_PORT) {
 380                     ret = Exynos_OSAL_MutexCreate(&pExynosComponent->pExynosPort[i].way.port1WayDataBuffer.dataBuffer.bufferMutex);
 381                     if (ret != OMX_ErrorNone) {
 382                         ret = OMX_ErrorInsufficientResources;
 383                         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
 384                         goto EXIT;
 385                     }
 386                 } else if (pExynosComponent->pExynosPort[i].portWayType == WAY2_PORT) {
 387                     ret = Exynos_OSAL_MutexCreate(&pExynosComponent->pExynosPort[i].way.port2WayDataBuffer.inputDataBuffer.bufferMutex);
 388                     if (ret != OMX_ErrorNone) {
 389                         ret = OMX_ErrorInsufficientResources;
 390                         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
 391                         goto EXIT;
 392                     }
 393                     ret = Exynos_OSAL_MutexCreate(&pExynosComponent->pExynosPort[i].way.port2WayDataBuffer.outputDataBuffer.bufferMutex);
 394                     if (ret != OMX_ErrorNone) {
 395                         ret = OMX_ErrorInsufficientResources;
 396                         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
 397                         goto EXIT;
 398                     }
 399                 }
 400                 ret = Exynos_OSAL_MutexCreate(&pExynosComponent->pExynosPort[i].hPortMutex);
 401                 if (ret != OMX_ErrorNone) {
 402                     ret = OMX_ErrorInsufficientResources;
 403                     goto EXIT;
 404                 }
 405             }
 406
 407             ret = pExynosComponent->exynos_BufferProcessCreate(pOMXComponent);
 408             if (ret != OMX_ErrorNone) {
 409                 /*
 410                  * if (CHECK_PORT_TUNNELED == OMX_TRUE) thenTunnel Buffer Free
 411                  */
 412                 if (pExynosComponent->bMultiThreadProcess == OMX_FALSE) {
 413                     Exynos_OSAL_SignalTerminate(pExynosComponent->pauseEvent);
 414                     pExynosComponent->pauseEvent = NULL;
 415                 } else {
 416                     for (i = 0; i < ALL_PORT_NUM; i++) {
 417                         Exynos_OSAL_SignalTerminate(pExynosComponent->pExynosPort[i].pauseEvent);
 418                         pExynosComponent->pExynosPort[i].pauseEvent = NULL;
 419                         if (pExynosComponent->pExynosPort[i].bufferProcessType & BUFFER_SHARE) {
 420                             Exynos_OSAL_SignalTerminate(pExynosComponent->pExynosPort[i].hAllCodecBufferReturnEvent);
 421                             pExynosComponent->pExynosPort[i].hAllCodecBufferReturnEvent = NULL;
 422                         }
 423                     }
 424                 }
 425                 for (i = 0; i < ALL_PORT_NUM; i++) {
 426                     if (pExynosComponent->pExynosPort[i].portWayType == WAY1_PORT) {
 427                         Exynos_OSAL_MutexTerminate(pExynosComponent->pExynosPort[i].way.port1WayDataBuffer.dataBuffer.bufferMutex);
 428                         pExynosComponent->pExynosPort[i].way.port1WayDataBuffer.dataBuffer.bufferMutex = NULL;
 429                     } else if (pExynosComponent->pExynosPort[i].portWayType == WAY2_PORT) {
 430                         Exynos_OSAL_MutexTerminate(pExynosComponent->pExynosPort[i].way.port2WayDataBuffer.inputDataBuffer.bufferMutex);
 431                         pExynosComponent->pExynosPort[i].way.port2WayDataBuffer.inputDataBuffer.bufferMutex = NULL;
 432                         Exynos_OSAL_MutexTerminate(pExynosComponent->pExynosPort[i].way.port2WayDataBuffer.outputDataBuffer.bufferMutex);
 433                         pExynosComponent->pExynosPort[i].way.port2WayDataBuffer.outputDataBuffer.bufferMutex = NULL;
 434                     }
 435                     Exynos_OSAL_MutexTerminate(pExynosComponent->pExynosPort[i].hPortMutex);
 436                     pExynosComponent->pExynosPort[i].hPortMutex = NULL;
 437                 }
 438                 for (i = 0; i < ALL_PORT_NUM; i++) {
 439                     Exynos_OSAL_SemaphoreTerminate(pExynosComponent->pExynosPort[i].bufferSemID);
 440                     pExynosComponent->pExynosPort[i].bufferSemID = NULL;
 441                 }
 442
 443                 ret = OMX_ErrorInsufficientResources;
 444                 goto EXIT;
 445             }
 446             pExynosComponent->currentState = OMX_StateIdle;
 447             break;
 448         case OMX_StateExecuting:
 449         case OMX_StatePause:
 450             Exynos_OMX_BufferFlushProcess(pOMXComponent, ALL_PORT_INDEX, OMX_FALSE);
 451             pExynosComponent->currentState = OMX_StateIdle;
 452             break;
 453         case OMX_StateWaitForResources:
 454             pExynosComponent->currentState = OMX_StateIdle;
 455             break;
 456         default:
 457             ret = OMX_ErrorIncorrectStateTransition;
 458             break;
 459         }
 460         break;
 461     case OMX_StateExecuting:
 462         switch (currentState) {
 463         case OMX_StateLoaded:
 464             ret = OMX_ErrorIncorrectStateTransition;
 465             break;
 466         case OMX_StateIdle:
 467             for (i = 0; i < pExynosComponent->portParam.nPorts; i++) {
 468                 pExynosPort = &pExynosComponent->pExynosPort[i];
 469                 if (CHECK_PORT_TUNNELED(pExynosPort) && CHECK_PORT_BUFFER_SUPPLIER(pExynosPort) && CHECK_PORT_ENABLED(pExynosPort)) {
 470                     for (j = 0; j < pExynosPort->tunnelBufferNum; j++) {
 471                         Exynos_OSAL_SemaphorePost(pExynosComponent->pExynosPort[i].bufferSemID);
 472                     }
 473                 }
 474             }
 475
 476             pExynosComponent->transientState = EXYNOS_OMX_TransStateMax;
 477             pExynosComponent->currentState = OMX_StateExecuting;
 478             if (pExynosComponent->bMultiThreadProcess == OMX_FALSE) {
 479                 Exynos_OSAL_SignalSet(pExynosComponent->pauseEvent);
 480             } else {
 481                 for (i = 0; i < ALL_PORT_NUM; i++) {
 482                     Exynos_OSAL_SignalSet(pExynosComponent->pExynosPort[i].pauseEvent);
 483                 }
 484             }
 485             break;
 486         case OMX_StatePause:
 487             for (i = 0; i < pExynosComponent->portParam.nPorts; i++) {
 488                 pExynosPort = &pExynosComponent->pExynosPort[i];
 489                 if (CHECK_PORT_TUNNELED(pExynosPort) && CHECK_PORT_BUFFER_SUPPLIER(pExynosPort) && CHECK_PORT_ENABLED(pExynosPort)) {
 490                     OMX_S32 semaValue = 0, cnt = 0;
 491                     Exynos_OSAL_Get_SemaphoreCount(pExynosComponent->pExynosPort[i].bufferSemID, &semaValue);
 492                     if (Exynos_OSAL_GetElemNum(&pExynosPort->bufferQ) > semaValue) {
 493                         cnt = Exynos_OSAL_GetElemNum(&pExynosPort->bufferQ) - semaValue;
 494                         for (k = 0; k < cnt; k++) {
 495                             Exynos_OSAL_SemaphorePost(pExynosComponent->pExynosPort[i].bufferSemID);
 496                         }
 497                     }
 498                 }
 499             }
 500
 501             pExynosComponent->currentState = OMX_StateExecuting;
 502             if (pExynosComponent->bMultiThreadProcess == OMX_FALSE) {
 503                 Exynos_OSAL_SignalSet(pExynosComponent->pauseEvent);
 504             } else {
 505                 for (i = 0; i < ALL_PORT_NUM; i++) {
 506                     Exynos_OSAL_SignalSet(pExynosComponent->pExynosPort[i].pauseEvent);
 507                 }
 508             }
 509             break;
 510         case OMX_StateWaitForResources:
 511             ret = OMX_ErrorIncorrectStateTransition;
 512             break;
 513         default:
 514             ret = OMX_ErrorIncorrectStateTransition;
 515             break;
 516         }
 517         break;
 518     case OMX_StatePause:
 519         switch (currentState) {
 520         case OMX_StateLoaded:
 521             ret = OMX_ErrorIncorrectStateTransition;
 522             break;
 523         case OMX_StateIdle:
 524             pExynosComponent->currentState = OMX_StatePause;
 525             break;
 526         case OMX_StateExecuting:
 527             pExynosComponent->currentState = OMX_StatePause;
 528             break;
 529         case OMX_StateWaitForResources:
 530             ret = OMX_ErrorIncorrectStateTransition;
 531             break;
 532         default:
 533             ret = OMX_ErrorIncorrectStateTransition;
 534             break;
 535         }
 536         break;
 537     case OMX_StateWaitForResources:
 538         switch (currentState) {
 539         case OMX_StateLoaded:
 540             ret = Exynos_OMX_In_WaitForResource(pOMXComponent);
 541             pExynosComponent->currentState = OMX_StateWaitForResources;
 542             break;
 543         case OMX_StateIdle:
 544         case OMX_StateExecuting:
 545         case OMX_StatePause:
 546             ret = OMX_ErrorIncorrectStateTransition;
 547             break;
 548         default:
 549             ret = OMX_ErrorIncorrectStateTransition;
 550             break;
 551         }
 552         break;
 553     default:
 554         ret = OMX_ErrorIncorrectStateTransition;
 555         break;
 556     }
 557
 558 EXIT:
 559     if (ret == OMX_ErrorNone) {
 560         if (pExynosComponent->pCallbacks != NULL) {
 561             pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
 562             pExynosComponent->callbackData,
 563             OMX_EventCmdComplete, OMX_CommandStateSet,
 564             destState, NULL);
 565         }
 566     } else {
 567         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s:%d", __FUNCTION__, __LINE__);
 568         if (pExynosComponent->pCallbacks != NULL) {
 569             pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
 570             pExynosComponent->callbackData,
 571             OMX_EventError, ret, 0, NULL);
 572         }
 573     }
 574     FunctionOut();
 575
 576     return ret;
 577 }
 578
 579 static OMX_ERRORTYPE Exynos_OMX_MessageHandlerThread(OMX_PTR threadData)
 580 {
 581     OMX_ERRORTYPE             ret = OMX_ErrorNone;
 582     OMX_COMPONENTTYPE        *pOMXComponent = NULL;
 583     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
 584     EXYNOS_OMX_MESSAGE       *message = NULL;
 585     OMX_U32                   messageType = 0, portIndex = 0;
 586
 587     FunctionIn();
 588
 589     if (threadData == NULL) {
 590         ret = OMX_ErrorBadParameter;
 591         goto EXIT;
 592     }
 593
 594     pOMXComponent = (OMX_COMPONENTTYPE *)threadData;
 595     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
 596     if (ret != OMX_ErrorNone) {
 597         goto EXIT;
 598     }
 599
 600     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 601
 602     while (pExynosComponent->bExitMessageHandlerThread == OMX_FALSE) {
 603         Exynos_OSAL_SemaphoreWait(pExynosComponent->msgSemaphoreHandle);
 604         message = (EXYNOS_OMX_MESSAGE *)Exynos_OSAL_Dequeue(&pExynosComponent->messageQ);
 605         if (message != NULL) {
 606             messageType = message->messageType;
 607             switch (messageType) {
 608             case OMX_CommandStateSet:
 609                 ret = Exynos_OMX_ComponentStateSet(pOMXComponent, message->messageParam);
 610                 break;
 611             case OMX_CommandFlush:
 612                 ret = Exynos_OMX_BufferFlushProcess(pOMXComponent, message->messageParam, OMX_TRUE);
 613                 break;
 614             case OMX_CommandPortDisable:
 615                 ret = Exynos_OMX_PortDisableProcess(pOMXComponent, message->messageParam);
 616                 break;
 617             case OMX_CommandPortEnable:
 618                 ret = Exynos_OMX_PortEnableProcess(pOMXComponent, message->messageParam);
 619                 break;
 620             case OMX_CommandMarkBuffer:
 621                 portIndex = message->messageParam;
 622                 pExynosComponent->pExynosPort[portIndex].markType.hMarkTargetComponent = ((OMX_MARKTYPE *)message->pCmdData)->hMarkTargetComponent;
 623                 pExynosComponent->pExynosPort[portIndex].markType.pMarkData            = ((OMX_MARKTYPE *)message->pCmdData)->pMarkData;
 624                 break;
 625             case (OMX_COMMANDTYPE)EXYNOS_OMX_CommandComponentDeInit:
 626                 pExynosComponent->bExitMessageHandlerThread = OMX_TRUE;
 627                 break;
 628             default:
 629                 break;
 630             }
 631             Exynos_OSAL_Free(message);
 632             message = NULL;
 633         }
 634     }
 635
 636     Exynos_OSAL_ThreadExit(NULL);
 637
 638 EXIT:
 639     FunctionOut();
 640
 641     return ret;
 642 }
 643
 644 static OMX_ERRORTYPE Exynos_StateSet(EXYNOS_OMX_BASECOMPONENT *pExynosComponent, OMX_U32 nParam)
 645 {
 646     OMX_U32 destState = nParam;
 647     OMX_U32 i = 0;
 648
 649     if ((destState == OMX_StateIdle) && (pExynosComponent->currentState == OMX_StateLoaded)) {
 650         pExynosComponent->transientState = EXYNOS_OMX_TransStateLoadedToIdle;
 651         for(i = 0; i < pExynosComponent->portParam.nPorts; i++) {
 652             pExynosComponent->pExynosPort[i].portState = OMX_StateIdle;
 653         }
 654         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "to OMX_StateIdle");
 655     } else if ((destState == OMX_StateLoaded) && (pExynosComponent->currentState == OMX_StateIdle)) {
 656         pExynosComponent->transientState = EXYNOS_OMX_TransStateIdleToLoaded;
 657         for (i = 0; i < pExynosComponent->portParam.nPorts; i++) {
 658             pExynosComponent->pExynosPort[i].portState = OMX_StateLoaded;
 659         }
 660         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "to OMX_StateLoaded");
 661     } else if ((destState == OMX_StateIdle) && (pExynosComponent->currentState == OMX_StateExecuting)) {
 662         pExynosComponent->transientState = EXYNOS_OMX_TransStateExecutingToIdle;
 663         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "to OMX_StateIdle");
 664     } else if ((destState == OMX_StateExecuting) && (pExynosComponent->currentState == OMX_StateIdle)) {
 665         pExynosComponent->transientState = EXYNOS_OMX_TransStateIdleToExecuting;
 666         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "to OMX_StateExecuting");
 667     } else if (destState == OMX_StateInvalid) {
 668         for (i = 0; i < pExynosComponent->portParam.nPorts; i++) {
 669             pExynosComponent->pExynosPort[i].portState = OMX_StateInvalid;
 670         }
 671     }
 672
 673     return OMX_ErrorNone;
 674 }
 675
 676 static OMX_ERRORTYPE Exynos_SetPortFlush(EXYNOS_OMX_BASECOMPONENT *pExynosComponent, OMX_U32 nParam)
 677 {
 678     OMX_ERRORTYPE        ret = OMX_ErrorNone;
 679     OMX_S32              portIndex = nParam;
 680     OMX_U16              i = 0, cnt = 0, index = 0;
 681
 682
 683     if ((pExynosComponent->currentState == OMX_StateExecuting) ||
 684         (pExynosComponent->currentState == OMX_StatePause)) {
 685         if ((portIndex != ALL_PORT_INDEX) &&
 686            ((OMX_S32)portIndex >= (OMX_S32)pExynosComponent->portParam.nPorts)) {
 687             ret = OMX_ErrorBadPortIndex;
 688             goto EXIT;
 689         }
 690
 691         /*********************
 692         *    need flush event set ?????
 693         **********************/
 694         cnt = (portIndex == ALL_PORT_INDEX ) ? ALL_PORT_NUM : 1;
 695         for (i = 0; i < cnt; i++) {
 696             if (portIndex == ALL_PORT_INDEX)
 697                 index = i;
 698             else
 699                 index = portIndex;
 700             pExynosComponent->pExynosPort[index].bIsPortFlushed = OMX_TRUE;
 701         }
 702     } else {
 703         ret = OMX_ErrorIncorrectStateOperation;
 704         goto EXIT;
 705     }
 706     ret = OMX_ErrorNone;
 707
 708 EXIT:
 709     return ret;
 710 }
 711
 712 static OMX_ERRORTYPE Exynos_SetPortEnable(EXYNOS_OMX_BASECOMPONENT *pExynosComponent, OMX_U32 nParam)
 713 {
 714     OMX_ERRORTYPE        ret = OMX_ErrorNone;
 715     EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
 716     OMX_S32              portIndex = nParam;
 717     OMX_U16              i = 0;
 718
 719     FunctionIn();
 720
 721     if ((portIndex != ALL_PORT_INDEX) &&
 722         ((OMX_S32)portIndex >= (OMX_S32)pExynosComponent->portParam.nPorts)) {
 723         ret = OMX_ErrorBadPortIndex;
 724         goto EXIT;
 725     }
 726
 727     if (portIndex == ALL_PORT_INDEX) {
 728         for (i = 0; i < pExynosComponent->portParam.nPorts; i++) {
 729             pExynosPort = &pExynosComponent->pExynosPort[i];
 730             if (CHECK_PORT_ENABLED(pExynosPort)) {
 731                 ret = OMX_ErrorIncorrectStateOperation;
 732                 goto EXIT;
 733             } else {
 734                 pExynosPort->portState = OMX_StateIdle;
 735             }
 736         }
 737     } else {
 738         pExynosPort = &pExynosComponent->pExynosPort[portIndex];
 739         if (CHECK_PORT_ENABLED(pExynosPort)) {
 740             ret = OMX_ErrorIncorrectStateOperation;
 741             goto EXIT;
 742         } else {
 743             pExynosPort->portState = OMX_StateIdle;
 744         }
 745     }
 746     ret = OMX_ErrorNone;
 747
 748 EXIT:
 749     FunctionOut();
 750
 751     return ret;
 752
 753 }
 754
 755 static OMX_ERRORTYPE Exynos_SetPortDisable(EXYNOS_OMX_BASECOMPONENT *pExynosComponent, OMX_U32 nParam)
 756 {
 757     OMX_ERRORTYPE        ret = OMX_ErrorNone;
 758     EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
 759     OMX_S32              portIndex = nParam;
 760     OMX_U16              i = 0;
 761
 762     FunctionIn();
 763
 764     if ((portIndex != ALL_PORT_INDEX) &&
 765         ((OMX_S32)portIndex >= (OMX_S32)pExynosComponent->portParam.nPorts)) {
 766         ret = OMX_ErrorBadPortIndex;
 767         goto EXIT;
 768     }
 769
 770     if (portIndex == ALL_PORT_INDEX) {
 771         for (i = 0; i < pExynosComponent->portParam.nPorts; i++) {
 772             pExynosPort = &pExynosComponent->pExynosPort[i];
 773             if (!CHECK_PORT_ENABLED(pExynosPort)) {
 774                 ret = OMX_ErrorIncorrectStateOperation;
 775                 goto EXIT;
 776             }
 777             pExynosPort->portState = OMX_StateLoaded;
 778             pExynosPort->bIsPortDisabled = OMX_TRUE;
 779         }
 780     } else {
 781         pExynosPort = &pExynosComponent->pExynosPort[portIndex];
 782         pExynosPort->portState = OMX_StateLoaded;
 783         pExynosPort->bIsPortDisabled = OMX_TRUE;
 784     }
 785     ret = OMX_ErrorNone;
 786
 787 EXIT:
 788     FunctionOut();
 789
 790     return ret;
 791 }
 792
 793 static OMX_ERRORTYPE Exynos_SetMarkBuffer(EXYNOS_OMX_BASECOMPONENT *pExynosComponent, OMX_U32 nParam)
 794 {
 795     OMX_ERRORTYPE        ret = OMX_ErrorNone;
 796
 797     if (nParam >= pExynosComponent->portParam.nPorts) {
 798         ret = OMX_ErrorBadPortIndex;
 799         goto EXIT;
 800     }
 801
 802     if ((pExynosComponent->currentState == OMX_StateExecuting) ||
 803         (pExynosComponent->currentState == OMX_StatePause)) {
 804         ret = OMX_ErrorNone;
 805     } else {
 806         ret = OMX_ErrorIncorrectStateOperation;
 807     }
 808
 809 EXIT:
 810     return ret;
 811 }
 812
 813 static OMX_ERRORTYPE Exynos_OMX_CommandQueue(
 814     EXYNOS_OMX_BASECOMPONENT *pExynosComponent,
 815     OMX_COMMANDTYPE        Cmd,
 816     OMX_U32                nParam,
 817     OMX_PTR                pCmdData)
 818 {
 819     OMX_ERRORTYPE    ret = OMX_ErrorNone;
 820     EXYNOS_OMX_MESSAGE *command = (EXYNOS_OMX_MESSAGE *)Exynos_OSAL_Malloc(sizeof(EXYNOS_OMX_MESSAGE));
 821
 822     if (command == NULL) {
 823         ret = OMX_ErrorInsufficientResources;
 824         goto EXIT;
 825     }
 826     command->messageType  = (OMX_U32)Cmd;
 827     command->messageParam = nParam;
 828     command->pCmdData     = pCmdData;
 829
 830     ret = Exynos_OSAL_Queue(&pExynosComponent->messageQ, (void *)command);
 831     if (ret != 0) {
 832         ret = OMX_ErrorUndefined;
 833         goto EXIT;
 834     }
 835     ret = Exynos_OSAL_SemaphorePost(pExynosComponent->msgSemaphoreHandle);
 836
 837 EXIT:
 838     return ret;
 839 }
 840
 841 OMX_ERRORTYPE Exynos_OMX_SendCommand(
 842     OMX_IN OMX_HANDLETYPE  hComponent,
 843     OMX_IN OMX_COMMANDTYPE Cmd,
 844     OMX_IN OMX_U32         nParam,
 845     OMX_IN OMX_PTR         pCmdData)
 846 {
 847     OMX_ERRORTYPE             ret = OMX_ErrorNone;
 848     OMX_COMPONENTTYPE        *pOMXComponent = NULL;
 849     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
 850
 851     FunctionIn();
 852
 853     if (hComponent == NULL) {
 854         ret = OMX_ErrorBadParameter;
 855         goto EXIT;
 856     }
 857     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
 858     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
 859     if (ret != OMX_ErrorNone) {
 860         goto EXIT;
 861     }
 862
 863     if (pOMXComponent->pComponentPrivate == NULL) {
 864         ret = OMX_ErrorBadParameter;
 865         goto EXIT;
 866     }
 867     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 868
 869     if (pExynosComponent->currentState == OMX_StateInvalid) {
 870         ret = OMX_ErrorInvalidState;
 871         goto EXIT;
 872     }
 873
 874     switch (Cmd) {
 875     case OMX_CommandStateSet :
 876         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Command: OMX_CommandStateSet");
 877         Exynos_StateSet(pExynosComponent, nParam);
 878         break;
 879     case OMX_CommandFlush :
 880         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Command: OMX_CommandFlush");
 881         ret = Exynos_SetPortFlush(pExynosComponent, nParam);
 882         if (ret != OMX_ErrorNone)
 883             goto EXIT;
 884         break;
 885     case OMX_CommandPortDisable :
 886         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Command: OMX_CommandPortDisable");
 887         ret = Exynos_SetPortDisable(pExynosComponent, nParam);
 888         if (ret != OMX_ErrorNone)
 889             goto EXIT;
 890         break;
 891     case OMX_CommandPortEnable :
 892         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Command: OMX_CommandPortEnable");
 893         ret = Exynos_SetPortEnable(pExynosComponent, nParam);
 894         if (ret != OMX_ErrorNone)
 895             goto EXIT;
 896         break;
 897     case OMX_CommandMarkBuffer :
 898         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Command: OMX_CommandMarkBuffer");
 899         ret = Exynos_SetMarkBuffer(pExynosComponent, nParam);
 900         if (ret != OMX_ErrorNone)
 901             goto EXIT;
 902         break;
 903     default:
 904         break;
 905     }
 906
 907     ret = Exynos_OMX_CommandQueue(pExynosComponent, Cmd, nParam, pCmdData);
 908
 909 EXIT:
 910     FunctionOut();
 911
 912     return ret;
 913 }
 914
 915 OMX_ERRORTYPE Exynos_OMX_GetParameter(
 916     OMX_IN OMX_HANDLETYPE hComponent,
 917     OMX_IN OMX_INDEXTYPE  nParamIndex,
 918     OMX_INOUT OMX_PTR     ComponentParameterStructure)
 919 {
 920     OMX_ERRORTYPE             ret = OMX_ErrorNone;
 921     OMX_COMPONENTTYPE        *pOMXComponent = NULL;
 922     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
 923
 924     FunctionIn();
 925
 926     if (hComponent == NULL) {
 927         ret = OMX_ErrorBadParameter;
 928         goto EXIT;
 929     }
 930     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
 931     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
 932     if (ret != OMX_ErrorNone) {
 933         goto EXIT;
 934     }
 935
 936     if (pOMXComponent->pComponentPrivate == NULL) {
 937         ret = OMX_ErrorBadParameter;
 938         goto EXIT;
 939     }
 940     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 941
 942     if (ComponentParameterStructure == NULL) {
 943         ret = OMX_ErrorBadParameter;
 944         goto EXIT;
 945     }
 946     if (pExynosComponent->currentState == OMX_StateInvalid) {
 947         ret = OMX_ErrorInvalidState;
 948         goto EXIT;
 949     }
 950
 951     switch (nParamIndex) {
 952     case OMX_IndexParamAudioInit:
 953     case OMX_IndexParamVideoInit:
 954     case OMX_IndexParamImageInit:
 955     case OMX_IndexParamOtherInit:
 956     {
 957         OMX_PORT_PARAM_TYPE *portParam = (OMX_PORT_PARAM_TYPE *)ComponentParameterStructure;
 958         ret = Exynos_OMX_Check_SizeVersion(portParam, sizeof(OMX_PORT_PARAM_TYPE));
 959         if (ret != OMX_ErrorNone) {
 960             goto EXIT;
 961         }
 962         portParam->nPorts         = 0;
 963         portParam->nStartPortNumber     = 0;
 964     }
 965         break;
 966     case OMX_IndexParamPortDefinition:
 967     {
 968         OMX_PARAM_PORTDEFINITIONTYPE *portDefinition = (OMX_PARAM_PORTDEFINITIONTYPE *)ComponentParameterStructure;
 969         OMX_U32                       portIndex = portDefinition->nPortIndex;
 970         EXYNOS_OMX_BASEPORT          *pExynosPort;
 971
 972         if (portIndex >= pExynosComponent->portParam.nPorts) {
 973             ret = OMX_ErrorBadPortIndex;
 974             goto EXIT;
 975         }
 976         ret = Exynos_OMX_Check_SizeVersion(portDefinition, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
 977         if (ret != OMX_ErrorNone) {
 978             goto EXIT;
 979         }
 980
 981         pExynosPort = &pExynosComponent->pExynosPort[portIndex];
 982         Exynos_OSAL_Memcpy(portDefinition, &pExynosPort->portDefinition, portDefinition->nSize);
 983     }
 984         break;
 985     case OMX_IndexParamPriorityMgmt:
 986     {
 987         OMX_PRIORITYMGMTTYPE *compPriority = (OMX_PRIORITYMGMTTYPE *)ComponentParameterStructure;
 988
 989         ret = Exynos_OMX_Check_SizeVersion(compPriority, sizeof(OMX_PRIORITYMGMTTYPE));
 990         if (ret != OMX_ErrorNone) {
 991             goto EXIT;
 992         }
 993
 994         compPriority->nGroupID       = pExynosComponent->compPriority.nGroupID;
 995         compPriority->nGroupPriority = pExynosComponent->compPriority.nGroupPriority;
 996     }
 997         break;
 998
 999     case OMX_IndexParamCompBufferSupplier:
1000     {
1001         OMX_PARAM_BUFFERSUPPLIERTYPE *bufferSupplier = (OMX_PARAM_BUFFERSUPPLIERTYPE *)ComponentParameterStructure;
1002         OMX_U32                       portIndex = bufferSupplier->nPortIndex;
1003         EXYNOS_OMX_BASEPORT          *pExynosPort;
1004
1005         if ((pExynosComponent->currentState == OMX_StateLoaded) ||
1006             (pExynosComponent->currentState == OMX_StateWaitForResources)) {
1007             if (portIndex >= pExynosComponent->portParam.nPorts) {
1008                 ret = OMX_ErrorBadPortIndex;
1009                 goto EXIT;
1010             }
1011             ret = Exynos_OMX_Check_SizeVersion(bufferSupplier, sizeof(OMX_PARAM_BUFFERSUPPLIERTYPE));
1012             if (ret != OMX_ErrorNone) {
1013                 goto EXIT;
1014             }
1015
1016             pExynosPort = &pExynosComponent->pExynosPort[portIndex];
1017
1018
1019             if (pExynosPort->portDefinition.eDir == OMX_DirInput) {
1020                 if (CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)) {
1021                     bufferSupplier->eBufferSupplier = OMX_BufferSupplyInput;
1022                 } else if (CHECK_PORT_TUNNELED(pExynosPort)) {
1023                     bufferSupplier->eBufferSupplier = OMX_BufferSupplyOutput;
1024                 } else {
1025                     bufferSupplier->eBufferSupplier = OMX_BufferSupplyUnspecified;
1026                 }
1027             } else {
1028                 if (CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)) {
1029                     bufferSupplier->eBufferSupplier = OMX_BufferSupplyOutput;
1030                 } else if (CHECK_PORT_TUNNELED(pExynosPort)) {
1031                     bufferSupplier->eBufferSupplier = OMX_BufferSupplyInput;
1032                 } else {
1033                     bufferSupplier->eBufferSupplier = OMX_BufferSupplyUnspecified;
1034                 }
1035             }
1036         }
1037         else
1038         {
1039             ret = OMX_ErrorIncorrectStateOperation;
1040             goto EXIT;
1041         }
1042     }
1043         break;
1044     default:
1045     {
1046         ret = OMX_ErrorUnsupportedIndex;
1047         goto EXIT;
1048     }
1049         break;
1050     }
1051
1052     ret = OMX_ErrorNone;
1053
1054 EXIT:
1055
1056     FunctionOut();
1057
1058     return ret;
1059 }
1060
1061 OMX_ERRORTYPE Exynos_OMX_SetParameter(
1062     OMX_IN OMX_HANDLETYPE hComponent,
1063     OMX_IN OMX_INDEXTYPE  nIndex,
1064     OMX_IN OMX_PTR        ComponentParameterStructure)
1065 {
1066     OMX_ERRORTYPE             ret = OMX_ErrorNone;
1067     OMX_COMPONENTTYPE        *pOMXComponent = NULL;
1068     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1069
1070     FunctionIn();
1071
1072     if (hComponent == NULL) {
1073         ret = OMX_ErrorBadParameter;
1074         goto EXIT;
1075     }
1076     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1077     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1078     if (ret != OMX_ErrorNone) {
1079         goto EXIT;
1080     }
1081
1082     if (pOMXComponent->pComponentPrivate == NULL) {
1083         ret = OMX_ErrorBadParameter;
1084         goto EXIT;
1085     }
1086     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1087
1088     if (ComponentParameterStructure == NULL) {
1089         ret = OMX_ErrorBadParameter;
1090         goto EXIT;
1091     }
1092     if (pExynosComponent->currentState == OMX_StateInvalid) {
1093         ret = OMX_ErrorInvalidState;
1094         goto EXIT;
1095     }
1096
1097     switch (nIndex) {
1098     case OMX_IndexParamAudioInit:
1099     case OMX_IndexParamVideoInit:
1100     case OMX_IndexParamImageInit:
1101     case OMX_IndexParamOtherInit:
1102     {
1103         OMX_PORT_PARAM_TYPE *portParam = (OMX_PORT_PARAM_TYPE *)ComponentParameterStructure;
1104         ret = Exynos_OMX_Check_SizeVersion(portParam, sizeof(OMX_PORT_PARAM_TYPE));
1105         if (ret != OMX_ErrorNone) {
1106             goto EXIT;
1107         }
1108
1109         if ((pExynosComponent->currentState != OMX_StateLoaded) &&
1110             (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1111             ret = OMX_ErrorIncorrectStateOperation;
1112             goto EXIT;
1113         }
1114         ret = OMX_ErrorUndefined;
1115         /* Exynos_OSAL_Memcpy(&pExynosComponent->portParam, portParam, sizeof(OMX_PORT_PARAM_TYPE)); */
1116     }
1117         break;
1118     case OMX_IndexParamPortDefinition:
1119     {
1120         OMX_PARAM_PORTDEFINITIONTYPE *portDefinition = (OMX_PARAM_PORTDEFINITIONTYPE *)ComponentParameterStructure;
1121         OMX_U32                       portIndex = portDefinition->nPortIndex;
1122         EXYNOS_OMX_BASEPORT          *pExynosPort;
1123         OMX_PARAM_PORTDEFINITIONTYPE  portDefinition_backup;
1124
1125         if (portIndex >= pExynosComponent->portParam.nPorts) {
1126             ret = OMX_ErrorBadPortIndex;
1127             goto EXIT;
1128         }
1129         ret = Exynos_OMX_Check_SizeVersion(portDefinition, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1130         if (ret != OMX_ErrorNone) {
1131             goto EXIT;
1132         }
1133
1134         pExynosPort = &pExynosComponent->pExynosPort[portIndex];
1135
1136         if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1137             if (pExynosPort->portDefinition.bEnabled == OMX_TRUE) {
1138                 ret = OMX_ErrorIncorrectStateOperation;
1139                 goto EXIT;
1140             }
1141         }
1142         if (portDefinition->nBufferCountActual < pExynosPort->portDefinition.nBufferCountMin) {
1143             ret = OMX_ErrorBadParameter;
1144             goto EXIT;
1145         }
1146
1147         Exynos_OSAL_Memcpy(&portDefinition_backup, &pExynosPort->portDefinition, portDefinition->nSize);
1148         Exynos_OSAL_Memcpy(&pExynosPort->portDefinition, portDefinition, portDefinition->nSize);
1149         RESTORE_READONLYPARAMETERS_OMX_PARAM_PORTDEFINITIONTYPE(&pExynosPort->portDefinition,&portDefinition_backup);
1150     }
1151         break;
1152     case OMX_IndexParamPriorityMgmt:
1153     {
1154         OMX_PRIORITYMGMTTYPE *compPriority = (OMX_PRIORITYMGMTTYPE *)ComponentParameterStructure;
1155
1156         if ((pExynosComponent->currentState != OMX_StateLoaded) &&
1157             (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1158             ret = OMX_ErrorIncorrectStateOperation;
1159             goto EXIT;
1160         }
1161
1162         ret = Exynos_OMX_Check_SizeVersion(compPriority, sizeof(OMX_PRIORITYMGMTTYPE));
1163         if (ret != OMX_ErrorNone) {
1164             goto EXIT;
1165         }
1166
1167         pExynosComponent->compPriority.nGroupID = compPriority->nGroupID;
1168         pExynosComponent->compPriority.nGroupPriority = compPriority->nGroupPriority;
1169     }
1170         break;
1171     case OMX_IndexParamCompBufferSupplier:
1172     {
1173         OMX_PARAM_BUFFERSUPPLIERTYPE *bufferSupplier = (OMX_PARAM_BUFFERSUPPLIERTYPE *)ComponentParameterStructure;
1174         OMX_U32           portIndex = bufferSupplier->nPortIndex;
1175         EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1176
1177
1178         if (portIndex >= pExynosComponent->portParam.nPorts) {
1179             ret = OMX_ErrorBadPortIndex;
1180             goto EXIT;
1181         }
1182         ret = Exynos_OMX_Check_SizeVersion(bufferSupplier, sizeof(OMX_PARAM_BUFFERSUPPLIERTYPE));
1183         if (ret != OMX_ErrorNone) {
1184             goto EXIT;
1185         }
1186
1187         pExynosPort = &pExynosComponent->pExynosPort[portIndex];
1188         if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1189             if (pExynosPort->portDefinition.bEnabled == OMX_TRUE) {
1190                 ret = OMX_ErrorIncorrectStateOperation;
1191                 goto EXIT;
1192             }
1193         }
1194
1195         if (bufferSupplier->eBufferSupplier == OMX_BufferSupplyUnspecified) {
1196             ret = OMX_ErrorNone;
1197             goto EXIT;
1198         }
1199         if (CHECK_PORT_TUNNELED(pExynosPort) == 0) {
1200             ret = OMX_ErrorNone; /*OMX_ErrorNone ?????*/
1201             goto EXIT;
1202         }
1203
1204         if (pExynosPort->portDefinition.eDir == OMX_DirInput) {
1205             if (bufferSupplier->eBufferSupplier == OMX_BufferSupplyInput) {
1206                 /*
1207                 if (CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)) {
1208                     ret = OMX_ErrorNone;
1209                 }
1210                 */
1211                 pExynosPort->tunnelFlags |= EXYNOS_TUNNEL_IS_SUPPLIER;
1212                 bufferSupplier->nPortIndex = pExynosPort->tunneledPort;
1213                 ret = OMX_SetParameter(pExynosPort->tunneledComponent, OMX_IndexParamCompBufferSupplier, bufferSupplier);
1214                 goto EXIT;
1215             } else if (bufferSupplier->eBufferSupplier == OMX_BufferSupplyOutput) {
1216                 ret = OMX_ErrorNone;
1217                 if (CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)) {
1218                     pExynosPort->tunnelFlags &= ~EXYNOS_TUNNEL_IS_SUPPLIER;
1219                     bufferSupplier->nPortIndex = pExynosPort->tunneledPort;
1220                     ret = OMX_SetParameter(pExynosPort->tunneledComponent, OMX_IndexParamCompBufferSupplier, bufferSupplier);
1221                 }
1222                 goto EXIT;
1223             }
1224         } else if (pExynosPort->portDefinition.eDir == OMX_DirOutput) {
1225             if (bufferSupplier->eBufferSupplier == OMX_BufferSupplyInput) {
1226                 ret = OMX_ErrorNone;
1227                 if (CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)) {
1228                     pExynosPort->tunnelFlags &= ~EXYNOS_TUNNEL_IS_SUPPLIER;
1229                     ret = OMX_ErrorNone;
1230                 }
1231                 goto EXIT;
1232             } else if (bufferSupplier->eBufferSupplier == OMX_BufferSupplyOutput) {
1233                 /*
1234                 if (CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)) {
1235                     ret = OMX_ErrorNone;
1236                 }
1237                 */
1238                 pExynosPort->tunnelFlags |= EXYNOS_TUNNEL_IS_SUPPLIER;
1239                 ret = OMX_ErrorNone;
1240                 goto EXIT;
1241             }
1242         }
1243     }
1244         break;
1245     default:
1246     {
1247         ret = OMX_ErrorUnsupportedIndex;
1248         goto EXIT;
1249     }
1250         break;
1251     }
1252
1253     ret = OMX_ErrorNone;
1254
1255 EXIT:
1256
1257     FunctionOut();
1258
1259     return ret;
1260 }
1261
1262 OMX_ERRORTYPE Exynos_OMX_GetConfig(
1263     OMX_IN OMX_HANDLETYPE hComponent,
1264     OMX_IN OMX_INDEXTYPE  nIndex,
1265     OMX_INOUT OMX_PTR     pComponentConfigStructure)
1266 {
1267     OMX_ERRORTYPE             ret = OMX_ErrorNone;
1268     OMX_COMPONENTTYPE        *pOMXComponent = NULL;
1269     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1270
1271     FunctionIn();
1272
1273     if (hComponent == NULL) {
1274         ret = OMX_ErrorBadParameter;
1275         goto EXIT;
1276     }
1277     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1278     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1279     if (ret != OMX_ErrorNone) {
1280         goto EXIT;
1281     }
1282
1283     if (pOMXComponent->pComponentPrivate == NULL) {
1284         ret = OMX_ErrorBadParameter;
1285         goto EXIT;
1286     }
1287     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1288
1289     if (pComponentConfigStructure == NULL) {
1290         ret = OMX_ErrorBadParameter;
1291         goto EXIT;
1292     }
1293     if (pExynosComponent->currentState == OMX_StateInvalid) {
1294         ret = OMX_ErrorInvalidState;
1295         goto EXIT;
1296     }
1297
1298     switch (nIndex) {
1299     default:
1300         ret = OMX_ErrorUnsupportedIndex;
1301         break;
1302     }
1303
1304 EXIT:
1305     FunctionOut();
1306
1307     return ret;
1308 }
1309
1310 OMX_ERRORTYPE Exynos_OMX_SetConfig(
1311     OMX_IN OMX_HANDLETYPE hComponent,
1312     OMX_IN OMX_INDEXTYPE  nIndex,
1313     OMX_IN OMX_PTR        pComponentConfigStructure)
1314 {
1315     OMX_ERRORTYPE             ret = OMX_ErrorNone;
1316     OMX_COMPONENTTYPE        *pOMXComponent = NULL;
1317     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1318
1319     FunctionIn();
1320
1321     if (hComponent == NULL) {
1322         ret = OMX_ErrorBadParameter;
1323         goto EXIT;
1324     }
1325     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1326     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1327     if (ret != OMX_ErrorNone) {
1328         goto EXIT;
1329     }
1330
1331     if (pOMXComponent->pComponentPrivate == NULL) {
1332         ret = OMX_ErrorBadParameter;
1333         goto EXIT;
1334     }
1335     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1336
1337     if (pComponentConfigStructure == NULL) {
1338         ret = OMX_ErrorBadParameter;
1339         goto EXIT;
1340     }
1341     if (pExynosComponent->currentState == OMX_StateInvalid) {
1342         ret = OMX_ErrorInvalidState;
1343         goto EXIT;
1344     }
1345
1346     switch (nIndex) {
1347     default:
1348         ret = OMX_ErrorUnsupportedIndex;
1349         break;
1350     }
1351
1352 EXIT:
1353     FunctionOut();
1354
1355     return ret;
1356 }
1357
1358 OMX_ERRORTYPE Exynos_OMX_GetExtensionIndex(
1359     OMX_IN OMX_HANDLETYPE  hComponent,
1360     OMX_IN OMX_STRING      cParameterName,
1361     OMX_OUT OMX_INDEXTYPE *pIndexType)
1362 {
1363     OMX_ERRORTYPE             ret = OMX_ErrorNone;
1364     OMX_COMPONENTTYPE        *pOMXComponent = NULL;
1365     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1366
1367     FunctionIn();
1368
1369     if (hComponent == NULL) {
1370         ret = OMX_ErrorBadParameter;
1371         goto EXIT;
1372     }
1373     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1374     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1375     if (ret != OMX_ErrorNone) {
1376         goto EXIT;
1377     }
1378
1379     if (pOMXComponent->pComponentPrivate == NULL) {
1380         ret = OMX_ErrorBadParameter;
1381         goto EXIT;
1382     }
1383     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1384
1385     if ((cParameterName == NULL) || (pIndexType == NULL)) {
1386         ret = OMX_ErrorBadParameter;
1387         goto EXIT;
1388     }
1389     if (pExynosComponent->currentState == OMX_StateInvalid) {
1390         ret = OMX_ErrorInvalidState;
1391         goto EXIT;
1392     }
1393
1394     ret = OMX_ErrorBadParameter;
1395
1396 EXIT:
1397     FunctionOut();
1398
1399     return ret;
1400 }
1401
1402 OMX_ERRORTYPE Exynos_OMX_SetCallbacks (
1403     OMX_IN OMX_HANDLETYPE    hComponent,
1404     OMX_IN OMX_CALLBACKTYPE* pCallbacks,
1405     OMX_IN OMX_PTR           pAppData)
1406 {
1407     OMX_ERRORTYPE             ret = OMX_ErrorNone;
1408     OMX_COMPONENTTYPE        *pOMXComponent = NULL;
1409     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1410
1411     FunctionIn();
1412
1413     if (hComponent == NULL) {
1414         ret = OMX_ErrorBadParameter;
1415         goto EXIT;
1416     }
1417     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1418     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1419     if (ret != OMX_ErrorNone) {
1420         goto EXIT;
1421     }
1422
1423     if (pOMXComponent->pComponentPrivate == NULL) {
1424         ret = OMX_ErrorBadParameter;
1425         goto EXIT;
1426     }
1427     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1428
1429     if (pCallbacks == NULL) {
1430         ret = OMX_ErrorBadParameter;
1431         goto EXIT;
1432     }
1433     if (pExynosComponent->currentState == OMX_StateInvalid) {
1434         ret = OMX_ErrorInvalidState;
1435         goto EXIT;
1436     }
1437     if (pExynosComponent->currentState != OMX_StateLoaded) {
1438         ret = OMX_ErrorIncorrectStateOperation;
1439         goto EXIT;
1440     }
1441
1442     pExynosComponent->pCallbacks = pCallbacks;
1443     pExynosComponent->callbackData = pAppData;
1444
1445     ret = OMX_ErrorNone;
1446
1447 EXIT:
1448     FunctionOut();
1449
1450     return ret;
1451 }
1452
1453 OMX_ERRORTYPE Exynos_OMX_UseEGLImage(
1454     OMX_IN OMX_HANDLETYPE            hComponent,
1455     OMX_INOUT OMX_BUFFERHEADERTYPE **ppBufferHdr,
1456     OMX_IN OMX_U32                   nPortIndex,
1457     OMX_IN OMX_PTR                   pAppPrivate,
1458     OMX_IN void                     *eglImage)
1459 {
1460     return OMX_ErrorNotImplemented;
1461 }
1462
1463 OMX_ERRORTYPE Exynos_OMX_BaseComponent_Constructor(
1464     OMX_IN OMX_HANDLETYPE hComponent)
1465 {
1466     OMX_ERRORTYPE             ret = OMX_ErrorNone;
1467     OMX_COMPONENTTYPE        *pOMXComponent;
1468     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1469
1470     FunctionIn();
1471
1472     if (hComponent == NULL) {
1473         ret = OMX_ErrorBadParameter;
1474         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
1475         goto EXIT;
1476     }
1477     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1478     pExynosComponent = Exynos_OSAL_Malloc(sizeof(EXYNOS_OMX_BASECOMPONENT));
1479     if (pExynosComponent == NULL) {
1480         ret = OMX_ErrorInsufficientResources;
1481         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
1482         goto EXIT;
1483     }
1484     Exynos_OSAL_Memset(pExynosComponent, 0, sizeof(EXYNOS_OMX_BASECOMPONENT));
1485     pOMXComponent->pComponentPrivate = (OMX_PTR)pExynosComponent;
1486
1487     ret = Exynos_OSAL_SemaphoreCreate(&pExynosComponent->msgSemaphoreHandle);
1488     if (ret != OMX_ErrorNone) {
1489         ret = OMX_ErrorInsufficientResources;
1490         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
1491         goto EXIT;
1492     }
1493     ret = Exynos_OSAL_MutexCreate(&pExynosComponent->compMutex);
1494     if (ret != OMX_ErrorNone) {
1495         ret = OMX_ErrorInsufficientResources;
1496         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
1497         goto EXIT;
1498     }
1499
1500     pExynosComponent->bExitMessageHandlerThread = OMX_FALSE;
1501     Exynos_OSAL_QueueCreate(&pExynosComponent->messageQ, MAX_QUEUE_ELEMENTS);
1502     ret = Exynos_OSAL_ThreadCreate(&pExynosComponent->hMessageHandler, Exynos_OMX_MessageHandlerThread, pOMXComponent);
1503     if (ret != OMX_ErrorNone) {
1504         ret = OMX_ErrorInsufficientResources;
1505         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
1506         goto EXIT;
1507     }
1508
1509     pExynosComponent->bMultiThreadProcess = OMX_FALSE;
1510
1511     pOMXComponent->GetComponentVersion = &Exynos_OMX_GetComponentVersion;
1512     pOMXComponent->SendCommand         = &Exynos_OMX_SendCommand;
1513     pOMXComponent->GetState            = &Exynos_OMX_GetState;
1514     pOMXComponent->SetCallbacks        = &Exynos_OMX_SetCallbacks;
1515     pOMXComponent->UseEGLImage         = &Exynos_OMX_UseEGLImage;
1516
1517 EXIT:
1518     FunctionOut();
1519
1520     return ret;
1521 }
1522
1523 OMX_ERRORTYPE Exynos_OMX_BaseComponent_Destructor(
1524     OMX_IN OMX_HANDLETYPE hComponent)
1525 {
1526     OMX_ERRORTYPE             ret = OMX_ErrorNone;
1527     OMX_COMPONENTTYPE        *pOMXComponent = NULL;
1528     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1529     OMX_S32                   semaValue = 0;
1530
1531     FunctionIn();
1532
1533     if (hComponent == NULL) {
1534         ret = OMX_ErrorBadParameter;
1535         goto EXIT;
1536     }
1537     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1538     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1539     if (ret != OMX_ErrorNone) {
1540         goto EXIT;
1541     }
1542
1543     if (pOMXComponent->pComponentPrivate == NULL) {
1544         ret = OMX_ErrorBadParameter;
1545         goto EXIT;
1546     }
1547     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1548
1549     Exynos_OMX_CommandQueue(pExynosComponent, EXYNOS_OMX_CommandComponentDeInit, 0, NULL);
1550     Exynos_OSAL_SleepMillisec(0);
1551     Exynos_OSAL_Get_SemaphoreCount(pExynosComponent->msgSemaphoreHandle, &semaValue);
1552     if (semaValue == 0)
1553         Exynos_OSAL_SemaphorePost(pExynosComponent->msgSemaphoreHandle);
1554     Exynos_OSAL_SemaphorePost(pExynosComponent->msgSemaphoreHandle);
1555
1556     Exynos_OSAL_ThreadTerminate(pExynosComponent->hMessageHandler);
1557     pExynosComponent->hMessageHandler = NULL;
1558
1559     Exynos_OSAL_MutexTerminate(pExynosComponent->compMutex);
1560     pExynosComponent->compMutex = NULL;
1561     Exynos_OSAL_SemaphoreTerminate(pExynosComponent->msgSemaphoreHandle);
1562     pExynosComponent->msgSemaphoreHandle = NULL;
1563     Exynos_OSAL_QueueTerminate(&pExynosComponent->messageQ);
1564
1565     Exynos_OSAL_Free(pExynosComponent);
1566     pExynosComponent = NULL;
1567
1568     ret = OMX_ErrorNone;
1569 EXIT:
1570     FunctionOut();
1571
1572     return ret;
1573 }
1574
1575