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_Basecomponent.c
21 * @author SeungBeom Kim (sbcrux.kim@samsung.com)
22 * Yunji Kim (yunji.kim@samsung.com)
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"
44 #define EXYNOS_LOG_TAG "EXYNOS_BASE_COMP"
45 #define EXYNOS_LOG_OFF
46 //#define EXYNOS_TRACE_ON
47 #include "Exynos_OSAL_Log.h"
50 /* Change CHECK_SIZE_VERSION Macro */
51 OMX_ERRORTYPE Exynos_OMX_Check_SizeVersion(OMX_PTR header, OMX_U32 size)
53 OMX_ERRORTYPE ret = OMX_ErrorNone;
55 OMX_VERSIONTYPE* version = NULL;
57 ret = OMX_ErrorBadParameter;
60 version = (OMX_VERSIONTYPE*)((char*)header + sizeof(OMX_U32));
61 if (*((OMX_U32*)header) != size) {
62 ret = OMX_ErrorBadParameter;
65 if (version->s.nVersionMajor != VERSIONMAJOR_NUMBER ||
66 version->s.nVersionMinor != VERSIONMINOR_NUMBER) {
67 ret = OMX_ErrorVersionMismatch;
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)
82 OMX_ERRORTYPE ret = OMX_ErrorNone;
83 OMX_COMPONENTTYPE *pOMXComponent = NULL;
84 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
89 /* check parameters */
90 if (hComponent == NULL ||
91 pComponentName == NULL || pComponentVersion == NULL ||
92 pSpecVersion == NULL || pComponentUUID == NULL) {
93 ret = OMX_ErrorBadParameter;
96 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
97 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
98 if (ret != OMX_ErrorNone) {
102 if (pOMXComponent->pComponentPrivate == NULL) {
103 ret = OMX_ErrorBadParameter;
106 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
108 if (pExynosComponent->currentState == OMX_StateInvalid) {
109 ret = OMX_ErrorInvalidState;
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));
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));
132 OMX_ERRORTYPE Exynos_OMX_GetState (
133 OMX_IN OMX_HANDLETYPE hComponent,
134 OMX_OUT OMX_STATETYPE *pState)
136 OMX_ERRORTYPE ret = OMX_ErrorNone;
137 OMX_COMPONENTTYPE *pOMXComponent = NULL;
138 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
142 if (hComponent == NULL || pState == NULL) {
143 ret = OMX_ErrorBadParameter;
146 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
147 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
148 if (ret != OMX_ErrorNone) {
152 if (pOMXComponent->pComponentPrivate == NULL) {
153 ret = OMX_ErrorBadParameter;
156 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
158 *pState = pExynosComponent->currentState;
167 OMX_ERRORTYPE Exynos_OMX_ComponentStateSet(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 messageParam)
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 OMX_S32 countValue = 0;
176 unsigned int i = 0, j = 0;
181 /* check parameters */
182 if (currentState == destState) {
183 ret = OMX_ErrorSameState;
186 if (currentState == OMX_StateInvalid) {
187 ret = OMX_ErrorInvalidState;
191 if ((currentState == OMX_StateLoaded) && (destState == OMX_StateIdle)) {
192 ret = Exynos_OMX_Get_Resource(pOMXComponent);
193 if (ret != OMX_ErrorNone) {
197 if (((currentState == OMX_StateIdle) && (destState == OMX_StateLoaded)) ||
198 ((currentState == OMX_StateIdle) && (destState == OMX_StateInvalid)) ||
199 ((currentState == OMX_StateExecuting) && (destState == OMX_StateInvalid)) ||
200 ((currentState == OMX_StatePause) && (destState == OMX_StateInvalid))) {
201 Exynos_OMX_Release_Resource(pOMXComponent);
205 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "destState: %d", destState);
207 Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "destState: %d", destState);
210 case OMX_StateInvalid:
211 switch (currentState) {
212 case OMX_StateWaitForResources:
213 Exynos_OMX_Out_WaitForResource(pOMXComponent);
215 case OMX_StateExecuting:
217 case OMX_StateLoaded:
218 pExynosComponent->currentState = OMX_StateInvalid;
219 ret = pExynosComponent->exynos_BufferProcessTerminate(pOMXComponent);
221 for (i = 0; i < ALL_PORT_NUM; i++) {
222 if (pExynosComponent->pExynosPort[i].portWayType == WAY1_PORT) {
223 Exynos_OSAL_MutexTerminate(pExynosComponent->pExynosPort[i].way.port1WayDataBuffer.dataBuffer.bufferMutex);
224 pExynosComponent->pExynosPort[i].way.port1WayDataBuffer.dataBuffer.bufferMutex = NULL;
225 } else if (pExynosComponent->pExynosPort[i].portWayType == WAY2_PORT) {
226 Exynos_OSAL_MutexTerminate(pExynosComponent->pExynosPort[i].way.port2WayDataBuffer.inputDataBuffer.bufferMutex);
227 pExynosComponent->pExynosPort[i].way.port2WayDataBuffer.inputDataBuffer.bufferMutex = NULL;
228 Exynos_OSAL_MutexTerminate(pExynosComponent->pExynosPort[i].way.port2WayDataBuffer.outputDataBuffer.bufferMutex);
229 pExynosComponent->pExynosPort[i].way.port2WayDataBuffer.outputDataBuffer.bufferMutex = NULL;
231 Exynos_OSAL_MutexTerminate(pExynosComponent->pExynosPort[i].hPortMutex);
232 pExynosComponent->pExynosPort[i].hPortMutex = NULL;
235 if (pExynosComponent->bMultiThreadProcess == OMX_FALSE) {
236 Exynos_OSAL_SignalTerminate(pExynosComponent->pauseEvent);
237 pExynosComponent->pauseEvent = NULL;
239 for (i = 0; i < ALL_PORT_NUM; i++) {
240 Exynos_OSAL_SignalTerminate(pExynosComponent->pExynosPort[i].pauseEvent);
241 pExynosComponent->pExynosPort[i].pauseEvent = NULL;
242 if (pExynosComponent->pExynosPort[i].bufferProcessType & BUFFER_SHARE) {
243 Exynos_OSAL_SignalTerminate(pExynosComponent->pExynosPort[i].hAllCodecBufferReturnEvent);
244 pExynosComponent->pExynosPort[i].hAllCodecBufferReturnEvent = NULL;
248 for (i = 0; i < ALL_PORT_NUM; i++) {
249 Exynos_OSAL_SemaphoreTerminate(pExynosComponent->pExynosPort[i].bufferSemID);
250 pExynosComponent->pExynosPort[i].bufferSemID = NULL;
252 if (pExynosComponent->exynos_codec_componentTerminate != NULL)
253 pExynosComponent->exynos_codec_componentTerminate(pOMXComponent);
255 ret = OMX_ErrorInvalidState;
258 ret = OMX_ErrorInvalidState;
262 case OMX_StateLoaded:
263 switch (currentState) {
265 ret = pExynosComponent->exynos_BufferProcessTerminate(pOMXComponent);
267 for (i = 0; i < ALL_PORT_NUM; i++) {
268 if (pExynosComponent->pExynosPort[i].portWayType == WAY1_PORT) {
269 Exynos_OSAL_MutexTerminate(pExynosComponent->pExynosPort[i].way.port1WayDataBuffer.dataBuffer.bufferMutex);
270 pExynosComponent->pExynosPort[i].way.port1WayDataBuffer.dataBuffer.bufferMutex = NULL;
271 } else if (pExynosComponent->pExynosPort[i].portWayType == WAY2_PORT) {
272 Exynos_OSAL_MutexTerminate(pExynosComponent->pExynosPort[i].way.port2WayDataBuffer.inputDataBuffer.bufferMutex);
273 pExynosComponent->pExynosPort[i].way.port2WayDataBuffer.inputDataBuffer.bufferMutex = NULL;
274 Exynos_OSAL_MutexTerminate(pExynosComponent->pExynosPort[i].way.port2WayDataBuffer.outputDataBuffer.bufferMutex);
275 pExynosComponent->pExynosPort[i].way.port2WayDataBuffer.outputDataBuffer.bufferMutex = NULL;
277 Exynos_OSAL_MutexTerminate(pExynosComponent->pExynosPort[i].hPortMutex);
278 pExynosComponent->pExynosPort[i].hPortMutex = NULL;
280 if (pExynosComponent->bMultiThreadProcess == OMX_FALSE) {
281 Exynos_OSAL_SignalTerminate(pExynosComponent->pauseEvent);
282 pExynosComponent->pauseEvent = NULL;
284 for (i = 0; i < ALL_PORT_NUM; i++) {
285 Exynos_OSAL_SignalTerminate(pExynosComponent->pExynosPort[i].pauseEvent);
286 pExynosComponent->pExynosPort[i].pauseEvent = NULL;
287 if (pExynosComponent->pExynosPort[i].bufferProcessType & BUFFER_SHARE) {
288 Exynos_OSAL_SignalTerminate(pExynosComponent->pExynosPort[i].hAllCodecBufferReturnEvent);
289 pExynosComponent->pExynosPort[i].hAllCodecBufferReturnEvent = NULL;
293 for (i = 0; i < ALL_PORT_NUM; i++) {
294 Exynos_OSAL_SemaphoreTerminate(pExynosComponent->pExynosPort[i].bufferSemID);
295 pExynosComponent->pExynosPort[i].bufferSemID = NULL;
298 pExynosComponent->exynos_codec_componentTerminate(pOMXComponent);
300 for (i = 0; i < (pExynosComponent->portParam.nPorts); i++) {
301 pExynosPort = (pExynosComponent->pExynosPort + i);
302 if (CHECK_PORT_TUNNELED(pExynosPort) && CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)) {
303 while (Exynos_OSAL_GetElemNum(&pExynosPort->bufferQ) > 0) {
304 message = (EXYNOS_OMX_MESSAGE*)Exynos_OSAL_Dequeue(&pExynosPort->bufferQ);
306 Exynos_OSAL_Free(message);
308 ret = pExynosComponent->exynos_FreeTunnelBuffer(pExynosPort, i);
309 if (OMX_ErrorNone != ret) {
313 if (CHECK_PORT_ENABLED(pExynosPort)) {
314 Exynos_OSAL_SemaphoreWait(pExynosPort->unloadedResource);
315 while (Exynos_OSAL_GetElemNum(&pExynosPort->bufferQ) > 0) {
316 message = (EXYNOS_OMX_MESSAGE *)Exynos_OSAL_Dequeue(&pExynosPort->bufferQ);
318 Exynos_OSAL_Free(message);
320 pExynosPort->portDefinition.bPopulated = OMX_FALSE;
324 pExynosComponent->currentState = OMX_StateLoaded;
326 case OMX_StateWaitForResources:
327 ret = Exynos_OMX_Out_WaitForResource(pOMXComponent);
328 pExynosComponent->currentState = OMX_StateLoaded;
330 case OMX_StateExecuting:
333 ret = OMX_ErrorIncorrectStateTransition;
338 switch (currentState) {
339 case OMX_StateLoaded:
340 for (i = 0; i < pExynosComponent->portParam.nPorts; i++) {
341 pExynosPort = (pExynosComponent->pExynosPort + i);
342 if (CHECK_PORT_TUNNELED(pExynosPort) && CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)) {
343 if (CHECK_PORT_ENABLED(pExynosPort)) {
344 ret = pExynosComponent->exynos_AllocateTunnelBuffer(pExynosPort, i);
345 if (ret!=OMX_ErrorNone)
349 if (CHECK_PORT_ENABLED(pExynosPort)) {
350 Exynos_OSAL_SemaphoreWait(pExynosComponent->pExynosPort[i].loadedResource);
351 pExynosPort->portDefinition.bPopulated = OMX_TRUE;
355 ret = pExynosComponent->exynos_codec_componentInit(pOMXComponent);
356 if (ret != OMX_ErrorNone) {
358 * if (CHECK_PORT_TUNNELED == OMX_TRUE) thenTunnel Buffer Free
362 if (pExynosComponent->bMultiThreadProcess == OMX_FALSE) {
363 Exynos_OSAL_SignalCreate(&pExynosComponent->pauseEvent);
365 for (i = 0; i < ALL_PORT_NUM; i++) {
366 Exynos_OSAL_SignalCreate(&pExynosComponent->pExynosPort[i].pauseEvent);
367 if (pExynosComponent->pExynosPort[i].bufferProcessType & BUFFER_SHARE)
368 Exynos_OSAL_SignalCreate(&pExynosComponent->pExynosPort[i].hAllCodecBufferReturnEvent);
371 for (i = 0; i < ALL_PORT_NUM; i++) {
372 ret = Exynos_OSAL_SemaphoreCreate(&pExynosComponent->pExynosPort[i].bufferSemID);
373 if (ret != OMX_ErrorNone) {
374 ret = OMX_ErrorInsufficientResources;
375 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
379 for (i = 0; i < ALL_PORT_NUM; i++) {
380 if (pExynosComponent->pExynosPort[i].portWayType == WAY1_PORT) {
381 ret = Exynos_OSAL_MutexCreate(&pExynosComponent->pExynosPort[i].way.port1WayDataBuffer.dataBuffer.bufferMutex);
382 if (ret != OMX_ErrorNone) {
383 ret = OMX_ErrorInsufficientResources;
384 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
387 } else if (pExynosComponent->pExynosPort[i].portWayType == WAY2_PORT) {
388 ret = Exynos_OSAL_MutexCreate(&pExynosComponent->pExynosPort[i].way.port2WayDataBuffer.inputDataBuffer.bufferMutex);
389 if (ret != OMX_ErrorNone) {
390 ret = OMX_ErrorInsufficientResources;
391 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
394 ret = Exynos_OSAL_MutexCreate(&pExynosComponent->pExynosPort[i].way.port2WayDataBuffer.outputDataBuffer.bufferMutex);
395 if (ret != OMX_ErrorNone) {
396 ret = OMX_ErrorInsufficientResources;
397 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
401 ret = Exynos_OSAL_MutexCreate(&pExynosComponent->pExynosPort[i].hPortMutex);
402 if (ret != OMX_ErrorNone) {
403 ret = OMX_ErrorInsufficientResources;
408 ret = pExynosComponent->exynos_BufferProcessCreate(pOMXComponent);
409 if (ret != OMX_ErrorNone) {
411 * if (CHECK_PORT_TUNNELED == OMX_TRUE) thenTunnel Buffer Free
413 if (pExynosComponent->bMultiThreadProcess == OMX_FALSE) {
414 Exynos_OSAL_SignalTerminate(pExynosComponent->pauseEvent);
415 pExynosComponent->pauseEvent = NULL;
417 for (i = 0; i < ALL_PORT_NUM; i++) {
418 Exynos_OSAL_SignalTerminate(pExynosComponent->pExynosPort[i].pauseEvent);
419 pExynosComponent->pExynosPort[i].pauseEvent = NULL;
420 if (pExynosComponent->pExynosPort[i].bufferProcessType & BUFFER_SHARE) {
421 Exynos_OSAL_SignalTerminate(pExynosComponent->pExynosPort[i].hAllCodecBufferReturnEvent);
422 pExynosComponent->pExynosPort[i].hAllCodecBufferReturnEvent = NULL;
426 for (i = 0; i < ALL_PORT_NUM; i++) {
427 if (pExynosComponent->pExynosPort[i].portWayType == WAY1_PORT) {
428 Exynos_OSAL_MutexTerminate(pExynosComponent->pExynosPort[i].way.port1WayDataBuffer.dataBuffer.bufferMutex);
429 pExynosComponent->pExynosPort[i].way.port1WayDataBuffer.dataBuffer.bufferMutex = NULL;
430 } else if (pExynosComponent->pExynosPort[i].portWayType == WAY2_PORT) {
431 Exynos_OSAL_MutexTerminate(pExynosComponent->pExynosPort[i].way.port2WayDataBuffer.inputDataBuffer.bufferMutex);
432 pExynosComponent->pExynosPort[i].way.port2WayDataBuffer.inputDataBuffer.bufferMutex = NULL;
433 Exynos_OSAL_MutexTerminate(pExynosComponent->pExynosPort[i].way.port2WayDataBuffer.outputDataBuffer.bufferMutex);
434 pExynosComponent->pExynosPort[i].way.port2WayDataBuffer.outputDataBuffer.bufferMutex = NULL;
436 Exynos_OSAL_MutexTerminate(pExynosComponent->pExynosPort[i].hPortMutex);
437 pExynosComponent->pExynosPort[i].hPortMutex = NULL;
439 for (i = 0; i < ALL_PORT_NUM; i++) {
440 Exynos_OSAL_SemaphoreTerminate(pExynosComponent->pExynosPort[i].bufferSemID);
441 pExynosComponent->pExynosPort[i].bufferSemID = NULL;
444 ret = OMX_ErrorInsufficientResources;
447 pExynosComponent->currentState = OMX_StateIdle;
449 case OMX_StateExecuting:
451 Exynos_OMX_BufferFlushProcess(pOMXComponent, ALL_PORT_INDEX, OMX_FALSE);
452 pExynosComponent->currentState = OMX_StateIdle;
454 case OMX_StateWaitForResources:
455 pExynosComponent->currentState = OMX_StateIdle;
458 ret = OMX_ErrorIncorrectStateTransition;
462 case OMX_StateExecuting:
463 switch (currentState) {
464 case OMX_StateLoaded:
465 ret = OMX_ErrorIncorrectStateTransition;
468 for (i = 0; i < pExynosComponent->portParam.nPorts; i++) {
469 pExynosPort = &pExynosComponent->pExynosPort[i];
470 if (CHECK_PORT_TUNNELED(pExynosPort) && CHECK_PORT_BUFFER_SUPPLIER(pExynosPort) && CHECK_PORT_ENABLED(pExynosPort)) {
471 for (j = 0; j < pExynosPort->tunnelBufferNum; j++) {
472 Exynos_OSAL_SemaphorePost(pExynosComponent->pExynosPort[i].bufferSemID);
477 pExynosComponent->transientState = EXYNOS_OMX_TransStateMax;
478 pExynosComponent->currentState = OMX_StateExecuting;
479 if (pExynosComponent->bMultiThreadProcess == OMX_FALSE) {
480 Exynos_OSAL_SignalSet(pExynosComponent->pauseEvent);
482 for (i = 0; i < ALL_PORT_NUM; i++) {
483 Exynos_OSAL_SignalSet(pExynosComponent->pExynosPort[i].pauseEvent);
488 for (i = 0; i < pExynosComponent->portParam.nPorts; i++) {
489 pExynosPort = &pExynosComponent->pExynosPort[i];
490 if (CHECK_PORT_TUNNELED(pExynosPort) && CHECK_PORT_BUFFER_SUPPLIER(pExynosPort) && CHECK_PORT_ENABLED(pExynosPort)) {
491 OMX_S32 semaValue = 0, cnt = 0;
492 Exynos_OSAL_Get_SemaphoreCount(pExynosComponent->pExynosPort[i].bufferSemID, &semaValue);
493 if (Exynos_OSAL_GetElemNum(&pExynosPort->bufferQ) > semaValue) {
494 cnt = Exynos_OSAL_GetElemNum(&pExynosPort->bufferQ) - semaValue;
495 for (k = 0; k < cnt; k++) {
496 Exynos_OSAL_SemaphorePost(pExynosComponent->pExynosPort[i].bufferSemID);
502 pExynosComponent->currentState = OMX_StateExecuting;
503 if (pExynosComponent->bMultiThreadProcess == OMX_FALSE) {
504 Exynos_OSAL_SignalSet(pExynosComponent->pauseEvent);
506 for (i = 0; i < ALL_PORT_NUM; i++) {
507 Exynos_OSAL_SignalSet(pExynosComponent->pExynosPort[i].pauseEvent);
511 case OMX_StateWaitForResources:
512 ret = OMX_ErrorIncorrectStateTransition;
515 ret = OMX_ErrorIncorrectStateTransition;
520 switch (currentState) {
521 case OMX_StateLoaded:
522 ret = OMX_ErrorIncorrectStateTransition;
525 pExynosComponent->currentState = OMX_StatePause;
527 case OMX_StateExecuting:
528 pExynosComponent->currentState = OMX_StatePause;
530 case OMX_StateWaitForResources:
531 ret = OMX_ErrorIncorrectStateTransition;
534 ret = OMX_ErrorIncorrectStateTransition;
538 case OMX_StateWaitForResources:
539 switch (currentState) {
540 case OMX_StateLoaded:
541 ret = Exynos_OMX_In_WaitForResource(pOMXComponent);
542 pExynosComponent->currentState = OMX_StateWaitForResources;
545 case OMX_StateExecuting:
547 ret = OMX_ErrorIncorrectStateTransition;
550 ret = OMX_ErrorIncorrectStateTransition;
555 ret = OMX_ErrorIncorrectStateTransition;
560 if (ret == OMX_ErrorNone) {
561 if (pExynosComponent->pCallbacks != NULL) {
562 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
563 pExynosComponent->callbackData,
564 OMX_EventCmdComplete, OMX_CommandStateSet,
568 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s:%d", __FUNCTION__, __LINE__);
569 if (pExynosComponent->pCallbacks != NULL) {
570 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
571 pExynosComponent->callbackData,
572 OMX_EventError, ret, 0, NULL);
580 static OMX_ERRORTYPE Exynos_OMX_MessageHandlerThread(OMX_PTR threadData)
582 OMX_ERRORTYPE ret = OMX_ErrorNone;
583 OMX_COMPONENTTYPE *pOMXComponent = NULL;
584 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
585 EXYNOS_OMX_MESSAGE *message = NULL;
586 OMX_U32 messageType = 0, portIndex = 0;
590 if (threadData == NULL) {
591 ret = OMX_ErrorBadParameter;
595 pOMXComponent = (OMX_COMPONENTTYPE *)threadData;
596 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
597 if (ret != OMX_ErrorNone) {
601 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
603 while (pExynosComponent->bExitMessageHandlerThread == OMX_FALSE) {
604 Exynos_OSAL_SemaphoreWait(pExynosComponent->msgSemaphoreHandle);
605 message = (EXYNOS_OMX_MESSAGE *)Exynos_OSAL_Dequeue(&pExynosComponent->messageQ);
606 if (message != NULL) {
607 messageType = message->messageType;
608 switch (messageType) {
609 case OMX_CommandStateSet:
610 ret = Exynos_OMX_ComponentStateSet(pOMXComponent, message->messageParam);
612 case OMX_CommandFlush:
613 ret = Exynos_OMX_BufferFlushProcess(pOMXComponent, message->messageParam, OMX_TRUE);
615 case OMX_CommandPortDisable:
616 ret = Exynos_OMX_PortDisableProcess(pOMXComponent, message->messageParam);
618 case OMX_CommandPortEnable:
619 ret = Exynos_OMX_PortEnableProcess(pOMXComponent, message->messageParam);
621 case OMX_CommandMarkBuffer:
622 portIndex = message->messageParam;
623 pExynosComponent->pExynosPort[portIndex].markType.hMarkTargetComponent = ((OMX_MARKTYPE *)message->pCmdData)->hMarkTargetComponent;
624 pExynosComponent->pExynosPort[portIndex].markType.pMarkData = ((OMX_MARKTYPE *)message->pCmdData)->pMarkData;
626 case (OMX_COMMANDTYPE)EXYNOS_OMX_CommandComponentDeInit:
627 pExynosComponent->bExitMessageHandlerThread = OMX_TRUE;
632 Exynos_OSAL_Free(message);
637 Exynos_OSAL_ThreadExit(NULL);
645 static OMX_ERRORTYPE Exynos_StateSet(EXYNOS_OMX_BASECOMPONENT *pExynosComponent, OMX_U32 nParam)
647 OMX_U32 destState = nParam;
650 if ((destState == OMX_StateIdle) && (pExynosComponent->currentState == OMX_StateLoaded)) {
651 pExynosComponent->transientState = EXYNOS_OMX_TransStateLoadedToIdle;
652 for(i = 0; i < pExynosComponent->portParam.nPorts; i++) {
653 pExynosComponent->pExynosPort[i].portState = OMX_StateIdle;
655 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "to OMX_StateIdle");
656 } else if ((destState == OMX_StateLoaded) && (pExynosComponent->currentState == OMX_StateIdle)) {
657 pExynosComponent->transientState = EXYNOS_OMX_TransStateIdleToLoaded;
658 for (i = 0; i < pExynosComponent->portParam.nPorts; i++) {
659 pExynosComponent->pExynosPort[i].portState = OMX_StateLoaded;
661 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "to OMX_StateLoaded");
662 } else if ((destState == OMX_StateIdle) && (pExynosComponent->currentState == OMX_StateExecuting)) {
663 pExynosComponent->transientState = EXYNOS_OMX_TransStateExecutingToIdle;
664 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "to OMX_StateIdle");
665 } else if ((destState == OMX_StateExecuting) && (pExynosComponent->currentState == OMX_StateIdle)) {
666 pExynosComponent->transientState = EXYNOS_OMX_TransStateIdleToExecuting;
667 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "to OMX_StateExecuting");
668 } else if (destState == OMX_StateInvalid) {
669 for (i = 0; i < pExynosComponent->portParam.nPorts; i++) {
670 pExynosComponent->pExynosPort[i].portState = OMX_StateInvalid;
674 return OMX_ErrorNone;
677 static OMX_ERRORTYPE Exynos_SetPortFlush(EXYNOS_OMX_BASECOMPONENT *pExynosComponent, OMX_U32 nParam)
679 OMX_ERRORTYPE ret = OMX_ErrorNone;
680 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
681 OMX_S32 portIndex = nParam;
682 OMX_U16 i = 0, cnt = 0, index = 0;
685 if ((pExynosComponent->currentState == OMX_StateExecuting) ||
686 (pExynosComponent->currentState == OMX_StatePause)) {
687 if ((portIndex != ALL_PORT_INDEX) &&
688 ((OMX_S32)portIndex >= (OMX_S32)pExynosComponent->portParam.nPorts)) {
689 ret = OMX_ErrorBadPortIndex;
693 /*********************
694 * need flush event set ?????
695 **********************/
696 cnt = (portIndex == ALL_PORT_INDEX ) ? ALL_PORT_NUM : 1;
697 for (i = 0; i < cnt; i++) {
698 if (portIndex == ALL_PORT_INDEX)
702 pExynosComponent->pExynosPort[index].bIsPortFlushed = OMX_TRUE;
705 ret = OMX_ErrorIncorrectStateOperation;
714 static OMX_ERRORTYPE Exynos_SetPortEnable(EXYNOS_OMX_BASECOMPONENT *pExynosComponent, OMX_U32 nParam)
716 OMX_ERRORTYPE ret = OMX_ErrorNone;
717 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
718 OMX_S32 portIndex = nParam;
719 OMX_U16 i = 0, cnt = 0;
723 if ((portIndex != ALL_PORT_INDEX) &&
724 ((OMX_S32)portIndex >= (OMX_S32)pExynosComponent->portParam.nPorts)) {
725 ret = OMX_ErrorBadPortIndex;
729 if (portIndex == ALL_PORT_INDEX) {
730 for (i = 0; i < pExynosComponent->portParam.nPorts; i++) {
731 pExynosPort = &pExynosComponent->pExynosPort[i];
732 if (CHECK_PORT_ENABLED(pExynosPort)) {
733 ret = OMX_ErrorIncorrectStateOperation;
736 pExynosPort->portState = OMX_StateIdle;
740 pExynosPort = &pExynosComponent->pExynosPort[portIndex];
741 if (CHECK_PORT_ENABLED(pExynosPort)) {
742 ret = OMX_ErrorIncorrectStateOperation;
745 pExynosPort->portState = OMX_StateIdle;
757 static OMX_ERRORTYPE Exynos_SetPortDisable(EXYNOS_OMX_BASECOMPONENT *pExynosComponent, OMX_U32 nParam)
759 OMX_ERRORTYPE ret = OMX_ErrorNone;
760 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
761 OMX_S32 portIndex = nParam;
762 OMX_U16 i = 0, cnt = 0;
766 if ((portIndex != ALL_PORT_INDEX) &&
767 ((OMX_S32)portIndex >= (OMX_S32)pExynosComponent->portParam.nPorts)) {
768 ret = OMX_ErrorBadPortIndex;
772 if (portIndex == ALL_PORT_INDEX) {
773 for (i = 0; i < pExynosComponent->portParam.nPorts; i++) {
774 pExynosPort = &pExynosComponent->pExynosPort[i];
775 if (!CHECK_PORT_ENABLED(pExynosPort)) {
776 ret = OMX_ErrorIncorrectStateOperation;
779 pExynosPort->portState = OMX_StateLoaded;
780 pExynosPort->bIsPortDisabled = OMX_TRUE;
783 pExynosPort = &pExynosComponent->pExynosPort[portIndex];
784 pExynosPort->portState = OMX_StateLoaded;
785 pExynosPort->bIsPortDisabled = OMX_TRUE;
795 static OMX_ERRORTYPE Exynos_SetMarkBuffer(EXYNOS_OMX_BASECOMPONENT *pExynosComponent, OMX_U32 nParam)
797 OMX_ERRORTYPE ret = OMX_ErrorNone;
798 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
799 OMX_U32 portIndex = nParam;
800 OMX_U16 i = 0, cnt = 0;
803 if (nParam >= pExynosComponent->portParam.nPorts) {
804 ret = OMX_ErrorBadPortIndex;
808 if ((pExynosComponent->currentState == OMX_StateExecuting) ||
809 (pExynosComponent->currentState == OMX_StatePause)) {
812 ret = OMX_ErrorIncorrectStateOperation;
819 static OMX_ERRORTYPE Exynos_OMX_CommandQueue(
820 EXYNOS_OMX_BASECOMPONENT *pExynosComponent,
825 OMX_ERRORTYPE ret = OMX_ErrorNone;
826 EXYNOS_OMX_MESSAGE *command = (EXYNOS_OMX_MESSAGE *)Exynos_OSAL_Malloc(sizeof(EXYNOS_OMX_MESSAGE));
828 if (command == NULL) {
829 ret = OMX_ErrorInsufficientResources;
832 command->messageType = (OMX_U32)Cmd;
833 command->messageParam = nParam;
834 command->pCmdData = pCmdData;
836 ret = Exynos_OSAL_Queue(&pExynosComponent->messageQ, (void *)command);
838 ret = OMX_ErrorUndefined;
841 ret = Exynos_OSAL_SemaphorePost(pExynosComponent->msgSemaphoreHandle);
847 OMX_ERRORTYPE Exynos_OMX_SendCommand(
848 OMX_IN OMX_HANDLETYPE hComponent,
849 OMX_IN OMX_COMMANDTYPE Cmd,
850 OMX_IN OMX_U32 nParam,
851 OMX_IN OMX_PTR pCmdData)
853 OMX_ERRORTYPE ret = OMX_ErrorNone;
854 OMX_COMPONENTTYPE *pOMXComponent = NULL;
855 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
856 EXYNOS_OMX_MESSAGE *message = NULL;
860 if (hComponent == NULL) {
861 ret = OMX_ErrorBadParameter;
864 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
865 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
866 if (ret != OMX_ErrorNone) {
870 if (pOMXComponent->pComponentPrivate == NULL) {
871 ret = OMX_ErrorBadParameter;
874 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
876 if (pExynosComponent->currentState == OMX_StateInvalid) {
877 ret = OMX_ErrorInvalidState;
882 case OMX_CommandStateSet :
883 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Command: OMX_CommandStateSet");
884 Exynos_StateSet(pExynosComponent, nParam);
886 case OMX_CommandFlush :
887 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Command: OMX_CommandFlush");
888 ret = Exynos_SetPortFlush(pExynosComponent, nParam);
889 if (ret != OMX_ErrorNone)
892 case OMX_CommandPortDisable :
893 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Command: OMX_CommandPortDisable");
894 ret = Exynos_SetPortDisable(pExynosComponent, nParam);
895 if (ret != OMX_ErrorNone)
898 case OMX_CommandPortEnable :
899 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Command: OMX_CommandPortEnable");
900 ret = Exynos_SetPortEnable(pExynosComponent, nParam);
901 if (ret != OMX_ErrorNone)
904 case OMX_CommandMarkBuffer :
905 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Command: OMX_CommandMarkBuffer");
906 ret = Exynos_SetMarkBuffer(pExynosComponent, nParam);
907 if (ret != OMX_ErrorNone)
914 ret = Exynos_OMX_CommandQueue(pExynosComponent, Cmd, nParam, pCmdData);
922 OMX_ERRORTYPE Exynos_OMX_GetParameter(
923 OMX_IN OMX_HANDLETYPE hComponent,
924 OMX_IN OMX_INDEXTYPE nParamIndex,
925 OMX_INOUT OMX_PTR ComponentParameterStructure)
927 OMX_ERRORTYPE ret = OMX_ErrorNone;
928 OMX_COMPONENTTYPE *pOMXComponent = NULL;
929 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
933 if (hComponent == NULL) {
934 ret = OMX_ErrorBadParameter;
937 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
938 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
939 if (ret != OMX_ErrorNone) {
943 if (pOMXComponent->pComponentPrivate == NULL) {
944 ret = OMX_ErrorBadParameter;
947 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
949 if (ComponentParameterStructure == NULL) {
950 ret = OMX_ErrorBadParameter;
953 if (pExynosComponent->currentState == OMX_StateInvalid) {
954 ret = OMX_ErrorInvalidState;
958 switch (nParamIndex) {
959 case OMX_IndexParamAudioInit:
960 case OMX_IndexParamVideoInit:
961 case OMX_IndexParamImageInit:
962 case OMX_IndexParamOtherInit:
964 OMX_PORT_PARAM_TYPE *portParam = (OMX_PORT_PARAM_TYPE *)ComponentParameterStructure;
965 ret = Exynos_OMX_Check_SizeVersion(portParam, sizeof(OMX_PORT_PARAM_TYPE));
966 if (ret != OMX_ErrorNone) {
969 portParam->nPorts = 0;
970 portParam->nStartPortNumber = 0;
973 case OMX_IndexParamPortDefinition:
975 OMX_PARAM_PORTDEFINITIONTYPE *portDefinition = (OMX_PARAM_PORTDEFINITIONTYPE *)ComponentParameterStructure;
976 OMX_U32 portIndex = portDefinition->nPortIndex;
977 EXYNOS_OMX_BASEPORT *pExynosPort;
979 if (portIndex >= pExynosComponent->portParam.nPorts) {
980 ret = OMX_ErrorBadPortIndex;
983 ret = Exynos_OMX_Check_SizeVersion(portDefinition, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
984 if (ret != OMX_ErrorNone) {
988 pExynosPort = &pExynosComponent->pExynosPort[portIndex];
989 Exynos_OSAL_Memcpy(portDefinition, &pExynosPort->portDefinition, portDefinition->nSize);
992 case OMX_IndexParamPriorityMgmt:
994 OMX_PRIORITYMGMTTYPE *compPriority = (OMX_PRIORITYMGMTTYPE *)ComponentParameterStructure;
996 ret = Exynos_OMX_Check_SizeVersion(compPriority, sizeof(OMX_PRIORITYMGMTTYPE));
997 if (ret != OMX_ErrorNone) {
1001 compPriority->nGroupID = pExynosComponent->compPriority.nGroupID;
1002 compPriority->nGroupPriority = pExynosComponent->compPriority.nGroupPriority;
1006 case OMX_IndexParamCompBufferSupplier:
1008 OMX_PARAM_BUFFERSUPPLIERTYPE *bufferSupplier = (OMX_PARAM_BUFFERSUPPLIERTYPE *)ComponentParameterStructure;
1009 OMX_U32 portIndex = bufferSupplier->nPortIndex;
1010 EXYNOS_OMX_BASEPORT *pExynosPort;
1012 if ((pExynosComponent->currentState == OMX_StateLoaded) ||
1013 (pExynosComponent->currentState == OMX_StateWaitForResources)) {
1014 if (portIndex >= pExynosComponent->portParam.nPorts) {
1015 ret = OMX_ErrorBadPortIndex;
1018 ret = Exynos_OMX_Check_SizeVersion(bufferSupplier, sizeof(OMX_PARAM_BUFFERSUPPLIERTYPE));
1019 if (ret != OMX_ErrorNone) {
1023 pExynosPort = &pExynosComponent->pExynosPort[portIndex];
1026 if (pExynosPort->portDefinition.eDir == OMX_DirInput) {
1027 if (CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)) {
1028 bufferSupplier->eBufferSupplier = OMX_BufferSupplyInput;
1029 } else if (CHECK_PORT_TUNNELED(pExynosPort)) {
1030 bufferSupplier->eBufferSupplier = OMX_BufferSupplyOutput;
1032 bufferSupplier->eBufferSupplier = OMX_BufferSupplyUnspecified;
1035 if (CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)) {
1036 bufferSupplier->eBufferSupplier = OMX_BufferSupplyOutput;
1037 } else if (CHECK_PORT_TUNNELED(pExynosPort)) {
1038 bufferSupplier->eBufferSupplier = OMX_BufferSupplyInput;
1040 bufferSupplier->eBufferSupplier = OMX_BufferSupplyUnspecified;
1046 ret = OMX_ErrorIncorrectStateOperation;
1053 ret = OMX_ErrorUnsupportedIndex;
1059 ret = OMX_ErrorNone;
1068 OMX_ERRORTYPE Exynos_OMX_SetParameter(
1069 OMX_IN OMX_HANDLETYPE hComponent,
1070 OMX_IN OMX_INDEXTYPE nIndex,
1071 OMX_IN OMX_PTR ComponentParameterStructure)
1073 OMX_ERRORTYPE ret = OMX_ErrorNone;
1074 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1075 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1079 if (hComponent == NULL) {
1080 ret = OMX_ErrorBadParameter;
1083 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1084 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1085 if (ret != OMX_ErrorNone) {
1089 if (pOMXComponent->pComponentPrivate == NULL) {
1090 ret = OMX_ErrorBadParameter;
1093 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1095 if (ComponentParameterStructure == NULL) {
1096 ret = OMX_ErrorBadParameter;
1099 if (pExynosComponent->currentState == OMX_StateInvalid) {
1100 ret = OMX_ErrorInvalidState;
1105 case OMX_IndexParamAudioInit:
1106 case OMX_IndexParamVideoInit:
1107 case OMX_IndexParamImageInit:
1108 case OMX_IndexParamOtherInit:
1110 OMX_PORT_PARAM_TYPE *portParam = (OMX_PORT_PARAM_TYPE *)ComponentParameterStructure;
1111 ret = Exynos_OMX_Check_SizeVersion(portParam, sizeof(OMX_PORT_PARAM_TYPE));
1112 if (ret != OMX_ErrorNone) {
1116 if ((pExynosComponent->currentState != OMX_StateLoaded) &&
1117 (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1118 ret = OMX_ErrorIncorrectStateOperation;
1121 ret = OMX_ErrorUndefined;
1122 /* Exynos_OSAL_Memcpy(&pExynosComponent->portParam, portParam, sizeof(OMX_PORT_PARAM_TYPE)); */
1125 case OMX_IndexParamPortDefinition:
1127 OMX_PARAM_PORTDEFINITIONTYPE *portDefinition = (OMX_PARAM_PORTDEFINITIONTYPE *)ComponentParameterStructure;
1128 OMX_U32 portIndex = portDefinition->nPortIndex;
1129 EXYNOS_OMX_BASEPORT *pExynosPort;
1130 OMX_PARAM_PORTDEFINITIONTYPE portDefinition_backup;
1132 if (portIndex >= pExynosComponent->portParam.nPorts) {
1133 ret = OMX_ErrorBadPortIndex;
1136 ret = Exynos_OMX_Check_SizeVersion(portDefinition, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1137 if (ret != OMX_ErrorNone) {
1141 pExynosPort = &pExynosComponent->pExynosPort[portIndex];
1143 if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1144 if (pExynosPort->portDefinition.bEnabled == OMX_TRUE) {
1145 ret = OMX_ErrorIncorrectStateOperation;
1149 if (portDefinition->nBufferCountActual < pExynosPort->portDefinition.nBufferCountMin) {
1150 ret = OMX_ErrorBadParameter;
1154 Exynos_OSAL_Memcpy(&portDefinition_backup, &pExynosPort->portDefinition, portDefinition->nSize);
1155 Exynos_OSAL_Memcpy(&pExynosPort->portDefinition, portDefinition, portDefinition->nSize);
1156 RESTORE_READONLYPARAMETERS_OMX_PARAM_PORTDEFINITIONTYPE(&pExynosPort->portDefinition,&portDefinition_backup);
1159 case OMX_IndexParamPriorityMgmt:
1161 OMX_PRIORITYMGMTTYPE *compPriority = (OMX_PRIORITYMGMTTYPE *)ComponentParameterStructure;
1163 if ((pExynosComponent->currentState != OMX_StateLoaded) &&
1164 (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1165 ret = OMX_ErrorIncorrectStateOperation;
1169 ret = Exynos_OMX_Check_SizeVersion(compPriority, sizeof(OMX_PRIORITYMGMTTYPE));
1170 if (ret != OMX_ErrorNone) {
1174 pExynosComponent->compPriority.nGroupID = compPriority->nGroupID;
1175 pExynosComponent->compPriority.nGroupPriority = compPriority->nGroupPriority;
1178 case OMX_IndexParamCompBufferSupplier:
1180 OMX_PARAM_BUFFERSUPPLIERTYPE *bufferSupplier = (OMX_PARAM_BUFFERSUPPLIERTYPE *)ComponentParameterStructure;
1181 OMX_U32 portIndex = bufferSupplier->nPortIndex;
1182 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1185 if (portIndex >= pExynosComponent->portParam.nPorts) {
1186 ret = OMX_ErrorBadPortIndex;
1189 ret = Exynos_OMX_Check_SizeVersion(bufferSupplier, sizeof(OMX_PARAM_BUFFERSUPPLIERTYPE));
1190 if (ret != OMX_ErrorNone) {
1194 pExynosPort = &pExynosComponent->pExynosPort[portIndex];
1195 if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1196 if (pExynosPort->portDefinition.bEnabled == OMX_TRUE) {
1197 ret = OMX_ErrorIncorrectStateOperation;
1202 if (bufferSupplier->eBufferSupplier == OMX_BufferSupplyUnspecified) {
1203 ret = OMX_ErrorNone;
1206 if (CHECK_PORT_TUNNELED(pExynosPort) == 0) {
1207 ret = OMX_ErrorNone; /*OMX_ErrorNone ?????*/
1211 if (pExynosPort->portDefinition.eDir == OMX_DirInput) {
1212 if (bufferSupplier->eBufferSupplier == OMX_BufferSupplyInput) {
1214 if (CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)) {
1215 ret = OMX_ErrorNone;
1218 pExynosPort->tunnelFlags |= EXYNOS_TUNNEL_IS_SUPPLIER;
1219 bufferSupplier->nPortIndex = pExynosPort->tunneledPort;
1220 ret = OMX_SetParameter(pExynosPort->tunneledComponent, OMX_IndexParamCompBufferSupplier, bufferSupplier);
1222 } else if (bufferSupplier->eBufferSupplier == OMX_BufferSupplyOutput) {
1223 ret = OMX_ErrorNone;
1224 if (CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)) {
1225 pExynosPort->tunnelFlags &= ~EXYNOS_TUNNEL_IS_SUPPLIER;
1226 bufferSupplier->nPortIndex = pExynosPort->tunneledPort;
1227 ret = OMX_SetParameter(pExynosPort->tunneledComponent, OMX_IndexParamCompBufferSupplier, bufferSupplier);
1231 } else if (pExynosPort->portDefinition.eDir == OMX_DirOutput) {
1232 if (bufferSupplier->eBufferSupplier == OMX_BufferSupplyInput) {
1233 ret = OMX_ErrorNone;
1234 if (CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)) {
1235 pExynosPort->tunnelFlags &= ~EXYNOS_TUNNEL_IS_SUPPLIER;
1236 ret = OMX_ErrorNone;
1239 } else if (bufferSupplier->eBufferSupplier == OMX_BufferSupplyOutput) {
1241 if (CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)) {
1242 ret = OMX_ErrorNone;
1245 pExynosPort->tunnelFlags |= EXYNOS_TUNNEL_IS_SUPPLIER;
1246 ret = OMX_ErrorNone;
1254 ret = OMX_ErrorUnsupportedIndex;
1260 ret = OMX_ErrorNone;
1269 OMX_ERRORTYPE Exynos_OMX_GetConfig(
1270 OMX_IN OMX_HANDLETYPE hComponent,
1271 OMX_IN OMX_INDEXTYPE nIndex,
1272 OMX_INOUT OMX_PTR pComponentConfigStructure)
1274 OMX_ERRORTYPE ret = OMX_ErrorNone;
1275 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1276 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1280 if (hComponent == NULL) {
1281 ret = OMX_ErrorBadParameter;
1284 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1285 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1286 if (ret != OMX_ErrorNone) {
1290 if (pOMXComponent->pComponentPrivate == NULL) {
1291 ret = OMX_ErrorBadParameter;
1294 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1296 if (pComponentConfigStructure == NULL) {
1297 ret = OMX_ErrorBadParameter;
1300 if (pExynosComponent->currentState == OMX_StateInvalid) {
1301 ret = OMX_ErrorInvalidState;
1307 ret = OMX_ErrorUnsupportedIndex;
1317 OMX_ERRORTYPE Exynos_OMX_SetConfig(
1318 OMX_IN OMX_HANDLETYPE hComponent,
1319 OMX_IN OMX_INDEXTYPE nIndex,
1320 OMX_IN OMX_PTR pComponentConfigStructure)
1322 OMX_ERRORTYPE ret = OMX_ErrorNone;
1323 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1324 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1328 if (hComponent == NULL) {
1329 ret = OMX_ErrorBadParameter;
1332 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1333 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1334 if (ret != OMX_ErrorNone) {
1338 if (pOMXComponent->pComponentPrivate == NULL) {
1339 ret = OMX_ErrorBadParameter;
1342 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1344 if (pComponentConfigStructure == NULL) {
1345 ret = OMX_ErrorBadParameter;
1348 if (pExynosComponent->currentState == OMX_StateInvalid) {
1349 ret = OMX_ErrorInvalidState;
1355 ret = OMX_ErrorUnsupportedIndex;
1365 OMX_ERRORTYPE Exynos_OMX_GetExtensionIndex(
1366 OMX_IN OMX_HANDLETYPE hComponent,
1367 OMX_IN OMX_STRING cParameterName,
1368 OMX_OUT OMX_INDEXTYPE *pIndexType)
1370 OMX_ERRORTYPE ret = OMX_ErrorNone;
1371 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1372 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1376 if (hComponent == NULL) {
1377 ret = OMX_ErrorBadParameter;
1380 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1381 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1382 if (ret != OMX_ErrorNone) {
1386 if (pOMXComponent->pComponentPrivate == NULL) {
1387 ret = OMX_ErrorBadParameter;
1390 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1392 if ((cParameterName == NULL) || (pIndexType == NULL)) {
1393 ret = OMX_ErrorBadParameter;
1396 if (pExynosComponent->currentState == OMX_StateInvalid) {
1397 ret = OMX_ErrorInvalidState;
1401 ret = OMX_ErrorBadParameter;
1409 OMX_ERRORTYPE Exynos_OMX_SetCallbacks (
1410 OMX_IN OMX_HANDLETYPE hComponent,
1411 OMX_IN OMX_CALLBACKTYPE* pCallbacks,
1412 OMX_IN OMX_PTR pAppData)
1414 OMX_ERRORTYPE ret = OMX_ErrorNone;
1415 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1416 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1420 if (hComponent == NULL) {
1421 ret = OMX_ErrorBadParameter;
1424 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1425 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1426 if (ret != OMX_ErrorNone) {
1430 if (pOMXComponent->pComponentPrivate == NULL) {
1431 ret = OMX_ErrorBadParameter;
1434 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1436 if (pCallbacks == NULL) {
1437 ret = OMX_ErrorBadParameter;
1440 if (pExynosComponent->currentState == OMX_StateInvalid) {
1441 ret = OMX_ErrorInvalidState;
1444 if (pExynosComponent->currentState != OMX_StateLoaded) {
1445 ret = OMX_ErrorIncorrectStateOperation;
1449 pExynosComponent->pCallbacks = pCallbacks;
1450 pExynosComponent->callbackData = pAppData;
1452 ret = OMX_ErrorNone;
1460 OMX_ERRORTYPE Exynos_OMX_UseEGLImage(
1461 OMX_IN OMX_HANDLETYPE hComponent,
1462 OMX_INOUT OMX_BUFFERHEADERTYPE **ppBufferHdr,
1463 OMX_IN OMX_U32 nPortIndex,
1464 OMX_IN OMX_PTR pAppPrivate,
1465 OMX_IN void *eglImage)
1467 return OMX_ErrorNotImplemented;
1470 OMX_ERRORTYPE Exynos_OMX_BaseComponent_Constructor(
1471 OMX_IN OMX_HANDLETYPE hComponent)
1473 OMX_ERRORTYPE ret = OMX_ErrorNone;
1474 OMX_COMPONENTTYPE *pOMXComponent;
1475 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1479 if (hComponent == NULL) {
1480 ret = OMX_ErrorBadParameter;
1481 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
1484 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1485 pExynosComponent = Exynos_OSAL_Malloc(sizeof(EXYNOS_OMX_BASECOMPONENT));
1486 if (pExynosComponent == NULL) {
1487 ret = OMX_ErrorInsufficientResources;
1488 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
1491 Exynos_OSAL_Memset(pExynosComponent, 0, sizeof(EXYNOS_OMX_BASECOMPONENT));
1492 pOMXComponent->pComponentPrivate = (OMX_PTR)pExynosComponent;
1494 ret = Exynos_OSAL_SemaphoreCreate(&pExynosComponent->msgSemaphoreHandle);
1495 if (ret != OMX_ErrorNone) {
1496 ret = OMX_ErrorInsufficientResources;
1497 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
1500 ret = Exynos_OSAL_MutexCreate(&pExynosComponent->compMutex);
1501 if (ret != OMX_ErrorNone) {
1502 ret = OMX_ErrorInsufficientResources;
1503 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
1507 pExynosComponent->bExitMessageHandlerThread = OMX_FALSE;
1508 Exynos_OSAL_QueueCreate(&pExynosComponent->messageQ, MAX_QUEUE_ELEMENTS);
1509 ret = Exynos_OSAL_ThreadCreate(&pExynosComponent->hMessageHandler, Exynos_OMX_MessageHandlerThread, pOMXComponent);
1510 if (ret != OMX_ErrorNone) {
1511 ret = OMX_ErrorInsufficientResources;
1512 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
1516 pExynosComponent->bMultiThreadProcess = OMX_FALSE;
1518 pOMXComponent->GetComponentVersion = &Exynos_OMX_GetComponentVersion;
1519 pOMXComponent->SendCommand = &Exynos_OMX_SendCommand;
1520 pOMXComponent->GetState = &Exynos_OMX_GetState;
1521 pOMXComponent->SetCallbacks = &Exynos_OMX_SetCallbacks;
1522 pOMXComponent->UseEGLImage = &Exynos_OMX_UseEGLImage;
1530 OMX_ERRORTYPE Exynos_OMX_BaseComponent_Destructor(
1531 OMX_IN OMX_HANDLETYPE hComponent)
1533 OMX_ERRORTYPE ret = OMX_ErrorNone;
1534 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1535 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1536 OMX_S32 semaValue = 0;
1540 if (hComponent == NULL) {
1541 ret = OMX_ErrorBadParameter;
1544 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1545 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1546 if (ret != OMX_ErrorNone) {
1550 if (pOMXComponent->pComponentPrivate == NULL) {
1551 ret = OMX_ErrorBadParameter;
1554 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1556 Exynos_OMX_CommandQueue(pExynosComponent, EXYNOS_OMX_CommandComponentDeInit, 0, NULL);
1557 Exynos_OSAL_SleepMillisec(0);
1558 Exynos_OSAL_Get_SemaphoreCount(pExynosComponent->msgSemaphoreHandle, &semaValue);
1560 Exynos_OSAL_SemaphorePost(pExynosComponent->msgSemaphoreHandle);
1561 Exynos_OSAL_SemaphorePost(pExynosComponent->msgSemaphoreHandle);
1563 Exynos_OSAL_ThreadTerminate(pExynosComponent->hMessageHandler);
1564 pExynosComponent->hMessageHandler = NULL;
1566 Exynos_OSAL_MutexTerminate(pExynosComponent->compMutex);
1567 pExynosComponent->compMutex = NULL;
1568 Exynos_OSAL_SemaphoreTerminate(pExynosComponent->msgSemaphoreHandle);
1569 pExynosComponent->msgSemaphoreHandle = NULL;
1570 Exynos_OSAL_QueueTerminate(&pExynosComponent->messageQ);
1572 Exynos_OSAL_Free(pExynosComponent);
1573 pExynosComponent = NULL;
1575 ret = OMX_ErrorNone;