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