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)
638 if (pExynosPort->bufferProcessType & BUFFER_COPY)
639 pVideoEnc->exynos_codec_enqueueAllBuffer(pOMXComponent, nPortIndex);
640 Exynos_ResetCodecData(&pExynosPort->processData);
642 if (ret == OMX_ErrorNone) {
643 if (nPortIndex == INPUT_PORT_INDEX) {
644 pExynosComponent->checkTimeStamp.needSetStartTimeStamp = OMX_TRUE;
645 pExynosComponent->checkTimeStamp.needCheckStartTimeStamp = OMX_FALSE;
646 Exynos_OSAL_Memset(pExynosComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
647 Exynos_OSAL_Memset(pExynosComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
648 pExynosComponent->getAllDelayBuffer = OMX_FALSE;
649 pExynosComponent->bSaveFlagEOS = OMX_FALSE;
650 pExynosComponent->reInputData = OMX_FALSE;
653 pExynosPort->bIsPortFlushed = OMX_FALSE;
654 Exynos_OSAL_Log(EXYNOS_LOG_TRACE,"OMX_CommandFlush EventCmdComplete, port:%d", nPortIndex);
655 if (bEvent == OMX_TRUE)
656 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
657 pExynosComponent->callbackData,
658 OMX_EventCmdComplete,
659 OMX_CommandFlush, nPortIndex, NULL);
662 if (pDataBuffer[1] != NULL)
663 Exynos_OSAL_MutexUnlock(pDataBuffer[1]->bufferMutex);
665 Exynos_OSAL_MutexUnlock(pDataBuffer[0]->bufferMutex);
668 if ((ret != OMX_ErrorNone) && (pOMXComponent != NULL) && (pExynosComponent != NULL)) {
669 Exynos_OSAL_Log(EXYNOS_LOG_ERROR,"%s : %d", __FUNCTION__, __LINE__);
670 pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
671 pExynosComponent->callbackData,
681 OMX_ERRORTYPE Exynos_InputBufferReturn(
682 OMX_COMPONENTTYPE *pOMXComponent)
684 OMX_ERRORTYPE ret = OMX_ErrorNone;
685 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
686 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
687 EXYNOS_OMX_DATABUFFER *pDataBuffer = NULL;
688 OMX_BUFFERHEADERTYPE *pBufferHdr = NULL;
692 if (pOMXComponent == NULL) {
693 ret = OMX_ErrorBadParameter;
697 if (pOMXComponent->pComponentPrivate == NULL) {
698 ret = OMX_ErrorBadParameter;
701 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
702 pExynosPort = &(pExynosComponent->pExynosPort[INPUT_PORT_INDEX]);
704 if (pExynosPort->bufferProcessType & BUFFER_COPY) {
705 pDataBuffer = &(pExynosPort->way.port2WayDataBuffer.inputDataBuffer);
706 } else if (pExynosPort->bufferProcessType & BUFFER_SHARE) {
707 pDataBuffer = &(pExynosPort->way.port2WayDataBuffer.outputDataBuffer);
710 pBufferHdr = pDataBuffer->bufferHeader;
712 if (pBufferHdr != NULL) {
713 if (pExynosPort->markType.hMarkTargetComponent != NULL) {
714 pBufferHdr->hMarkTargetComponent = pExynosPort->markType.hMarkTargetComponent;
715 pBufferHdr->pMarkData = pExynosPort->markType.pMarkData;
716 pExynosPort->markType.hMarkTargetComponent = NULL;
717 pExynosPort->markType.pMarkData = NULL;
720 if (pBufferHdr->hMarkTargetComponent != NULL) {
721 if (pBufferHdr->hMarkTargetComponent == pOMXComponent) {
722 pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
723 pExynosComponent->callbackData,
725 0, 0, pBufferHdr->pMarkData);
727 pExynosComponent->propagateMarkType.hMarkTargetComponent = pBufferHdr->hMarkTargetComponent;
728 pExynosComponent->propagateMarkType.pMarkData = pBufferHdr->pMarkData;
732 pBufferHdr->nFilledLen = 0;
733 pBufferHdr->nOffset = 0;
734 Exynos_OMX_InputBufferReturn(pOMXComponent, pBufferHdr);
737 /* reset dataBuffer */
738 Exynos_ResetDataBuffer(pDataBuffer);
746 OMX_ERRORTYPE Exynos_FlushInputBufferReturn(
747 OMX_COMPONENTTYPE *pOMXComponent,
748 EXYNOS_OMX_DATABUFFER *pDataBuffer)
750 OMX_ERRORTYPE ret = OMX_ErrorNone;
751 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
752 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
753 OMX_BUFFERHEADERTYPE *pBufferHdr = NULL;
757 if (pOMXComponent == NULL) {
758 ret = OMX_ErrorBadParameter;
762 if (pOMXComponent->pComponentPrivate == NULL) {
763 ret = OMX_ErrorBadParameter;
766 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
767 pExynosPort = &(pExynosComponent->pExynosPort[INPUT_PORT_INDEX]);
769 pBufferHdr = pDataBuffer->bufferHeader;
771 if (pBufferHdr != NULL) {
772 if (pExynosPort->markType.hMarkTargetComponent != NULL) {
773 pBufferHdr->hMarkTargetComponent = pExynosPort->markType.hMarkTargetComponent;
774 pBufferHdr->pMarkData = pExynosPort->markType.pMarkData;
775 pExynosPort->markType.hMarkTargetComponent = NULL;
776 pExynosPort->markType.pMarkData = NULL;
779 if (pBufferHdr->hMarkTargetComponent != NULL) {
780 if (pBufferHdr->hMarkTargetComponent == pOMXComponent) {
781 pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
782 pExynosComponent->callbackData,
784 0, 0, pBufferHdr->pMarkData);
786 pExynosComponent->propagateMarkType.hMarkTargetComponent = pBufferHdr->hMarkTargetComponent;
787 pExynosComponent->propagateMarkType.pMarkData = pBufferHdr->pMarkData;
791 pBufferHdr->nFilledLen = 0;
792 pBufferHdr->nOffset = 0;
793 Exynos_OMX_InputBufferReturn(pOMXComponent, pBufferHdr);
796 /* reset dataBuffer */
797 Exynos_ResetDataBuffer(pDataBuffer);
805 OMX_ERRORTYPE Exynos_InputBufferGetQueue(
806 EXYNOS_OMX_BASECOMPONENT *pExynosComponent)
808 OMX_ERRORTYPE ret = OMX_ErrorUndefined;
809 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
810 EXYNOS_OMX_MESSAGE *pMessage = NULL;
811 EXYNOS_OMX_DATABUFFER *pDataBuffer = NULL;
815 if (pExynosComponent == NULL) {
816 ret = OMX_ErrorBadParameter;
819 pExynosPort = &(pExynosComponent->pExynosPort[INPUT_PORT_INDEX]);
820 pDataBuffer = &(pExynosPort->way.port2WayDataBuffer.inputDataBuffer);
822 if (pExynosComponent->currentState != OMX_StateExecuting) {
823 ret = OMX_ErrorUndefined;
825 } else if ((pExynosComponent->transientState != EXYNOS_OMX_TransStateExecutingToIdle) &&
826 (!CHECK_PORT_BEING_FLUSHED(pExynosPort))) {
827 Exynos_OSAL_SemaphoreWait(pExynosPort->bufferSemID);
828 if (pDataBuffer->dataValid != OMX_TRUE) {
829 pMessage = (EXYNOS_OMX_MESSAGE *)Exynos_OSAL_Dequeue(&pExynosPort->bufferQ);
830 if (pMessage == NULL) {
831 ret = OMX_ErrorUndefined;
834 if (pMessage->messageType == EXYNOS_OMX_CommandFakeBuffer) {
835 Exynos_OSAL_Free(pMessage);
836 ret = OMX_ErrorCodecFlush;
840 pDataBuffer->bufferHeader = (OMX_BUFFERHEADERTYPE *)(pMessage->pCmdData);
841 pDataBuffer->allocSize = pDataBuffer->bufferHeader->nAllocLen;
842 pDataBuffer->dataLen = pDataBuffer->bufferHeader->nFilledLen;
843 pDataBuffer->remainDataLen = pDataBuffer->dataLen;
844 pDataBuffer->usedDataLen = 0;
845 pDataBuffer->dataValid = OMX_TRUE;
846 pDataBuffer->nFlags = pDataBuffer->bufferHeader->nFlags;
847 pDataBuffer->timeStamp = pDataBuffer->bufferHeader->nTimeStamp;
849 Exynos_OSAL_Free(pMessage);
851 #ifndef TIZEN_FEATURE_E3250
852 if (pDataBuffer->allocSize <= pDataBuffer->dataLen)
853 Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "Input Buffer Full, Check input buffer size! allocSize:%d, dataLen:%d", pDataBuffer->allocSize, pDataBuffer->dataLen);
864 OMX_ERRORTYPE Exynos_OutputBufferReturn(
865 OMX_COMPONENTTYPE *pOMXComponent)
867 OMX_ERRORTYPE ret = OMX_ErrorNone;
868 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
869 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
870 EXYNOS_OMX_DATABUFFER *pDataBuffer = NULL;
871 OMX_BUFFERHEADERTYPE *pBufferHdr = NULL;
875 if (pOMXComponent == NULL) {
876 ret = OMX_ErrorBadParameter;
880 if (pOMXComponent->pComponentPrivate == NULL) {
881 ret = OMX_ErrorBadParameter;
884 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
885 pExynosPort = &(pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX]);
887 pDataBuffer = &(pExynosPort->way.port2WayDataBuffer.outputDataBuffer);
888 pBufferHdr = pDataBuffer->bufferHeader;
890 if (pBufferHdr != NULL) {
891 pBufferHdr->nFilledLen = pDataBuffer->remainDataLen;
892 pBufferHdr->nOffset = 0;
893 pBufferHdr->nFlags = pDataBuffer->nFlags;
894 pBufferHdr->nTimeStamp = pDataBuffer->timeStamp;
896 if (pExynosComponent->propagateMarkType.hMarkTargetComponent != NULL) {
897 pBufferHdr->hMarkTargetComponent = pExynosComponent->propagateMarkType.hMarkTargetComponent;
898 pBufferHdr->pMarkData = pExynosComponent->propagateMarkType.pMarkData;
899 pExynosComponent->propagateMarkType.hMarkTargetComponent = NULL;
900 pExynosComponent->propagateMarkType.pMarkData = NULL;
903 if ((pBufferHdr->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
904 pBufferHdr->nFilledLen = 0;
905 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "event OMX_BUFFERFLAG_EOS!!!");
906 pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
907 pExynosComponent->callbackData,
910 pBufferHdr->nFlags, NULL);
913 Exynos_OMX_OutputBufferReturn(pOMXComponent, pBufferHdr);
916 /* reset dataBuffer */
917 Exynos_ResetDataBuffer(pDataBuffer);
925 OMX_ERRORTYPE Exynos_FlushOutputBufferReturn(
926 OMX_COMPONENTTYPE *pOMXComponent,
927 EXYNOS_OMX_DATABUFFER *pDataBuffer)
929 OMX_ERRORTYPE ret = OMX_ErrorNone;
930 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
931 OMX_BUFFERHEADERTYPE *pBufferHdr = NULL;
935 if (pOMXComponent == NULL) {
936 ret = OMX_ErrorBadParameter;
940 if (pOMXComponent->pComponentPrivate == NULL) {
941 ret = OMX_ErrorBadParameter;
944 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
945 pBufferHdr = pDataBuffer->bufferHeader;
947 if (pBufferHdr != NULL) {
948 pBufferHdr->nFilledLen = pDataBuffer->remainDataLen;
949 pBufferHdr->nOffset = 0;
950 pBufferHdr->nFlags = pDataBuffer->nFlags;
951 pBufferHdr->nTimeStamp = pDataBuffer->timeStamp;
953 if (pExynosComponent->propagateMarkType.hMarkTargetComponent != NULL) {
954 pBufferHdr->hMarkTargetComponent = pExynosComponent->propagateMarkType.hMarkTargetComponent;
955 pBufferHdr->pMarkData = pExynosComponent->propagateMarkType.pMarkData;
956 pExynosComponent->propagateMarkType.hMarkTargetComponent = NULL;
957 pExynosComponent->propagateMarkType.pMarkData = NULL;
960 if ((pBufferHdr->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
961 pBufferHdr->nFilledLen = 0;
962 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "event OMX_BUFFERFLAG_EOS!!!");
963 pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
964 pExynosComponent->callbackData,
967 pBufferHdr->nFlags, NULL);
969 Exynos_OMX_OutputBufferReturn(pOMXComponent, pBufferHdr);
972 /* reset dataBuffer */
973 Exynos_ResetDataBuffer(pDataBuffer);
981 OMX_ERRORTYPE Exynos_OutputBufferGetQueue(
982 EXYNOS_OMX_BASECOMPONENT *pExynosComponent)
984 OMX_ERRORTYPE ret = OMX_ErrorUndefined;
985 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
986 EXYNOS_OMX_MESSAGE *pMessage = NULL;
987 EXYNOS_OMX_DATABUFFER *pDataBuffer = NULL;
991 if (pExynosComponent == NULL) {
992 ret = OMX_ErrorBadParameter;
995 pExynosPort = &(pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX]);
997 if (pExynosPort->bufferProcessType & BUFFER_COPY) {
998 pDataBuffer = &(pExynosPort->way.port2WayDataBuffer.outputDataBuffer);
999 } else if (pExynosPort->bufferProcessType & BUFFER_SHARE) {
1000 pDataBuffer = &(pExynosPort->way.port2WayDataBuffer.inputDataBuffer);
1003 if (pExynosComponent->currentState != OMX_StateExecuting) {
1004 ret = OMX_ErrorUndefined;
1006 } else if ((pExynosComponent->transientState != EXYNOS_OMX_TransStateExecutingToIdle) &&
1007 (!CHECK_PORT_BEING_FLUSHED(pExynosPort))) {
1008 Exynos_OSAL_SemaphoreWait(pExynosPort->bufferSemID);
1009 if (pDataBuffer->dataValid != OMX_TRUE) {
1010 pMessage = (EXYNOS_OMX_MESSAGE *)Exynos_OSAL_Dequeue(&pExynosPort->bufferQ);
1011 if (pMessage == NULL) {
1012 ret = OMX_ErrorUndefined;
1015 if (pMessage->messageType == EXYNOS_OMX_CommandFakeBuffer) {
1016 Exynos_OSAL_Free(pMessage);
1017 ret = OMX_ErrorCodecFlush;
1021 pDataBuffer->bufferHeader = (OMX_BUFFERHEADERTYPE *)(pMessage->pCmdData);
1022 pDataBuffer->allocSize = pDataBuffer->bufferHeader->nAllocLen;
1023 pDataBuffer->dataLen = 0; //dataBuffer->bufferHeader->nFilledLen;
1024 pDataBuffer->remainDataLen = pDataBuffer->dataLen;
1025 pDataBuffer->usedDataLen = 0; //dataBuffer->bufferHeader->nOffset;
1026 pDataBuffer->dataValid = OMX_TRUE;
1027 /* pDataBuffer->nFlags = pDataBuffer->bufferHeader->nFlags; */
1028 /* pDtaBuffer->nTimeStamp = pDataBuffer->bufferHeader->nTimeStamp; */
1030 if (pExynosPort->bufferProcessType & BUFFER_SHARE)
1031 pDataBuffer->pPrivate = pDataBuffer->bufferHeader->pOutputPortPrivate;
1032 else if (pExynosPort->bufferProcessType & BUFFER_COPY) {
1033 pExynosPort->processData.dataBuffer = pDataBuffer->bufferHeader->pBuffer;
1034 pExynosPort->processData.allocSize = pDataBuffer->bufferHeader->nAllocLen;
1037 Exynos_OSAL_Free(pMessage);
1039 ret = OMX_ErrorNone;
1047 OMX_BUFFERHEADERTYPE *Exynos_OutputBufferGetQueue_Direct(
1048 EXYNOS_OMX_BASECOMPONENT *pExynosComponent)
1050 OMX_BUFFERHEADERTYPE *pBufferHdr = NULL;
1051 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1052 EXYNOS_OMX_MESSAGE *pMessage = NULL;
1056 if (pExynosComponent == NULL) {
1060 pExynosPort = &(pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX]);
1062 if (pExynosComponent->currentState != OMX_StateExecuting) {
1065 } else if ((pExynosComponent->transientState != EXYNOS_OMX_TransStateExecutingToIdle) &&
1066 (!CHECK_PORT_BEING_FLUSHED(pExynosPort))) {
1067 Exynos_OSAL_SemaphoreWait(pExynosPort->bufferSemID);
1069 pMessage = (EXYNOS_OMX_MESSAGE *)Exynos_OSAL_Dequeue(&pExynosPort->bufferQ);
1070 if (pMessage == NULL) {
1074 if (pMessage->messageType == EXYNOS_OMX_CommandFakeBuffer) {
1075 Exynos_OSAL_Free(pMessage);
1080 pBufferHdr = (OMX_BUFFERHEADERTYPE *)(pMessage->pCmdData);
1081 Exynos_OSAL_Free(pMessage);
1090 OMX_ERRORTYPE Exynos_CodecBufferEnqueue(
1091 EXYNOS_OMX_BASECOMPONENT *pExynosComponent,
1095 OMX_ERRORTYPE ret = OMX_ErrorNone;
1096 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1100 if (pExynosComponent == NULL) {
1101 ret = OMX_ErrorBadParameter;
1105 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1106 ret = OMX_ErrorBadPortIndex;
1109 pExynosPort = &(pExynosComponent->pExynosPort[nPortIndex]);
1111 if (pData == NULL) {
1112 ret = OMX_ErrorInsufficientResources;
1116 ret = Exynos_OSAL_Queue(&pExynosPort->codecBufferQ, (void *)pData);
1118 ret = OMX_ErrorUndefined;
1121 Exynos_OSAL_SemaphorePost(pExynosPort->codecSemID);
1123 ret = OMX_ErrorNone;
1131 OMX_ERRORTYPE Exynos_CodecBufferDequeue(
1132 EXYNOS_OMX_BASECOMPONENT *pExynosComponent,
1136 OMX_ERRORTYPE ret = OMX_ErrorNone;
1137 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1138 OMX_PTR pTempData = NULL;
1142 if (pExynosComponent == NULL) {
1143 ret = OMX_ErrorBadParameter;
1147 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1148 ret = OMX_ErrorBadPortIndex;
1151 pExynosPort = &(pExynosComponent->pExynosPort[nPortIndex]);
1153 Exynos_OSAL_SemaphoreWait(pExynosPort->codecSemID);
1154 pTempData = (OMX_PTR)Exynos_OSAL_Dequeue(&pExynosPort->codecBufferQ);
1155 if (pTempData != NULL) {
1156 *pData = (OMX_PTR)pTempData;
1157 ret = OMX_ErrorNone;
1160 ret = OMX_ErrorUndefined;
1169 OMX_ERRORTYPE Exynos_CodecBufferReset(
1170 EXYNOS_OMX_BASECOMPONENT *pExynosComponent,
1173 OMX_ERRORTYPE ret = OMX_ErrorNone;
1174 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1178 if (pExynosComponent == NULL) {
1179 ret = OMX_ErrorBadParameter;
1183 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1184 ret = OMX_ErrorBadPortIndex;
1187 pExynosPort = &(pExynosComponent->pExynosPort[nPortIndex]);
1189 ret = Exynos_OSAL_ResetQueue(&pExynosPort->codecBufferQ);
1191 ret = OMX_ErrorUndefined;
1197 Exynos_OSAL_Get_SemaphoreCount(pExynosPort->codecSemID, &cnt);
1199 Exynos_OSAL_SemaphoreWait(pExynosPort->codecSemID);
1203 ret = OMX_ErrorNone;
1211 OMX_ERRORTYPE Exynos_OMX_VideoEncodeGetParameter(
1212 OMX_IN OMX_HANDLETYPE hComponent,
1213 OMX_IN OMX_INDEXTYPE nParamIndex,
1214 OMX_INOUT OMX_PTR pComponentParameterStructure)
1216 OMX_ERRORTYPE ret = OMX_ErrorNone;
1217 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1218 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1222 if (hComponent == NULL) {
1223 ret = OMX_ErrorBadParameter;
1226 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1228 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1229 if (ret != OMX_ErrorNone) {
1233 if (pOMXComponent->pComponentPrivate == NULL) {
1234 ret = OMX_ErrorBadParameter;
1237 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1239 if (pExynosComponent->currentState == OMX_StateInvalid) {
1240 ret = OMX_ErrorInvalidState;
1244 if (pComponentParameterStructure == NULL) {
1245 ret = OMX_ErrorBadParameter;
1249 switch (nParamIndex) {
1250 case OMX_IndexParamVideoInit:
1252 OMX_PORT_PARAM_TYPE *pPortParam = (OMX_PORT_PARAM_TYPE *)pComponentParameterStructure;
1253 ret = Exynos_OMX_Check_SizeVersion(pPortParam, sizeof(OMX_PORT_PARAM_TYPE));
1254 if (ret != OMX_ErrorNone) {
1258 pPortParam->nPorts = pExynosComponent->portParam.nPorts;
1259 pPortParam->nStartPortNumber = pExynosComponent->portParam.nStartPortNumber;
1260 ret = OMX_ErrorNone;
1263 case OMX_IndexParamVideoPortFormat:
1265 OMX_VIDEO_PARAM_PORTFORMATTYPE *pPortFormat = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)pComponentParameterStructure;
1266 OMX_U32 nPortIndex = pPortFormat->nPortIndex;
1267 OMX_U32 nIndex = pPortFormat->nIndex;
1268 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1269 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = NULL;
1270 OMX_U32 nSupportFormat = 0;
1272 ret = Exynos_OMX_Check_SizeVersion(pPortFormat, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
1273 if (ret != OMX_ErrorNone) {
1277 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1278 ret = OMX_ErrorBadPortIndex;
1282 if (nPortIndex == INPUT_PORT_INDEX) {
1283 pExynosPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1284 pPortDef = &pExynosPort->portDefinition;
1287 case supportFormat_0:
1288 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1289 pPortFormat->eColorFormat = OMX_COLOR_FormatYUV420Planar;
1290 pPortFormat->xFramerate = pPortDef->format.video.xFramerate;
1292 case supportFormat_1:
1293 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1294 pPortFormat->eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
1295 pPortFormat->xFramerate = pPortDef->format.video.xFramerate;
1297 case supportFormat_2:
1298 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1299 pPortFormat->eColorFormat = OMX_SEC_COLOR_FormatNV12Tiled;
1300 pPortFormat->xFramerate = pPortDef->format.video.xFramerate;
1302 case supportFormat_3:
1303 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1304 pPortFormat->eColorFormat = OMX_SEC_COLOR_FormatNV21Linear;
1305 pPortFormat->xFramerate = pPortDef->format.video.xFramerate;
1307 case supportFormat_4:
1308 #ifdef TIZEN_FEATURE_E3250
1309 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "can not support this format");
1311 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1312 pPortFormat->eColorFormat = OMX_COLOR_FormatAndroidOpaque;
1313 pPortFormat->xFramerate = pPortDef->format.video.xFramerate;
1316 case supportFormat_5:
1317 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1318 pPortFormat->eColorFormat = OMX_SEC_COLOR_FormatNV12L_DmaBuf_Fd;
1319 pPortFormat->xFramerate = pPortDef->format.video.xFramerate;
1321 case supportFormat_6:
1322 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1323 pPortFormat->eColorFormat = OMX_SEC_COLOR_FormatNV12T_DmaBuf_Fd;
1324 pPortFormat->xFramerate = pPortDef->format.video.xFramerate;
1327 if (nIndex > supportFormat_0) {
1328 ret = OMX_ErrorNoMore;
1333 } else if (nPortIndex == OUTPUT_PORT_INDEX) {
1334 nSupportFormat = OUTPUT_PORT_SUPPORTFORMAT_NUM_MAX - 1;
1335 if (nIndex > nSupportFormat) {
1336 ret = OMX_ErrorNoMore;
1340 pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1341 pPortDef = &pExynosPort->portDefinition;
1343 pPortFormat->eCompressionFormat = pPortDef->format.video.eCompressionFormat;
1344 pPortFormat->eColorFormat = pPortDef->format.video.eColorFormat;
1345 pPortFormat->xFramerate = pPortDef->format.video.xFramerate;
1347 ret = OMX_ErrorNone;
1350 case OMX_IndexParamVideoBitrate:
1352 OMX_VIDEO_PARAM_BITRATETYPE *pVideoBitrate = (OMX_VIDEO_PARAM_BITRATETYPE *)pComponentParameterStructure;
1353 OMX_U32 nPortIndex = pVideoBitrate->nPortIndex;
1354 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1355 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1356 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = NULL;
1358 if (nPortIndex != OUTPUT_PORT_INDEX) {
1359 ret = OMX_ErrorBadPortIndex;
1362 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1363 if (pVideoEnc == NULL) {
1364 ret = OMX_ErrorBadParameter;
1367 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1368 pPortDef = &pExynosPort->portDefinition;
1370 pVideoBitrate->eControlRate = pVideoEnc->eControlRate[nPortIndex];
1371 pVideoBitrate->nTargetBitrate = pPortDef->format.video.nBitrate;
1373 ret = OMX_ErrorNone;
1376 case OMX_IndexParamVideoQuantization:
1378 OMX_VIDEO_PARAM_QUANTIZATIONTYPE *pVideoQuantization = (OMX_VIDEO_PARAM_QUANTIZATIONTYPE *)pComponentParameterStructure;
1379 OMX_U32 nPortIndex = pVideoQuantization->nPortIndex;
1380 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1382 if (nPortIndex != OUTPUT_PORT_INDEX) {
1383 ret = OMX_ErrorBadPortIndex;
1386 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1387 if (pVideoEnc == NULL) {
1388 ret = OMX_ErrorBadParameter;
1392 pVideoQuantization->nQpI = pVideoEnc->quantization.nQpI;
1393 pVideoQuantization->nQpP = pVideoEnc->quantization.nQpP;
1394 pVideoQuantization->nQpB = pVideoEnc->quantization.nQpB;
1396 ret = OMX_ErrorNone;
1399 case OMX_IndexParamPortDefinition:
1401 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = (OMX_PARAM_PORTDEFINITIONTYPE *)pComponentParameterStructure;
1402 OMX_U32 nPortIndex = pPortDef->nPortIndex;
1403 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1405 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1406 ret = OMX_ErrorBadPortIndex;
1410 ret = Exynos_OMX_Check_SizeVersion(pPortDef, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1411 if (ret != OMX_ErrorNone) {
1415 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1416 Exynos_OSAL_Memcpy(pPortDef, &pExynosPort->portDefinition, pPortDef->nSize);
1418 #ifdef USE_STOREMETADATA
1419 if ((nPortIndex == 0) &&
1420 (pExynosPort->bStoreMetaData == OMX_TRUE)) {
1421 pPortDef->nBufferSize = MAX_INPUT_METADATA_BUFFER_SIZE;
1428 ret = Exynos_OMX_GetParameter(hComponent, nParamIndex, pComponentParameterStructure);
1438 OMX_ERRORTYPE Exynos_OMX_VideoEncodeSetParameter(
1439 OMX_IN OMX_HANDLETYPE hComponent,
1440 OMX_IN OMX_INDEXTYPE nParamIndex,
1441 OMX_IN OMX_PTR pComponentParameterStructure)
1443 OMX_ERRORTYPE ret = OMX_ErrorNone;
1444 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1445 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1449 if (hComponent == NULL) {
1450 ret = OMX_ErrorBadParameter;
1453 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1455 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1456 if (ret != OMX_ErrorNone) {
1460 if (pOMXComponent->pComponentPrivate == NULL) {
1461 ret = OMX_ErrorBadParameter;
1464 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1466 if (pExynosComponent->currentState == OMX_StateInvalid) {
1467 ret = OMX_ErrorInvalidState;
1471 if (pComponentParameterStructure == NULL) {
1472 ret = OMX_ErrorBadParameter;
1476 switch (nParamIndex) {
1477 case OMX_IndexParamVideoPortFormat:
1479 OMX_VIDEO_PARAM_PORTFORMATTYPE *pPortFormat = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)pComponentParameterStructure;
1480 OMX_U32 nPortIndex = pPortFormat->nPortIndex;
1481 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = NULL;
1483 ret = Exynos_OMX_Check_SizeVersion(pPortFormat, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
1484 if (ret != OMX_ErrorNone) {
1488 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1489 ret = OMX_ErrorBadPortIndex;
1492 pPortDef = &(pExynosComponent->pExynosPort[nPortIndex].portDefinition);
1494 pPortDef->format.video.eColorFormat = pPortFormat->eColorFormat;
1495 pPortDef->format.video.eCompressionFormat = pPortFormat->eCompressionFormat;
1496 pPortDef->format.video.xFramerate = pPortFormat->xFramerate;
1499 case OMX_IndexParamVideoBitrate:
1501 OMX_VIDEO_PARAM_BITRATETYPE *pVideoBitrate = (OMX_VIDEO_PARAM_BITRATETYPE *)pComponentParameterStructure;
1502 OMX_U32 nPortIndex = pVideoBitrate->nPortIndex;
1503 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1504 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = NULL;
1506 if (nPortIndex != OUTPUT_PORT_INDEX) {
1507 ret = OMX_ErrorBadPortIndex;
1510 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1511 if (pVideoEnc == NULL) {
1512 ret = OMX_ErrorBadParameter;
1515 pPortDef = &(pExynosComponent->pExynosPort[nPortIndex].portDefinition);
1517 pVideoEnc->eControlRate[nPortIndex] = pVideoBitrate->eControlRate;
1518 pPortDef->format.video.nBitrate = pVideoBitrate->nTargetBitrate;
1520 ret = OMX_ErrorNone;
1523 case OMX_IndexParamVideoQuantization:
1525 OMX_VIDEO_PARAM_QUANTIZATIONTYPE *pVideoQuantization = (OMX_VIDEO_PARAM_QUANTIZATIONTYPE *)pComponentParameterStructure;
1526 OMX_U32 nPortIndex = pVideoQuantization->nPortIndex;
1527 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1529 if (nPortIndex != OUTPUT_PORT_INDEX) {
1530 ret = OMX_ErrorBadPortIndex;
1533 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1534 if (pVideoEnc == NULL) {
1535 ret = OMX_ErrorBadParameter;
1539 pVideoEnc->quantization.nQpI = pVideoQuantization->nQpI;
1540 pVideoEnc->quantization.nQpP = pVideoQuantization->nQpP;
1541 pVideoEnc->quantization.nQpB = pVideoQuantization->nQpB;
1543 ret = OMX_ErrorNone;
1546 case OMX_IndexParamPortDefinition:
1548 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = (OMX_PARAM_PORTDEFINITIONTYPE *)pComponentParameterStructure;
1549 OMX_U32 nPortIndex = pPortDef->nPortIndex;
1550 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1552 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1553 ret = OMX_ErrorBadPortIndex;
1557 ret = Exynos_OMX_Check_SizeVersion(pPortDef, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1558 if (ret != OMX_ErrorNone) {
1562 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1564 if ((pExynosComponent->currentState != OMX_StateLoaded) &&
1565 (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1566 if (pExynosPort->portDefinition.bEnabled == OMX_TRUE) {
1567 ret = OMX_ErrorIncorrectStateOperation;
1572 if (pPortDef->nBufferCountActual < pExynosPort->portDefinition.nBufferCountMin) {
1573 ret = OMX_ErrorBadParameter;
1577 Exynos_OSAL_Memcpy(&pExynosPort->portDefinition, pPortDef, pPortDef->nSize);
1578 if (nPortIndex == INPUT_PORT_INDEX) {
1579 pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1580 Exynos_UpdateFrameSize(pOMXComponent);
1581 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pExynosOutputPort->portDefinition.nBufferSize: %d",
1582 pExynosPort->portDefinition.nBufferSize);
1584 ret = OMX_ErrorNone;
1587 #ifdef USE_STOREMETADATA
1588 case OMX_IndexParamStoreMetaDataBuffer:
1590 ret = Exynos_OSAL_SetANBParameter(hComponent, nParamIndex, pComponentParameterStructure);
1596 ret = Exynos_OMX_SetParameter(hComponent, nParamIndex, pComponentParameterStructure);
1606 OMX_ERRORTYPE Exynos_OMX_VideoEncodeGetConfig(
1607 OMX_HANDLETYPE hComponent,
1608 OMX_INDEXTYPE nParamIndex,
1609 OMX_PTR pComponentConfigStructure)
1611 OMX_ERRORTYPE ret = OMX_ErrorNone;
1612 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1613 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1617 if ((hComponent == NULL) ||
1618 (pComponentConfigStructure == NULL)) {
1619 ret = OMX_ErrorBadParameter;
1622 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1624 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1625 if (ret != OMX_ErrorNone) {
1629 if (pOMXComponent->pComponentPrivate == NULL) {
1630 ret = OMX_ErrorBadParameter;
1633 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1635 if (pExynosComponent->currentState == OMX_StateInvalid) {
1636 ret = OMX_ErrorInvalidState;
1640 switch (nParamIndex) {
1641 case OMX_IndexConfigVideoBitrate:
1643 OMX_VIDEO_CONFIG_BITRATETYPE *pConfigBitrate = (OMX_VIDEO_CONFIG_BITRATETYPE *)pComponentConfigStructure;
1644 OMX_U32 nPortIndex = pConfigBitrate->nPortIndex;
1645 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1647 if (nPortIndex != OUTPUT_PORT_INDEX) {
1648 ret = OMX_ErrorBadPortIndex;
1651 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1652 pConfigBitrate->nEncodeBitrate = pExynosPort->portDefinition.format.video.nBitrate;
1656 case OMX_IndexConfigVideoFramerate:
1658 OMX_CONFIG_FRAMERATETYPE *pConfigFramerate = (OMX_CONFIG_FRAMERATETYPE *)pComponentConfigStructure;
1659 OMX_U32 nPortIndex = pConfigFramerate->nPortIndex;
1660 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1662 if (nPortIndex != OUTPUT_PORT_INDEX) {
1663 ret = OMX_ErrorBadPortIndex;
1666 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1667 pConfigFramerate->xEncodeFramerate = pExynosPort->portDefinition.format.video.xFramerate;
1673 ret = Exynos_OMX_GetConfig(hComponent, nParamIndex, pComponentConfigStructure);
1683 OMX_ERRORTYPE Exynos_OMX_VideoEncodeSetConfig(
1684 OMX_HANDLETYPE hComponent,
1685 OMX_INDEXTYPE nParamIndex,
1686 OMX_PTR pComponentConfigStructure)
1688 OMX_ERRORTYPE ret = OMX_ErrorNone;
1689 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1690 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1694 if ((hComponent == NULL) ||
1695 (pComponentConfigStructure == NULL)) {
1696 ret = OMX_ErrorBadParameter;
1699 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1701 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1702 if (ret != OMX_ErrorNone) {
1706 if (pOMXComponent->pComponentPrivate == NULL) {
1707 ret = OMX_ErrorBadParameter;
1710 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1712 if (pExynosComponent->currentState == OMX_StateInvalid) {
1713 ret = OMX_ErrorInvalidState;
1717 switch (nParamIndex) {
1718 case OMX_IndexConfigVideoBitrate:
1720 OMX_VIDEO_CONFIG_BITRATETYPE *pConfigBitrate = (OMX_VIDEO_CONFIG_BITRATETYPE *)pComponentConfigStructure;
1721 OMX_U32 nPortIndex = pConfigBitrate->nPortIndex;
1722 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1724 if (nPortIndex != OUTPUT_PORT_INDEX) {
1725 ret = OMX_ErrorBadPortIndex;
1728 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1729 pExynosPort->portDefinition.format.video.nBitrate = pConfigBitrate->nEncodeBitrate;
1733 case OMX_IndexConfigVideoFramerate:
1735 OMX_CONFIG_FRAMERATETYPE *pConfigFramerate = (OMX_CONFIG_FRAMERATETYPE *)pComponentConfigStructure;
1736 OMX_U32 nPortIndex = pConfigFramerate->nPortIndex;
1737 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1739 if (nPortIndex != OUTPUT_PORT_INDEX) {
1740 ret = OMX_ErrorBadPortIndex;
1743 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1744 pExynosPort->portDefinition.format.video.xFramerate = pConfigFramerate->xEncodeFramerate;
1748 case OMX_IndexConfigVideoIntraVOPRefresh:
1750 OMX_CONFIG_INTRAREFRESHVOPTYPE *pIntraRefreshVOP = (OMX_CONFIG_INTRAREFRESHVOPTYPE *)pComponentConfigStructure;
1751 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1752 OMX_U32 nPortIndex = pIntraRefreshVOP->nPortIndex;
1754 if (pExynosComponent->hComponentHandle == NULL) {
1755 ret = OMX_ErrorBadParameter;
1758 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1760 if (nPortIndex != OUTPUT_PORT_INDEX) {
1761 ret = OMX_ErrorBadPortIndex;
1764 pVideoEnc->IntraRefreshVOP = pIntraRefreshVOP->IntraRefreshVOP;
1770 ret = Exynos_OMX_SetConfig(hComponent, nParamIndex, pComponentConfigStructure);
1780 OMX_ERRORTYPE Exynos_OMX_VideoEncodeGetExtensionIndex(
1781 OMX_IN OMX_HANDLETYPE hComponent,
1782 OMX_IN OMX_STRING szParamName,
1783 OMX_OUT OMX_INDEXTYPE *pIndexType)
1785 OMX_ERRORTYPE ret = OMX_ErrorNone;
1786 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1787 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1791 if (hComponent == NULL) {
1792 ret = OMX_ErrorBadParameter;
1795 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1797 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1798 if (ret != OMX_ErrorNone) {
1802 if (pOMXComponent->pComponentPrivate == NULL) {
1803 ret = OMX_ErrorBadParameter;
1806 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1808 if ((szParamName == NULL) || (pIndexType == NULL)) {
1809 ret = OMX_ErrorBadParameter;
1813 if (pExynosComponent->currentState == OMX_StateInvalid) {
1814 ret = OMX_ErrorInvalidState;
1818 #ifdef USE_STOREMETADATA
1819 if (Exynos_OSAL_Strcmp(szParamName, EXYNOS_INDEX_PARAM_STORE_METADATA_BUFFER) == 0) {
1820 *pIndexType = (OMX_INDEXTYPE)OMX_IndexParamStoreMetaDataBuffer;
1822 ret = Exynos_OMX_GetExtensionIndex(hComponent, szParamName, pIndexType);
1825 ret = Exynos_OMX_GetExtensionIndex(hComponent, szParamName, pIndexType);