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_VencControl.c
21 * @author SeungBeom Kim (sbcrux.kim@samsung.com)
31 #include "Exynos_OMX_Macros.h"
32 #include "Exynos_OSAL_Event.h"
33 #include "Exynos_OMX_Venc.h"
34 #include "Exynos_OMX_VencControl.h"
35 #include "Exynos_OMX_Basecomponent.h"
36 #include "Exynos_OSAL_Thread.h"
37 #include "Exynos_OSAL_Semaphore.h"
38 #include "Exynos_OSAL_Mutex.h"
39 #include "Exynos_OSAL_ETC.h"
40 #include "Exynos_OSAL_SharedMemory.h"
43 #include "Exynos_OSAL_Platform_Specific.h"
47 #define EXYNOS_LOG_TAG "EXYNOS_VIDEO_ENCCONTROL"
48 #define EXYNOS_LOG_OFF
49 //#define EXYNOS_TRACE_ON
50 #include "Exynos_OSAL_Log.h"
53 OMX_ERRORTYPE Exynos_OMX_UseBuffer(
54 OMX_IN OMX_HANDLETYPE hComponent,
55 OMX_INOUT OMX_BUFFERHEADERTYPE **ppBufferHdr,
56 OMX_IN OMX_U32 nPortIndex,
57 OMX_IN OMX_PTR pAppPrivate,
58 OMX_IN OMX_U32 nSizeBytes,
59 OMX_IN OMX_U8 *pBuffer)
61 OMX_ERRORTYPE ret = OMX_ErrorNone;
62 OMX_COMPONENTTYPE *pOMXComponent = NULL;
63 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
64 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
65 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
66 OMX_BUFFERHEADERTYPE *pTempBufferHdr = NULL;
71 if (hComponent == NULL) {
72 ret = OMX_ErrorBadParameter;
75 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
77 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
78 if (ret != OMX_ErrorNone) {
82 if (pOMXComponent->pComponentPrivate == NULL) {
83 ret = OMX_ErrorBadParameter;
86 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
88 if (pExynosComponent->hComponentHandle == NULL) {
89 ret = OMX_ErrorBadParameter;
92 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
94 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
95 ret = OMX_ErrorBadPortIndex;
98 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
100 if (pExynosPort->portState != OMX_StateIdle) {
101 ret = OMX_ErrorIncorrectStateOperation;
105 if (CHECK_PORT_TUNNELED(pExynosPort) && CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)) {
106 ret = OMX_ErrorBadPortIndex;
110 pTempBufferHdr = (OMX_BUFFERHEADERTYPE *)Exynos_OSAL_Malloc(sizeof(OMX_BUFFERHEADERTYPE));
111 if (pTempBufferHdr == NULL) {
112 ret = OMX_ErrorInsufficientResources;
115 Exynos_OSAL_Memset(pTempBufferHdr, 0, sizeof(OMX_BUFFERHEADERTYPE));
117 for (i = 0; i < pExynosPort->portDefinition.nBufferCountActual; i++) {
118 if (pExynosPort->bufferStateAllocate[i] == BUFFER_STATE_FREE) {
119 pExynosPort->extendBufferHeader[i].OMXBufferHeader = pTempBufferHdr;
120 pExynosPort->bufferStateAllocate[i] = (BUFFER_STATE_ASSIGNED | HEADER_STATE_ALLOCATED);
121 INIT_SET_SIZE_VERSION(pTempBufferHdr, OMX_BUFFERHEADERTYPE);
122 pTempBufferHdr->pBuffer = pBuffer;
123 pTempBufferHdr->nAllocLen = nSizeBytes;
124 pTempBufferHdr->pAppPrivate = pAppPrivate;
125 if (nPortIndex == INPUT_PORT_INDEX)
126 pTempBufferHdr->nInputPortIndex = INPUT_PORT_INDEX;
128 pTempBufferHdr->nOutputPortIndex = OUTPUT_PORT_INDEX;
129 #ifdef TIZEN_FEATURE_E3250
130 if (nPortIndex == OUTPUT_PORT_INDEX && pVideoEnc->bSharedOutputFD == OMX_TRUE)
131 pExynosPort->extendBufferHeader[i].buf_fd[0] = (int)(pBuffer); /*IL Client provides only FD value*/
133 MMVideoBuffer * pSlpOutBuf = (MMVideoBuffer *)pBuffer;
135 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "fd[0] =%d, fd[1] =%d, vaddr[0] =%p, vaddr[1] = %p, y_size=%d, uv_size=%d\n",
136 pSlpOutBuf->handle.dmabuf_fd[0], pSlpOutBuf->handle.dmabuf_fd[1], pSlpOutBuf->data[0], pSlpOutBuf->data[1],
137 pSlpOutBuf->size[0],pSlpOutBuf->size[1]);
138 if(nPortIndex == OUTPUT_PORT_INDEX )
139 pTempBufferHdr->pBuffer = pSlpOutBuf->handle.paddr[0];
141 pExynosPort->extendBufferHeader[i].buf_fd[0] = pSlpOutBuf->handle.dmabuf_fd[0];
142 pExynosPort->extendBufferHeader[i].buf_fd[1] = pSlpOutBuf->handle.dmabuf_fd[1];
143 pExynosPort->extendBufferHeader[i].buf_fd[2] = 0;
145 pExynosPort->extendBufferHeader[i].pYUVBuf[0] = pSlpOutBuf->data[0];
146 pExynosPort->extendBufferHeader[i].pYUVBuf[1] = pSlpOutBuf->data[1];
147 pExynosPort->extendBufferHeader[i].pYUVBuf[2] = NULL;
149 //pExynosPort->extendBufferHeader[i].tbm_bo[0] = pSlpOutBuf->handle.bo[0];
150 //pExynosPort->extendBufferHeader[i].tbm_bo[1] = pSlpOutBuf->handle.bo[1];
151 //pExynosPort->extendBufferHeader[i].tbm_bo[2] = NULL;
153 //pExynosPort->extendBufferHeader[i].size[0] = pSlpOutBuf->size[0];
154 //pExynosPort->extendBufferHeader[i].size[1] = pSlpOutBuf->size[1];
155 //pExynosPort->extendBufferHeader[i].size[2] = 0;
159 pExynosPort->assignedBufferNum++;
160 if (pExynosPort->assignedBufferNum == pExynosPort->portDefinition.nBufferCountActual) {
161 pExynosPort->portDefinition.bPopulated = OMX_TRUE;
162 /* Exynos_OSAL_MutexLock(pExynosComponent->compMutex); */
163 Exynos_OSAL_SemaphorePost(pExynosPort->loadedResource);
164 /* Exynos_OSAL_MutexUnlock(pExynosComponent->compMutex); */
166 *ppBufferHdr = pTempBufferHdr;
172 Exynos_OSAL_Free(pTempBufferHdr);
173 ret = OMX_ErrorInsufficientResources;
181 OMX_ERRORTYPE Exynos_OMX_AllocateBuffer(
182 OMX_IN OMX_HANDLETYPE hComponent,
183 OMX_INOUT OMX_BUFFERHEADERTYPE **ppBufferHdr,
184 OMX_IN OMX_U32 nPortIndex,
185 OMX_IN OMX_PTR pAppPrivate,
186 OMX_IN OMX_U32 nSizeBytes)
188 OMX_ERRORTYPE ret = OMX_ErrorNone;
189 OMX_COMPONENTTYPE *pOMXComponent = NULL;
190 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
191 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
192 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
193 OMX_BUFFERHEADERTYPE *pTempBufferHdr = NULL;
194 OMX_U8 *pTempBuffer = NULL;
195 int fdTempBuffer = -1;
196 MEMORY_TYPE eMemType;
201 if (hComponent == NULL) {
202 ret = OMX_ErrorBadParameter;
205 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
207 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
208 if (ret != OMX_ErrorNone) {
212 if (pOMXComponent->pComponentPrivate == NULL) {
213 ret = OMX_ErrorBadParameter;
216 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
218 if (pExynosComponent->hComponentHandle == NULL) {
219 ret = OMX_ErrorBadParameter;
222 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
224 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
225 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "[%p][%s] invalid parameter(0x%x)", pExynosComponent, __FUNCTION__, nPortIndex);
226 ret = OMX_ErrorBadPortIndex;
229 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
231 if (pExynosPort->portState != OMX_StateIdle ) {
232 ret = OMX_ErrorIncorrectStateOperation;
236 if (CHECK_PORT_TUNNELED(pExynosPort) && CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)) {
237 ret = OMX_ErrorBadPortIndex;
241 if (pExynosPort->bufferProcessType & BUFFER_SHARE)
242 eMemType = NORMAL_MEMORY;
244 eMemType = SYSTEM_MEMORY;
246 pTempBuffer = Exynos_OSAL_SharedMemory_Alloc(pVideoEnc->hSharedMemory, nSizeBytes, eMemType);
247 if (pTempBuffer == NULL) {
248 ret = OMX_ErrorInsufficientResources;
251 fdTempBuffer = Exynos_OSAL_SharedMemory_VirtToION(pVideoEnc->hSharedMemory, pTempBuffer);
253 pTempBufferHdr = (OMX_BUFFERHEADERTYPE *)Exynos_OSAL_Malloc(sizeof(OMX_BUFFERHEADERTYPE));
254 if (pTempBufferHdr == NULL) {
255 Exynos_OSAL_SharedMemory_Free(pVideoEnc->hSharedMemory, pTempBuffer);
256 ret = OMX_ErrorInsufficientResources;
259 Exynos_OSAL_Memset(pTempBufferHdr, 0, sizeof(OMX_BUFFERHEADERTYPE));
261 for (i = 0; i < pExynosPort->portDefinition.nBufferCountActual; i++) {
262 if (pExynosPort->bufferStateAllocate[i] == BUFFER_STATE_FREE) {
263 pExynosPort->extendBufferHeader[i].OMXBufferHeader = pTempBufferHdr;
264 pExynosPort->extendBufferHeader[i].buf_fd[0] = fdTempBuffer;
265 pExynosPort->bufferStateAllocate[i] = (BUFFER_STATE_ALLOCATED | HEADER_STATE_ALLOCATED);
266 INIT_SET_SIZE_VERSION(pTempBufferHdr, OMX_BUFFERHEADERTYPE);
267 pTempBufferHdr->pBuffer = pTempBuffer;
268 pTempBufferHdr->nAllocLen = nSizeBytes;
269 pTempBufferHdr->pAppPrivate = pAppPrivate;
270 if (nPortIndex == INPUT_PORT_INDEX)
271 pTempBufferHdr->nInputPortIndex = INPUT_PORT_INDEX;
273 pTempBufferHdr->nOutputPortIndex = OUTPUT_PORT_INDEX;
274 pExynosPort->assignedBufferNum++;
275 if (pExynosPort->assignedBufferNum == pExynosPort->portDefinition.nBufferCountActual) {
276 pExynosPort->portDefinition.bPopulated = OMX_TRUE;
277 /* Exynos_OSAL_MutexLock(pExynosComponent->compMutex); */
278 Exynos_OSAL_SemaphorePost(pExynosPort->loadedResource);
279 /* Exynos_OSAL_MutexUnlock(pExynosComponent->compMutex); */
281 *ppBufferHdr = pTempBufferHdr;
287 Exynos_OSAL_Free(pTempBufferHdr);
288 Exynos_OSAL_SharedMemory_Free(pVideoEnc->hSharedMemory, pTempBuffer);
289 ret = OMX_ErrorInsufficientResources;
297 OMX_ERRORTYPE Exynos_OMX_FreeBuffer(
298 OMX_IN OMX_HANDLETYPE hComponent,
299 OMX_IN OMX_U32 nPortIndex,
300 OMX_IN OMX_BUFFERHEADERTYPE *pBufferHdr)
302 OMX_ERRORTYPE ret = OMX_ErrorNone;
303 OMX_COMPONENTTYPE *pOMXComponent = NULL;
304 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
305 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
306 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
307 OMX_BUFFERHEADERTYPE *pOMXBufferHdr = NULL;
312 if (hComponent == NULL) {
313 ret = OMX_ErrorBadParameter;
316 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
318 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
319 if (ret != OMX_ErrorNone) {
323 if (pOMXComponent->pComponentPrivate == NULL) {
324 ret = OMX_ErrorBadParameter;
327 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
329 if (pExynosComponent->hComponentHandle == NULL) {
330 ret = OMX_ErrorBadParameter;
333 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
335 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
336 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "[%p][%s] invalid parameter(0x%x)", pExynosComponent, __FUNCTION__, nPortIndex);
337 ret = OMX_ErrorBadPortIndex;
340 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
342 if (CHECK_PORT_TUNNELED(pExynosPort) && CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)) {
343 ret = OMX_ErrorBadPortIndex;
347 if ((pExynosPort->portState != OMX_StateLoaded) &&
348 (pExynosPort->portState != OMX_StateInvalid)) {
349 (*(pExynosComponent->pCallbacks->EventHandler)) (pOMXComponent,
350 pExynosComponent->callbackData,
351 (OMX_U32)OMX_EventError,
352 (OMX_U32)OMX_ErrorPortUnpopulated,
356 for (i = 0; i < /*pExynosPort->portDefinition.nBufferCountActual*/MAX_BUFFER_NUM; i++) {
357 if ((pExynosPort->bufferStateAllocate[i] != BUFFER_STATE_FREE) &&
358 (pExynosPort->extendBufferHeader[i].OMXBufferHeader != NULL)) {
359 pOMXBufferHdr = pExynosPort->extendBufferHeader[i].OMXBufferHeader;
361 if (pOMXBufferHdr->pBuffer == pBufferHdr->pBuffer) {
362 if (pExynosPort->bufferStateAllocate[i] & BUFFER_STATE_ALLOCATED) {
363 Exynos_OSAL_SharedMemory_Free(pVideoEnc->hSharedMemory, pOMXBufferHdr->pBuffer);
364 pOMXBufferHdr->pBuffer = NULL;
365 pBufferHdr->pBuffer = NULL;
366 } else if (pExynosPort->bufferStateAllocate[i] & BUFFER_STATE_ASSIGNED) {
369 pExynosPort->assignedBufferNum--;
371 if (pExynosPort->bufferStateAllocate[i] & HEADER_STATE_ALLOCATED) {
372 Exynos_OSAL_Free(pOMXBufferHdr);
373 pExynosPort->extendBufferHeader[i].OMXBufferHeader = NULL;
377 pExynosPort->bufferStateAllocate[i] = BUFFER_STATE_FREE;
385 if ((ret == OMX_ErrorNone) &&
386 (pExynosPort->assignedBufferNum == 0)) {
387 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pExynosPort->unloadedResource signal set");
388 /* Exynos_OSAL_MutexLock(pExynosComponent->compMutex); */
389 Exynos_OSAL_SemaphorePost(pExynosPort->unloadedResource);
390 /* Exynos_OSAL_MutexUnlock(pExynosComponent->compMutex); */
391 pExynosPort->portDefinition.bPopulated = OMX_FALSE;
399 OMX_ERRORTYPE Exynos_OMX_AllocateTunnelBuffer(
400 EXYNOS_OMX_BASEPORT *pOMXBasePort,
403 return OMX_ErrorTunnelingUnsupported;
406 OMX_ERRORTYPE Exynos_OMX_FreeTunnelBuffer(
407 EXYNOS_OMX_BASEPORT *pOMXBasePort,
410 return OMX_ErrorTunnelingUnsupported;
413 OMX_ERRORTYPE Exynos_OMX_ComponentTunnelRequest(
414 OMX_IN OMX_HANDLETYPE hComp,
415 OMX_IN OMX_U32 nPort,
416 OMX_IN OMX_HANDLETYPE hTunneledComp,
417 OMX_IN OMX_U32 nTunneledPort,
418 OMX_INOUT OMX_TUNNELSETUPTYPE *pTunnelSetup)
420 return OMX_ErrorTunnelingUnsupported;
423 OMX_ERRORTYPE Exynos_OMX_GetFlushBuffer(
424 EXYNOS_OMX_BASEPORT *pExynosPort,
425 EXYNOS_OMX_DATABUFFER *pDataBuffer[])
427 OMX_ERRORTYPE ret = OMX_ErrorNone;
433 if (pExynosPort->portWayType == WAY1_PORT) {
434 *pDataBuffer = &pExynosPort->way.port1WayDataBuffer.dataBuffer;
435 } else if (pExynosPort->portWayType == WAY2_PORT) {
436 pDataBuffer[0] = &(pExynosPort->way.port2WayDataBuffer.inputDataBuffer);
437 pDataBuffer[1] = &(pExynosPort->way.port2WayDataBuffer.outputDataBuffer);
445 OMX_ERRORTYPE Exynos_OMX_FlushPort(
446 OMX_COMPONENTTYPE *pOMXComponent,
449 OMX_ERRORTYPE ret = OMX_ErrorNone;
450 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
451 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
452 OMX_BUFFERHEADERTYPE *pBufferHdr = NULL;
453 EXYNOS_OMX_DATABUFFER *pDataBuffer[2] = {NULL, NULL};
454 EXYNOS_OMX_MESSAGE *pMessage = NULL;
455 OMX_S32 nSemaCnt = 0;
459 #ifdef TIZEN_FEATURE_E3250
460 Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "flushPort idx:%d", nPortIndex);
463 if (pOMXComponent == NULL) {
464 ret = OMX_ErrorBadParameter;
468 if (pOMXComponent->pComponentPrivate == NULL) {
469 ret = OMX_ErrorBadParameter;
472 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
474 if ((nPortIndex < 0) ||
475 (nPortIndex >= pExynosComponent->portParam.nPorts)) {
476 ret = OMX_ErrorBadPortIndex;
479 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
481 while (Exynos_OSAL_GetElemNum(&pExynosPort->bufferQ) > 0) {
482 Exynos_OSAL_Get_SemaphoreCount(pExynosPort->bufferSemID, &nSemaCnt);
484 Exynos_OSAL_SemaphorePost(pExynosPort->bufferSemID);
486 Exynos_OSAL_SemaphoreWait(pExynosPort->bufferSemID);
487 pMessage = (EXYNOS_OMX_MESSAGE *)Exynos_OSAL_Dequeue(&pExynosPort->bufferQ);
488 if ((pMessage != NULL) &&
489 (pMessage->messageType != EXYNOS_OMX_CommandFakeBuffer)) {
490 pBufferHdr = (OMX_BUFFERHEADERTYPE *)pMessage->pCmdData;
491 pBufferHdr->nFilledLen = 0;
493 if (nPortIndex == OUTPUT_PORT_INDEX) {
494 Exynos_OMX_OutputBufferReturn(pOMXComponent, pBufferHdr);
495 } else if (nPortIndex == INPUT_PORT_INDEX) {
496 Exynos_OMX_InputBufferReturn(pOMXComponent, pBufferHdr);
499 Exynos_OSAL_Free(pMessage);
503 Exynos_OMX_GetFlushBuffer(pExynosPort, pDataBuffer);
504 if ((pDataBuffer[0] != NULL) &&
505 (pDataBuffer[0]->dataValid == OMX_TRUE)) {
506 if (nPortIndex == INPUT_PORT_INDEX)
507 Exynos_FlushInputBufferReturn(pOMXComponent, pDataBuffer[0]);
508 else if (nPortIndex == OUTPUT_PORT_INDEX)
509 Exynos_FlushOutputBufferReturn(pOMXComponent, pDataBuffer[0]);
511 if ((pDataBuffer[1] != NULL) &&
512 (pDataBuffer[1]->dataValid == OMX_TRUE)) {
513 if (nPortIndex == INPUT_PORT_INDEX)
514 Exynos_FlushInputBufferReturn(pOMXComponent, pDataBuffer[1]);
515 else if (nPortIndex == OUTPUT_PORT_INDEX)
516 Exynos_FlushOutputBufferReturn(pOMXComponent, pDataBuffer[1]);
519 if (pExynosComponent->bMultiThreadProcess == OMX_TRUE) {
520 if (pExynosPort->bufferProcessType & BUFFER_SHARE) {
521 if (pExynosPort->processData.bufferHeader != NULL) {
522 if (nPortIndex == INPUT_PORT_INDEX) {
523 Exynos_OMX_InputBufferReturn(pOMXComponent, pExynosPort->processData.bufferHeader);
524 } else if (nPortIndex == OUTPUT_PORT_INDEX) {
525 Exynos_OMX_OutputBufferReturn(pOMXComponent, pExynosPort->processData.bufferHeader);
528 Exynos_ResetCodecData(&pExynosPort->processData);
530 for (i = 0; i < pExynosPort->portDefinition.nBufferCountActual; i++) {
531 if (pExynosPort->extendBufferHeader[i].bBufferInOMX == OMX_TRUE) {
532 if (nPortIndex == OUTPUT_PORT_INDEX) {
533 Exynos_OMX_OutputBufferReturn(pOMXComponent,
534 pExynosPort->extendBufferHeader[i].OMXBufferHeader);
535 } else if (nPortIndex == INPUT_PORT_INDEX) {
536 Exynos_OMX_InputBufferReturn(pOMXComponent,
537 pExynosPort->extendBufferHeader[i].OMXBufferHeader);
543 Exynos_ResetCodecData(&pExynosPort->processData);
548 Exynos_OSAL_Get_SemaphoreCount(pExynosPort->bufferSemID, &cnt);
551 Exynos_OSAL_SemaphoreWait(pExynosPort->bufferSemID);
553 Exynos_OSAL_ResetQueue(&pExynosPort->bufferQ);
561 OMX_ERRORTYPE Exynos_OMX_BufferFlush(
562 OMX_COMPONENTTYPE *pOMXComponent,
566 OMX_ERRORTYPE ret = OMX_ErrorNone;
567 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
568 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
569 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
570 EXYNOS_OMX_DATABUFFER *pDataBuffer[2] = {NULL, NULL};
573 #ifdef TIZEN_FEATURE_E3250
574 Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "bufferFlush idx:%d", nPortIndex);
577 if (pOMXComponent == NULL) {
578 ret = OMX_ErrorBadParameter;
582 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
583 if (ret != OMX_ErrorNone) {
587 if (pOMXComponent->pComponentPrivate == NULL) {
588 ret = OMX_ErrorBadParameter;
591 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
593 if (pExynosComponent->hComponentHandle == NULL) {
594 ret = OMX_ErrorBadParameter;
597 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
599 if ((nPortIndex < 0) ||
600 (nPortIndex >= pExynosComponent->portParam.nPorts)) {
601 ret = OMX_ErrorBadPortIndex;
604 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
606 Exynos_OSAL_Log(EXYNOS_LOG_TRACE,"OMX_CommandFlush start, port:%d", nPortIndex);
608 pExynosPort->bIsPortFlushed = OMX_TRUE;
610 if (pExynosComponent->bMultiThreadProcess == OMX_FALSE) {
611 Exynos_OSAL_SignalSet(pExynosComponent->pauseEvent);
613 Exynos_OSAL_SignalSet(pExynosPort->pauseEvent);
616 Exynos_OMX_GetFlushBuffer(pExynosPort, pDataBuffer);
617 if (pDataBuffer[0] == NULL) {
618 ret = OMX_ErrorBadParameter;
622 if (pExynosPort->bufferProcessType & BUFFER_COPY)
623 Exynos_OSAL_SemaphorePost(pExynosPort->codecSemID);
624 Exynos_OSAL_SemaphorePost(pExynosPort->bufferSemID);
626 pVideoEnc->exynos_codec_bufferProcessRun(pOMXComponent, nPortIndex);
628 Exynos_OSAL_MutexLock(pDataBuffer[0]->bufferMutex);
629 pVideoEnc->exynos_codec_stop(pOMXComponent, nPortIndex);
631 if (pDataBuffer[1] != NULL)
632 Exynos_OSAL_MutexLock(pDataBuffer[1]->bufferMutex);
634 ret = Exynos_OMX_FlushPort(pOMXComponent, nPortIndex);
635 if (ret != OMX_ErrorNone) {
636 if (pDataBuffer[1] != NULL)
637 Exynos_OSAL_MutexUnlock(pDataBuffer[1]->bufferMutex);
639 Exynos_OSAL_MutexUnlock(pDataBuffer[0]->bufferMutex);
644 if (pExynosPort->bufferProcessType & BUFFER_COPY)
645 pVideoEnc->exynos_codec_enqueueAllBuffer(pOMXComponent, nPortIndex);
646 Exynos_ResetCodecData(&pExynosPort->processData);
648 if (ret == OMX_ErrorNone) {
649 if (nPortIndex == INPUT_PORT_INDEX) {
650 pExynosComponent->checkTimeStamp.needSetStartTimeStamp = OMX_TRUE;
651 pExynosComponent->checkTimeStamp.needCheckStartTimeStamp = OMX_FALSE;
652 Exynos_OSAL_Memset(pExynosComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
653 Exynos_OSAL_Memset(pExynosComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
654 pExynosComponent->getAllDelayBuffer = OMX_FALSE;
655 pExynosComponent->bSaveFlagEOS = OMX_FALSE;
656 pExynosComponent->reInputData = OMX_FALSE;
659 pExynosPort->bIsPortFlushed = OMX_FALSE;
660 Exynos_OSAL_Log(EXYNOS_LOG_TRACE,"OMX_CommandFlush EventCmdComplete, port:%d", nPortIndex);
661 if (bEvent == OMX_TRUE)
662 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
663 pExynosComponent->callbackData,
664 OMX_EventCmdComplete,
665 OMX_CommandFlush, nPortIndex, NULL);
668 if (pDataBuffer[1] != NULL)
669 Exynos_OSAL_MutexUnlock(pDataBuffer[1]->bufferMutex);
671 Exynos_OSAL_MutexUnlock(pDataBuffer[0]->bufferMutex);
674 if ((ret != OMX_ErrorNone) && (pOMXComponent != NULL) && (pExynosComponent != NULL)) {
675 Exynos_OSAL_Log(EXYNOS_LOG_ERROR,"%s : %d", __FUNCTION__, __LINE__);
676 pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
677 pExynosComponent->callbackData,
687 OMX_ERRORTYPE Exynos_InputBufferReturn(
688 OMX_COMPONENTTYPE *pOMXComponent)
690 OMX_ERRORTYPE ret = OMX_ErrorNone;
691 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
692 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
693 EXYNOS_OMX_DATABUFFER *pDataBuffer = NULL;
694 OMX_BUFFERHEADERTYPE *pBufferHdr = NULL;
698 if (pOMXComponent == NULL) {
699 ret = OMX_ErrorBadParameter;
703 if (pOMXComponent->pComponentPrivate == NULL) {
704 ret = OMX_ErrorBadParameter;
707 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
708 pExynosPort = &(pExynosComponent->pExynosPort[INPUT_PORT_INDEX]);
710 if (pExynosPort->bufferProcessType & BUFFER_COPY) {
711 pDataBuffer = &(pExynosPort->way.port2WayDataBuffer.inputDataBuffer);
712 } else if (pExynosPort->bufferProcessType & BUFFER_SHARE) {
713 pDataBuffer = &(pExynosPort->way.port2WayDataBuffer.outputDataBuffer);
716 pBufferHdr = pDataBuffer->bufferHeader;
718 if (pBufferHdr != NULL) {
719 if (pExynosPort->markType.hMarkTargetComponent != NULL) {
720 pBufferHdr->hMarkTargetComponent = pExynosPort->markType.hMarkTargetComponent;
721 pBufferHdr->pMarkData = pExynosPort->markType.pMarkData;
722 pExynosPort->markType.hMarkTargetComponent = NULL;
723 pExynosPort->markType.pMarkData = NULL;
726 if (pBufferHdr->hMarkTargetComponent != NULL) {
727 if (pBufferHdr->hMarkTargetComponent == pOMXComponent) {
728 pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
729 pExynosComponent->callbackData,
731 0, 0, pBufferHdr->pMarkData);
733 pExynosComponent->propagateMarkType.hMarkTargetComponent = pBufferHdr->hMarkTargetComponent;
734 pExynosComponent->propagateMarkType.pMarkData = pBufferHdr->pMarkData;
738 pBufferHdr->nFilledLen = 0;
739 pBufferHdr->nOffset = 0;
740 Exynos_OMX_InputBufferReturn(pOMXComponent, pBufferHdr);
743 /* reset dataBuffer */
744 Exynos_ResetDataBuffer(pDataBuffer);
752 OMX_ERRORTYPE Exynos_FlushInputBufferReturn(
753 OMX_COMPONENTTYPE *pOMXComponent,
754 EXYNOS_OMX_DATABUFFER *pDataBuffer)
756 OMX_ERRORTYPE ret = OMX_ErrorNone;
757 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
758 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
759 OMX_BUFFERHEADERTYPE *pBufferHdr = NULL;
763 if (pOMXComponent == NULL) {
764 ret = OMX_ErrorBadParameter;
768 if (pOMXComponent->pComponentPrivate == NULL) {
769 ret = OMX_ErrorBadParameter;
772 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
773 pExynosPort = &(pExynosComponent->pExynosPort[INPUT_PORT_INDEX]);
775 pBufferHdr = pDataBuffer->bufferHeader;
777 if (pBufferHdr != NULL) {
778 if (pExynosPort->markType.hMarkTargetComponent != NULL) {
779 pBufferHdr->hMarkTargetComponent = pExynosPort->markType.hMarkTargetComponent;
780 pBufferHdr->pMarkData = pExynosPort->markType.pMarkData;
781 pExynosPort->markType.hMarkTargetComponent = NULL;
782 pExynosPort->markType.pMarkData = NULL;
785 if (pBufferHdr->hMarkTargetComponent != NULL) {
786 if (pBufferHdr->hMarkTargetComponent == pOMXComponent) {
787 pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
788 pExynosComponent->callbackData,
790 0, 0, pBufferHdr->pMarkData);
792 pExynosComponent->propagateMarkType.hMarkTargetComponent = pBufferHdr->hMarkTargetComponent;
793 pExynosComponent->propagateMarkType.pMarkData = pBufferHdr->pMarkData;
797 pBufferHdr->nFilledLen = 0;
798 pBufferHdr->nOffset = 0;
799 Exynos_OMX_InputBufferReturn(pOMXComponent, pBufferHdr);
802 /* reset dataBuffer */
803 Exynos_ResetDataBuffer(pDataBuffer);
811 OMX_ERRORTYPE Exynos_InputBufferGetQueue(
812 EXYNOS_OMX_BASECOMPONENT *pExynosComponent)
814 OMX_ERRORTYPE ret = OMX_ErrorUndefined;
815 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
816 EXYNOS_OMX_MESSAGE *pMessage = NULL;
817 EXYNOS_OMX_DATABUFFER *pDataBuffer = NULL;
821 if (pExynosComponent == NULL) {
822 ret = OMX_ErrorBadParameter;
825 pExynosPort = &(pExynosComponent->pExynosPort[INPUT_PORT_INDEX]);
826 pDataBuffer = &(pExynosPort->way.port2WayDataBuffer.inputDataBuffer);
828 if (pExynosComponent->currentState != OMX_StateExecuting) {
829 ret = OMX_ErrorUndefined;
831 } else if ((pExynosComponent->transientState != EXYNOS_OMX_TransStateExecutingToIdle) &&
832 (!CHECK_PORT_BEING_FLUSHED(pExynosPort))) {
833 Exynos_OSAL_SemaphoreWait(pExynosPort->bufferSemID);
834 if (pDataBuffer->dataValid != OMX_TRUE) {
835 pMessage = (EXYNOS_OMX_MESSAGE *)Exynos_OSAL_Dequeue(&pExynosPort->bufferQ);
836 if (pMessage == NULL) {
837 ret = OMX_ErrorUndefined;
840 if (pMessage->messageType == EXYNOS_OMX_CommandFakeBuffer) {
841 Exynos_OSAL_Free(pMessage);
842 ret = OMX_ErrorCodecFlush;
846 pDataBuffer->bufferHeader = (OMX_BUFFERHEADERTYPE *)(pMessage->pCmdData);
847 pDataBuffer->allocSize = pDataBuffer->bufferHeader->nAllocLen;
848 pDataBuffer->dataLen = pDataBuffer->bufferHeader->nFilledLen;
849 pDataBuffer->remainDataLen = pDataBuffer->dataLen;
850 pDataBuffer->usedDataLen = 0;
851 pDataBuffer->dataValid = OMX_TRUE;
852 pDataBuffer->nFlags = pDataBuffer->bufferHeader->nFlags;
853 pDataBuffer->timeStamp = pDataBuffer->bufferHeader->nTimeStamp;
855 Exynos_OSAL_Free(pMessage);
857 #ifndef TIZEN_FEATURE_E3250
858 if (pDataBuffer->allocSize <= pDataBuffer->dataLen)
859 Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "Input Buffer Full, Check input buffer size! allocSize:%d, dataLen:%d", pDataBuffer->allocSize, pDataBuffer->dataLen);
870 OMX_ERRORTYPE Exynos_OutputBufferReturn(
871 OMX_COMPONENTTYPE *pOMXComponent)
873 OMX_ERRORTYPE ret = OMX_ErrorNone;
874 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
875 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
876 EXYNOS_OMX_DATABUFFER *pDataBuffer = NULL;
877 OMX_BUFFERHEADERTYPE *pBufferHdr = NULL;
881 if (pOMXComponent == NULL) {
882 ret = OMX_ErrorBadParameter;
886 if (pOMXComponent->pComponentPrivate == NULL) {
887 ret = OMX_ErrorBadParameter;
890 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
891 pExynosPort = &(pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX]);
893 pDataBuffer = &(pExynosPort->way.port2WayDataBuffer.outputDataBuffer);
894 pBufferHdr = pDataBuffer->bufferHeader;
896 if (pBufferHdr != NULL) {
897 pBufferHdr->nFilledLen = pDataBuffer->remainDataLen;
898 pBufferHdr->nOffset = 0;
899 pBufferHdr->nFlags = pDataBuffer->nFlags;
900 pBufferHdr->nTimeStamp = pDataBuffer->timeStamp;
902 if (pExynosComponent->propagateMarkType.hMarkTargetComponent != NULL) {
903 pBufferHdr->hMarkTargetComponent = pExynosComponent->propagateMarkType.hMarkTargetComponent;
904 pBufferHdr->pMarkData = pExynosComponent->propagateMarkType.pMarkData;
905 pExynosComponent->propagateMarkType.hMarkTargetComponent = NULL;
906 pExynosComponent->propagateMarkType.pMarkData = NULL;
909 if ((pBufferHdr->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
910 pBufferHdr->nFilledLen = 0;
911 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "event OMX_BUFFERFLAG_EOS!!!");
912 pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
913 pExynosComponent->callbackData,
916 pBufferHdr->nFlags, NULL);
919 Exynos_OMX_OutputBufferReturn(pOMXComponent, pBufferHdr);
922 /* reset dataBuffer */
923 Exynos_ResetDataBuffer(pDataBuffer);
931 OMX_ERRORTYPE Exynos_FlushOutputBufferReturn(
932 OMX_COMPONENTTYPE *pOMXComponent,
933 EXYNOS_OMX_DATABUFFER *pDataBuffer)
935 OMX_ERRORTYPE ret = OMX_ErrorNone;
936 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
937 OMX_BUFFERHEADERTYPE *pBufferHdr = NULL;
941 if (pOMXComponent == NULL) {
942 ret = OMX_ErrorBadParameter;
946 if (pOMXComponent->pComponentPrivate == NULL) {
947 ret = OMX_ErrorBadParameter;
950 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
951 pBufferHdr = pDataBuffer->bufferHeader;
953 if (pBufferHdr != NULL) {
954 pBufferHdr->nFilledLen = pDataBuffer->remainDataLen;
955 pBufferHdr->nOffset = 0;
956 pBufferHdr->nFlags = pDataBuffer->nFlags;
957 pBufferHdr->nTimeStamp = pDataBuffer->timeStamp;
959 if (pExynosComponent->propagateMarkType.hMarkTargetComponent != NULL) {
960 pBufferHdr->hMarkTargetComponent = pExynosComponent->propagateMarkType.hMarkTargetComponent;
961 pBufferHdr->pMarkData = pExynosComponent->propagateMarkType.pMarkData;
962 pExynosComponent->propagateMarkType.hMarkTargetComponent = NULL;
963 pExynosComponent->propagateMarkType.pMarkData = NULL;
966 if ((pBufferHdr->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
967 pBufferHdr->nFilledLen = 0;
968 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "event OMX_BUFFERFLAG_EOS!!!");
969 pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
970 pExynosComponent->callbackData,
973 pBufferHdr->nFlags, NULL);
975 Exynos_OMX_OutputBufferReturn(pOMXComponent, pBufferHdr);
978 /* reset dataBuffer */
979 Exynos_ResetDataBuffer(pDataBuffer);
987 OMX_ERRORTYPE Exynos_OutputBufferGetQueue(
988 EXYNOS_OMX_BASECOMPONENT *pExynosComponent)
990 OMX_ERRORTYPE ret = OMX_ErrorUndefined;
991 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
992 EXYNOS_OMX_MESSAGE *pMessage = NULL;
993 EXYNOS_OMX_DATABUFFER *pDataBuffer = NULL;
997 if (pExynosComponent == NULL) {
998 ret = OMX_ErrorBadParameter;
1001 pExynosPort = &(pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX]);
1003 if (pExynosPort->bufferProcessType & BUFFER_COPY) {
1004 pDataBuffer = &(pExynosPort->way.port2WayDataBuffer.outputDataBuffer);
1005 } else if (pExynosPort->bufferProcessType & BUFFER_SHARE) {
1006 pDataBuffer = &(pExynosPort->way.port2WayDataBuffer.inputDataBuffer);
1009 if (pExynosComponent->currentState != OMX_StateExecuting) {
1010 ret = OMX_ErrorUndefined;
1012 } else if ((pExynosComponent->transientState != EXYNOS_OMX_TransStateExecutingToIdle) &&
1013 (!CHECK_PORT_BEING_FLUSHED(pExynosPort))) {
1014 Exynos_OSAL_SemaphoreWait(pExynosPort->bufferSemID);
1015 if (pDataBuffer->dataValid != OMX_TRUE) {
1016 pMessage = (EXYNOS_OMX_MESSAGE *)Exynos_OSAL_Dequeue(&pExynosPort->bufferQ);
1017 if (pMessage == NULL) {
1018 ret = OMX_ErrorUndefined;
1021 if (pMessage->messageType == EXYNOS_OMX_CommandFakeBuffer) {
1022 Exynos_OSAL_Free(pMessage);
1023 ret = OMX_ErrorCodecFlush;
1027 pDataBuffer->bufferHeader = (OMX_BUFFERHEADERTYPE *)(pMessage->pCmdData);
1028 pDataBuffer->allocSize = pDataBuffer->bufferHeader->nAllocLen;
1029 pDataBuffer->dataLen = 0; //dataBuffer->bufferHeader->nFilledLen;
1030 pDataBuffer->remainDataLen = pDataBuffer->dataLen;
1031 pDataBuffer->usedDataLen = 0; //dataBuffer->bufferHeader->nOffset;
1032 pDataBuffer->dataValid = OMX_TRUE;
1033 /* pDataBuffer->nFlags = pDataBuffer->bufferHeader->nFlags; */
1034 /* pDtaBuffer->nTimeStamp = pDataBuffer->bufferHeader->nTimeStamp; */
1036 if (pExynosPort->bufferProcessType & BUFFER_SHARE)
1037 pDataBuffer->pPrivate = pDataBuffer->bufferHeader->pOutputPortPrivate;
1038 else if (pExynosPort->bufferProcessType & BUFFER_COPY) {
1039 pExynosPort->processData.dataBuffer = pDataBuffer->bufferHeader->pBuffer;
1040 pExynosPort->processData.allocSize = pDataBuffer->bufferHeader->nAllocLen;
1043 Exynos_OSAL_Free(pMessage);
1045 ret = OMX_ErrorNone;
1053 OMX_BUFFERHEADERTYPE *Exynos_OutputBufferGetQueue_Direct(
1054 EXYNOS_OMX_BASECOMPONENT *pExynosComponent)
1056 OMX_BUFFERHEADERTYPE *pBufferHdr = NULL;
1057 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1058 EXYNOS_OMX_MESSAGE *pMessage = NULL;
1062 if (pExynosComponent == NULL) {
1066 pExynosPort = &(pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX]);
1068 if (pExynosComponent->currentState != OMX_StateExecuting) {
1071 } else if ((pExynosComponent->transientState != EXYNOS_OMX_TransStateExecutingToIdle) &&
1072 (!CHECK_PORT_BEING_FLUSHED(pExynosPort))) {
1073 Exynos_OSAL_SemaphoreWait(pExynosPort->bufferSemID);
1075 pMessage = (EXYNOS_OMX_MESSAGE *)Exynos_OSAL_Dequeue(&pExynosPort->bufferQ);
1076 if (pMessage == NULL) {
1080 if (pMessage->messageType == EXYNOS_OMX_CommandFakeBuffer) {
1081 Exynos_OSAL_Free(pMessage);
1086 pBufferHdr = (OMX_BUFFERHEADERTYPE *)(pMessage->pCmdData);
1087 Exynos_OSAL_Free(pMessage);
1096 OMX_ERRORTYPE Exynos_CodecBufferEnqueue(
1097 EXYNOS_OMX_BASECOMPONENT *pExynosComponent,
1101 OMX_ERRORTYPE ret = OMX_ErrorNone;
1102 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1106 if (pExynosComponent == NULL) {
1107 ret = OMX_ErrorBadParameter;
1111 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1112 ret = OMX_ErrorBadPortIndex;
1115 pExynosPort = &(pExynosComponent->pExynosPort[nPortIndex]);
1117 if (pData == NULL) {
1118 ret = OMX_ErrorInsufficientResources;
1122 ret = Exynos_OSAL_Queue(&pExynosPort->codecBufferQ, (void *)pData);
1124 ret = OMX_ErrorUndefined;
1127 Exynos_OSAL_SemaphorePost(pExynosPort->codecSemID);
1129 ret = OMX_ErrorNone;
1137 OMX_ERRORTYPE Exynos_CodecBufferDequeue(
1138 EXYNOS_OMX_BASECOMPONENT *pExynosComponent,
1142 OMX_ERRORTYPE ret = OMX_ErrorNone;
1143 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1144 OMX_PTR pTempData = NULL;
1148 if (pExynosComponent == NULL) {
1149 ret = OMX_ErrorBadParameter;
1153 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1154 ret = OMX_ErrorBadPortIndex;
1157 pExynosPort = &(pExynosComponent->pExynosPort[nPortIndex]);
1159 Exynos_OSAL_SemaphoreWait(pExynosPort->codecSemID);
1160 pTempData = (OMX_PTR)Exynos_OSAL_Dequeue(&pExynosPort->codecBufferQ);
1161 if (pTempData != NULL) {
1162 *pData = (OMX_PTR)pTempData;
1163 ret = OMX_ErrorNone;
1166 ret = OMX_ErrorUndefined;
1175 OMX_ERRORTYPE Exynos_CodecBufferReset(
1176 EXYNOS_OMX_BASECOMPONENT *pExynosComponent,
1179 OMX_ERRORTYPE ret = OMX_ErrorNone;
1180 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1184 if (pExynosComponent == NULL) {
1185 ret = OMX_ErrorBadParameter;
1189 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1190 ret = OMX_ErrorBadPortIndex;
1193 pExynosPort = &(pExynosComponent->pExynosPort[nPortIndex]);
1195 ret = Exynos_OSAL_ResetQueue(&pExynosPort->codecBufferQ);
1197 ret = OMX_ErrorUndefined;
1203 Exynos_OSAL_Get_SemaphoreCount(pExynosPort->codecSemID, &cnt);
1205 Exynos_OSAL_SemaphoreWait(pExynosPort->codecSemID);
1209 ret = OMX_ErrorNone;
1217 OMX_ERRORTYPE Exynos_OMX_VideoEncodeGetParameter(
1218 OMX_IN OMX_HANDLETYPE hComponent,
1219 OMX_IN OMX_INDEXTYPE nParamIndex,
1220 OMX_INOUT OMX_PTR pComponentParameterStructure)
1222 OMX_ERRORTYPE ret = OMX_ErrorNone;
1223 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1224 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1228 if (hComponent == NULL) {
1229 ret = OMX_ErrorBadParameter;
1232 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1234 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1235 if (ret != OMX_ErrorNone) {
1239 if (pOMXComponent->pComponentPrivate == NULL) {
1240 ret = OMX_ErrorBadParameter;
1243 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1245 if (pExynosComponent->currentState == OMX_StateInvalid) {
1246 ret = OMX_ErrorInvalidState;
1250 if (pComponentParameterStructure == NULL) {
1251 ret = OMX_ErrorBadParameter;
1255 switch (nParamIndex) {
1256 case OMX_IndexParamVideoInit:
1258 OMX_PORT_PARAM_TYPE *pPortParam = (OMX_PORT_PARAM_TYPE *)pComponentParameterStructure;
1259 ret = Exynos_OMX_Check_SizeVersion(pPortParam, sizeof(OMX_PORT_PARAM_TYPE));
1260 if (ret != OMX_ErrorNone) {
1264 pPortParam->nPorts = pExynosComponent->portParam.nPorts;
1265 pPortParam->nStartPortNumber = pExynosComponent->portParam.nStartPortNumber;
1266 ret = OMX_ErrorNone;
1269 case OMX_IndexParamVideoPortFormat:
1271 OMX_VIDEO_PARAM_PORTFORMATTYPE *pPortFormat = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)pComponentParameterStructure;
1272 OMX_U32 nPortIndex = pPortFormat->nPortIndex;
1273 OMX_U32 nIndex = pPortFormat->nIndex;
1274 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1275 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = NULL;
1276 OMX_U32 nSupportFormat = 0;
1278 ret = Exynos_OMX_Check_SizeVersion(pPortFormat, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
1279 if (ret != OMX_ErrorNone) {
1283 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1284 ret = OMX_ErrorBadPortIndex;
1288 if (nPortIndex == INPUT_PORT_INDEX) {
1289 pExynosPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1290 pPortDef = &pExynosPort->portDefinition;
1293 case supportFormat_0:
1294 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1295 pPortFormat->eColorFormat = OMX_COLOR_FormatYUV420Planar;
1296 pPortFormat->xFramerate = pPortDef->format.video.xFramerate;
1298 case supportFormat_1:
1299 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1300 pPortFormat->eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
1301 pPortFormat->xFramerate = pPortDef->format.video.xFramerate;
1303 case supportFormat_2:
1304 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1305 pPortFormat->eColorFormat = OMX_SEC_COLOR_FormatNV12Tiled;
1306 pPortFormat->xFramerate = pPortDef->format.video.xFramerate;
1308 case supportFormat_3:
1309 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1310 pPortFormat->eColorFormat = OMX_SEC_COLOR_FormatNV21Linear;
1311 pPortFormat->xFramerate = pPortDef->format.video.xFramerate;
1313 case supportFormat_4:
1314 #ifdef TIZEN_FEATURE_E3250
1315 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "can not support this format");
1317 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1318 pPortFormat->eColorFormat = OMX_COLOR_FormatAndroidOpaque;
1319 pPortFormat->xFramerate = pPortDef->format.video.xFramerate;
1322 case supportFormat_5:
1323 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1324 pPortFormat->eColorFormat = OMX_SEC_COLOR_FormatNV12L_DmaBuf_Fd;
1325 pPortFormat->xFramerate = pPortDef->format.video.xFramerate;
1327 case supportFormat_6:
1328 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1329 pPortFormat->eColorFormat = OMX_SEC_COLOR_FormatNV12T_DmaBuf_Fd;
1330 pPortFormat->xFramerate = pPortDef->format.video.xFramerate;
1333 if (nIndex > supportFormat_0) {
1334 ret = OMX_ErrorNoMore;
1339 } else if (nPortIndex == OUTPUT_PORT_INDEX) {
1340 nSupportFormat = OUTPUT_PORT_SUPPORTFORMAT_NUM_MAX - 1;
1341 if (nIndex > nSupportFormat) {
1342 ret = OMX_ErrorNoMore;
1346 pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1347 pPortDef = &pExynosPort->portDefinition;
1349 pPortFormat->eCompressionFormat = pPortDef->format.video.eCompressionFormat;
1350 pPortFormat->eColorFormat = pPortDef->format.video.eColorFormat;
1351 pPortFormat->xFramerate = pPortDef->format.video.xFramerate;
1353 ret = OMX_ErrorNone;
1356 case OMX_IndexParamVideoBitrate:
1358 OMX_VIDEO_PARAM_BITRATETYPE *pVideoBitrate = (OMX_VIDEO_PARAM_BITRATETYPE *)pComponentParameterStructure;
1359 OMX_U32 nPortIndex = pVideoBitrate->nPortIndex;
1360 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1361 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1362 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = NULL;
1364 if (nPortIndex != OUTPUT_PORT_INDEX) {
1365 ret = OMX_ErrorBadPortIndex;
1368 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1369 if (pVideoEnc == NULL) {
1370 ret = OMX_ErrorBadParameter;
1373 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1374 pPortDef = &pExynosPort->portDefinition;
1376 pVideoBitrate->eControlRate = pVideoEnc->eControlRate[nPortIndex];
1377 pVideoBitrate->nTargetBitrate = pPortDef->format.video.nBitrate;
1379 ret = OMX_ErrorNone;
1382 case OMX_IndexParamVideoQuantization:
1384 OMX_VIDEO_PARAM_QUANTIZATIONTYPE *pVideoQuantization = (OMX_VIDEO_PARAM_QUANTIZATIONTYPE *)pComponentParameterStructure;
1385 OMX_U32 nPortIndex = pVideoQuantization->nPortIndex;
1386 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1388 if (nPortIndex != OUTPUT_PORT_INDEX) {
1389 ret = OMX_ErrorBadPortIndex;
1392 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1393 if (pVideoEnc == NULL) {
1394 ret = OMX_ErrorBadParameter;
1398 pVideoQuantization->nQpI = pVideoEnc->quantization.nQpI;
1399 pVideoQuantization->nQpP = pVideoEnc->quantization.nQpP;
1400 pVideoQuantization->nQpB = pVideoEnc->quantization.nQpB;
1402 ret = OMX_ErrorNone;
1405 case OMX_IndexParamPortDefinition:
1407 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = (OMX_PARAM_PORTDEFINITIONTYPE *)pComponentParameterStructure;
1408 OMX_U32 nPortIndex = pPortDef->nPortIndex;
1409 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1411 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1412 ret = OMX_ErrorBadPortIndex;
1416 ret = Exynos_OMX_Check_SizeVersion(pPortDef, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1417 if (ret != OMX_ErrorNone) {
1421 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1422 Exynos_OSAL_Memcpy(pPortDef, &pExynosPort->portDefinition, pPortDef->nSize);
1424 #ifdef USE_STOREMETADATA
1425 if ((nPortIndex == 0) &&
1426 (pExynosPort->bStoreMetaData == OMX_TRUE)) {
1427 pPortDef->nBufferSize = MAX_INPUT_METADATA_BUFFER_SIZE;
1434 ret = Exynos_OMX_GetParameter(hComponent, nParamIndex, pComponentParameterStructure);
1444 OMX_ERRORTYPE Exynos_OMX_VideoEncodeSetParameter(
1445 OMX_IN OMX_HANDLETYPE hComponent,
1446 OMX_IN OMX_INDEXTYPE nParamIndex,
1447 OMX_IN OMX_PTR pComponentParameterStructure)
1449 OMX_ERRORTYPE ret = OMX_ErrorNone;
1450 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1451 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1455 if (hComponent == NULL) {
1456 ret = OMX_ErrorBadParameter;
1459 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1461 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1462 if (ret != OMX_ErrorNone) {
1466 if (pOMXComponent->pComponentPrivate == NULL) {
1467 ret = OMX_ErrorBadParameter;
1470 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1472 if (pExynosComponent->currentState == OMX_StateInvalid) {
1473 ret = OMX_ErrorInvalidState;
1477 if (pComponentParameterStructure == NULL) {
1478 ret = OMX_ErrorBadParameter;
1482 switch (nParamIndex) {
1483 case OMX_IndexParamVideoPortFormat:
1485 OMX_VIDEO_PARAM_PORTFORMATTYPE *pPortFormat = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)pComponentParameterStructure;
1486 OMX_U32 nPortIndex = pPortFormat->nPortIndex;
1487 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = NULL;
1489 ret = Exynos_OMX_Check_SizeVersion(pPortFormat, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
1490 if (ret != OMX_ErrorNone) {
1494 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1495 ret = OMX_ErrorBadPortIndex;
1498 pPortDef = &(pExynosComponent->pExynosPort[nPortIndex].portDefinition);
1500 pPortDef->format.video.eColorFormat = pPortFormat->eColorFormat;
1501 pPortDef->format.video.eCompressionFormat = pPortFormat->eCompressionFormat;
1502 pPortDef->format.video.xFramerate = pPortFormat->xFramerate;
1505 case OMX_IndexParamVideoBitrate:
1507 OMX_VIDEO_PARAM_BITRATETYPE *pVideoBitrate = (OMX_VIDEO_PARAM_BITRATETYPE *)pComponentParameterStructure;
1508 OMX_U32 nPortIndex = pVideoBitrate->nPortIndex;
1509 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1510 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = NULL;
1512 if (nPortIndex != OUTPUT_PORT_INDEX) {
1513 ret = OMX_ErrorBadPortIndex;
1516 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1517 if (pVideoEnc == NULL) {
1518 ret = OMX_ErrorBadParameter;
1521 pPortDef = &(pExynosComponent->pExynosPort[nPortIndex].portDefinition);
1523 pVideoEnc->eControlRate[nPortIndex] = pVideoBitrate->eControlRate;
1524 pPortDef->format.video.nBitrate = pVideoBitrate->nTargetBitrate;
1526 ret = OMX_ErrorNone;
1529 case OMX_IndexParamVideoQuantization:
1531 OMX_VIDEO_PARAM_QUANTIZATIONTYPE *pVideoQuantization = (OMX_VIDEO_PARAM_QUANTIZATIONTYPE *)pComponentParameterStructure;
1532 OMX_U32 nPortIndex = pVideoQuantization->nPortIndex;
1533 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1535 if (nPortIndex != OUTPUT_PORT_INDEX) {
1536 ret = OMX_ErrorBadPortIndex;
1539 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1540 if (pVideoEnc == NULL) {
1541 ret = OMX_ErrorBadParameter;
1545 pVideoEnc->quantization.nQpI = pVideoQuantization->nQpI;
1546 pVideoEnc->quantization.nQpP = pVideoQuantization->nQpP;
1547 pVideoEnc->quantization.nQpB = pVideoQuantization->nQpB;
1549 ret = OMX_ErrorNone;
1552 case OMX_IndexParamPortDefinition:
1554 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = (OMX_PARAM_PORTDEFINITIONTYPE *)pComponentParameterStructure;
1555 OMX_U32 nPortIndex = pPortDef->nPortIndex;
1556 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1558 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1559 ret = OMX_ErrorBadPortIndex;
1563 ret = Exynos_OMX_Check_SizeVersion(pPortDef, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1564 if (ret != OMX_ErrorNone) {
1568 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1570 if ((pExynosComponent->currentState != OMX_StateLoaded) &&
1571 (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1572 if (pExynosPort->portDefinition.bEnabled == OMX_TRUE) {
1573 ret = OMX_ErrorIncorrectStateOperation;
1578 if (pPortDef->nBufferCountActual < pExynosPort->portDefinition.nBufferCountMin) {
1579 ret = OMX_ErrorBadParameter;
1583 Exynos_OSAL_Memcpy(&pExynosPort->portDefinition, pPortDef, pPortDef->nSize);
1584 if (nPortIndex == INPUT_PORT_INDEX) {
1585 pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1586 Exynos_UpdateFrameSize(pOMXComponent);
1587 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pExynosOutputPort->portDefinition.nBufferSize: %d",
1588 pExynosPort->portDefinition.nBufferSize);
1590 ret = OMX_ErrorNone;
1593 #ifdef USE_STOREMETADATA
1594 case OMX_IndexParamStoreMetaDataBuffer:
1596 ret = Exynos_OSAL_SetANBParameter(hComponent, nParamIndex, pComponentParameterStructure);
1602 ret = Exynos_OMX_SetParameter(hComponent, nParamIndex, pComponentParameterStructure);
1612 OMX_ERRORTYPE Exynos_OMX_VideoEncodeGetConfig(
1613 OMX_HANDLETYPE hComponent,
1614 OMX_INDEXTYPE nParamIndex,
1615 OMX_PTR pComponentConfigStructure)
1617 OMX_ERRORTYPE ret = OMX_ErrorNone;
1618 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1619 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1623 if ((hComponent == NULL) ||
1624 (pComponentConfigStructure == NULL)) {
1625 ret = OMX_ErrorBadParameter;
1628 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1630 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1631 if (ret != OMX_ErrorNone) {
1635 if (pOMXComponent->pComponentPrivate == NULL) {
1636 ret = OMX_ErrorBadParameter;
1639 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1641 if (pExynosComponent->currentState == OMX_StateInvalid) {
1642 ret = OMX_ErrorInvalidState;
1646 switch (nParamIndex) {
1647 case OMX_IndexConfigVideoBitrate:
1649 OMX_VIDEO_CONFIG_BITRATETYPE *pConfigBitrate = (OMX_VIDEO_CONFIG_BITRATETYPE *)pComponentConfigStructure;
1650 OMX_U32 nPortIndex = pConfigBitrate->nPortIndex;
1651 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1653 if (nPortIndex != OUTPUT_PORT_INDEX) {
1654 ret = OMX_ErrorBadPortIndex;
1657 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1658 pConfigBitrate->nEncodeBitrate = pExynosPort->portDefinition.format.video.nBitrate;
1662 case OMX_IndexConfigVideoFramerate:
1664 OMX_CONFIG_FRAMERATETYPE *pConfigFramerate = (OMX_CONFIG_FRAMERATETYPE *)pComponentConfigStructure;
1665 OMX_U32 nPortIndex = pConfigFramerate->nPortIndex;
1666 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1668 if (nPortIndex != OUTPUT_PORT_INDEX) {
1669 ret = OMX_ErrorBadPortIndex;
1672 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1673 pConfigFramerate->xEncodeFramerate = pExynosPort->portDefinition.format.video.xFramerate;
1679 ret = Exynos_OMX_GetConfig(hComponent, nParamIndex, pComponentConfigStructure);
1689 OMX_ERRORTYPE Exynos_OMX_VideoEncodeSetConfig(
1690 OMX_HANDLETYPE hComponent,
1691 OMX_INDEXTYPE nParamIndex,
1692 OMX_PTR pComponentConfigStructure)
1694 OMX_ERRORTYPE ret = OMX_ErrorNone;
1695 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1696 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1700 if ((hComponent == NULL) ||
1701 (pComponentConfigStructure == NULL)) {
1702 ret = OMX_ErrorBadParameter;
1705 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1707 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1708 if (ret != OMX_ErrorNone) {
1712 if (pOMXComponent->pComponentPrivate == NULL) {
1713 ret = OMX_ErrorBadParameter;
1716 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1718 if (pExynosComponent->currentState == OMX_StateInvalid) {
1719 ret = OMX_ErrorInvalidState;
1723 switch (nParamIndex) {
1724 case OMX_IndexConfigVideoBitrate:
1726 OMX_VIDEO_CONFIG_BITRATETYPE *pConfigBitrate = (OMX_VIDEO_CONFIG_BITRATETYPE *)pComponentConfigStructure;
1727 OMX_U32 nPortIndex = pConfigBitrate->nPortIndex;
1728 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1730 if (nPortIndex != OUTPUT_PORT_INDEX) {
1731 ret = OMX_ErrorBadPortIndex;
1734 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1735 pExynosPort->portDefinition.format.video.nBitrate = pConfigBitrate->nEncodeBitrate;
1739 case OMX_IndexConfigVideoFramerate:
1741 OMX_CONFIG_FRAMERATETYPE *pConfigFramerate = (OMX_CONFIG_FRAMERATETYPE *)pComponentConfigStructure;
1742 OMX_U32 nPortIndex = pConfigFramerate->nPortIndex;
1743 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1745 if (nPortIndex != OUTPUT_PORT_INDEX) {
1746 ret = OMX_ErrorBadPortIndex;
1749 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1750 pExynosPort->portDefinition.format.video.xFramerate = pConfigFramerate->xEncodeFramerate;
1754 case OMX_IndexConfigVideoIntraVOPRefresh:
1756 OMX_CONFIG_INTRAREFRESHVOPTYPE *pIntraRefreshVOP = (OMX_CONFIG_INTRAREFRESHVOPTYPE *)pComponentConfigStructure;
1757 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1758 OMX_U32 nPortIndex = pIntraRefreshVOP->nPortIndex;
1760 if (pExynosComponent->hComponentHandle == NULL) {
1761 ret = OMX_ErrorBadParameter;
1764 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1766 if (nPortIndex != OUTPUT_PORT_INDEX) {
1767 ret = OMX_ErrorBadPortIndex;
1770 pVideoEnc->IntraRefreshVOP = pIntraRefreshVOP->IntraRefreshVOP;
1776 ret = Exynos_OMX_SetConfig(hComponent, nParamIndex, pComponentConfigStructure);
1786 OMX_ERRORTYPE Exynos_OMX_VideoEncodeGetExtensionIndex(
1787 OMX_IN OMX_HANDLETYPE hComponent,
1788 OMX_IN OMX_STRING szParamName,
1789 OMX_OUT OMX_INDEXTYPE *pIndexType)
1791 OMX_ERRORTYPE ret = OMX_ErrorNone;
1792 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1793 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1797 if (hComponent == NULL) {
1798 ret = OMX_ErrorBadParameter;
1801 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1803 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1804 if (ret != OMX_ErrorNone) {
1808 if (pOMXComponent->pComponentPrivate == NULL) {
1809 ret = OMX_ErrorBadParameter;
1812 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1814 if ((szParamName == NULL) || (pIndexType == NULL)) {
1815 ret = OMX_ErrorBadParameter;
1819 if (pExynosComponent->currentState == OMX_StateInvalid) {
1820 ret = OMX_ErrorInvalidState;
1824 #ifdef USE_STOREMETADATA
1825 if (Exynos_OSAL_Strcmp(szParamName, EXYNOS_INDEX_PARAM_STORE_METADATA_BUFFER) == 0) {
1826 *pIndexType = (OMX_INDEXTYPE)OMX_IndexParamStoreMetaDataBuffer;
1828 ret = Exynos_OMX_GetExtensionIndex(hComponent, szParamName, pIndexType);
1831 ret = Exynos_OMX_GetExtensionIndex(hComponent, szParamName, pIndexType);