projects / GitHub / LineageOS / android_hardware_samsung_slsi_openmax.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
venc: removed FlushXXBufferReturn function
[GitHub/LineageOS/android_hardware_samsung_slsi_openmax.git] / component / video / enc / Exynos_OMX_VencControl.c
CommitLineData
c6f4bc34
YK		 1/*
2 *
3 * Copyright 2012 Samsung Electronics S.LSI Co. LTD
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18/*
19 * @file Exynos_OMX_VencControl.c
20 * @brief
21 * @author SeungBeom Kim (sbcrux.kim@samsung.com)
22 * @version 2.0.0
23 * @history
24 * 2012.02.20 : Create
25 */
26
27#include <stdio.h>
28#include <stdlib.h>
29#include <string.h>
30#include "Exynos_OMX_Macros.h"
31#include "Exynos_OSAL_Event.h"
32#include "Exynos_OMX_Venc.h"
33#include "Exynos_OMX_VencControl.h"
34#include "Exynos_OMX_Basecomponent.h"
35#include "Exynos_OSAL_Thread.h"
36#include "Exynos_OSAL_Semaphore.h"
37#include "Exynos_OSAL_Mutex.h"
38#include "Exynos_OSAL_ETC.h"
39#include "Exynos_OSAL_SharedMemory.h"
40
41#ifdef USE_ANB
42#include "Exynos_OSAL_Android.h"
43#endif
44
45#undef EXYNOS_LOG_TAG
46#define EXYNOS_LOG_TAG "EXYNOS_VIDEO_ENCCONTROL"
47#define EXYNOS_LOG_OFF
48//#define EXYNOS_TRACE_ON
49#include "Exynos_OSAL_Log.h"
50
51
52OMX_ERRORTYPE Exynos_OMX_UseBuffer(
53 OMX_IN OMX_HANDLETYPE hComponent,
54 OMX_INOUT OMX_BUFFERHEADERTYPE **ppBufferHdr,
55 OMX_IN OMX_U32 nPortIndex,
56 OMX_IN OMX_PTR pAppPrivate,
57 OMX_IN OMX_U32 nSizeBytes,
58 OMX_IN OMX_U8 *pBuffer)
59{
e4e150b8
HK		 60 OMX_ERRORTYPE ret = OMX_ErrorNone;
61 OMX_COMPONENTTYPE *pOMXComponent = NULL;
62 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
63 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
64 OMX_BUFFERHEADERTYPE *pTempBufferHdr = NULL;
65 OMX_U32 i = 0;
c6f4bc34
YK		 66
67 FunctionIn();
68
69 if (hComponent == NULL) {
70 ret = OMX_ErrorBadParameter;
71 goto EXIT;
72 }
73 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
e4e150b8 74
c6f4bc34
YK		 75 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
76 if (ret != OMX_ErrorNone) {
77 goto EXIT;
78 }
79
80 if (pOMXComponent->pComponentPrivate == NULL) {
81 ret = OMX_ErrorBadParameter;
82 goto EXIT;
83 }
84 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
85
c6f4bc34
YK		 86 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
87 ret = OMX_ErrorBadPortIndex;
88 goto EXIT;
89 }
e4e150b8
HK		 90 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
91
c6f4bc34
YK		 92 if (pExynosPort->portState != OMX_StateIdle) {
93 ret = OMX_ErrorIncorrectStateOperation;
94 goto EXIT;
95 }
96
97 if (CHECK_PORT_TUNNELED(pExynosPort) && CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)) {
98 ret = OMX_ErrorBadPortIndex;
99 goto EXIT;
100 }
101
e4e150b8
HK		 102 pTempBufferHdr = (OMX_BUFFERHEADERTYPE *)Exynos_OSAL_Malloc(sizeof(OMX_BUFFERHEADERTYPE));
103 if (pTempBufferHdr == NULL) {
c6f4bc34
YK		 104 ret = OMX_ErrorInsufficientResources;
105 goto EXIT;
106 }
e4e150b8 107 Exynos_OSAL_Memset(pTempBufferHdr, 0, sizeof(OMX_BUFFERHEADERTYPE));
c6f4bc34
YK		 108
109 for (i = 0; i < pExynosPort->portDefinition.nBufferCountActual; i++) {
110 if (pExynosPort->bufferStateAllocate[i] == BUFFER_STATE_FREE) {
e4e150b8 111 pExynosPort->extendBufferHeader[i].OMXBufferHeader = pTempBufferHdr;
c6f4bc34 112 pExynosPort->bufferStateAllocate[i] = (BUFFER_STATE_ASSIGNED | HEADER_STATE_ALLOCATED);
e4e150b8
HK		 113 INIT_SET_SIZE_VERSION(pTempBufferHdr, OMX_BUFFERHEADERTYPE);
114 pTempBufferHdr->pBuffer = pBuffer;
115 pTempBufferHdr->nAllocLen = nSizeBytes;
116 pTempBufferHdr->pAppPrivate = pAppPrivate;
c6f4bc34 117 if (nPortIndex == INPUT_PORT_INDEX)
e4e150b8 118 pTempBufferHdr->nInputPortIndex = INPUT_PORT_INDEX;
c6f4bc34 119 else
e4e150b8 120 pTempBufferHdr->nOutputPortIndex = OUTPUT_PORT_INDEX;
c6f4bc34
YK		 121
122 pExynosPort->assignedBufferNum++;
123 if (pExynosPort->assignedBufferNum == pExynosPort->portDefinition.nBufferCountActual) {
124 pExynosPort->portDefinition.bPopulated = OMX_TRUE;
125 /* Exynos_OSAL_MutexLock(pExynosComponent->compMutex); */
126 Exynos_OSAL_SemaphorePost(pExynosPort->loadedResource);
127 /* Exynos_OSAL_MutexUnlock(pExynosComponent->compMutex); */
128 }
e4e150b8 129 *ppBufferHdr = pTempBufferHdr;
c6f4bc34
YK		 130 ret = OMX_ErrorNone;
131 goto EXIT;
132 }
133 }
134
e4e150b8 135 Exynos_OSAL_Free(pTempBufferHdr);
c6f4bc34
YK		 136 ret = OMX_ErrorInsufficientResources;
137
138EXIT:
139 FunctionOut();
140
141 return ret;
142}
143
144OMX_ERRORTYPE Exynos_OMX_AllocateBuffer(
145 OMX_IN OMX_HANDLETYPE hComponent,
e4e150b8 146 OMX_INOUT OMX_BUFFERHEADERTYPE **ppBufferHdr,
c6f4bc34
YK		 147 OMX_IN OMX_U32 nPortIndex,
148 OMX_IN OMX_PTR pAppPrivate,
149 OMX_IN OMX_U32 nSizeBytes)
150{
e4e150b8
HK		 151 OMX_ERRORTYPE ret = OMX_ErrorNone;
152 OMX_COMPONENTTYPE *pOMXComponent = NULL;
153 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
154 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
155 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
156 OMX_BUFFERHEADERTYPE *pTempBufferHdr = NULL;
157 OMX_U8 *pTempBuffer = NULL;
158 int fdTempBuffer = -1;
026e5b24 159 MEMORY_TYPE eMemType = SYSTEM_MEMORY;
e4e150b8 160 OMX_U32 i = 0;
c6f4bc34
YK		 161
162 FunctionIn();
163
164 if (hComponent == NULL) {
165 ret = OMX_ErrorBadParameter;
166 goto EXIT;
167 }
168 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
e4e150b8 169
c6f4bc34
YK		 170 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
171 if (ret != OMX_ErrorNone) {
172 goto EXIT;
173 }
174
175 if (pOMXComponent->pComponentPrivate == NULL) {
176 ret = OMX_ErrorBadParameter;
177 goto EXIT;
178 }
179 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
e4e150b8
HK		 180
181 if (pExynosComponent->hComponentHandle == NULL) {
182 ret = OMX_ErrorBadParameter;
183 goto EXIT;
184 }
c6f4bc34
YK		 185 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
186
c6f4bc34
YK		 187 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
188 ret = OMX_ErrorBadPortIndex;
189 goto EXIT;
190 }
e4e150b8 191 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
c6f4bc34
YK		 192/*
193 if (pExynosPort->portState != OMX_StateIdle ) {
194 ret = OMX_ErrorIncorrectStateOperation;
195 goto EXIT;
196 }
197*/
198 if (CHECK_PORT_TUNNELED(pExynosPort) && CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)) {
199 ret = OMX_ErrorBadPortIndex;
200 goto EXIT;
201 }
202
10db72aa
SK		 203 if ((pVideoEnc->bDRMPlayerMode == OMX_TRUE) &&
204 (nPortIndex == OUTPUT_PORT_INDEX)) {
205 eMemType = SECURE_MEMORY;
206 } else if (pExynosPort->bNeedContigMem == OMX_TRUE) {
c31a957e
TK		 207 eMemType = CONTIG_MEMORY;
208 } else if ((nPortIndex == INPUT_PORT_INDEX) &&
10db72aa 209 (pExynosPort->bufferProcessType & BUFFER_SHARE)) {
e4e150b8 210 eMemType = NORMAL_MEMORY;
026e5b24 211 }
e4e150b8
HK		 212
213 pTempBuffer = Exynos_OSAL_SharedMemory_Alloc(pVideoEnc->hSharedMemory, nSizeBytes, eMemType);
214 if (pTempBuffer == NULL) {
c6f4bc34
YK		 215 ret = OMX_ErrorInsufficientResources;
216 goto EXIT;
217 }
e4e150b8 218 fdTempBuffer = Exynos_OSAL_SharedMemory_VirtToION(pVideoEnc->hSharedMemory, pTempBuffer);
c6f4bc34 219
e4e150b8
HK		 220 pTempBufferHdr = (OMX_BUFFERHEADERTYPE *)Exynos_OSAL_Malloc(sizeof(OMX_BUFFERHEADERTYPE));
221 if (pTempBufferHdr == NULL) {
222 Exynos_OSAL_SharedMemory_Free(pVideoEnc->hSharedMemory, pTempBuffer);
c6f4bc34
YK		 223 ret = OMX_ErrorInsufficientResources;
224 goto EXIT;
225 }
e4e150b8 226 Exynos_OSAL_Memset(pTempBufferHdr, 0, sizeof(OMX_BUFFERHEADERTYPE));
c6f4bc34
YK		 227
228 for (i = 0; i < pExynosPort->portDefinition.nBufferCountActual; i++) {
229 if (pExynosPort->bufferStateAllocate[i] == BUFFER_STATE_FREE) {
e4e150b8
HK		 230 pExynosPort->extendBufferHeader[i].OMXBufferHeader = pTempBufferHdr;
231 pExynosPort->extendBufferHeader[i].buf_fd[0] = fdTempBuffer;
c6f4bc34 232 pExynosPort->bufferStateAllocate[i] = (BUFFER_STATE_ALLOCATED | HEADER_STATE_ALLOCATED);
e4e150b8 233 INIT_SET_SIZE_VERSION(pTempBufferHdr, OMX_BUFFERHEADERTYPE);
10db72aa
SK		 234 if (eMemType == SECURE_MEMORY)
235 pTempBufferHdr->pBuffer = fdTempBuffer;
236 else
237 pTempBufferHdr->pBuffer = pTempBuffer;
e4e150b8
HK		 238 pTempBufferHdr->nAllocLen = nSizeBytes;
239 pTempBufferHdr->pAppPrivate = pAppPrivate;
c6f4bc34 240 if (nPortIndex == INPUT_PORT_INDEX)
e4e150b8 241 pTempBufferHdr->nInputPortIndex = INPUT_PORT_INDEX;
c6f4bc34 242 else
e4e150b8 243 pTempBufferHdr->nOutputPortIndex = OUTPUT_PORT_INDEX;
c6f4bc34
YK		 244 pExynosPort->assignedBufferNum++;
245 if (pExynosPort->assignedBufferNum == pExynosPort->portDefinition.nBufferCountActual) {
246 pExynosPort->portDefinition.bPopulated = OMX_TRUE;
247 /* Exynos_OSAL_MutexLock(pExynosComponent->compMutex); */
248 Exynos_OSAL_SemaphorePost(pExynosPort->loadedResource);
249 /* Exynos_OSAL_MutexUnlock(pExynosComponent->compMutex); */
250 }
e4e150b8 251 *ppBufferHdr = pTempBufferHdr;
c6f4bc34
YK		 252 ret = OMX_ErrorNone;
253 goto EXIT;
254 }
255 }
256
e4e150b8
HK		 257 Exynos_OSAL_Free(pTempBufferHdr);
258 Exynos_OSAL_SharedMemory_Free(pVideoEnc->hSharedMemory, pTempBuffer);
c6f4bc34
YK		 259
260 ret = OMX_ErrorInsufficientResources;
261
262EXIT:
263 FunctionOut();
264
265 return ret;
266}
267
268OMX_ERRORTYPE Exynos_OMX_FreeBuffer(
e4e150b8
HK		 269 OMX_IN OMX_HANDLETYPE hComponent,
270 OMX_IN OMX_U32 nPortIndex,
c6f4bc34
YK		 271 OMX_IN OMX_BUFFERHEADERTYPE *pBufferHdr)
272{
e4e150b8
HK		 273 OMX_ERRORTYPE ret = OMX_ErrorNone;
274 OMX_COMPONENTTYPE *pOMXComponent = NULL;
275 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
276 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
277 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
278 OMX_BUFFERHEADERTYPE *pOMXBufferHdr = NULL;
279 OMX_U32 i = 0;
c6f4bc34
YK		 280
281 FunctionIn();
282
283 if (hComponent == NULL) {
284 ret = OMX_ErrorBadParameter;
285 goto EXIT;
286 }
287 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
e4e150b8 288
c6f4bc34
YK		 289 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
290 if (ret != OMX_ErrorNone) {
291 goto EXIT;
292 }
293
294 if (pOMXComponent->pComponentPrivate == NULL) {
295 ret = OMX_ErrorBadParameter;
296 goto EXIT;
297 }
298 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
e4e150b8
HK		 299
300 if (pExynosComponent->hComponentHandle == NULL) {
301 ret = OMX_ErrorBadParameter;
302 goto EXIT;
303 }
c6f4bc34 304 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
e4e150b8
HK		 305
306 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
307 ret = OMX_ErrorBadPortIndex;
308 goto EXIT;
309 }
c6f4bc34
YK		 310 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
311
312 if (CHECK_PORT_TUNNELED(pExynosPort) && CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)) {
313 ret = OMX_ErrorBadPortIndex;
314 goto EXIT;
315 }
316
e4e150b8
HK		 317 if ((pExynosPort->portState != OMX_StateLoaded) &&
318 (pExynosPort->portState != OMX_StateInvalid)) {
c6f4bc34
YK		 319 (*(pExynosComponent->pCallbacks->EventHandler)) (pOMXComponent,
320 pExynosComponent->callbackData,
321 (OMX_U32)OMX_EventError,
322 (OMX_U32)OMX_ErrorPortUnpopulated,
323 nPortIndex, NULL);
324 }
325
326 for (i = 0; i < /*pExynosPort->portDefinition.nBufferCountActual*/MAX_BUFFER_NUM; i++) {
e4e150b8
HK		 327 if ((pExynosPort->bufferStateAllocate[i] != BUFFER_STATE_FREE) &&
328 (pExynosPort->extendBufferHeader[i].OMXBufferHeader != NULL)) {
329 pOMXBufferHdr = pExynosPort->extendBufferHeader[i].OMXBufferHeader;
330
331 if (pOMXBufferHdr->pBuffer == pBufferHdr->pBuffer) {
c6f4bc34 332 if (pExynosPort->bufferStateAllocate[i] & BUFFER_STATE_ALLOCATED) {
10db72aa
SK		 333 if ((pVideoEnc->bDRMPlayerMode == OMX_TRUE) &&
334 (nPortIndex == OUTPUT_PORT_INDEX)) {
335 OMX_PTR mapBuffer = Exynos_OSAL_SharedMemory_IONToVirt(pVideoEnc->hSharedMemory, (int)pOMXBufferHdr->pBuffer);
336 Exynos_OSAL_SharedMemory_Free(pVideoEnc->hSharedMemory, mapBuffer);
337 } else {
338 Exynos_OSAL_SharedMemory_Free(pVideoEnc->hSharedMemory, pOMXBufferHdr->pBuffer);
339 }
e4e150b8 340 pOMXBufferHdr->pBuffer = NULL;
c6f4bc34
YK		 341 pBufferHdr->pBuffer = NULL;
342 } else if (pExynosPort->bufferStateAllocate[i] & BUFFER_STATE_ASSIGNED) {
343 ; /* None*/
344 }
345 pExynosPort->assignedBufferNum--;
e4e150b8 346
c6f4bc34 347 if (pExynosPort->bufferStateAllocate[i] & HEADER_STATE_ALLOCATED) {
e4e150b8 348 Exynos_OSAL_Free(pOMXBufferHdr);
c6f4bc34
YK		 349 pExynosPort->extendBufferHeader[i].OMXBufferHeader = NULL;
350 pBufferHdr = NULL;
351 }
e4e150b8 352
c6f4bc34
YK		 353 pExynosPort->bufferStateAllocate[i] = BUFFER_STATE_FREE;
354 ret = OMX_ErrorNone;
355 goto EXIT;
356 }
357 }
358 }
359
360EXIT:
e4e150b8
HK		 361 if ((ret == OMX_ErrorNone) &&
362 (pExynosPort->assignedBufferNum == 0)) {
363 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pExynosPort->unloadedResource signal set");
364 /* Exynos_OSAL_MutexLock(pExynosComponent->compMutex); */
365 Exynos_OSAL_SemaphorePost(pExynosPort->unloadedResource);
366 /* Exynos_OSAL_MutexUnlock(pExynosComponent->compMutex); */
367 pExynosPort->portDefinition.bPopulated = OMX_FALSE;
c6f4bc34
YK		 368 }
369
370 FunctionOut();
371
372 return ret;
373}
374
e4e150b8
HK		 375OMX_ERRORTYPE Exynos_OMX_AllocateTunnelBuffer(
376 EXYNOS_OMX_BASEPORT *pOMXBasePort,
377 OMX_U32 nPortIndex)
c6f4bc34 378{
e4e150b8
HK		 379 OMX_ERRORTYPE ret = OMX_ErrorNone;
380 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
381 OMX_BUFFERHEADERTYPE *pTempBufferHdr = NULL;
382 OMX_U8 *pTempBuffer = NULL;
383 OMX_U32 nBufferSize = 0;
c6f4bc34
YK		 384 OMX_PARAM_PORTDEFINITIONTYPE portDefinition;
385
386 ret = OMX_ErrorTunnelingUnsupported;
387EXIT:
388 return ret;
389}
390
e4e150b8
HK		 391OMX_ERRORTYPE Exynos_OMX_FreeTunnelBuffer(
392 EXYNOS_OMX_BASEPORT *pOMXBasePort,
393 OMX_U32 nPortIndex)
c6f4bc34 394{
e4e150b8
HK		 395 OMX_ERRORTYPE ret = OMX_ErrorNone;
396 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
397 OMX_BUFFERHEADERTYPE *pTempBufferHdr = NULL;
398 OMX_U8 *pTempBuffer = NULL;
399 OMX_U32 nBufferSize = 0;
c6f4bc34
YK		 400
401 ret = OMX_ErrorTunnelingUnsupported;
402EXIT:
403 return ret;
404}
405
406OMX_ERRORTYPE Exynos_OMX_ComponentTunnelRequest(
407 OMX_IN OMX_HANDLETYPE hComp,
408 OMX_IN OMX_U32 nPort,
409 OMX_IN OMX_HANDLETYPE hTunneledComp,
410 OMX_IN OMX_U32 nTunneledPort,
411 OMX_INOUT OMX_TUNNELSETUPTYPE *pTunnelSetup)
412{
413 OMX_ERRORTYPE ret = OMX_ErrorNone;
414
415 ret = OMX_ErrorTunnelingUnsupported;
416EXIT:
417 return ret;
418}
419
e4e150b8
HK		 420OMX_ERRORTYPE Exynos_OMX_GetFlushBuffer(
421 EXYNOS_OMX_BASEPORT *pExynosPort,
422 EXYNOS_OMX_DATABUFFER *pDataBuffer[])
c6f4bc34
YK		 423{
424 OMX_ERRORTYPE ret = OMX_ErrorNone;
425
426 FunctionIn();
427
428 *pDataBuffer = NULL;
429
430 if (pExynosPort->portWayType == WAY1_PORT) {
431 *pDataBuffer = &pExynosPort->way.port1WayDataBuffer.dataBuffer;
432 } else if (pExynosPort->portWayType == WAY2_PORT) {
e4e150b8
HK		 433 pDataBuffer[0] = &(pExynosPort->way.port2WayDataBuffer.inputDataBuffer);
434 pDataBuffer[1] = &(pExynosPort->way.port2WayDataBuffer.outputDataBuffer);
c6f4bc34
YK		 435 }
436
437EXIT:
438 FunctionOut();
439
440 return ret;
441}
442
e4e150b8
HK		 443OMX_ERRORTYPE Exynos_OMX_FlushPort(
444 OMX_COMPONENTTYPE *pOMXComponent,
445 OMX_S32 nPortIndex)
c6f4bc34 446{
e4e150b8
HK		 447 OMX_ERRORTYPE ret = OMX_ErrorNone;
448 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
449 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
450 OMX_BUFFERHEADERTYPE *pBufferHdr = NULL;
451 EXYNOS_OMX_DATABUFFER *pDataBuffer[2] = {NULL, NULL};
452 EXYNOS_OMX_MESSAGE *pMessage = NULL;
453 OMX_S32 nSemaCnt = 0;
454 int i = 0;
455
c6f4bc34
YK		 456 FunctionIn();
457
e4e150b8
HK		 458 if (pOMXComponent == NULL) {
459 ret = OMX_ErrorBadParameter;
460 goto EXIT;
461 }
462
463 if (pOMXComponent->pComponentPrivate == NULL) {
464 ret = OMX_ErrorBadParameter;
465 goto EXIT;
466 }
467 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
468
469 if ((nPortIndex < 0) ||
470 (nPortIndex >= pExynosComponent->portParam.nPorts)) {
471 ret = OMX_ErrorBadPortIndex;
472 goto EXIT;
473 }
474 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
c6f4bc34
YK		 475
476 while (Exynos_OSAL_GetElemNum(&pExynosPort->bufferQ) > 0) {
e4e150b8
HK		 477 Exynos_OSAL_Get_SemaphoreCount(pExynosPort->bufferSemID, &nSemaCnt);
478 if (nSemaCnt == 0)
479 Exynos_OSAL_SemaphorePost(pExynosPort->bufferSemID);
480
481 Exynos_OSAL_SemaphoreWait(pExynosPort->bufferSemID);
482 pMessage = (EXYNOS_OMX_MESSAGE *)Exynos_OSAL_Dequeue(&pExynosPort->bufferQ);
483 if ((pMessage != NULL) &&
484 (pMessage->messageType != EXYNOS_OMX_CommandFakeBuffer)) {
485 pBufferHdr = (OMX_BUFFERHEADERTYPE *)pMessage->pCmdData;
486 pBufferHdr->nFilledLen = 0;
487
488 if (nPortIndex == OUTPUT_PORT_INDEX) {
489 Exynos_OMX_OutputBufferReturn(pOMXComponent, pBufferHdr);
490 } else if (nPortIndex == INPUT_PORT_INDEX) {
491 Exynos_OMX_InputBufferReturn(pOMXComponent, pBufferHdr);
c6f4bc34
YK		 492 }
493 }
e4e150b8
HK		 494 Exynos_OSAL_Free(pMessage);
495 pMessage = NULL;
c6f4bc34
YK		 496 }
497
e4e150b8
HK		 498 Exynos_OMX_GetFlushBuffer(pExynosPort, pDataBuffer);
499 if ((pDataBuffer[0] != NULL) &&
500 (pDataBuffer[0]->dataValid == OMX_TRUE)) {
501 if (nPortIndex == INPUT_PORT_INDEX)
3858590d 502 Exynos_InputBufferReturn(pOMXComponent, pDataBuffer[0]);
e4e150b8 503 else if (nPortIndex == OUTPUT_PORT_INDEX)
3858590d 504 Exynos_OutputBufferReturn(pOMXComponent, pDataBuffer[0]);
e4e150b8
HK		 505 }
506 if ((pDataBuffer[1] != NULL) &&
507 (pDataBuffer[1]->dataValid == OMX_TRUE)) {
508 if (nPortIndex == INPUT_PORT_INDEX)
3858590d 509 Exynos_InputBufferReturn(pOMXComponent, pDataBuffer[1]);
e4e150b8 510 else if (nPortIndex == OUTPUT_PORT_INDEX)
3858590d 511 Exynos_OutputBufferReturn(pOMXComponent, pDataBuffer[1]);
c6f4bc34
YK		 512 }
513
514 if (pExynosComponent->bMultiThreadProcess == OMX_TRUE) {
24ec2c82 515 if (pExynosPort->bufferProcessType & BUFFER_SHARE) {
c6f4bc34 516 if (pExynosPort->processData.bufferHeader != NULL) {
e4e150b8 517 if (nPortIndex == INPUT_PORT_INDEX) {
323488ff
SK		 518#ifdef USE_METADATABUFFERTYPE
519 if ((pExynosPort->bStoreMetaData == OMX_TRUE) &&
520 (pExynosPort->portDefinition.format.video.eColorFormat == OMX_COLOR_FormatAndroidOpaque)) {
521 OMX_PTR ppBuf[MAX_BUFFER_PLANE];
522 Exynos_OSAL_GetInfoFromMetaData((OMX_BYTE)pExynosPort->processData.bufferHeader->pBuffer, ppBuf);
523 Exynos_OSAL_UnlockANBHandle(ppBuf[0]);
524 }
525#endif
c6f4bc34 526 Exynos_OMX_InputBufferReturn(pOMXComponent, pExynosPort->processData.bufferHeader);
e4e150b8 527 } else if (nPortIndex == OUTPUT_PORT_INDEX) {
c6f4bc34
YK		 528 Exynos_OMX_OutputBufferReturn(pOMXComponent, pExynosPort->processData.bufferHeader);
529 }
530 }
531 Exynos_ResetCodecData(&pExynosPort->processData);
532
e4e150b8 533 for (i = 0; i < pExynosPort->portDefinition.nBufferCountActual; i++) {
c6f4bc34 534 if (pExynosPort->extendBufferHeader[i].bBufferInOMX == OMX_TRUE) {
e4e150b8
HK		 535 if (nPortIndex == OUTPUT_PORT_INDEX) {
536 Exynos_OMX_OutputBufferReturn(pOMXComponent,
537 pExynosPort->extendBufferHeader[i].OMXBufferHeader);
538 } else if (nPortIndex == INPUT_PORT_INDEX) {
323488ff
SK		 539#ifdef USE_METADATABUFFERTYPE
540 if ((pExynosPort->bStoreMetaData == OMX_TRUE) &&
541 (pExynosPort->portDefinition.format.video.eColorFormat == OMX_COLOR_FormatAndroidOpaque)) {
542 OMX_PTR ppBuf[MAX_BUFFER_PLANE];
543 Exynos_OSAL_GetInfoFromMetaData((OMX_BYTE)pExynosPort->extendBufferHeader[i].OMXBufferHeader->pBuffer, ppBuf);
544 Exynos_OSAL_UnlockANBHandle(ppBuf[0]);
545 }
546#endif
e4e150b8
HK		 547 Exynos_OMX_InputBufferReturn(pOMXComponent,
548 pExynosPort->extendBufferHeader[i].OMXBufferHeader);
c6f4bc34
YK		 549 }
550 }
551 }
552 }
553 } else {
554 Exynos_ResetCodecData(&pExynosPort->processData);
555 }
556
e4e150b8 557 while (1) {
c6f4bc34 558 OMX_S32 cnt = 0;
e4e150b8 559 Exynos_OSAL_Get_SemaphoreCount(pExynosPort->bufferSemID, &cnt);
c6f4bc34
YK		 560 if (cnt <= 0)
561 break;
e4e150b8 562 Exynos_OSAL_SemaphoreWait(pExynosPort->bufferSemID);
c6f4bc34
YK		 563 }
564 Exynos_OSAL_ResetQueue(&pExynosPort->bufferQ);
565
566EXIT:
567 FunctionOut();
568
569 return ret;
570}
571
e4e150b8
HK		 572OMX_ERRORTYPE Exynos_OMX_BufferFlush(
573 OMX_COMPONENTTYPE *pOMXComponent,
574 OMX_S32 nPortIndex,
575 OMX_BOOL bEvent)
c6f4bc34 576{
e4e150b8
HK		 577 OMX_ERRORTYPE ret = OMX_ErrorNone;
578 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
579 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
580 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
581 EXYNOS_OMX_DATABUFFER *pDataBuffer[2] = {NULL, NULL};
582 OMX_U32 i = 0;
c6f4bc34
YK		 583
584 FunctionIn();
585
586 if (pOMXComponent == NULL) {
587 ret = OMX_ErrorBadParameter;
588 goto EXIT;
589 }
e4e150b8 590
c6f4bc34
YK		 591 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
592 if (ret != OMX_ErrorNone) {
593 goto EXIT;
594 }
595
596 if (pOMXComponent->pComponentPrivate == NULL) {
597 ret = OMX_ErrorBadParameter;
598 goto EXIT;
599 }
600 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
e4e150b8
HK		 601
602 if (pExynosComponent->hComponentHandle == NULL) {
603 ret = OMX_ErrorBadParameter;
604 goto EXIT;
605 }
c6f4bc34
YK		 606 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
607
e4e150b8
HK		 608 if ((nPortIndex < 0) ||
609 (nPortIndex >= pExynosComponent->portParam.nPorts)) {
610 ret = OMX_ErrorBadPortIndex;
611 goto EXIT;
612 }
613 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
614
c6f4bc34
YK		 615 Exynos_OSAL_Log(EXYNOS_LOG_TRACE,"OMX_CommandFlush start, port:%d", nPortIndex);
616
e4e150b8 617 pExynosPort->bIsPortFlushed = OMX_TRUE;
c6f4bc34
YK		 618
619 if (pExynosComponent->bMultiThreadProcess == OMX_FALSE) {
620 Exynos_OSAL_SignalSet(pExynosComponent->pauseEvent);
621 } else {
e4e150b8 622 Exynos_OSAL_SignalSet(pExynosPort->pauseEvent);
c6f4bc34
YK		 623 }
624
e4e150b8
HK		 625 Exynos_OMX_GetFlushBuffer(pExynosPort, pDataBuffer);
626 if (pDataBuffer[0] == NULL) {
627 ret = OMX_ErrorBadParameter;
628 goto EXIT;
629 }
c6f4bc34 630
e4e150b8 631 if (pExynosPort->bufferProcessType & BUFFER_COPY)
c6f4bc34
YK		 632 Exynos_OSAL_SemaphorePost(pExynosPort->codecSemID);
633 Exynos_OSAL_SemaphorePost(pExynosPort->bufferSemID);
634
635 pVideoEnc->exynos_codec_bufferProcessRun(pOMXComponent, nPortIndex);
e4e150b8
HK		 636
637 Exynos_OSAL_MutexLock(pDataBuffer[0]->bufferMutex);
c6f4bc34 638 pVideoEnc->exynos_codec_stop(pOMXComponent, nPortIndex);
e4e150b8
HK		 639
640 if (pDataBuffer[1] != NULL)
641 Exynos_OSAL_MutexLock(pDataBuffer[1]->bufferMutex);
642
c6f4bc34 643 ret = Exynos_OMX_FlushPort(pOMXComponent, nPortIndex);
e4e150b8
HK		 644 if (ret != OMX_ErrorNone)
645 goto EXIT;
646
647 if (pExynosPort->bufferProcessType & BUFFER_COPY)
c6f4bc34
YK		 648 pVideoEnc->exynos_codec_enqueueAllBuffer(pOMXComponent, nPortIndex);
649 Exynos_ResetCodecData(&pExynosPort->processData);
650
651 if (ret == OMX_ErrorNone) {
652 if (nPortIndex == INPUT_PORT_INDEX) {
653 pExynosComponent->checkTimeStamp.needSetStartTimeStamp = OMX_TRUE;
654 pExynosComponent->checkTimeStamp.needCheckStartTimeStamp = OMX_FALSE;
655 Exynos_OSAL_Memset(pExynosComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
656 Exynos_OSAL_Memset(pExynosComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
657 pExynosComponent->getAllDelayBuffer = OMX_FALSE;
658 pExynosComponent->bSaveFlagEOS = OMX_FALSE;
659 pExynosComponent->reInputData = OMX_FALSE;
660 }
661
e4e150b8 662 pExynosPort->bIsPortFlushed = OMX_FALSE;
c6f4bc34
YK		 663 Exynos_OSAL_Log(EXYNOS_LOG_TRACE,"OMX_CommandFlush EventCmdComplete, port:%d", nPortIndex);
664 if (bEvent == OMX_TRUE)
665 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
666 pExynosComponent->callbackData,
667 OMX_EventCmdComplete,
668 OMX_CommandFlush, nPortIndex, NULL);
669 }
e4e150b8
HK		 670
671 if (pDataBuffer[1] != NULL)
672 Exynos_OSAL_MutexUnlock(pDataBuffer[1]->bufferMutex);
673
674 Exynos_OSAL_MutexUnlock(pDataBuffer[0]->bufferMutex);
c6f4bc34
YK		 675
676EXIT:
677 if ((ret != OMX_ErrorNone) && (pOMXComponent != NULL) && (pExynosComponent != NULL)) {
678 Exynos_OSAL_Log(EXYNOS_LOG_ERROR,"%s : %d", __FUNCTION__, __LINE__);
679 pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
680 pExynosComponent->callbackData,
681 OMX_EventError,
682 ret, 0, NULL);
683 }
684
685 FunctionOut();
686
687 return ret;
688}
689
e4e150b8 690OMX_ERRORTYPE Exynos_InputBufferReturn(
3858590d
TK		 691 OMX_COMPONENTTYPE *pOMXComponent,
692 EXYNOS_OMX_DATABUFFER *pDataBuffer)
c6f4bc34 693{
e4e150b8
HK		 694 OMX_ERRORTYPE ret = OMX_ErrorNone;
695 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
696 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
e4e150b8 697 OMX_BUFFERHEADERTYPE *pBufferHdr = NULL;
c6f4bc34
YK		 698
699 FunctionIn();
700
e4e150b8
HK		 701 if (pOMXComponent == NULL) {
702 ret = OMX_ErrorBadParameter;
703 goto EXIT;
704 }
705
706 if (pOMXComponent->pComponentPrivate == NULL) {
707 ret = OMX_ErrorBadParameter;
708 goto EXIT;
709 }
710 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
711 pExynosPort = &(pExynosComponent->pExynosPort[INPUT_PORT_INDEX]);
712
e4e150b8
HK		 713 if (pDataBuffer != NULL)
714 pBufferHdr = pDataBuffer->bufferHeader;
c6f4bc34 715
e4e150b8
HK		 716 if (pBufferHdr != NULL) {
717 if (pExynosPort->markType.hMarkTargetComponent != NULL) {
3858590d
TK		 718 pBufferHdr->hMarkTargetComponent = pExynosPort->markType.hMarkTargetComponent;
719 pBufferHdr->pMarkData = pExynosPort->markType.pMarkData;
720 pExynosPort->markType.hMarkTargetComponent = NULL;
721 pExynosPort->markType.pMarkData = NULL;
c6f4bc34
YK		 722 }
723
e4e150b8
HK		 724 if (pBufferHdr->hMarkTargetComponent != NULL) {
725 if (pBufferHdr->hMarkTargetComponent == pOMXComponent) {
c6f4bc34
YK		 726 pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
727 pExynosComponent->callbackData,
728 OMX_EventMark,
e4e150b8 729 0, 0, pBufferHdr->pMarkData);
c6f4bc34 730 } else {
3858590d
TK		 731 pExynosComponent->propagateMarkType.hMarkTargetComponent = pBufferHdr->hMarkTargetComponent;
732 pExynosComponent->propagateMarkType.pMarkData = pBufferHdr->pMarkData;
c6f4bc34
YK		 733 }
734 }
735
3858590d
TK		 736 pBufferHdr->nFilledLen = 0;
737 pBufferHdr->nOffset = 0;
e4e150b8 738 Exynos_OMX_InputBufferReturn(pOMXComponent, pBufferHdr);
c6f4bc34
YK		 739 }
740
741 /* reset dataBuffer */
e4e150b8 742 Exynos_ResetDataBuffer(pDataBuffer);
c6f4bc34
YK		 743
744EXIT:
745 FunctionOut();
746
747 return ret;
748}
749
e4e150b8
HK		 750OMX_ERRORTYPE Exynos_InputBufferGetQueue(
751 EXYNOS_OMX_BASECOMPONENT *pExynosComponent)
c6f4bc34 752{
e4e150b8
HK		 753 OMX_ERRORTYPE ret = OMX_ErrorUndefined;
754 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
755 EXYNOS_OMX_MESSAGE *pMessage = NULL;
756 EXYNOS_OMX_DATABUFFER *pDataBuffer = NULL;
c6f4bc34
YK		 757
758 FunctionIn();
759
e4e150b8
HK		 760 if (pExynosComponent == NULL) {
761 ret = OMX_ErrorBadParameter;
762 goto EXIT;
763 }
764 pExynosPort = &(pExynosComponent->pExynosPort[INPUT_PORT_INDEX]);
765 pDataBuffer = &(pExynosPort->way.port2WayDataBuffer.inputDataBuffer);
c6f4bc34
YK		 766
767 if (pExynosComponent->currentState != OMX_StateExecuting) {
768 ret = OMX_ErrorUndefined;
769 goto EXIT;
770 } else if ((pExynosComponent->transientState != EXYNOS_OMX_TransStateExecutingToIdle) &&
771 (!CHECK_PORT_BEING_FLUSHED(pExynosPort))) {
772 Exynos_OSAL_SemaphoreWait(pExynosPort->bufferSemID);
e4e150b8
HK		 773 if (pDataBuffer->dataValid != OMX_TRUE) {
774 pMessage = (EXYNOS_OMX_MESSAGE *)Exynos_OSAL_Dequeue(&pExynosPort->bufferQ);
775 if (pMessage == NULL) {
c6f4bc34
YK		 776 ret = OMX_ErrorUndefined;
777 goto EXIT;
778 }
e4e150b8
HK		 779 if (pMessage->messageType == EXYNOS_OMX_CommandFakeBuffer) {
780 Exynos_OSAL_Free(pMessage);
c6f4bc34
YK		 781 ret = OMX_ErrorCodecFlush;
782 goto EXIT;
783 }
784
e4e150b8
HK		 785 pDataBuffer->bufferHeader = (OMX_BUFFERHEADERTYPE *)(pMessage->pCmdData);
786 pDataBuffer->allocSize = pDataBuffer->bufferHeader->nAllocLen;
787 pDataBuffer->dataLen = pDataBuffer->bufferHeader->nFilledLen;
788 pDataBuffer->remainDataLen = pDataBuffer->dataLen;
789 pDataBuffer->usedDataLen = 0;
790 pDataBuffer->dataValid = OMX_TRUE;
791 pDataBuffer->nFlags = pDataBuffer->bufferHeader->nFlags;
792 pDataBuffer->timeStamp = pDataBuffer->bufferHeader->nTimeStamp;
c6f4bc34 793
e4e150b8 794 Exynos_OSAL_Free(pMessage);
c6f4bc34 795
e4e150b8
HK		 796 if (pDataBuffer->allocSize <= pDataBuffer->dataLen)
797 Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "Input Buffer Full, Check input buffer size! allocSize:%d, dataLen:%d", pDataBuffer->allocSize, pDataBuffer->dataLen);
c6f4bc34
YK		 798 }
799 ret = OMX_ErrorNone;
800 }
801EXIT:
802 FunctionOut();
803
804 return ret;
805}
806
e4e150b8 807OMX_ERRORTYPE Exynos_OutputBufferReturn(
3858590d
TK		 808 OMX_COMPONENTTYPE *pOMXComponent,
809 EXYNOS_OMX_DATABUFFER *pDataBuffer)
c6f4bc34 810{
e4e150b8
HK		 811 OMX_ERRORTYPE ret = OMX_ErrorNone;
812 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
813 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
e4e150b8 814 OMX_BUFFERHEADERTYPE *pBufferHdr = NULL;
c6f4bc34
YK		 815
816 FunctionIn();
817
e4e150b8
HK		 818 if (pOMXComponent == NULL) {
819 ret = OMX_ErrorBadParameter;
820 goto EXIT;
821 }
c6f4bc34 822
e4e150b8
HK		 823 if (pOMXComponent->pComponentPrivate == NULL) {
824 ret = OMX_ErrorBadParameter;
825 goto EXIT;
826 }
827 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
828 pExynosPort = &(pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX]);
829
3858590d
TK		 830 if (pDataBuffer != NULL)
831 pBufferHdr = pDataBuffer->bufferHeader;
e4e150b8
HK		 832
833 if (pBufferHdr != NULL) {
834 pBufferHdr->nFilledLen = pDataBuffer->remainDataLen;
835 pBufferHdr->nOffset = 0;
836 pBufferHdr->nFlags = pDataBuffer->nFlags;
837 pBufferHdr->nTimeStamp = pDataBuffer->timeStamp;
c6f4bc34
YK		 838
839 if (pExynosComponent->propagateMarkType.hMarkTargetComponent != NULL) {
e4e150b8
HK		 840 pBufferHdr->hMarkTargetComponent = pExynosComponent->propagateMarkType.hMarkTargetComponent;
841 pBufferHdr->pMarkData = pExynosComponent->propagateMarkType.pMarkData;
3858590d
TK		 842 pExynosComponent->propagateMarkType.hMarkTargetComponent = NULL;
843 pExynosComponent->propagateMarkType.pMarkData = NULL;
c6f4bc34
YK		 844 }
845
e4e150b8
HK		 846 if ((pBufferHdr->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
847 pBufferHdr->nFilledLen = 0;
848 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "event OMX_BUFFERFLAG_EOS!!!");
c6f4bc34
YK		 849 pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
850 pExynosComponent->callbackData,
851 OMX_EventBufferFlag,
852 OUTPUT_PORT_INDEX,
e4e150b8 853 pBufferHdr->nFlags, NULL);
c6f4bc34
YK		 854 }
855
e4e150b8 856 Exynos_OMX_OutputBufferReturn(pOMXComponent, pBufferHdr);
c6f4bc34
YK		 857 }
858
859 /* reset dataBuffer */
e4e150b8 860 Exynos_ResetDataBuffer(pDataBuffer);
c6f4bc34
YK		 861
862EXIT:
863 FunctionOut();
864
865 return ret;
866}
867
e4e150b8
HK		 868OMX_ERRORTYPE Exynos_OutputBufferGetQueue(
869 EXYNOS_OMX_BASECOMPONENT *pExynosComponent)
c6f4bc34 870{
e4e150b8
HK		 871 OMX_ERRORTYPE ret = OMX_ErrorUndefined;
872 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
873 EXYNOS_OMX_MESSAGE *pMessage = NULL;
874 EXYNOS_OMX_DATABUFFER *pDataBuffer = NULL;
c6f4bc34
YK		 875
876 FunctionIn();
877
e4e150b8
HK		 878 if (pExynosComponent == NULL) {
879 ret = OMX_ErrorBadParameter;
880 goto EXIT;
881 }
882 pExynosPort = &(pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX]);
883
24ec2c82 884 if (pExynosPort->bufferProcessType & BUFFER_COPY) {
e4e150b8 885 pDataBuffer = &(pExynosPort->way.port2WayDataBuffer.outputDataBuffer);
24ec2c82 886 } else if (pExynosPort->bufferProcessType & BUFFER_SHARE) {
e4e150b8 887 pDataBuffer = &(pExynosPort->way.port2WayDataBuffer.inputDataBuffer);
9c39c5ff
TK		 888 } else {
889 ret = OMX_ErrorUndefined;
890 goto EXIT;
c6f4bc34
YK		 891 }
892
893 if (pExynosComponent->currentState != OMX_StateExecuting) {
894 ret = OMX_ErrorUndefined;
895 goto EXIT;
896 } else if ((pExynosComponent->transientState != EXYNOS_OMX_TransStateExecutingToIdle) &&
e4e150b8 897 (!CHECK_PORT_BEING_FLUSHED(pExynosPort))) {
c6f4bc34 898 Exynos_OSAL_SemaphoreWait(pExynosPort->bufferSemID);
9c39c5ff 899 if (pDataBuffer->dataValid != OMX_TRUE) {
e4e150b8
HK		 900 pMessage = (EXYNOS_OMX_MESSAGE *)Exynos_OSAL_Dequeue(&pExynosPort->bufferQ);
901 if (pMessage == NULL) {
c6f4bc34
YK		 902 ret = OMX_ErrorUndefined;
903 goto EXIT;
904 }
e4e150b8
HK		 905 if (pMessage->messageType == EXYNOS_OMX_CommandFakeBuffer) {
906 Exynos_OSAL_Free(pMessage);
c6f4bc34
YK		 907 ret = OMX_ErrorCodecFlush;
908 goto EXIT;
909 }
910
e4e150b8
HK		 911 pDataBuffer->bufferHeader = (OMX_BUFFERHEADERTYPE *)(pMessage->pCmdData);
912 pDataBuffer->allocSize = pDataBuffer->bufferHeader->nAllocLen;
913 pDataBuffer->dataLen = 0; //dataBuffer->bufferHeader->nFilledLen;
914 pDataBuffer->remainDataLen = pDataBuffer->dataLen;
915 pDataBuffer->usedDataLen = 0; //dataBuffer->bufferHeader->nOffset;
916 pDataBuffer->dataValid = OMX_TRUE;
917 /* pDataBuffer->nFlags = pDataBuffer->bufferHeader->nFlags; */
918 /* pDtaBuffer->nTimeStamp = pDataBuffer->bufferHeader->nTimeStamp; */
c6f4bc34 919/*
24ec2c82 920 if (pExynosPort->bufferProcessType & BUFFER_SHARE)
e4e150b8 921 pDataBuffer->pPrivate = pDataBuffer->bufferHeader->pOutputPortPrivate;
24ec2c82 922 else if (pExynosPort->bufferProcessType & BUFFER_COPY) {
e4e150b8
HK		 923 pExynosPort->processData.dataBuffer = pDataBuffer->bufferHeader->pBuffer;
924 pExynosPort->processData.allocSize = pDataBuffer->bufferHeader->nAllocLen;
c6f4bc34
YK		 925 }
926*/
e4e150b8 927 Exynos_OSAL_Free(pMessage);
c6f4bc34
YK		 928 }
929 ret = OMX_ErrorNone;
930 }
931EXIT:
932 FunctionOut();
933
934 return ret;
c6f4bc34
YK		 935}
936
e4e150b8
HK		 937OMX_BUFFERHEADERTYPE *Exynos_OutputBufferGetQueue_Direct(
938 EXYNOS_OMX_BASECOMPONENT *pExynosComponent)
c6f4bc34 939{
e4e150b8
HK		 940 OMX_BUFFERHEADERTYPE *pBufferHdr = NULL;
941 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
942 EXYNOS_OMX_MESSAGE *pMessage = NULL;
c6f4bc34
YK		 943
944 FunctionIn();
945
e4e150b8
HK		 946 if (pExynosComponent == NULL) {
947 pBufferHdr = NULL;
948 goto EXIT;
949 }
950 pExynosPort = &(pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX]);
951
c6f4bc34 952 if (pExynosComponent->currentState != OMX_StateExecuting) {
e4e150b8 953 pBufferHdr = NULL;
c6f4bc34
YK		 954 goto EXIT;
955 } else if ((pExynosComponent->transientState != EXYNOS_OMX_TransStateExecutingToIdle) &&
e4e150b8 956 (!CHECK_PORT_BEING_FLUSHED(pExynosPort))) {
c6f4bc34
YK		 957 Exynos_OSAL_SemaphoreWait(pExynosPort->bufferSemID);
958
e4e150b8
HK		 959 pMessage = (EXYNOS_OMX_MESSAGE *)Exynos_OSAL_Dequeue(&pExynosPort->bufferQ);
960 if (pMessage == NULL) {
961 pBufferHdr = NULL;
c6f4bc34
YK		 962 goto EXIT;
963 }
e4e150b8
HK		 964 if (pMessage->messageType == EXYNOS_OMX_CommandFakeBuffer) {
965 Exynos_OSAL_Free(pMessage);
966 pBufferHdr = NULL;
c6f4bc34
YK		 967 goto EXIT;
968 }
969
e4e150b8
HK		 970 pBufferHdr = (OMX_BUFFERHEADERTYPE *)(pMessage->pCmdData);
971 Exynos_OSAL_Free(pMessage);
c6f4bc34
YK		 972 }
973
974EXIT:
975 FunctionOut();
976
e4e150b8 977 return pBufferHdr;
c6f4bc34
YK		 978}
979
e4e150b8
HK		 980OMX_ERRORTYPE Exynos_CodecBufferEnqueue(
981 EXYNOS_OMX_BASECOMPONENT *pExynosComponent,
982 OMX_U32 nPortIndex,
983 OMX_PTR pData)
c6f4bc34 984{
e4e150b8 985 OMX_ERRORTYPE ret = OMX_ErrorNone;
c6f4bc34
YK		 986 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
987
988 FunctionIn();
989
e4e150b8
HK		 990 if (pExynosComponent == NULL) {
991 ret = OMX_ErrorBadParameter;
992 goto EXIT;
993 }
c6f4bc34 994
e4e150b8
HK		 995 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
996 ret = OMX_ErrorBadPortIndex;
997 goto EXIT;
998 }
999 pExynosPort = &(pExynosComponent->pExynosPort[nPortIndex]);
1000
1001 if (pData == NULL) {
c6f4bc34
YK		 1002 ret = OMX_ErrorInsufficientResources;
1003 goto EXIT;
1004 }
1005
e4e150b8 1006 ret = Exynos_OSAL_Queue(&pExynosPort->codecBufferQ, (void *)pData);
c6f4bc34
YK		 1007 if (ret != 0) {
1008 ret = OMX_ErrorUndefined;
1009 goto EXIT;
1010 }
1011 Exynos_OSAL_SemaphorePost(pExynosPort->codecSemID);
1012
1013 ret = OMX_ErrorNone;
1014
1015EXIT:
1016 FunctionOut();
1017
1018 return ret;
1019}
1020
e4e150b8
HK		 1021OMX_ERRORTYPE Exynos_CodecBufferDequeue(
1022 EXYNOS_OMX_BASECOMPONENT *pExynosComponent,
1023 OMX_U32 nPortIndex,
1024 OMX_PTR *pData)
c6f4bc34 1025{
e4e150b8 1026 OMX_ERRORTYPE ret = OMX_ErrorNone;
c6f4bc34 1027 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
e4e150b8 1028 OMX_PTR pTempData = NULL;
c6f4bc34
YK		 1029
1030 FunctionIn();
1031
e4e150b8
HK		 1032 if (pExynosComponent == NULL) {
1033 ret = OMX_ErrorBadParameter;
c6f4bc34
YK		 1034 goto EXIT;
1035 }
c6f4bc34 1036
e4e150b8
HK		 1037 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1038 ret = OMX_ErrorBadPortIndex;
1039 goto EXIT;
1040 }
1041 pExynosPort = &(pExynosComponent->pExynosPort[nPortIndex]);
1042
1043 Exynos_OSAL_SemaphoreWait(pExynosPort->codecSemID);
1044 pTempData = (OMX_PTR)Exynos_OSAL_Dequeue(&pExynosPort->codecBufferQ);
1045 if (pTempData != NULL) {
1046 *pData = (OMX_PTR)pTempData;
1047 ret = OMX_ErrorNone;
1048 } else {
1049 *pData = NULL;
1050 ret = OMX_ErrorUndefined;
1051 }
c6f4bc34
YK		 1052
1053EXIT:
1054 FunctionOut();
1055
1056 return ret;
1057}
1058
e4e150b8
HK		 1059OMX_ERRORTYPE Exynos_CodecBufferReset(
1060 EXYNOS_OMX_BASECOMPONENT *pExynosComponent,
1061 OMX_U32 nPortIndex)
c6f4bc34 1062{
e4e150b8
HK		 1063 OMX_ERRORTYPE ret = OMX_ErrorNone;
1064 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
c6f4bc34
YK		 1065
1066 FunctionIn();
1067
e4e150b8
HK		 1068 if (pExynosComponent == NULL) {
1069 ret = OMX_ErrorBadParameter;
1070 goto EXIT;
1071 }
1072
1073 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1074 ret = OMX_ErrorBadPortIndex;
1075 goto EXIT;
1076 }
1077 pExynosPort = &(pExynosComponent->pExynosPort[nPortIndex]);
c6f4bc34
YK		 1078
1079 ret = Exynos_OSAL_ResetQueue(&pExynosPort->codecBufferQ);
1080 if (ret != 0) {
1081 ret = OMX_ErrorUndefined;
1082 goto EXIT;
1083 }
e4e150b8 1084
c6f4bc34
YK		 1085 while (1) {
1086 int cnt = 0;
1087 Exynos_OSAL_Get_SemaphoreCount(pExynosPort->codecSemID, &cnt);
1088 if (cnt > 0)
1089 Exynos_OSAL_SemaphoreWait(pExynosPort->codecSemID);
1090 else
1091 break;
1092 }
1093 ret = OMX_ErrorNone;
1094
1095EXIT:
1096 FunctionOut();
1097
1098 return ret;
1099}
1100
1101OMX_ERRORTYPE Exynos_OMX_VideoEncodeGetParameter(
1102 OMX_IN OMX_HANDLETYPE hComponent,
1103 OMX_IN OMX_INDEXTYPE nParamIndex,
e4e150b8 1104 OMX_INOUT OMX_PTR pComponentParameterStructure)
c6f4bc34 1105{
e4e150b8
HK		 1106 OMX_ERRORTYPE ret = OMX_ErrorNone;
1107 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1108 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1109 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
c6f4bc34
YK		 1110
1111 FunctionIn();
1112
1113 if (hComponent == NULL) {
1114 ret = OMX_ErrorBadParameter;
1115 goto EXIT;
1116 }
1117 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
e4e150b8 1118
c6f4bc34
YK		 1119 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1120 if (ret != OMX_ErrorNone) {
1121 goto EXIT;
1122 }
1123
1124 if (pOMXComponent->pComponentPrivate == NULL) {
1125 ret = OMX_ErrorBadParameter;
1126 goto EXIT;
1127 }
1128 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1129
e4e150b8 1130 if (pExynosComponent->currentState == OMX_StateInvalid) {
c6f4bc34
YK		 1131 ret = OMX_ErrorInvalidState;
1132 goto EXIT;
1133 }
1134
e4e150b8 1135 if (pComponentParameterStructure == NULL) {
c6f4bc34
YK		 1136 ret = OMX_ErrorBadParameter;
1137 goto EXIT;
1138 }
1139
1140 switch (nParamIndex) {
1141 case OMX_IndexParamVideoInit:
1142 {
e4e150b8
HK		 1143 OMX_PORT_PARAM_TYPE *pPortParam = (OMX_PORT_PARAM_TYPE *)pComponentParameterStructure;
1144 ret = Exynos_OMX_Check_SizeVersion(pPortParam, sizeof(OMX_PORT_PARAM_TYPE));
c6f4bc34
YK		 1145 if (ret != OMX_ErrorNone) {
1146 goto EXIT;
1147 }
1148
e4e150b8
HK		 1149 pPortParam->nPorts = pExynosComponent->portParam.nPorts;
1150 pPortParam->nStartPortNumber = pExynosComponent->portParam.nStartPortNumber;
c6f4bc34
YK		 1151 ret = OMX_ErrorNone;
1152 }
1153 break;
1154 case OMX_IndexParamVideoPortFormat:
1155 {
e4e150b8
HK		 1156 OMX_VIDEO_PARAM_PORTFORMATTYPE *pPortFormat = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)pComponentParameterStructure;
1157 OMX_U32 nPortIndex = pPortFormat->nPortIndex;
1158 OMX_U32 nIndex = pPortFormat->nIndex;
1159 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1160 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = NULL;
1161 OMX_U32 nSupportFormat = 0;
1162
1163 ret = Exynos_OMX_Check_SizeVersion(pPortFormat, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
c6f4bc34
YK		 1164 if (ret != OMX_ErrorNone) {
1165 goto EXIT;
1166 }
1167
e4e150b8 1168 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
c6f4bc34
YK		 1169 ret = OMX_ErrorBadPortIndex;
1170 goto EXIT;
1171 }
1172
e4e150b8 1173 if (nPortIndex == INPUT_PORT_INDEX) {
c6f4bc34 1174 pExynosPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
e4e150b8 1175 pPortDef = &pExynosPort->portDefinition;
c6f4bc34 1176
e4e150b8 1177 switch (nIndex) {
c6f4bc34 1178 case supportFormat_0:
e4e150b8
HK		 1179 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1180 pPortFormat->eColorFormat = OMX_COLOR_FormatYUV420Planar;
1181 pPortFormat->xFramerate = pPortDef->format.video.xFramerate;
c6f4bc34
YK		 1182 break;
1183 case supportFormat_1:
e4e150b8
HK		 1184 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1185 pPortFormat->eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
1186 pPortFormat->xFramerate = pPortDef->format.video.xFramerate;
c6f4bc34
YK		 1187 break;
1188 case supportFormat_2:
e4e150b8
HK		 1189 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1190 pPortFormat->eColorFormat = OMX_SEC_COLOR_FormatNV12Tiled;
1191 pPortFormat->xFramerate = pPortDef->format.video.xFramerate;
c6f4bc34
YK		 1192 break;
1193 case supportFormat_3:
e4e150b8
HK		 1194 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1195 pPortFormat->eColorFormat = OMX_SEC_COLOR_FormatNV21Linear;
1196 pPortFormat->xFramerate = pPortDef->format.video.xFramerate;
c6f4bc34
YK		 1197 break;
1198 case supportFormat_4:
e4e150b8
HK		 1199 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1200 pPortFormat->eColorFormat = OMX_COLOR_FormatAndroidOpaque;
1201 pPortFormat->xFramerate = pPortDef->format.video.xFramerate;
c6f4bc34
YK		 1202 break;
1203 default:
e4e150b8 1204 if (nIndex > supportFormat_0) {
c6f4bc34
YK		 1205 ret = OMX_ErrorNoMore;
1206 goto EXIT;
1207 }
1208 break;
1209 }
e4e150b8
HK		 1210 } else if (nPortIndex == OUTPUT_PORT_INDEX) {
1211 nSupportFormat = OUTPUT_PORT_SUPPORTFORMAT_NUM_MAX - 1;
1212 if (nIndex > nSupportFormat) {
c6f4bc34
YK		 1213 ret = OMX_ErrorNoMore;
1214 goto EXIT;
1215 }
1216
1217 pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
e4e150b8 1218 pPortDef = &pExynosPort->portDefinition;
c6f4bc34 1219
e4e150b8
HK		 1220 pPortFormat->eCompressionFormat = pPortDef->format.video.eCompressionFormat;
1221 pPortFormat->eColorFormat = pPortDef->format.video.eColorFormat;
1222 pPortFormat->xFramerate = pPortDef->format.video.xFramerate;
c6f4bc34
YK		 1223 }
1224 ret = OMX_ErrorNone;
1225 }
1226 break;
1227 case OMX_IndexParamVideoBitrate:
1228 {
e4e150b8
HK		 1229 OMX_VIDEO_PARAM_BITRATETYPE *pVideoBitrate = (OMX_VIDEO_PARAM_BITRATETYPE *)pComponentParameterStructure;
1230 OMX_U32 nPortIndex = pVideoBitrate->nPortIndex;
1231 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1232 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1233 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = NULL;
c6f4bc34 1234
e4e150b8 1235 if (nPortIndex != OUTPUT_PORT_INDEX) {
c6f4bc34
YK		 1236 ret = OMX_ErrorBadPortIndex;
1237 goto EXIT;
1238 } else {
1239 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
e4e150b8
HK		 1240 if (pVideoEnc == NULL) {
1241 ret = OMX_ErrorBadParameter;
1242 goto EXIT;
1243 }
1244 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1245 pPortDef = &pExynosPort->portDefinition;
c6f4bc34 1246
e4e150b8
HK		 1247 pVideoBitrate->eControlRate = pVideoEnc->eControlRate[nPortIndex];
1248 pVideoBitrate->nTargetBitrate = pPortDef->format.video.nBitrate;
c6f4bc34
YK		 1249 }
1250 ret = OMX_ErrorNone;
1251 }
1252 break;
1253 case OMX_IndexParamVideoQuantization:
1254 {
e4e150b8
HK		 1255 OMX_VIDEO_PARAM_QUANTIZATIONTYPE *pVideoQuantization = (OMX_VIDEO_PARAM_QUANTIZATIONTYPE *)pComponentParameterStructure;
1256 OMX_U32 nPortIndex = pVideoQuantization->nPortIndex;
1257 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1258 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1259 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = NULL;
c6f4bc34 1260
e4e150b8 1261 if (nPortIndex != OUTPUT_PORT_INDEX) {
c6f4bc34
YK		 1262 ret = OMX_ErrorBadPortIndex;
1263 goto EXIT;
1264 } else {
1265 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
e4e150b8
HK		 1266 if (pVideoEnc == NULL) {
1267 ret = OMX_ErrorBadParameter;
1268 goto EXIT;
1269 }
1270 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1271 pPortDef = &pExynosPort->portDefinition;
c6f4bc34 1272
e4e150b8
HK		 1273 pVideoQuantization->nQpI = pVideoEnc->quantization.nQpI;
1274 pVideoQuantization->nQpP = pVideoEnc->quantization.nQpP;
1275 pVideoQuantization->nQpB = pVideoEnc->quantization.nQpB;
c6f4bc34
YK		 1276 }
1277 ret = OMX_ErrorNone;
c6f4bc34
YK		 1278 }
1279 break;
1280 case OMX_IndexParamPortDefinition:
1281 {
e4e150b8
HK		 1282 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = (OMX_PARAM_PORTDEFINITIONTYPE *)pComponentParameterStructure;
1283 OMX_U32 nPortIndex = pPortDef->nPortIndex;
1284 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
c6f4bc34 1285
e4e150b8 1286 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
c6f4bc34
YK		 1287 ret = OMX_ErrorBadPortIndex;
1288 goto EXIT;
1289 }
e4e150b8
HK		 1290
1291 ret = Exynos_OMX_Check_SizeVersion(pPortDef, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
c6f4bc34
YK		 1292 if (ret != OMX_ErrorNone) {
1293 goto EXIT;
1294 }
1295
e4e150b8
HK		 1296 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1297 Exynos_OSAL_Memcpy(pPortDef, &pExynosPort->portDefinition, pPortDef->nSize);
c6f4bc34
YK		 1298
1299#ifdef USE_STOREMETADATA
e4e150b8
HK		 1300 if ((nPortIndex == 0) &&
1301 (pExynosPort->bStoreMetaData == OMX_TRUE)) {
1302 pPortDef->nBufferSize = MAX_INPUT_METADATA_BUFFER_SIZE;
c6f4bc34
YK		 1303 }
1304#endif
c31a957e
TK		 1305 }
1306 break;
1307 case OMX_IndexVendorNeedContigMemory:
1308 {
1309 EXYNOS_OMX_VIDEO_PARAM_PORTMEMTYPE *pPortMemType = (EXYNOS_OMX_VIDEO_PARAM_PORTMEMTYPE *)pComponentParameterStructure;
1310 OMX_U32 nPortIndex = pPortMemType->nPortIndex;
1311 EXYNOS_OMX_BASEPORT *pExynosPort;
1312
1313 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1314 ret = OMX_ErrorBadPortIndex;
1315 goto EXIT;
1316 }
1317
1318 ret = Exynos_OMX_Check_SizeVersion(pPortMemType, sizeof(EXYNOS_OMX_VIDEO_PARAM_PORTMEMTYPE));
1319 if (ret != OMX_ErrorNone)
1320 goto EXIT;
1321
1322 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1323
1324 pPortMemType->bNeedContigMem = pExynosPort->bNeedContigMem;
c6f4bc34
YK		 1325 }
1326 break;
aa4a2b3e
TK		 1327 case OMX_IndexParamVideoIntraRefresh:
1328 {
1329 OMX_VIDEO_PARAM_INTRAREFRESHTYPE *pIntraRefresh = (OMX_VIDEO_PARAM_INTRAREFRESHTYPE *)pComponentParameterStructure;
1330 OMX_U32 nPortIndex = pIntraRefresh->nPortIndex;
1331 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1332
1333 ret = Exynos_OMX_Check_SizeVersion(pIntraRefresh, sizeof(OMX_VIDEO_PARAM_INTRAREFRESHTYPE));
1334 if (ret != OMX_ErrorNone)
1335 goto EXIT;
1336
1337 if (nPortIndex != OUTPUT_PORT_INDEX) {
1338 ret = OMX_ErrorBadPortIndex;
1339 goto EXIT;
1340 }
1341
1342 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1343 pIntraRefresh->eRefreshMode = pVideoEnc->intraRefresh.eRefreshMode;
1344 pIntraRefresh->nAirMBs = pVideoEnc->intraRefresh.nAirMBs;
1345 pIntraRefresh->nAirRef = pVideoEnc->intraRefresh.nAirRef;
1346 pIntraRefresh->nCirMBs = pVideoEnc->intraRefresh.nCirMBs;
1347
1348 ret = OMX_ErrorNone;
1349 }
1350 break;
c6f4bc34
YK		 1351 default:
1352 {
e4e150b8 1353 ret = Exynos_OMX_GetParameter(hComponent, nParamIndex, pComponentParameterStructure);
c6f4bc34
YK		 1354 }
1355 break;
1356 }
c6f4bc34
YK		 1357EXIT:
1358 FunctionOut();
1359
1360 return ret;
1361}
e4e150b8 1362
c6f4bc34
YK		 1363OMX_ERRORTYPE Exynos_OMX_VideoEncodeSetParameter(
1364 OMX_IN OMX_HANDLETYPE hComponent,
e4e150b8
HK		 1365 OMX_IN OMX_INDEXTYPE nParamIndex,
1366 OMX_IN OMX_PTR pComponentParameterStructure)
c6f4bc34 1367{
e4e150b8
HK		 1368 OMX_ERRORTYPE ret = OMX_ErrorNone;
1369 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1370 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1371 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
c6f4bc34
YK		 1372
1373 FunctionIn();
1374
1375 if (hComponent == NULL) {
1376 ret = OMX_ErrorBadParameter;
1377 goto EXIT;
1378 }
1379 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
e4e150b8 1380
c6f4bc34
YK		 1381 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1382 if (ret != OMX_ErrorNone) {
1383 goto EXIT;
1384 }
1385
1386 if (pOMXComponent->pComponentPrivate == NULL) {
1387 ret = OMX_ErrorBadParameter;
1388 goto EXIT;
1389 }
1390 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1391
e4e150b8 1392 if (pExynosComponent->currentState == OMX_StateInvalid) {
c6f4bc34
YK		 1393 ret = OMX_ErrorInvalidState;
1394 goto EXIT;
1395 }
1396
e4e150b8 1397 if (pComponentParameterStructure == NULL) {
c6f4bc34
YK		 1398 ret = OMX_ErrorBadParameter;
1399 goto EXIT;
1400 }
1401
e4e150b8 1402 switch (nParamIndex) {
c6f4bc34
YK		 1403 case OMX_IndexParamVideoPortFormat:
1404 {
e4e150b8
HK		 1405 OMX_VIDEO_PARAM_PORTFORMATTYPE *pPortFormat = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)pComponentParameterStructure;
1406 OMX_U32 nPortIndex = pPortFormat->nPortIndex;
1407 OMX_U32 nIndex = pPortFormat->nIndex;
1408 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = NULL;
1409 OMX_U32 nSupportFormat = 0;
1410
1411 ret = Exynos_OMX_Check_SizeVersion(pPortFormat, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
c6f4bc34
YK		 1412 if (ret != OMX_ErrorNone) {
1413 goto EXIT;
1414 }
1415
e4e150b8 1416 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
c6f4bc34
YK		 1417 ret = OMX_ErrorBadPortIndex;
1418 goto EXIT;
c6f4bc34 1419 }
e4e150b8
HK		 1420 pPortDef = &(pExynosComponent->pExynosPort[nPortIndex].portDefinition);
1421
1422 pPortDef->format.video.eColorFormat = pPortFormat->eColorFormat;
1423 pPortDef->format.video.eCompressionFormat = pPortFormat->eCompressionFormat;
1424 pPortDef->format.video.xFramerate = pPortFormat->xFramerate;
c6f4bc34
YK		 1425 }
1426 break;
1427 case OMX_IndexParamVideoBitrate:
1428 {
e4e150b8
HK		 1429 OMX_VIDEO_PARAM_BITRATETYPE *pVideoBitrate = (OMX_VIDEO_PARAM_BITRATETYPE *)pComponentParameterStructure;
1430 OMX_U32 nPortIndex = pVideoBitrate->nPortIndex;
1431 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1432 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1433 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = NULL;
c6f4bc34 1434
e4e150b8 1435 if (nPortIndex != OUTPUT_PORT_INDEX) {
c6f4bc34
YK		 1436 ret = OMX_ErrorBadPortIndex;
1437 goto EXIT;
1438 } else {
1439 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
e4e150b8
HK		 1440 if (pVideoEnc == NULL) {
1441 ret = OMX_ErrorBadParameter;
1442 goto EXIT;
1443 }
1444 pPortDef = &(pExynosComponent->pExynosPort[nPortIndex].portDefinition);
c6f4bc34 1445
e4e150b8
HK		 1446 pVideoEnc->eControlRate[nPortIndex] = pVideoBitrate->eControlRate;
1447 pPortDef->format.video.nBitrate = pVideoBitrate->nTargetBitrate;
c6f4bc34
YK		 1448 }
1449 ret = OMX_ErrorNone;
1450 }
1451 break;
1452 case OMX_IndexParamVideoQuantization:
1453 {
e4e150b8
HK		 1454 OMX_VIDEO_PARAM_QUANTIZATIONTYPE *pVideoQuantization = (OMX_VIDEO_PARAM_QUANTIZATIONTYPE *)pComponentParameterStructure;
1455 OMX_U32 nPortIndex = pVideoQuantization->nPortIndex;
1456 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1457 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1458 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = NULL;
c6f4bc34 1459
e4e150b8 1460 if (nPortIndex != OUTPUT_PORT_INDEX) {
c6f4bc34
YK		 1461 ret = OMX_ErrorBadPortIndex;
1462 goto EXIT;
1463 } else {
1464 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
e4e150b8
HK		 1465 if (pVideoEnc == NULL) {
1466 ret = OMX_ErrorBadParameter;
1467 goto EXIT;
1468 }
1469 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1470 pPortDef = &pExynosPort->portDefinition;
c6f4bc34 1471
e4e150b8
HK		 1472 pVideoEnc->quantization.nQpI = pVideoQuantization->nQpI;
1473 pVideoEnc->quantization.nQpP = pVideoQuantization->nQpP;
1474 pVideoEnc->quantization.nQpB = pVideoQuantization->nQpB;
c6f4bc34
YK		 1475 }
1476 ret = OMX_ErrorNone;
1477 }
1478 break;
1479 case OMX_IndexParamPortDefinition:
1480 {
e4e150b8
HK		 1481 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = (OMX_PARAM_PORTDEFINITIONTYPE *)pComponentParameterStructure;
1482 OMX_U32 nPortIndex = pPortDef->nPortIndex;
1483 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
c6f4bc34
YK		 1484 OMX_U32 width, height, size;
1485
e4e150b8 1486 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
c6f4bc34
YK		 1487 ret = OMX_ErrorBadPortIndex;
1488 goto EXIT;
1489 }
e4e150b8
HK		 1490
1491 ret = Exynos_OMX_Check_SizeVersion(pPortDef, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
c6f4bc34
YK		 1492 if (ret != OMX_ErrorNone) {
1493 goto EXIT;
1494 }
1495
e4e150b8 1496 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
c6f4bc34 1497
e4e150b8
HK		 1498 if ((pExynosComponent->currentState != OMX_StateLoaded) &&
1499 (pExynosComponent->currentState != OMX_StateWaitForResources)) {
c6f4bc34
YK		 1500 if (pExynosPort->portDefinition.bEnabled == OMX_TRUE) {
1501 ret = OMX_ErrorIncorrectStateOperation;
1502 goto EXIT;
1503 }
1504 }
e4e150b8
HK		 1505
1506 if (pPortDef->nBufferCountActual < pExynosPort->portDefinition.nBufferCountMin) {
c6f4bc34
YK		 1507 ret = OMX_ErrorBadParameter;
1508 goto EXIT;
1509 }
1510
e4e150b8
HK		 1511 Exynos_OSAL_Memcpy(&pExynosPort->portDefinition, pPortDef, pPortDef->nSize);
1512 if (nPortIndex == INPUT_PORT_INDEX) {
1513 pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
c6f4bc34
YK		 1514 Exynos_UpdateFrameSize(pOMXComponent);
1515 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pExynosOutputPort->portDefinition.nBufferSize: %d",
e4e150b8 1516 pExynosPort->portDefinition.nBufferSize);
c6f4bc34
YK		 1517 }
1518 ret = OMX_ErrorNone;
1519 }
1520 break;
1521#ifdef USE_STOREMETADATA
1522 case OMX_IndexParamStoreMetaDataBuffer:
1523 {
298ca87f
TK		 1524 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1525 if (pVideoEnc == NULL) {
1526 ret = OMX_ErrorBadParameter;
1527 goto EXIT;
1528 }
1529
e4e150b8 1530 ret = Exynos_OSAL_SetANBParameter(hComponent, nParamIndex, pComponentParameterStructure);
298ca87f
TK		 1531 if (ret == OMX_ErrorNone)
1532 pVideoEnc->bFirstInput = OMX_TRUE;
c6f4bc34
YK		 1533 }
1534 break;
1535#endif
c31a957e
TK		 1536 case OMX_IndexVendorNeedContigMemory:
1537 {
1538 EXYNOS_OMX_VIDEO_PARAM_PORTMEMTYPE *pPortMemType = (EXYNOS_OMX_VIDEO_PARAM_PORTMEMTYPE *)pComponentParameterStructure;
1539 OMX_U32 nPortIndex = pPortMemType->nPortIndex;
1540 EXYNOS_OMX_BASEPORT *pExynosPort;
1541
1542 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1543 ret = OMX_ErrorBadPortIndex;
1544 goto EXIT;
1545 }
1546
1547 ret = Exynos_OMX_Check_SizeVersion(pPortMemType, sizeof(EXYNOS_OMX_VIDEO_PARAM_PORTMEMTYPE));
1548 if (ret != OMX_ErrorNone)
1549 goto EXIT;
1550
1551 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1552
1553 if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1554 if (pExynosPort->portDefinition.bEnabled == OMX_TRUE) {
1555 ret = OMX_ErrorIncorrectStateOperation;
1556 goto EXIT;
1557 }
1558 }
1559
1560 pExynosPort->bNeedContigMem = pPortMemType->bNeedContigMem;
1561 }
1562 break;
aa4a2b3e
TK		 1563 case OMX_IndexParamVideoIntraRefresh:
1564 {
1565 OMX_VIDEO_PARAM_INTRAREFRESHTYPE *pIntraRefresh = (OMX_VIDEO_PARAM_INTRAREFRESHTYPE *)pComponentParameterStructure;
1566 OMX_U32 nPortIndex = pIntraRefresh->nPortIndex;
1567 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1568
1569 ret = Exynos_OMX_Check_SizeVersion(pIntraRefresh, sizeof(OMX_VIDEO_PARAM_INTRAREFRESHTYPE));
1570 if (ret != OMX_ErrorNone)
1571 goto EXIT;
1572
1573 if (nPortIndex != OUTPUT_PORT_INDEX) {
1574 ret = OMX_ErrorBadPortIndex;
1575 goto EXIT;
1576 }
1577
1578 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1579 if (pIntraRefresh->eRefreshMode == OMX_VIDEO_IntraRefreshCyclic) {
1580 pVideoEnc->intraRefresh.eRefreshMode = pIntraRefresh->eRefreshMode;
1581 pVideoEnc->intraRefresh.nCirMBs = pIntraRefresh->nCirMBs;
1582 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "OMX_VIDEO_IntraRefreshCyclic Enable, nCirMBs: %d",
1583 pVideoEnc->intraRefresh.nCirMBs);
1584 } else {
1585 ret = OMX_ErrorUnsupportedSetting;
1586 goto EXIT;
1587 }
1588
1589 ret = OMX_ErrorNone;
1590 }
1591 break;
c6f4bc34
YK		 1592 default:
1593 {
e4e150b8 1594 ret = Exynos_OMX_SetParameter(hComponent, nParamIndex, pComponentParameterStructure);
c6f4bc34
YK		 1595 }
1596 break;
1597 }
c6f4bc34
YK		 1598EXIT:
1599 FunctionOut();
1600
1601 return ret;
1602}
1603
1604OMX_ERRORTYPE Exynos_OMX_VideoEncodeGetConfig(
e4e150b8
HK		 1605 OMX_HANDLETYPE hComponent,
1606 OMX_INDEXTYPE nParamIndex,
1607 OMX_PTR pComponentConfigStructure)
c6f4bc34 1608{
e4e150b8
HK		 1609 OMX_ERRORTYPE ret = OMX_ErrorNone;
1610 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1611 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
c6f4bc34
YK		 1612
1613 FunctionIn();
1614
e4e150b8
HK		 1615 if ((hComponent == NULL) ||
1616 (pComponentConfigStructure == NULL)) {
c6f4bc34
YK		 1617 ret = OMX_ErrorBadParameter;
1618 goto EXIT;
1619 }
1620 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
e4e150b8 1621
c6f4bc34
YK		 1622 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1623 if (ret != OMX_ErrorNone) {
1624 goto EXIT;
1625 }
e4e150b8 1626
c6f4bc34
YK		 1627 if (pOMXComponent->pComponentPrivate == NULL) {
1628 ret = OMX_ErrorBadParameter;
1629 goto EXIT;
1630 }
1631 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
e4e150b8 1632
c6f4bc34
YK		 1633 if (pExynosComponent->currentState == OMX_StateInvalid) {
1634 ret = OMX_ErrorInvalidState;
1635 goto EXIT;
1636 }
1637
e4e150b8 1638 switch (nParamIndex) {
c6f4bc34
YK		 1639 case OMX_IndexConfigVideoBitrate:
1640 {
e4e150b8
HK		 1641 OMX_VIDEO_CONFIG_BITRATETYPE *pConfigBitrate = (OMX_VIDEO_CONFIG_BITRATETYPE *)pComponentConfigStructure;
1642 OMX_U32 nPortIndex = pConfigBitrate->nPortIndex;
1643 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
c6f4bc34 1644
e4e150b8 1645 if (nPortIndex != OUTPUT_PORT_INDEX) {
c6f4bc34
YK		 1646 ret = OMX_ErrorBadPortIndex;
1647 goto EXIT;
1648 } else {
e4e150b8
HK		 1649 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1650 pConfigBitrate->nEncodeBitrate = pExynosPort->portDefinition.format.video.nBitrate;
c6f4bc34
YK		 1651 }
1652 }
1653 break;
1654 case OMX_IndexConfigVideoFramerate:
1655 {
e4e150b8
HK		 1656 OMX_CONFIG_FRAMERATETYPE *pConfigFramerate = (OMX_CONFIG_FRAMERATETYPE *)pComponentConfigStructure;
1657 OMX_U32 nPortIndex = pConfigFramerate->nPortIndex;
1658 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
c6f4bc34 1659
e4e150b8 1660 if (nPortIndex != OUTPUT_PORT_INDEX) {
c6f4bc34
YK		 1661 ret = OMX_ErrorBadPortIndex;
1662 goto EXIT;
1663 } else {
e4e150b8
HK		 1664 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1665 pConfigFramerate->xEncodeFramerate = pExynosPort->portDefinition.format.video.xFramerate;
c6f4bc34
YK		 1666 }
1667 }
1668 break;
ea1234c8
TK		 1669 case OMX_IndexVendorGetBufferFD:
1670 {
1671 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1672 EXYNOS_OMX_VIDEO_CONFIG_BUFFERINFO *pBufferInfo = (EXYNOS_OMX_VIDEO_CONFIG_BUFFERINFO *)pComponentConfigStructure;
1673
1674 ret = Exynos_OMX_Check_SizeVersion(pBufferInfo, sizeof(EXYNOS_OMX_VIDEO_CONFIG_BUFFERINFO));
1675 if (ret != OMX_ErrorNone)
1676 goto EXIT;
1677
1678 pBufferInfo->fd = Exynos_OSAL_SharedMemory_VirtToION(pVideoEnc->hSharedMemory, pBufferInfo->pVirAddr);
1679 }
1680 break;
c6f4bc34 1681 default:
e4e150b8
HK		 1682 {
1683 ret = Exynos_OMX_GetConfig(hComponent, nParamIndex, pComponentConfigStructure);
1684 }
c6f4bc34
YK		 1685 break;
1686 }
c6f4bc34
YK		 1687EXIT:
1688 FunctionOut();
1689
1690 return ret;
1691}
1692
1693OMX_ERRORTYPE Exynos_OMX_VideoEncodeSetConfig(
e4e150b8
HK		 1694 OMX_HANDLETYPE hComponent,
1695 OMX_INDEXTYPE nParamIndex,
1696 OMX_PTR pComponentConfigStructure)
c6f4bc34 1697 {
e4e150b8
HK		 1698 OMX_ERRORTYPE ret = OMX_ErrorNone;
1699 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1700 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
c6f4bc34
YK		 1701
1702 FunctionIn();
1703
e4e150b8
HK		 1704 if ((hComponent == NULL) ||
1705 (pComponentConfigStructure == NULL)) {
c6f4bc34
YK		 1706 ret = OMX_ErrorBadParameter;
1707 goto EXIT;
1708 }
1709 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
e4e150b8 1710
c6f4bc34
YK		 1711 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1712 if (ret != OMX_ErrorNone) {
1713 goto EXIT;
1714 }
e4e150b8 1715
c6f4bc34
YK		 1716 if (pOMXComponent->pComponentPrivate == NULL) {
1717 ret = OMX_ErrorBadParameter;
1718 goto EXIT;
1719 }
1720 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
e4e150b8 1721
c6f4bc34
YK		 1722 if (pExynosComponent->currentState == OMX_StateInvalid) {
1723 ret = OMX_ErrorInvalidState;
1724 goto EXIT;
1725 }
1726
e4e150b8 1727 switch (nParamIndex) {
c6f4bc34
YK		 1728 case OMX_IndexConfigVideoBitrate:
1729 {
e4e150b8
HK		 1730 OMX_VIDEO_CONFIG_BITRATETYPE *pConfigBitrate = (OMX_VIDEO_CONFIG_BITRATETYPE *)pComponentConfigStructure;
1731 OMX_U32 nPortIndex = pConfigBitrate->nPortIndex;
1732 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
c6f4bc34 1733
e4e150b8 1734 if (nPortIndex != OUTPUT_PORT_INDEX) {
c6f4bc34
YK		 1735 ret = OMX_ErrorBadPortIndex;
1736 goto EXIT;
1737 } else {
e4e150b8
HK		 1738 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1739 pExynosPort->portDefinition.format.video.nBitrate = pConfigBitrate->nEncodeBitrate;
c6f4bc34
YK		 1740 }
1741 }
1742 break;
1743 case OMX_IndexConfigVideoFramerate:
1744 {
e4e150b8
HK		 1745 OMX_CONFIG_FRAMERATETYPE *pConfigFramerate = (OMX_CONFIG_FRAMERATETYPE *)pComponentConfigStructure;
1746 OMX_U32 nPortIndex = pConfigFramerate->nPortIndex;
1747 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
c6f4bc34 1748
e4e150b8 1749 if (nPortIndex != OUTPUT_PORT_INDEX) {
c6f4bc34
YK		 1750 ret = OMX_ErrorBadPortIndex;
1751 goto EXIT;
1752 } else {
e4e150b8
HK		 1753 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1754 pExynosPort->portDefinition.format.video.xFramerate = pConfigFramerate->xEncodeFramerate;
c6f4bc34
YK		 1755 }
1756 }
1757 break;
1758 case OMX_IndexConfigVideoIntraVOPRefresh:
1759 {
1760 OMX_CONFIG_INTRAREFRESHVOPTYPE *pIntraRefreshVOP = (OMX_CONFIG_INTRAREFRESHVOPTYPE *)pComponentConfigStructure;
e4e150b8
HK		 1761 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1762 OMX_U32 nPortIndex = pIntraRefreshVOP->nPortIndex;
1763
1764 if (pExynosComponent->hComponentHandle == NULL) {
1765 ret = OMX_ErrorBadParameter;
1766 goto EXIT;
1767 }
1768 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
c6f4bc34 1769
e4e150b8 1770 if (nPortIndex != OUTPUT_PORT_INDEX) {
c6f4bc34
YK		 1771 ret = OMX_ErrorBadPortIndex;
1772 goto EXIT;
1773 } else {
e4e150b8 1774 pVideoEnc->IntraRefreshVOP = pIntraRefreshVOP->IntraRefreshVOP;
c6f4bc34
YK		 1775 }
1776 }
1777 break;
1778 default:
e4e150b8
HK		 1779 {
1780 ret = Exynos_OMX_SetConfig(hComponent, nParamIndex, pComponentConfigStructure);
1781 }
c6f4bc34
YK		 1782 break;
1783 }
c6f4bc34
YK		 1784EXIT:
1785 FunctionOut();
1786
1787 return ret;
1788}
1789
1790OMX_ERRORTYPE Exynos_OMX_VideoEncodeGetExtensionIndex(
1791 OMX_IN OMX_HANDLETYPE hComponent,
e4e150b8 1792 OMX_IN OMX_STRING szParamName,
c6f4bc34
YK		 1793 OMX_OUT OMX_INDEXTYPE *pIndexType)
1794{
e4e150b8
HK		 1795 OMX_ERRORTYPE ret = OMX_ErrorNone;
1796 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1797 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
c6f4bc34
YK		 1798
1799 FunctionIn();
1800
1801 if (hComponent == NULL) {
1802 ret = OMX_ErrorBadParameter;
1803 goto EXIT;
1804 }
1805 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
e4e150b8 1806
c6f4bc34
YK		 1807 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1808 if (ret != OMX_ErrorNone) {
1809 goto EXIT;
1810 }
1811
1812 if (pOMXComponent->pComponentPrivate == NULL) {
1813 ret = OMX_ErrorBadParameter;
1814 goto EXIT;
1815 }
1816 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1817
e4e150b8 1818 if ((szParamName == NULL) || (pIndexType == NULL)) {
c6f4bc34
YK		 1819 ret = OMX_ErrorBadParameter;
1820 goto EXIT;
1821 }
e4e150b8 1822
c6f4bc34
YK		 1823 if (pExynosComponent->currentState == OMX_StateInvalid) {
1824 ret = OMX_ErrorInvalidState;
1825 goto EXIT;
1826 }
1827
c31a957e
TK		 1828 if (Exynos_OSAL_Strcmp(szParamName, EXYNOS_INDEX_PARAM_NEED_CONTIG_MEMORY) == 0) {
1829 *pIndexType = (OMX_INDEXTYPE) OMX_IndexVendorNeedContigMemory;
1830 ret = OMX_ErrorNone;
1831 goto EXIT;
ea1234c8
TK		 1832 } else if (Exynos_OSAL_Strcmp(szParamName, EXYNOS_INDEX_CONFIG_GET_BUFFER_FD) == 0) {
1833 *pIndexType = (OMX_INDEXTYPE) OMX_IndexVendorGetBufferFD;
1834 ret = OMX_ErrorNone;
1835 goto EXIT;
c31a957e
TK		 1836 }
1837
c6f4bc34 1838#ifdef USE_STOREMETADATA
e4e150b8
HK		 1839 if (Exynos_OSAL_Strcmp(szParamName, EXYNOS_INDEX_PARAM_STORE_METADATA_BUFFER) == 0) {
1840 *pIndexType = (OMX_INDEXTYPE)OMX_IndexParamStoreMetaDataBuffer;
c6f4bc34 1841 } else {
e4e150b8 1842 ret = Exynos_OMX_GetExtensionIndex(hComponent, szParamName, pIndexType);
c6f4bc34
YK		 1843 }
1844#else
e4e150b8 1845 ret = Exynos_OMX_GetExtensionIndex(hComponent, szParamName, pIndexType);
c6f4bc34 1846#endif
c6f4bc34
YK		 1847EXIT:
1848 FunctionOut();
1849
1850 return ret;
1851}
323488ff
SK		 1852
1853OMX_ERRORTYPE Exynos_Shared_DataToBuffer(EXYNOS_OMX_DATA *pData, EXYNOS_OMX_DATABUFFER *pUseBuffer, OMX_BOOL bNeedUnlock)
1854{
1855 OMX_ERRORTYPE ret = OMX_ErrorNone;
1856
1857 pUseBuffer->bufferHeader = pData->bufferHeader;
1858 pUseBuffer->allocSize = pData->allocSize;
1859 pUseBuffer->dataLen = pData->dataLen;
1860 pUseBuffer->usedDataLen = pData->usedDataLen;
1861 pUseBuffer->remainDataLen = pData->remainDataLen;
1862 pUseBuffer->timeStamp = pData->timeStamp;
1863 pUseBuffer->nFlags = pData->nFlags;
1864 pUseBuffer->pPrivate = pData->pPrivate;
1865
1866 if ((bNeedUnlock == OMX_TRUE) && (pUseBuffer->bufferHeader != NULL)) {
1867 OMX_PTR ppBuf[MAX_BUFFER_PLANE];
1868 Exynos_OSAL_GetInfoFromMetaData((OMX_BYTE)pUseBuffer->bufferHeader->pBuffer, ppBuf);
1869 Exynos_OSAL_UnlockANBHandle(ppBuf[0]);
1870 }
1871
1872 return ret;
1873}