3 * Copyright 2012 Samsung Electronics S.LSI Co. LTD
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
9 * http://www.apache.org/licenses/LICENSE-2.0
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.
19 * @file Exynos_OMX_Baseport.c
21 * @author SeungBeom Kim (sbcrux.kim@samsung.com)
22 * HyeYeon Chung (hyeon.chung@samsung.com)
32 #include "Exynos_OMX_Macros.h"
33 #include "Exynos_OSAL_Event.h"
34 #include "Exynos_OSAL_Semaphore.h"
35 #include "Exynos_OSAL_Mutex.h"
37 #include "Exynos_OMX_Baseport.h"
38 #include "Exynos_OMX_Basecomponent.h"
41 #define EXYNOS_LOG_TAG "EXYNOS_BASE_PORT"
42 #define EXYNOS_LOG_OFF
43 //#define EXYNOS_TRACE_ON
44 #include "Exynos_OSAL_Log.h"
47 OMX_ERRORTYPE Exynos_OMX_InputBufferReturn(OMX_COMPONENTTYPE *pOMXComponent, OMX_BUFFERHEADERTYPE* bufferHeader)
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];
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;
61 Exynos_OSAL_MutexUnlock(pExynosPort->hPortMutex);
63 if ((bufferHeader != NULL) && (bufferHeader->pBuffer != NULL))
65 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "%s : %d EmptyBufferDone", __FUNCTION__, __LINE__);
66 pExynosComponent->pCallbacks->EmptyBufferDone(pOMXComponent, pExynosComponent->callbackData, bufferHeader);
72 OMX_ERRORTYPE Exynos_OMX_OutputBufferReturn(OMX_COMPONENTTYPE *pOMXComponent, OMX_BUFFERHEADERTYPE* bufferHeader)
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];
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;
87 Exynos_OSAL_MutexUnlock(pExynosPort->hPortMutex);
89 if ((bufferHeader != NULL) && (bufferHeader->pBuffer != NULL))
91 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "%s : %d FillBufferDone", __FUNCTION__, __LINE__);
92 pExynosComponent->pCallbacks->FillBufferDone(pOMXComponent, pExynosComponent->callbackData, bufferHeader);
98 OMX_ERRORTYPE Exynos_OMX_BufferFlushProcess(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 nPortIndex, OMX_BOOL bEvent)
100 OMX_ERRORTYPE ret = OMX_ErrorNone;
101 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
102 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
103 OMX_S32 portIndex = 0;
104 EXYNOS_OMX_DATABUFFER *flushPortBuffer[2] = {NULL, NULL};
105 OMX_U32 i = 0, cnt = 0;
109 if (pOMXComponent == NULL) {
110 ret = OMX_ErrorBadParameter;
113 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
114 if (ret != OMX_ErrorNone) {
118 if (pOMXComponent->pComponentPrivate == NULL) {
119 ret = OMX_ErrorBadParameter;
122 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
124 cnt = (nPortIndex == ALL_PORT_INDEX ) ? ALL_PORT_NUM : 1;
127 Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "bufferFlushProcess cnt:%d port:%d", cnt, nPortIndex);
130 for (i = 0; i < cnt; i++) {
131 if (nPortIndex == ALL_PORT_INDEX)
134 portIndex = nPortIndex;
136 pExynosComponent->exynos_BufferFlush(pOMXComponent, portIndex, bEvent);
140 if (ret != OMX_ErrorNone) {
141 Exynos_OSAL_Log(EXYNOS_LOG_ERROR,"%s : %d", __FUNCTION__, __LINE__);
143 if ((pOMXComponent != NULL) && (pExynosComponent != NULL)) {
144 pExynosComponent->pCallbacks->EventHandler(pOMXComponent, pExynosComponent->callbackData, OMX_EventError, ret, 0, NULL);
153 OMX_ERRORTYPE Exynos_OMX_EnablePort(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 portIndex)
155 OMX_ERRORTYPE ret = OMX_ErrorNone;
156 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
157 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
158 OMX_U32 i = 0, cnt = 0;
162 Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "enablePort idx:%d", portIndex);
165 pExynosPort = &pExynosComponent->pExynosPort[portIndex];
167 if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
168 Exynos_OSAL_SemaphoreWait(pExynosPort->loadedResource);
169 pExynosPort->portDefinition.bPopulated = OMX_TRUE;
171 pExynosPort->exceptionFlag = GENERAL_STATE;
172 pExynosPort->portDefinition.bEnabled = OMX_TRUE;
182 OMX_ERRORTYPE Exynos_OMX_PortEnableProcess(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 nPortIndex)
184 OMX_ERRORTYPE ret = OMX_ErrorNone;
185 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
186 OMX_S32 portIndex = 0;
187 OMX_U32 i = 0, cnt = 0;
191 if (pOMXComponent == NULL) {
192 ret = OMX_ErrorBadParameter;
195 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
196 if (ret != OMX_ErrorNone) {
200 if (pOMXComponent->pComponentPrivate == NULL) {
201 ret = OMX_ErrorBadParameter;
204 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
206 cnt = (nPortIndex == ALL_PORT_INDEX) ? ALL_PORT_NUM : 1;
209 Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "portEnableProcess cnt:%d port:%d", cnt, nPortIndex);
212 for (i = 0; i < cnt; i++) {
213 if (nPortIndex == ALL_PORT_INDEX)
216 portIndex = nPortIndex;
218 ret = Exynos_OMX_EnablePort(pOMXComponent, portIndex);
219 if (ret == OMX_ErrorNone) {
220 pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
221 pExynosComponent->callbackData,
222 OMX_EventCmdComplete,
223 OMX_CommandPortEnable, portIndex, NULL);
228 if ((ret != OMX_ErrorNone) && (pOMXComponent != NULL) && (pExynosComponent != NULL)) {
229 pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
230 pExynosComponent->callbackData,
240 OMX_ERRORTYPE Exynos_OMX_DisablePort(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 portIndex)
242 OMX_ERRORTYPE ret = OMX_ErrorNone;
243 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
244 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
245 OMX_U32 i = 0, elemNum = 0;
246 EXYNOS_OMX_MESSAGE *message;
250 Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "disablePort idx:%d", portIndex);
253 pExynosPort = &pExynosComponent->pExynosPort[portIndex];
255 if (!CHECK_PORT_ENABLED(pExynosPort)) {
260 if (pExynosComponent->currentState != OMX_StateLoaded) {
261 if (CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)) {
262 while (Exynos_OSAL_GetElemNum(&pExynosPort->bufferQ) > 0) {
263 message = (EXYNOS_OMX_MESSAGE*)Exynos_OSAL_Dequeue(&pExynosPort->bufferQ);
264 Exynos_OSAL_Free(message);
267 pExynosPort->portDefinition.bPopulated = OMX_FALSE;
268 Exynos_OSAL_SemaphoreWait(pExynosPort->unloadedResource);
270 pExynosPort->portDefinition.bEnabled = OMX_FALSE;
279 OMX_ERRORTYPE Exynos_OMX_PortDisableProcess(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 nPortIndex)
281 OMX_ERRORTYPE ret = OMX_ErrorNone;
282 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
283 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
284 OMX_S32 portIndex = 0;
285 OMX_U32 i = 0, cnt = 0;
286 EXYNOS_OMX_DATABUFFER *flushPortBuffer[2] = {NULL, NULL};
290 if (pOMXComponent == NULL) {
291 ret = OMX_ErrorBadParameter;
294 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
295 if (ret != OMX_ErrorNone) {
299 if (pOMXComponent->pComponentPrivate == NULL) {
300 ret = OMX_ErrorBadParameter;
303 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
305 cnt = (nPortIndex == ALL_PORT_INDEX ) ? ALL_PORT_NUM : 1;
308 Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "portDisableProcess cnt:%d port:%d", cnt, nPortIndex);
312 for(i = 0; i < cnt; i++) {
313 if (nPortIndex == ALL_PORT_INDEX)
316 portIndex = nPortIndex;
318 Exynos_OMX_BufferFlushProcess(pOMXComponent, portIndex, OMX_FALSE);
321 for(i = 0; i < cnt; i++) {
322 if (nPortIndex == ALL_PORT_INDEX)
325 portIndex = nPortIndex;
327 ret = Exynos_OMX_DisablePort(pOMXComponent, portIndex);
328 pExynosComponent->pExynosPort[portIndex].bIsPortDisabled = OMX_FALSE;
329 if (ret == OMX_ErrorNone) {
330 pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
331 pExynosComponent->callbackData,
332 OMX_EventCmdComplete,
333 OMX_CommandPortDisable, portIndex, NULL);
338 if ((ret != OMX_ErrorNone) && (pOMXComponent != NULL) && (pExynosComponent != NULL)) {
339 pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
340 pExynosComponent->callbackData,
350 OMX_ERRORTYPE Exynos_OMX_EmptyThisBuffer(
351 OMX_IN OMX_HANDLETYPE hComponent,
352 OMX_IN OMX_BUFFERHEADERTYPE *pBuffer)
354 OMX_ERRORTYPE ret = OMX_ErrorNone;
355 OMX_COMPONENTTYPE *pOMXComponent = NULL;
356 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
357 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
358 OMX_BOOL findBuffer = OMX_FALSE;
359 EXYNOS_OMX_MESSAGE *message;
364 if (hComponent == NULL) {
365 ret = OMX_ErrorBadParameter;
368 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
369 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
370 if (ret != OMX_ErrorNone) {
374 if (pOMXComponent->pComponentPrivate == NULL) {
375 ret = OMX_ErrorBadParameter;
378 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
379 if (pExynosComponent->currentState == OMX_StateInvalid) {
380 ret = OMX_ErrorInvalidState;
384 if (pBuffer == NULL) {
385 ret = OMX_ErrorBadParameter;
388 if (pBuffer->nInputPortIndex != INPUT_PORT_INDEX) {
389 ret = OMX_ErrorBadPortIndex;
393 ret = Exynos_OMX_Check_SizeVersion(pBuffer, sizeof(OMX_BUFFERHEADERTYPE));
394 if (ret != OMX_ErrorNone) {
398 if ((pExynosComponent->currentState != OMX_StateIdle) &&
399 (pExynosComponent->currentState != OMX_StateExecuting) &&
400 (pExynosComponent->currentState != OMX_StatePause)) {
401 ret = OMX_ErrorIncorrectStateOperation;
405 pExynosPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
406 if ((!CHECK_PORT_ENABLED(pExynosPort)) ||
407 ((CHECK_PORT_BEING_FLUSHED(pExynosPort) || CHECK_PORT_BEING_DISABLED(pExynosPort)) &&
408 (!CHECK_PORT_TUNNELED(pExynosPort) || !CHECK_PORT_BUFFER_SUPPLIER(pExynosPort))) ||
409 ((pExynosComponent->transientState == EXYNOS_OMX_TransStateExecutingToIdle) &&
410 (CHECK_PORT_TUNNELED(pExynosPort) && !CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)))) {
411 ret = OMX_ErrorIncorrectStateOperation;
415 Exynos_OSAL_MutexLock(pExynosPort->hPortMutex);
416 for (i = 0; i < pExynosPort->portDefinition.nBufferCountActual; i++) {
417 if (pBuffer == pExynosPort->extendBufferHeader[i].OMXBufferHeader) {
418 pExynosPort->extendBufferHeader[i].bBufferInOMX = OMX_TRUE;
419 findBuffer = OMX_TRUE;
424 if (findBuffer == OMX_FALSE) {
425 ret = OMX_ErrorBadParameter;
426 Exynos_OSAL_MutexUnlock(pExynosPort->hPortMutex);
430 message = Exynos_OSAL_Malloc(sizeof(EXYNOS_OMX_MESSAGE));
431 if (message == NULL) {
432 ret = OMX_ErrorInsufficientResources;
433 Exynos_OSAL_MutexUnlock(pExynosPort->hPortMutex);
436 message->messageType = EXYNOS_OMX_CommandEmptyBuffer;
437 message->messageParam = (OMX_U32) i;
438 message->pCmdData = (OMX_PTR)pBuffer;
440 ret = Exynos_OSAL_Queue(&pExynosPort->bufferQ, (void *)message);
442 ret = OMX_ErrorUndefined;
443 Exynos_OSAL_MutexUnlock(pExynosPort->hPortMutex);
446 ret = Exynos_OSAL_SemaphorePost(pExynosPort->bufferSemID);
447 Exynos_OSAL_MutexUnlock(pExynosPort->hPortMutex);
455 OMX_ERRORTYPE Exynos_OMX_FillThisBuffer(
456 OMX_IN OMX_HANDLETYPE hComponent,
457 OMX_IN OMX_BUFFERHEADERTYPE *pBuffer)
459 OMX_ERRORTYPE ret = OMX_ErrorNone;
460 OMX_COMPONENTTYPE *pOMXComponent = NULL;
461 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
462 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
463 OMX_BOOL findBuffer = OMX_FALSE;
464 EXYNOS_OMX_MESSAGE *message;
469 if (hComponent == NULL) {
470 ret = OMX_ErrorBadParameter;
473 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
474 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
475 if (ret != OMX_ErrorNone) {
479 if (pOMXComponent->pComponentPrivate == NULL) {
480 ret = OMX_ErrorBadParameter;
483 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
484 if (pExynosComponent->currentState == OMX_StateInvalid) {
485 ret = OMX_ErrorInvalidState;
489 if (pBuffer == NULL) {
490 ret = OMX_ErrorBadParameter;
493 if (pBuffer->nOutputPortIndex != OUTPUT_PORT_INDEX) {
494 ret = OMX_ErrorBadPortIndex;
498 ret = Exynos_OMX_Check_SizeVersion(pBuffer, sizeof(OMX_BUFFERHEADERTYPE));
499 if (ret != OMX_ErrorNone) {
503 if ((pExynosComponent->currentState != OMX_StateIdle) &&
504 (pExynosComponent->currentState != OMX_StateExecuting) &&
505 (pExynosComponent->currentState != OMX_StatePause)) {
506 ret = OMX_ErrorIncorrectStateOperation;
510 pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
511 if ((!CHECK_PORT_ENABLED(pExynosPort)) ||
512 ((CHECK_PORT_BEING_FLUSHED(pExynosPort) || CHECK_PORT_BEING_DISABLED(pExynosPort)) &&
513 (!CHECK_PORT_TUNNELED(pExynosPort) || !CHECK_PORT_BUFFER_SUPPLIER(pExynosPort))) ||
514 ((pExynosComponent->transientState == EXYNOS_OMX_TransStateExecutingToIdle) &&
515 (CHECK_PORT_TUNNELED(pExynosPort) && !CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)))) {
516 ret = OMX_ErrorIncorrectStateOperation;
520 Exynos_OSAL_MutexLock(pExynosPort->hPortMutex);
521 for (i = 0; i < pExynosPort->portDefinition.nBufferCountActual; i++) {
522 if (pBuffer == pExynosPort->extendBufferHeader[i].OMXBufferHeader) {
523 pExynosPort->extendBufferHeader[i].bBufferInOMX = OMX_TRUE;
524 findBuffer = OMX_TRUE;
529 if (findBuffer == OMX_FALSE) {
530 ret = OMX_ErrorBadParameter;
531 Exynos_OSAL_MutexUnlock(pExynosPort->hPortMutex);
535 message = Exynos_OSAL_Malloc(sizeof(EXYNOS_OMX_MESSAGE));
536 if (message == NULL) {
537 ret = OMX_ErrorInsufficientResources;
538 Exynos_OSAL_MutexUnlock(pExynosPort->hPortMutex);
541 message->messageType = EXYNOS_OMX_CommandFillBuffer;
542 message->messageParam = (OMX_U32) i;
543 message->pCmdData = (OMX_PTR)pBuffer;
545 ret = Exynos_OSAL_Queue(&pExynosPort->bufferQ, (void *)message);
547 ret = OMX_ErrorUndefined;
548 Exynos_OSAL_MutexUnlock(pExynosPort->hPortMutex);
552 ret = Exynos_OSAL_SemaphorePost(pExynosPort->bufferSemID);
553 Exynos_OSAL_MutexUnlock(pExynosPort->hPortMutex);
561 OMX_ERRORTYPE Exynos_OMX_Port_Constructor(OMX_HANDLETYPE hComponent)
563 OMX_ERRORTYPE ret = OMX_ErrorNone;
564 OMX_COMPONENTTYPE *pOMXComponent = NULL;
565 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
566 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
567 EXYNOS_OMX_BASEPORT *pExynosInputPort = NULL;
568 EXYNOS_OMX_BASEPORT *pExynosOutputPort = NULL;
573 if (hComponent == NULL) {
574 ret = OMX_ErrorBadParameter;
575 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
578 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
579 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
580 if (ret != OMX_ErrorNone) {
584 if (pOMXComponent->pComponentPrivate == NULL) {
585 ret = OMX_ErrorBadParameter;
586 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
589 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
591 INIT_SET_SIZE_VERSION(&pExynosComponent->portParam, OMX_PORT_PARAM_TYPE);
592 pExynosComponent->portParam.nPorts = ALL_PORT_NUM;
593 pExynosComponent->portParam.nStartPortNumber = INPUT_PORT_INDEX;
595 pExynosPort = Exynos_OSAL_Malloc(sizeof(EXYNOS_OMX_BASEPORT) * ALL_PORT_NUM);
596 if (pExynosPort == NULL) {
597 ret = OMX_ErrorInsufficientResources;
598 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
601 Exynos_OSAL_Memset(pExynosPort, 0, sizeof(EXYNOS_OMX_BASEPORT) * ALL_PORT_NUM);
602 pExynosComponent->pExynosPort = pExynosPort;
605 pExynosInputPort = &pExynosPort[INPUT_PORT_INDEX];
607 Exynos_OSAL_QueueCreate(&pExynosInputPort->bufferQ, MAX_QUEUE_ELEMENTS);
609 pExynosInputPort->extendBufferHeader = Exynos_OSAL_Malloc(sizeof(EXYNOS_OMX_BUFFERHEADERTYPE) * MAX_BUFFER_NUM);
610 if (pExynosInputPort->extendBufferHeader == NULL) {
611 Exynos_OSAL_Free(pExynosPort);
613 ret = OMX_ErrorInsufficientResources;
614 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
617 Exynos_OSAL_Memset(pExynosInputPort->extendBufferHeader, 0, sizeof(EXYNOS_OMX_BUFFERHEADERTYPE) * MAX_BUFFER_NUM);
619 pExynosInputPort->bufferStateAllocate = Exynos_OSAL_Malloc(sizeof(OMX_U32) * MAX_BUFFER_NUM);
620 if (pExynosInputPort->bufferStateAllocate == NULL) {
621 Exynos_OSAL_Free(pExynosInputPort->extendBufferHeader);
622 pExynosInputPort->extendBufferHeader = NULL;
623 Exynos_OSAL_Free(pExynosPort);
625 ret = OMX_ErrorInsufficientResources;
626 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
629 Exynos_OSAL_Memset(pExynosInputPort->bufferStateAllocate, 0, sizeof(OMX_U32) * MAX_BUFFER_NUM);
631 pExynosInputPort->bufferSemID = NULL;
632 pExynosInputPort->assignedBufferNum = 0;
633 pExynosInputPort->portState = OMX_StateMax;
634 pExynosInputPort->bIsPortFlushed = OMX_FALSE;
635 pExynosInputPort->bIsPortDisabled = OMX_FALSE;
636 pExynosInputPort->tunneledComponent = NULL;
637 pExynosInputPort->tunneledPort = 0;
638 pExynosInputPort->tunnelBufferNum = 0;
639 pExynosInputPort->bufferSupplier = OMX_BufferSupplyUnspecified;
640 pExynosInputPort->tunnelFlags = 0;
641 ret = Exynos_OSAL_SemaphoreCreate(&pExynosInputPort->loadedResource);
642 if (ret != OMX_ErrorNone) {
643 Exynos_OSAL_Free(pExynosInputPort->bufferStateAllocate);
644 pExynosInputPort->bufferStateAllocate = NULL;
645 Exynos_OSAL_Free(pExynosInputPort->extendBufferHeader);
646 pExynosInputPort->extendBufferHeader = NULL;
647 Exynos_OSAL_Free(pExynosPort);
651 ret = Exynos_OSAL_SemaphoreCreate(&pExynosInputPort->unloadedResource);
652 if (ret != OMX_ErrorNone) {
653 Exynos_OSAL_SemaphoreTerminate(pExynosInputPort->loadedResource);
654 pExynosInputPort->loadedResource = NULL;
655 Exynos_OSAL_Free(pExynosInputPort->bufferStateAllocate);
656 pExynosInputPort->bufferStateAllocate = NULL;
657 Exynos_OSAL_Free(pExynosInputPort->extendBufferHeader);
658 pExynosInputPort->extendBufferHeader = NULL;
659 Exynos_OSAL_Free(pExynosPort);
664 INIT_SET_SIZE_VERSION(&pExynosInputPort->portDefinition, OMX_PARAM_PORTDEFINITIONTYPE);
665 pExynosInputPort->portDefinition.nPortIndex = INPUT_PORT_INDEX;
666 pExynosInputPort->portDefinition.eDir = OMX_DirInput;
667 pExynosInputPort->portDefinition.nBufferCountActual = 0;
668 pExynosInputPort->portDefinition.nBufferCountMin = 0;
669 pExynosInputPort->portDefinition.nBufferSize = 0;
670 pExynosInputPort->portDefinition.bEnabled = OMX_FALSE;
671 pExynosInputPort->portDefinition.bPopulated = OMX_FALSE;
672 pExynosInputPort->portDefinition.eDomain = OMX_PortDomainMax;
673 pExynosInputPort->portDefinition.bBuffersContiguous = OMX_FALSE;
674 pExynosInputPort->portDefinition.nBufferAlignment = 0;
675 pExynosInputPort->markType.hMarkTargetComponent = NULL;
676 pExynosInputPort->markType.pMarkData = NULL;
677 pExynosInputPort->exceptionFlag = GENERAL_STATE;
680 pExynosOutputPort = &pExynosPort[OUTPUT_PORT_INDEX];
682 Exynos_OSAL_QueueCreate(&pExynosOutputPort->bufferQ, MAX_QUEUE_ELEMENTS); /* For in case of "Output Buffer Share", MAX ELEMENTS(DPB + EDPB) */
684 pExynosOutputPort->extendBufferHeader = Exynos_OSAL_Malloc(sizeof(EXYNOS_OMX_BUFFERHEADERTYPE) * MAX_BUFFER_NUM);
685 if (pExynosOutputPort->extendBufferHeader == NULL) {
686 Exynos_OSAL_SemaphoreTerminate(pExynosInputPort->unloadedResource);
687 pExynosInputPort->unloadedResource = NULL;
688 Exynos_OSAL_SemaphoreTerminate(pExynosInputPort->loadedResource);
689 pExynosInputPort->loadedResource = NULL;
690 Exynos_OSAL_Free(pExynosInputPort->bufferStateAllocate);
691 pExynosInputPort->bufferStateAllocate = NULL;
692 Exynos_OSAL_Free(pExynosInputPort->extendBufferHeader);
693 pExynosInputPort->extendBufferHeader = NULL;
694 Exynos_OSAL_Free(pExynosPort);
696 ret = OMX_ErrorInsufficientResources;
699 Exynos_OSAL_Memset(pExynosOutputPort->extendBufferHeader, 0, sizeof(EXYNOS_OMX_BUFFERHEADERTYPE) * MAX_BUFFER_NUM);
701 pExynosOutputPort->bufferStateAllocate = Exynos_OSAL_Malloc(sizeof(OMX_U32) * MAX_BUFFER_NUM);
702 if (pExynosOutputPort->bufferStateAllocate == NULL) {
703 Exynos_OSAL_Free(pExynosOutputPort->extendBufferHeader);
704 pExynosOutputPort->extendBufferHeader = NULL;
706 Exynos_OSAL_SemaphoreTerminate(pExynosInputPort->unloadedResource);
707 pExynosInputPort->unloadedResource = NULL;
708 Exynos_OSAL_SemaphoreTerminate(pExynosInputPort->loadedResource);
709 pExynosInputPort->loadedResource = NULL;
710 Exynos_OSAL_Free(pExynosInputPort->bufferStateAllocate);
711 pExynosInputPort->bufferStateAllocate = NULL;
712 Exynos_OSAL_Free(pExynosInputPort->extendBufferHeader);
713 pExynosInputPort->extendBufferHeader = NULL;
714 Exynos_OSAL_Free(pExynosPort);
716 ret = OMX_ErrorInsufficientResources;
719 Exynos_OSAL_Memset(pExynosOutputPort->bufferStateAllocate, 0, sizeof(OMX_U32) * MAX_BUFFER_NUM);
721 pExynosOutputPort->bufferSemID = NULL;
722 pExynosOutputPort->assignedBufferNum = 0;
723 pExynosOutputPort->portState = OMX_StateMax;
724 pExynosOutputPort->bIsPortFlushed = OMX_FALSE;
725 pExynosOutputPort->bIsPortDisabled = OMX_FALSE;
726 pExynosOutputPort->tunneledComponent = NULL;
727 pExynosOutputPort->tunneledPort = 0;
728 pExynosOutputPort->tunnelBufferNum = 0;
729 pExynosOutputPort->bufferSupplier = OMX_BufferSupplyUnspecified;
730 pExynosOutputPort->tunnelFlags = 0;
731 ret = Exynos_OSAL_SemaphoreCreate(&pExynosOutputPort->loadedResource);
732 if (ret != OMX_ErrorNone) {
733 Exynos_OSAL_Free(pExynosOutputPort->bufferStateAllocate);
734 pExynosOutputPort->bufferStateAllocate = NULL;
735 Exynos_OSAL_Free(pExynosOutputPort->extendBufferHeader);
736 pExynosOutputPort->extendBufferHeader = NULL;
738 Exynos_OSAL_SemaphoreTerminate(pExynosInputPort->unloadedResource);
739 pExynosInputPort->unloadedResource = NULL;
740 Exynos_OSAL_SemaphoreTerminate(pExynosInputPort->loadedResource);
741 pExynosInputPort->loadedResource = NULL;
742 Exynos_OSAL_Free(pExynosInputPort->bufferStateAllocate);
743 pExynosInputPort->bufferStateAllocate = NULL;
744 Exynos_OSAL_Free(pExynosInputPort->extendBufferHeader);
745 pExynosInputPort->extendBufferHeader = NULL;
746 Exynos_OSAL_Free(pExynosPort);
750 ret = Exynos_OSAL_SemaphoreCreate(&pExynosOutputPort->unloadedResource);
751 if (ret != OMX_ErrorNone) {
752 Exynos_OSAL_SemaphoreTerminate(pExynosOutputPort->loadedResource);
753 pExynosOutputPort->loadedResource = NULL;
754 Exynos_OSAL_Free(pExynosOutputPort->bufferStateAllocate);
755 pExynosOutputPort->bufferStateAllocate = NULL;
756 Exynos_OSAL_Free(pExynosOutputPort->extendBufferHeader);
757 pExynosOutputPort->extendBufferHeader = NULL;
759 Exynos_OSAL_SemaphoreTerminate(pExynosInputPort->unloadedResource);
760 pExynosInputPort->unloadedResource = NULL;
761 Exynos_OSAL_SemaphoreTerminate(pExynosInputPort->loadedResource);
762 pExynosInputPort->loadedResource = NULL;
763 Exynos_OSAL_Free(pExynosInputPort->bufferStateAllocate);
764 pExynosInputPort->bufferStateAllocate = NULL;
765 Exynos_OSAL_Free(pExynosInputPort->extendBufferHeader);
766 pExynosInputPort->extendBufferHeader = NULL;
767 Exynos_OSAL_Free(pExynosPort);
772 INIT_SET_SIZE_VERSION(&pExynosOutputPort->portDefinition, OMX_PARAM_PORTDEFINITIONTYPE);
773 pExynosOutputPort->portDefinition.nPortIndex = OUTPUT_PORT_INDEX;
774 pExynosOutputPort->portDefinition.eDir = OMX_DirOutput;
775 pExynosOutputPort->portDefinition.nBufferCountActual = 0;
776 pExynosOutputPort->portDefinition.nBufferCountMin = 0;
777 pExynosOutputPort->portDefinition.nBufferSize = 0;
778 pExynosOutputPort->portDefinition.bEnabled = OMX_FALSE;
779 pExynosOutputPort->portDefinition.bPopulated = OMX_FALSE;
780 pExynosOutputPort->portDefinition.eDomain = OMX_PortDomainMax;
781 pExynosOutputPort->portDefinition.bBuffersContiguous = OMX_FALSE;
782 pExynosOutputPort->portDefinition.nBufferAlignment = 0;
783 pExynosOutputPort->markType.hMarkTargetComponent = NULL;
784 pExynosOutputPort->markType.pMarkData = NULL;
785 pExynosOutputPort->exceptionFlag = GENERAL_STATE;
787 pExynosComponent->checkTimeStamp.needSetStartTimeStamp = OMX_FALSE;
788 pExynosComponent->checkTimeStamp.needCheckStartTimeStamp = OMX_FALSE;
789 pExynosComponent->checkTimeStamp.startTimeStamp = 0;
790 pExynosComponent->checkTimeStamp.nStartFlags = 0x0;
792 pOMXComponent->EmptyThisBuffer = &Exynos_OMX_EmptyThisBuffer;
793 pOMXComponent->FillThisBuffer = &Exynos_OMX_FillThisBuffer;
802 OMX_ERRORTYPE Exynos_OMX_Port_Destructor(OMX_HANDLETYPE hComponent)
804 OMX_ERRORTYPE ret = OMX_ErrorNone;
805 OMX_COMPONENTTYPE *pOMXComponent = NULL;
806 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
807 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
813 if (hComponent == NULL) {
814 ret = OMX_ErrorBadParameter;
817 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
818 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
819 if (ret != OMX_ErrorNone) {
822 if (pOMXComponent->pComponentPrivate == NULL) {
823 ret = OMX_ErrorBadParameter;
826 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
827 for (i = 0; i < ALL_PORT_NUM; i++) {
828 pExynosPort = &pExynosComponent->pExynosPort[i];
830 Exynos_OSAL_SemaphoreTerminate(pExynosPort->loadedResource);
831 pExynosPort->loadedResource = NULL;
832 Exynos_OSAL_SemaphoreTerminate(pExynosPort->unloadedResource);
833 pExynosPort->unloadedResource = NULL;
834 Exynos_OSAL_Free(pExynosPort->bufferStateAllocate);
835 pExynosPort->bufferStateAllocate = NULL;
836 Exynos_OSAL_Free(pExynosPort->extendBufferHeader);
837 pExynosPort->extendBufferHeader = NULL;
839 Exynos_OSAL_QueueTerminate(&pExynosPort->bufferQ);
841 Exynos_OSAL_Free(pExynosComponent->pExynosPort);
842 pExynosComponent->pExynosPort = NULL;
850 OMX_ERRORTYPE Exynos_ResetDataBuffer(EXYNOS_OMX_DATABUFFER *pDataBuffer)
852 OMX_ERRORTYPE ret = OMX_ErrorNone;
854 if (pDataBuffer == NULL) {
855 ret = OMX_ErrorBadParameter;
859 pDataBuffer->dataValid = OMX_FALSE;
860 pDataBuffer->dataLen = 0;
861 pDataBuffer->remainDataLen = 0;
862 pDataBuffer->usedDataLen = 0;
863 pDataBuffer->bufferHeader = NULL;
864 pDataBuffer->nFlags = 0;
865 pDataBuffer->timeStamp = 0;
866 pDataBuffer->pPrivate = NULL;
872 OMX_ERRORTYPE Exynos_ResetCodecData(EXYNOS_OMX_DATA *pData)
874 OMX_ERRORTYPE ret = OMX_ErrorNone;
877 ret = OMX_ErrorBadParameter;
882 pData->usedDataLen = 0;
883 pData->remainDataLen = 0;
885 pData->timeStamp = 0;
886 pData->pPrivate = NULL;
887 pData->bufferHeader = NULL;
893 OMX_ERRORTYPE Exynos_Shared_BufferToData(EXYNOS_OMX_DATABUFFER *pUseBuffer, EXYNOS_OMX_DATA *pData, EXYNOS_OMX_PLANE nPlane)
895 OMX_ERRORTYPE ret = OMX_ErrorNone;
897 if (nPlane == ONE_PLANE) {
898 /* Case of Shared Buffer, Only support singlePlaneBuffer */
899 pData->buffer.singlePlaneBuffer.dataBuffer = pUseBuffer->bufferHeader->pBuffer;
901 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Can not support plane");
902 ret = OMX_ErrorNotImplemented;
906 pData->allocSize = pUseBuffer->allocSize;
907 pData->dataLen = pUseBuffer->dataLen;
908 pData->usedDataLen = pUseBuffer->usedDataLen;
909 pData->remainDataLen = pUseBuffer->remainDataLen;
910 pData->timeStamp = pUseBuffer->timeStamp;
911 pData->nFlags = pUseBuffer->nFlags;
912 pData->pPrivate = pUseBuffer->pPrivate;
913 pData->bufferHeader = pUseBuffer->bufferHeader;
919 OMX_ERRORTYPE Exynos_Shared_DataToBuffer(EXYNOS_OMX_DATA *pData, EXYNOS_OMX_DATABUFFER *pUseBuffer)
921 OMX_ERRORTYPE ret = OMX_ErrorNone;
923 pUseBuffer->bufferHeader = pData->bufferHeader;
924 pUseBuffer->allocSize = pData->allocSize;
925 pUseBuffer->dataLen = pData->dataLen;
926 pUseBuffer->usedDataLen = pData->usedDataLen;
927 pUseBuffer->remainDataLen = pData->remainDataLen;
928 pUseBuffer->timeStamp = pData->timeStamp;
929 pUseBuffer->nFlags = pData->nFlags;
930 pUseBuffer->pPrivate = pData->pPrivate;