projects / GitHub / LineageOS / android_hardware_samsung_slsi_openmax.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
venc: added OMX_IndexParamVideoIntraRefresh support
[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)
502 Exynos_FlushInputBufferReturn(pOMXComponent, pDataBuffer[0]);
503 else if (nPortIndex == OUTPUT_PORT_INDEX)
504 Exynos_FlushOutputBufferReturn(pOMXComponent, pDataBuffer[0]);
505 }
506 if ((pDataBuffer[1] != NULL) &&
507 (pDataBuffer[1]->dataValid == OMX_TRUE)) {
508 if (nPortIndex == INPUT_PORT_INDEX)
509 Exynos_FlushInputBufferReturn(pOMXComponent, pDataBuffer[1]);
510 else if (nPortIndex == OUTPUT_PORT_INDEX)
511 Exynos_FlushOutputBufferReturn(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
HK		 690OMX_ERRORTYPE Exynos_InputBufferReturn(
691 OMX_COMPONENTTYPE *pOMXComponent)
c6f4bc34 692{
e4e150b8
HK		 693 OMX_ERRORTYPE ret = OMX_ErrorNone;
694 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
695 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
696 EXYNOS_OMX_DATABUFFER *pDataBuffer = NULL;
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
24ec2c82 713 if (pExynosPort->bufferProcessType & BUFFER_COPY) {
e4e150b8 714 pDataBuffer = &(pExynosPort->way.port2WayDataBuffer.inputDataBuffer);
24ec2c82 715 } else if (pExynosPort->bufferProcessType & BUFFER_SHARE) {
e4e150b8 716 pDataBuffer = &(pExynosPort->way.port2WayDataBuffer.outputDataBuffer);
c6f4bc34
YK		 717 }
718
e4e150b8
HK		 719 if (pDataBuffer != NULL)
720 pBufferHdr = pDataBuffer->bufferHeader;
c6f4bc34 721
e4e150b8
HK		 722 if (pBufferHdr != NULL) {
723 if (pExynosPort->markType.hMarkTargetComponent != NULL) {
724 pBufferHdr->hMarkTargetComponent = pExynosPort->markType.hMarkTargetComponent;
725 pBufferHdr->pMarkData = pExynosPort->markType.pMarkData;
726 pExynosPort->markType.hMarkTargetComponent = NULL;
727 pExynosPort->markType.pMarkData = NULL;
c6f4bc34
YK		 728 }
729
e4e150b8
HK		 730 if (pBufferHdr->hMarkTargetComponent != NULL) {
731 if (pBufferHdr->hMarkTargetComponent == pOMXComponent) {
c6f4bc34
YK		 732 pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
733 pExynosComponent->callbackData,
734 OMX_EventMark,
e4e150b8 735 0, 0, pBufferHdr->pMarkData);
c6f4bc34 736 } else {
e4e150b8
HK		 737 pExynosComponent->propagateMarkType.hMarkTargetComponent = pBufferHdr->hMarkTargetComponent;
738 pExynosComponent->propagateMarkType.pMarkData = pBufferHdr->pMarkData;
c6f4bc34
YK		 739 }
740 }
741
e4e150b8
HK		 742 pBufferHdr->nFilledLen = 0;
743 pBufferHdr->nOffset = 0;
744 Exynos_OMX_InputBufferReturn(pOMXComponent, pBufferHdr);
c6f4bc34
YK		 745 }
746
747 /* reset dataBuffer */
e4e150b8 748 Exynos_ResetDataBuffer(pDataBuffer);
c6f4bc34
YK		 749
750EXIT:
751 FunctionOut();
752
753 return ret;
754}
755
e4e150b8
HK		 756OMX_ERRORTYPE Exynos_FlushInputBufferReturn(
757 OMX_COMPONENTTYPE *pOMXComponent,
758 EXYNOS_OMX_DATABUFFER *pDataBuffer)
c6f4bc34 759{
e4e150b8
HK		 760 OMX_ERRORTYPE ret = OMX_ErrorNone;
761 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
762 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
763 OMX_BUFFERHEADERTYPE *pBufferHdr = NULL;
c6f4bc34
YK		 764
765 FunctionIn();
766
e4e150b8
HK		 767 if (pOMXComponent == NULL) {
768 ret = OMX_ErrorBadParameter;
769 goto EXIT;
770 }
771
772 if (pOMXComponent->pComponentPrivate == NULL) {
773 ret = OMX_ErrorBadParameter;
774 goto EXIT;
775 }
776 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
777 pExynosPort = &(pExynosComponent->pExynosPort[INPUT_PORT_INDEX]);
778
779 pBufferHdr = pDataBuffer->bufferHeader;
c6f4bc34 780
e4e150b8
HK		 781 if (pBufferHdr != NULL) {
782 if (pExynosPort->markType.hMarkTargetComponent != NULL) {
783 pBufferHdr->hMarkTargetComponent = pExynosPort->markType.hMarkTargetComponent;
784 pBufferHdr->pMarkData = pExynosPort->markType.pMarkData;
785 pExynosPort->markType.hMarkTargetComponent = NULL;
786 pExynosPort->markType.pMarkData = NULL;
c6f4bc34
YK		 787 }
788
e4e150b8
HK		 789 if (pBufferHdr->hMarkTargetComponent != NULL) {
790 if (pBufferHdr->hMarkTargetComponent == pOMXComponent) {
c6f4bc34
YK		 791 pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
792 pExynosComponent->callbackData,
793 OMX_EventMark,
e4e150b8 794 0, 0, pBufferHdr->pMarkData);
c6f4bc34 795 } else {
e4e150b8
HK		 796 pExynosComponent->propagateMarkType.hMarkTargetComponent = pBufferHdr->hMarkTargetComponent;
797 pExynosComponent->propagateMarkType.pMarkData = pBufferHdr->pMarkData;
c6f4bc34
YK		 798 }
799 }
800
e4e150b8
HK		 801 pBufferHdr->nFilledLen = 0;
802 pBufferHdr->nOffset = 0;
803 Exynos_OMX_InputBufferReturn(pOMXComponent, pBufferHdr);
c6f4bc34
YK		 804 }
805
806 /* reset dataBuffer */
e4e150b8 807 Exynos_ResetDataBuffer(pDataBuffer);
c6f4bc34
YK		 808
809EXIT:
810 FunctionOut();
811
812 return ret;
813}
814
e4e150b8
HK		 815OMX_ERRORTYPE Exynos_InputBufferGetQueue(
816 EXYNOS_OMX_BASECOMPONENT *pExynosComponent)
c6f4bc34 817{
e4e150b8
HK		 818 OMX_ERRORTYPE ret = OMX_ErrorUndefined;
819 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
820 EXYNOS_OMX_MESSAGE *pMessage = NULL;
821 EXYNOS_OMX_DATABUFFER *pDataBuffer = NULL;
c6f4bc34
YK		 822
823 FunctionIn();
824
e4e150b8
HK		 825 if (pExynosComponent == NULL) {
826 ret = OMX_ErrorBadParameter;
827 goto EXIT;
828 }
829 pExynosPort = &(pExynosComponent->pExynosPort[INPUT_PORT_INDEX]);
830 pDataBuffer = &(pExynosPort->way.port2WayDataBuffer.inputDataBuffer);
c6f4bc34
YK		 831
832 if (pExynosComponent->currentState != OMX_StateExecuting) {
833 ret = OMX_ErrorUndefined;
834 goto EXIT;
835 } else if ((pExynosComponent->transientState != EXYNOS_OMX_TransStateExecutingToIdle) &&
836 (!CHECK_PORT_BEING_FLUSHED(pExynosPort))) {
837 Exynos_OSAL_SemaphoreWait(pExynosPort->bufferSemID);
e4e150b8
HK		 838 if (pDataBuffer->dataValid != OMX_TRUE) {
839 pMessage = (EXYNOS_OMX_MESSAGE *)Exynos_OSAL_Dequeue(&pExynosPort->bufferQ);
840 if (pMessage == NULL) {
c6f4bc34
YK		 841 ret = OMX_ErrorUndefined;
842 goto EXIT;
843 }
e4e150b8
HK		 844 if (pMessage->messageType == EXYNOS_OMX_CommandFakeBuffer) {
845 Exynos_OSAL_Free(pMessage);
c6f4bc34
YK		 846 ret = OMX_ErrorCodecFlush;
847 goto EXIT;
848 }
849
e4e150b8
HK		 850 pDataBuffer->bufferHeader = (OMX_BUFFERHEADERTYPE *)(pMessage->pCmdData);
851 pDataBuffer->allocSize = pDataBuffer->bufferHeader->nAllocLen;
852 pDataBuffer->dataLen = pDataBuffer->bufferHeader->nFilledLen;
853 pDataBuffer->remainDataLen = pDataBuffer->dataLen;
854 pDataBuffer->usedDataLen = 0;
855 pDataBuffer->dataValid = OMX_TRUE;
856 pDataBuffer->nFlags = pDataBuffer->bufferHeader->nFlags;
857 pDataBuffer->timeStamp = pDataBuffer->bufferHeader->nTimeStamp;
c6f4bc34 858
e4e150b8 859 Exynos_OSAL_Free(pMessage);
c6f4bc34 860
e4e150b8
HK		 861 if (pDataBuffer->allocSize <= pDataBuffer->dataLen)
862 Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "Input Buffer Full, Check input buffer size! allocSize:%d, dataLen:%d", pDataBuffer->allocSize, pDataBuffer->dataLen);
c6f4bc34
YK		 863 }
864 ret = OMX_ErrorNone;
865 }
866EXIT:
867 FunctionOut();
868
869 return ret;
870}
871
e4e150b8
HK		 872OMX_ERRORTYPE Exynos_OutputBufferReturn(
873 OMX_COMPONENTTYPE *pOMXComponent)
c6f4bc34 874{
e4e150b8
HK		 875 OMX_ERRORTYPE ret = OMX_ErrorNone;
876 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
877 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
878 EXYNOS_OMX_DATABUFFER *pDataBuffer = NULL;
879 OMX_BUFFERHEADERTYPE *pBufferHdr = NULL;
c6f4bc34
YK		 880
881 FunctionIn();
882
e4e150b8
HK		 883 if (pOMXComponent == NULL) {
884 ret = OMX_ErrorBadParameter;
885 goto EXIT;
886 }
c6f4bc34 887
e4e150b8
HK		 888 if (pOMXComponent->pComponentPrivate == NULL) {
889 ret = OMX_ErrorBadParameter;
890 goto EXIT;
891 }
892 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
893 pExynosPort = &(pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX]);
894
895 pDataBuffer = &(pExynosPort->way.port2WayDataBuffer.outputDataBuffer);
896 pBufferHdr = pDataBuffer->bufferHeader;
897
898 if (pBufferHdr != NULL) {
899 pBufferHdr->nFilledLen = pDataBuffer->remainDataLen;
900 pBufferHdr->nOffset = 0;
901 pBufferHdr->nFlags = pDataBuffer->nFlags;
902 pBufferHdr->nTimeStamp = pDataBuffer->timeStamp;
c6f4bc34
YK		 903
904 if (pExynosComponent->propagateMarkType.hMarkTargetComponent != NULL) {
e4e150b8
HK		 905 pBufferHdr->hMarkTargetComponent = pExynosComponent->propagateMarkType.hMarkTargetComponent;
906 pBufferHdr->pMarkData = pExynosComponent->propagateMarkType.pMarkData;
c6f4bc34
YK		 907 pExynosComponent->propagateMarkType.hMarkTargetComponent = NULL;
908 pExynosComponent->propagateMarkType.pMarkData = NULL;
909 }
910
e4e150b8
HK		 911 if ((pBufferHdr->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
912 pBufferHdr->nFilledLen = 0;
913 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "event OMX_BUFFERFLAG_EOS!!!");
c6f4bc34
YK		 914 pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
915 pExynosComponent->callbackData,
916 OMX_EventBufferFlag,
917 OUTPUT_PORT_INDEX,
e4e150b8 918 pBufferHdr->nFlags, NULL);
c6f4bc34
YK		 919 }
920
e4e150b8 921 Exynos_OMX_OutputBufferReturn(pOMXComponent, pBufferHdr);
c6f4bc34
YK		 922 }
923
924 /* reset dataBuffer */
e4e150b8 925 Exynos_ResetDataBuffer(pDataBuffer);
c6f4bc34
YK		 926
927EXIT:
928 FunctionOut();
929
930 return ret;
931}
932
e4e150b8
HK		 933OMX_ERRORTYPE Exynos_FlushOutputBufferReturn(
934 OMX_COMPONENTTYPE *pOMXComponent,
935 EXYNOS_OMX_DATABUFFER *pDataBuffer)
c6f4bc34 936{
e4e150b8
HK		 937 OMX_ERRORTYPE ret = OMX_ErrorNone;
938 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
939 OMX_BUFFERHEADERTYPE *pBufferHdr = NULL;
c6f4bc34
YK		 940
941 FunctionIn();
942
e4e150b8
HK		 943 if (pOMXComponent == NULL) {
944 ret = OMX_ErrorBadParameter;
945 goto EXIT;
946 }
947
948 if (pOMXComponent->pComponentPrivate == NULL) {
949 ret = OMX_ErrorBadParameter;
950 goto EXIT;
951 }
952 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
953 pBufferHdr = pDataBuffer->bufferHeader;
c6f4bc34 954
e4e150b8
HK		 955 if (pBufferHdr != NULL) {
956 pBufferHdr->nFilledLen = pDataBuffer->remainDataLen;
957 pBufferHdr->nOffset = 0;
958 pBufferHdr->nFlags = pDataBuffer->nFlags;
959 pBufferHdr->nTimeStamp = pDataBuffer->timeStamp;
c6f4bc34
YK		 960
961 if (pExynosComponent->propagateMarkType.hMarkTargetComponent != NULL) {
e4e150b8
HK		 962 pBufferHdr->hMarkTargetComponent = pExynosComponent->propagateMarkType.hMarkTargetComponent;
963 pBufferHdr->pMarkData = pExynosComponent->propagateMarkType.pMarkData;
c6f4bc34
YK		 964 pExynosComponent->propagateMarkType.hMarkTargetComponent = NULL;
965 pExynosComponent->propagateMarkType.pMarkData = NULL;
966 }
967
e4e150b8
HK		 968 if ((pBufferHdr->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
969 pBufferHdr->nFilledLen = 0;
970 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "event OMX_BUFFERFLAG_EOS!!!");
c6f4bc34
YK		 971 pExynosComponent->pCallbacks->EventHandler(pOMXComponent,
972 pExynosComponent->callbackData,
973 OMX_EventBufferFlag,
974 OUTPUT_PORT_INDEX,
e4e150b8 975 pBufferHdr->nFlags, NULL);
c6f4bc34 976 }
e4e150b8 977 Exynos_OMX_OutputBufferReturn(pOMXComponent, pBufferHdr);
c6f4bc34
YK		 978 }
979
980 /* reset dataBuffer */
e4e150b8 981 Exynos_ResetDataBuffer(pDataBuffer);
c6f4bc34
YK		 982
983EXIT:
984 FunctionOut();
985
986 return ret;
987}
988
e4e150b8
HK		 989OMX_ERRORTYPE Exynos_OutputBufferGetQueue(
990 EXYNOS_OMX_BASECOMPONENT *pExynosComponent)
c6f4bc34 991{
e4e150b8
HK		 992 OMX_ERRORTYPE ret = OMX_ErrorUndefined;
993 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
994 EXYNOS_OMX_MESSAGE *pMessage = NULL;
995 EXYNOS_OMX_DATABUFFER *pDataBuffer = NULL;
c6f4bc34
YK		 996
997 FunctionIn();
998
e4e150b8
HK		 999 if (pExynosComponent == NULL) {
1000 ret = OMX_ErrorBadParameter;
1001 goto EXIT;
1002 }
1003 pExynosPort = &(pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX]);
1004
24ec2c82 1005 if (pExynosPort->bufferProcessType & BUFFER_COPY) {
e4e150b8 1006 pDataBuffer = &(pExynosPort->way.port2WayDataBuffer.outputDataBuffer);
24ec2c82 1007 } else if (pExynosPort->bufferProcessType & BUFFER_SHARE) {
e4e150b8 1008 pDataBuffer = &(pExynosPort->way.port2WayDataBuffer.inputDataBuffer);
c6f4bc34
YK		 1009 }
1010
1011 if (pExynosComponent->currentState != OMX_StateExecuting) {
1012 ret = OMX_ErrorUndefined;
1013 goto EXIT;
1014 } else if ((pExynosComponent->transientState != EXYNOS_OMX_TransStateExecutingToIdle) &&
e4e150b8 1015 (!CHECK_PORT_BEING_FLUSHED(pExynosPort))) {
c6f4bc34 1016 Exynos_OSAL_SemaphoreWait(pExynosPort->bufferSemID);
e4e150b8
HK		 1017 if ((pDataBuffer != NULL) &&
1018 (pDataBuffer->dataValid != OMX_TRUE)) {
1019 pMessage = (EXYNOS_OMX_MESSAGE *)Exynos_OSAL_Dequeue(&pExynosPort->bufferQ);
1020 if (pMessage == NULL) {
c6f4bc34
YK		 1021 ret = OMX_ErrorUndefined;
1022 goto EXIT;
1023 }
e4e150b8
HK		 1024 if (pMessage->messageType == EXYNOS_OMX_CommandFakeBuffer) {
1025 Exynos_OSAL_Free(pMessage);
c6f4bc34
YK		 1026 ret = OMX_ErrorCodecFlush;
1027 goto EXIT;
1028 }
1029
e4e150b8
HK		 1030 pDataBuffer->bufferHeader = (OMX_BUFFERHEADERTYPE *)(pMessage->pCmdData);
1031 pDataBuffer->allocSize = pDataBuffer->bufferHeader->nAllocLen;
1032 pDataBuffer->dataLen = 0; //dataBuffer->bufferHeader->nFilledLen;
1033 pDataBuffer->remainDataLen = pDataBuffer->dataLen;
1034 pDataBuffer->usedDataLen = 0; //dataBuffer->bufferHeader->nOffset;
1035 pDataBuffer->dataValid = OMX_TRUE;
1036 /* pDataBuffer->nFlags = pDataBuffer->bufferHeader->nFlags; */
1037 /* pDtaBuffer->nTimeStamp = pDataBuffer->bufferHeader->nTimeStamp; */
c6f4bc34 1038/*
24ec2c82 1039 if (pExynosPort->bufferProcessType & BUFFER_SHARE)
e4e150b8 1040 pDataBuffer->pPrivate = pDataBuffer->bufferHeader->pOutputPortPrivate;
24ec2c82 1041 else if (pExynosPort->bufferProcessType & BUFFER_COPY) {
e4e150b8
HK		 1042 pExynosPort->processData.dataBuffer = pDataBuffer->bufferHeader->pBuffer;
1043 pExynosPort->processData.allocSize = pDataBuffer->bufferHeader->nAllocLen;
c6f4bc34
YK		 1044 }
1045*/
e4e150b8 1046 Exynos_OSAL_Free(pMessage);
c6f4bc34
YK		 1047 }
1048 ret = OMX_ErrorNone;
1049 }
1050EXIT:
1051 FunctionOut();
1052
1053 return ret;
c6f4bc34
YK		 1054}
1055
e4e150b8
HK		 1056OMX_BUFFERHEADERTYPE *Exynos_OutputBufferGetQueue_Direct(
1057 EXYNOS_OMX_BASECOMPONENT *pExynosComponent)
c6f4bc34 1058{
e4e150b8
HK		 1059 OMX_BUFFERHEADERTYPE *pBufferHdr = NULL;
1060 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1061 EXYNOS_OMX_MESSAGE *pMessage = NULL;
c6f4bc34
YK		 1062
1063 FunctionIn();
1064
e4e150b8
HK		 1065 if (pExynosComponent == NULL) {
1066 pBufferHdr = NULL;
1067 goto EXIT;
1068 }
1069 pExynosPort = &(pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX]);
1070
c6f4bc34 1071 if (pExynosComponent->currentState != OMX_StateExecuting) {
e4e150b8 1072 pBufferHdr = NULL;
c6f4bc34
YK		 1073 goto EXIT;
1074 } else if ((pExynosComponent->transientState != EXYNOS_OMX_TransStateExecutingToIdle) &&
e4e150b8 1075 (!CHECK_PORT_BEING_FLUSHED(pExynosPort))) {
c6f4bc34
YK		 1076 Exynos_OSAL_SemaphoreWait(pExynosPort->bufferSemID);
1077
e4e150b8
HK		 1078 pMessage = (EXYNOS_OMX_MESSAGE *)Exynos_OSAL_Dequeue(&pExynosPort->bufferQ);
1079 if (pMessage == NULL) {
1080 pBufferHdr = NULL;
c6f4bc34
YK		 1081 goto EXIT;
1082 }
e4e150b8
HK		 1083 if (pMessage->messageType == EXYNOS_OMX_CommandFakeBuffer) {
1084 Exynos_OSAL_Free(pMessage);
1085 pBufferHdr = NULL;
c6f4bc34
YK		 1086 goto EXIT;
1087 }
1088
e4e150b8
HK		 1089 pBufferHdr = (OMX_BUFFERHEADERTYPE *)(pMessage->pCmdData);
1090 Exynos_OSAL_Free(pMessage);
c6f4bc34
YK		 1091 }
1092
1093EXIT:
1094 FunctionOut();
1095
e4e150b8 1096 return pBufferHdr;
c6f4bc34
YK		 1097}
1098
e4e150b8
HK		 1099OMX_ERRORTYPE Exynos_CodecBufferEnqueue(
1100 EXYNOS_OMX_BASECOMPONENT *pExynosComponent,
1101 OMX_U32 nPortIndex,
1102 OMX_PTR pData)
c6f4bc34 1103{
e4e150b8 1104 OMX_ERRORTYPE ret = OMX_ErrorNone;
c6f4bc34
YK		 1105 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1106
1107 FunctionIn();
1108
e4e150b8
HK		 1109 if (pExynosComponent == NULL) {
1110 ret = OMX_ErrorBadParameter;
1111 goto EXIT;
1112 }
c6f4bc34 1113
e4e150b8
HK		 1114 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1115 ret = OMX_ErrorBadPortIndex;
1116 goto EXIT;
1117 }
1118 pExynosPort = &(pExynosComponent->pExynosPort[nPortIndex]);
1119
1120 if (pData == NULL) {
c6f4bc34
YK		 1121 ret = OMX_ErrorInsufficientResources;
1122 goto EXIT;
1123 }
1124
e4e150b8 1125 ret = Exynos_OSAL_Queue(&pExynosPort->codecBufferQ, (void *)pData);
c6f4bc34
YK		 1126 if (ret != 0) {
1127 ret = OMX_ErrorUndefined;
1128 goto EXIT;
1129 }
1130 Exynos_OSAL_SemaphorePost(pExynosPort->codecSemID);
1131
1132 ret = OMX_ErrorNone;
1133
1134EXIT:
1135 FunctionOut();
1136
1137 return ret;
1138}
1139
e4e150b8
HK		 1140OMX_ERRORTYPE Exynos_CodecBufferDequeue(
1141 EXYNOS_OMX_BASECOMPONENT *pExynosComponent,
1142 OMX_U32 nPortIndex,
1143 OMX_PTR *pData)
c6f4bc34 1144{
e4e150b8 1145 OMX_ERRORTYPE ret = OMX_ErrorNone;
c6f4bc34 1146 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
e4e150b8 1147 OMX_PTR pTempData = NULL;
c6f4bc34
YK		 1148
1149 FunctionIn();
1150
e4e150b8
HK		 1151 if (pExynosComponent == NULL) {
1152 ret = OMX_ErrorBadParameter;
c6f4bc34
YK		 1153 goto EXIT;
1154 }
c6f4bc34 1155
e4e150b8
HK		 1156 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1157 ret = OMX_ErrorBadPortIndex;
1158 goto EXIT;
1159 }
1160 pExynosPort = &(pExynosComponent->pExynosPort[nPortIndex]);
1161
1162 Exynos_OSAL_SemaphoreWait(pExynosPort->codecSemID);
1163 pTempData = (OMX_PTR)Exynos_OSAL_Dequeue(&pExynosPort->codecBufferQ);
1164 if (pTempData != NULL) {
1165 *pData = (OMX_PTR)pTempData;
1166 ret = OMX_ErrorNone;
1167 } else {
1168 *pData = NULL;
1169 ret = OMX_ErrorUndefined;
1170 }
c6f4bc34
YK		 1171
1172EXIT:
1173 FunctionOut();
1174
1175 return ret;
1176}
1177
e4e150b8
HK		 1178OMX_ERRORTYPE Exynos_CodecBufferReset(
1179 EXYNOS_OMX_BASECOMPONENT *pExynosComponent,
1180 OMX_U32 nPortIndex)
c6f4bc34 1181{
e4e150b8
HK		 1182 OMX_ERRORTYPE ret = OMX_ErrorNone;
1183 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
c6f4bc34
YK		 1184
1185 FunctionIn();
1186
e4e150b8
HK		 1187 if (pExynosComponent == NULL) {
1188 ret = OMX_ErrorBadParameter;
1189 goto EXIT;
1190 }
1191
1192 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1193 ret = OMX_ErrorBadPortIndex;
1194 goto EXIT;
1195 }
1196 pExynosPort = &(pExynosComponent->pExynosPort[nPortIndex]);
c6f4bc34
YK		 1197
1198 ret = Exynos_OSAL_ResetQueue(&pExynosPort->codecBufferQ);
1199 if (ret != 0) {
1200 ret = OMX_ErrorUndefined;
1201 goto EXIT;
1202 }
e4e150b8 1203
c6f4bc34
YK		 1204 while (1) {
1205 int cnt = 0;
1206 Exynos_OSAL_Get_SemaphoreCount(pExynosPort->codecSemID, &cnt);
1207 if (cnt > 0)
1208 Exynos_OSAL_SemaphoreWait(pExynosPort->codecSemID);
1209 else
1210 break;
1211 }
1212 ret = OMX_ErrorNone;
1213
1214EXIT:
1215 FunctionOut();
1216
1217 return ret;
1218}
1219
1220OMX_ERRORTYPE Exynos_OMX_VideoEncodeGetParameter(
1221 OMX_IN OMX_HANDLETYPE hComponent,
1222 OMX_IN OMX_INDEXTYPE nParamIndex,
e4e150b8 1223 OMX_INOUT OMX_PTR pComponentParameterStructure)
c6f4bc34 1224{
e4e150b8
HK		 1225 OMX_ERRORTYPE ret = OMX_ErrorNone;
1226 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1227 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1228 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
c6f4bc34
YK		 1229
1230 FunctionIn();
1231
1232 if (hComponent == NULL) {
1233 ret = OMX_ErrorBadParameter;
1234 goto EXIT;
1235 }
1236 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
e4e150b8 1237
c6f4bc34
YK		 1238 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1239 if (ret != OMX_ErrorNone) {
1240 goto EXIT;
1241 }
1242
1243 if (pOMXComponent->pComponentPrivate == NULL) {
1244 ret = OMX_ErrorBadParameter;
1245 goto EXIT;
1246 }
1247 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1248
e4e150b8 1249 if (pExynosComponent->currentState == OMX_StateInvalid) {
c6f4bc34
YK		 1250 ret = OMX_ErrorInvalidState;
1251 goto EXIT;
1252 }
1253
e4e150b8 1254 if (pComponentParameterStructure == NULL) {
c6f4bc34
YK		 1255 ret = OMX_ErrorBadParameter;
1256 goto EXIT;
1257 }
1258
1259 switch (nParamIndex) {
1260 case OMX_IndexParamVideoInit:
1261 {
e4e150b8
HK		 1262 OMX_PORT_PARAM_TYPE *pPortParam = (OMX_PORT_PARAM_TYPE *)pComponentParameterStructure;
1263 ret = Exynos_OMX_Check_SizeVersion(pPortParam, sizeof(OMX_PORT_PARAM_TYPE));
c6f4bc34
YK		 1264 if (ret != OMX_ErrorNone) {
1265 goto EXIT;
1266 }
1267
e4e150b8
HK		 1268 pPortParam->nPorts = pExynosComponent->portParam.nPorts;
1269 pPortParam->nStartPortNumber = pExynosComponent->portParam.nStartPortNumber;
c6f4bc34
YK		 1270 ret = OMX_ErrorNone;
1271 }
1272 break;
1273 case OMX_IndexParamVideoPortFormat:
1274 {
e4e150b8
HK		 1275 OMX_VIDEO_PARAM_PORTFORMATTYPE *pPortFormat = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)pComponentParameterStructure;
1276 OMX_U32 nPortIndex = pPortFormat->nPortIndex;
1277 OMX_U32 nIndex = pPortFormat->nIndex;
1278 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1279 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = NULL;
1280 OMX_U32 nSupportFormat = 0;
1281
1282 ret = Exynos_OMX_Check_SizeVersion(pPortFormat, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
c6f4bc34
YK		 1283 if (ret != OMX_ErrorNone) {
1284 goto EXIT;
1285 }
1286
e4e150b8 1287 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
c6f4bc34
YK		 1288 ret = OMX_ErrorBadPortIndex;
1289 goto EXIT;
1290 }
1291
e4e150b8 1292 if (nPortIndex == INPUT_PORT_INDEX) {
c6f4bc34 1293 pExynosPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
e4e150b8 1294 pPortDef = &pExynosPort->portDefinition;
c6f4bc34 1295
e4e150b8 1296 switch (nIndex) {
c6f4bc34 1297 case supportFormat_0:
e4e150b8
HK		 1298 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1299 pPortFormat->eColorFormat = OMX_COLOR_FormatYUV420Planar;
1300 pPortFormat->xFramerate = pPortDef->format.video.xFramerate;
c6f4bc34
YK		 1301 break;
1302 case supportFormat_1:
e4e150b8
HK		 1303 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1304 pPortFormat->eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
1305 pPortFormat->xFramerate = pPortDef->format.video.xFramerate;
c6f4bc34
YK		 1306 break;
1307 case supportFormat_2:
e4e150b8
HK		 1308 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1309 pPortFormat->eColorFormat = OMX_SEC_COLOR_FormatNV12Tiled;
1310 pPortFormat->xFramerate = pPortDef->format.video.xFramerate;
c6f4bc34
YK		 1311 break;
1312 case supportFormat_3:
e4e150b8
HK		 1313 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1314 pPortFormat->eColorFormat = OMX_SEC_COLOR_FormatNV21Linear;
1315 pPortFormat->xFramerate = pPortDef->format.video.xFramerate;
c6f4bc34
YK		 1316 break;
1317 case supportFormat_4:
e4e150b8
HK		 1318 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
1319 pPortFormat->eColorFormat = OMX_COLOR_FormatAndroidOpaque;
1320 pPortFormat->xFramerate = pPortDef->format.video.xFramerate;
c6f4bc34
YK		 1321 break;
1322 default:
e4e150b8 1323 if (nIndex > supportFormat_0) {
c6f4bc34
YK		 1324 ret = OMX_ErrorNoMore;
1325 goto EXIT;
1326 }
1327 break;
1328 }
e4e150b8
HK		 1329 } else if (nPortIndex == OUTPUT_PORT_INDEX) {
1330 nSupportFormat = OUTPUT_PORT_SUPPORTFORMAT_NUM_MAX - 1;
1331 if (nIndex > nSupportFormat) {
c6f4bc34
YK		 1332 ret = OMX_ErrorNoMore;
1333 goto EXIT;
1334 }
1335
1336 pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
e4e150b8 1337 pPortDef = &pExynosPort->portDefinition;
c6f4bc34 1338
e4e150b8
HK		 1339 pPortFormat->eCompressionFormat = pPortDef->format.video.eCompressionFormat;
1340 pPortFormat->eColorFormat = pPortDef->format.video.eColorFormat;
1341 pPortFormat->xFramerate = pPortDef->format.video.xFramerate;
c6f4bc34
YK		 1342 }
1343 ret = OMX_ErrorNone;
1344 }
1345 break;
1346 case OMX_IndexParamVideoBitrate:
1347 {
e4e150b8
HK		 1348 OMX_VIDEO_PARAM_BITRATETYPE *pVideoBitrate = (OMX_VIDEO_PARAM_BITRATETYPE *)pComponentParameterStructure;
1349 OMX_U32 nPortIndex = pVideoBitrate->nPortIndex;
1350 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1351 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1352 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = NULL;
c6f4bc34 1353
e4e150b8 1354 if (nPortIndex != OUTPUT_PORT_INDEX) {
c6f4bc34
YK		 1355 ret = OMX_ErrorBadPortIndex;
1356 goto EXIT;
1357 } else {
1358 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
e4e150b8
HK		 1359 if (pVideoEnc == NULL) {
1360 ret = OMX_ErrorBadParameter;
1361 goto EXIT;
1362 }
1363 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1364 pPortDef = &pExynosPort->portDefinition;
c6f4bc34 1365
e4e150b8
HK		 1366 pVideoBitrate->eControlRate = pVideoEnc->eControlRate[nPortIndex];
1367 pVideoBitrate->nTargetBitrate = pPortDef->format.video.nBitrate;
c6f4bc34
YK		 1368 }
1369 ret = OMX_ErrorNone;
1370 }
1371 break;
1372 case OMX_IndexParamVideoQuantization:
1373 {
e4e150b8
HK		 1374 OMX_VIDEO_PARAM_QUANTIZATIONTYPE *pVideoQuantization = (OMX_VIDEO_PARAM_QUANTIZATIONTYPE *)pComponentParameterStructure;
1375 OMX_U32 nPortIndex = pVideoQuantization->nPortIndex;
1376 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1377 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1378 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = NULL;
c6f4bc34 1379
e4e150b8 1380 if (nPortIndex != OUTPUT_PORT_INDEX) {
c6f4bc34
YK		 1381 ret = OMX_ErrorBadPortIndex;
1382 goto EXIT;
1383 } else {
1384 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
e4e150b8
HK		 1385 if (pVideoEnc == NULL) {
1386 ret = OMX_ErrorBadParameter;
1387 goto EXIT;
1388 }
1389 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1390 pPortDef = &pExynosPort->portDefinition;
c6f4bc34 1391
e4e150b8
HK		 1392 pVideoQuantization->nQpI = pVideoEnc->quantization.nQpI;
1393 pVideoQuantization->nQpP = pVideoEnc->quantization.nQpP;
1394 pVideoQuantization->nQpB = pVideoEnc->quantization.nQpB;
c6f4bc34
YK		 1395 }
1396 ret = OMX_ErrorNone;
c6f4bc34
YK		 1397 }
1398 break;
1399 case OMX_IndexParamPortDefinition:
1400 {
e4e150b8
HK		 1401 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = (OMX_PARAM_PORTDEFINITIONTYPE *)pComponentParameterStructure;
1402 OMX_U32 nPortIndex = pPortDef->nPortIndex;
1403 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
c6f4bc34 1404
e4e150b8 1405 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
c6f4bc34
YK		 1406 ret = OMX_ErrorBadPortIndex;
1407 goto EXIT;
1408 }
e4e150b8
HK		 1409
1410 ret = Exynos_OMX_Check_SizeVersion(pPortDef, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
c6f4bc34
YK		 1411 if (ret != OMX_ErrorNone) {
1412 goto EXIT;
1413 }
1414
e4e150b8
HK		 1415 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1416 Exynos_OSAL_Memcpy(pPortDef, &pExynosPort->portDefinition, pPortDef->nSize);
c6f4bc34
YK		 1417
1418#ifdef USE_STOREMETADATA
e4e150b8
HK		 1419 if ((nPortIndex == 0) &&
1420 (pExynosPort->bStoreMetaData == OMX_TRUE)) {
1421 pPortDef->nBufferSize = MAX_INPUT_METADATA_BUFFER_SIZE;
c6f4bc34
YK		 1422 }
1423#endif
c31a957e
TK		 1424 }
1425 break;
1426 case OMX_IndexVendorNeedContigMemory:
1427 {
1428 EXYNOS_OMX_VIDEO_PARAM_PORTMEMTYPE *pPortMemType = (EXYNOS_OMX_VIDEO_PARAM_PORTMEMTYPE *)pComponentParameterStructure;
1429 OMX_U32 nPortIndex = pPortMemType->nPortIndex;
1430 EXYNOS_OMX_BASEPORT *pExynosPort;
1431
1432 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1433 ret = OMX_ErrorBadPortIndex;
1434 goto EXIT;
1435 }
1436
1437 ret = Exynos_OMX_Check_SizeVersion(pPortMemType, sizeof(EXYNOS_OMX_VIDEO_PARAM_PORTMEMTYPE));
1438 if (ret != OMX_ErrorNone)
1439 goto EXIT;
1440
1441 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1442
1443 pPortMemType->bNeedContigMem = pExynosPort->bNeedContigMem;
c6f4bc34
YK		 1444 }
1445 break;
aa4a2b3e
TK		 1446 case OMX_IndexParamVideoIntraRefresh:
1447 {
1448 OMX_VIDEO_PARAM_INTRAREFRESHTYPE *pIntraRefresh = (OMX_VIDEO_PARAM_INTRAREFRESHTYPE *)pComponentParameterStructure;
1449 OMX_U32 nPortIndex = pIntraRefresh->nPortIndex;
1450 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1451
1452 ret = Exynos_OMX_Check_SizeVersion(pIntraRefresh, sizeof(OMX_VIDEO_PARAM_INTRAREFRESHTYPE));
1453 if (ret != OMX_ErrorNone)
1454 goto EXIT;
1455
1456 if (nPortIndex != OUTPUT_PORT_INDEX) {
1457 ret = OMX_ErrorBadPortIndex;
1458 goto EXIT;
1459 }
1460
1461 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1462 pIntraRefresh->eRefreshMode = pVideoEnc->intraRefresh.eRefreshMode;
1463 pIntraRefresh->nAirMBs = pVideoEnc->intraRefresh.nAirMBs;
1464 pIntraRefresh->nAirRef = pVideoEnc->intraRefresh.nAirRef;
1465 pIntraRefresh->nCirMBs = pVideoEnc->intraRefresh.nCirMBs;
1466
1467 ret = OMX_ErrorNone;
1468 }
1469 break;
c6f4bc34
YK		 1470 default:
1471 {
e4e150b8 1472 ret = Exynos_OMX_GetParameter(hComponent, nParamIndex, pComponentParameterStructure);
c6f4bc34
YK		 1473 }
1474 break;
1475 }
c6f4bc34
YK		 1476EXIT:
1477 FunctionOut();
1478
1479 return ret;
1480}
e4e150b8 1481
c6f4bc34
YK		 1482OMX_ERRORTYPE Exynos_OMX_VideoEncodeSetParameter(
1483 OMX_IN OMX_HANDLETYPE hComponent,
e4e150b8
HK		 1484 OMX_IN OMX_INDEXTYPE nParamIndex,
1485 OMX_IN OMX_PTR pComponentParameterStructure)
c6f4bc34 1486{
e4e150b8
HK		 1487 OMX_ERRORTYPE ret = OMX_ErrorNone;
1488 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1489 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1490 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
c6f4bc34
YK		 1491
1492 FunctionIn();
1493
1494 if (hComponent == NULL) {
1495 ret = OMX_ErrorBadParameter;
1496 goto EXIT;
1497 }
1498 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
e4e150b8 1499
c6f4bc34
YK		 1500 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1501 if (ret != OMX_ErrorNone) {
1502 goto EXIT;
1503 }
1504
1505 if (pOMXComponent->pComponentPrivate == NULL) {
1506 ret = OMX_ErrorBadParameter;
1507 goto EXIT;
1508 }
1509 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1510
e4e150b8 1511 if (pExynosComponent->currentState == OMX_StateInvalid) {
c6f4bc34
YK		 1512 ret = OMX_ErrorInvalidState;
1513 goto EXIT;
1514 }
1515
e4e150b8 1516 if (pComponentParameterStructure == NULL) {
c6f4bc34
YK		 1517 ret = OMX_ErrorBadParameter;
1518 goto EXIT;
1519 }
1520
e4e150b8 1521 switch (nParamIndex) {
c6f4bc34
YK		 1522 case OMX_IndexParamVideoPortFormat:
1523 {
e4e150b8
HK		 1524 OMX_VIDEO_PARAM_PORTFORMATTYPE *pPortFormat = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)pComponentParameterStructure;
1525 OMX_U32 nPortIndex = pPortFormat->nPortIndex;
1526 OMX_U32 nIndex = pPortFormat->nIndex;
1527 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = NULL;
1528 OMX_U32 nSupportFormat = 0;
1529
1530 ret = Exynos_OMX_Check_SizeVersion(pPortFormat, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
c6f4bc34
YK		 1531 if (ret != OMX_ErrorNone) {
1532 goto EXIT;
1533 }
1534
e4e150b8 1535 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
c6f4bc34
YK		 1536 ret = OMX_ErrorBadPortIndex;
1537 goto EXIT;
c6f4bc34 1538 }
e4e150b8
HK		 1539 pPortDef = &(pExynosComponent->pExynosPort[nPortIndex].portDefinition);
1540
1541 pPortDef->format.video.eColorFormat = pPortFormat->eColorFormat;
1542 pPortDef->format.video.eCompressionFormat = pPortFormat->eCompressionFormat;
1543 pPortDef->format.video.xFramerate = pPortFormat->xFramerate;
c6f4bc34
YK		 1544 }
1545 break;
1546 case OMX_IndexParamVideoBitrate:
1547 {
e4e150b8
HK		 1548 OMX_VIDEO_PARAM_BITRATETYPE *pVideoBitrate = (OMX_VIDEO_PARAM_BITRATETYPE *)pComponentParameterStructure;
1549 OMX_U32 nPortIndex = pVideoBitrate->nPortIndex;
1550 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1551 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1552 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = NULL;
c6f4bc34 1553
e4e150b8 1554 if (nPortIndex != OUTPUT_PORT_INDEX) {
c6f4bc34
YK		 1555 ret = OMX_ErrorBadPortIndex;
1556 goto EXIT;
1557 } else {
1558 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
e4e150b8
HK		 1559 if (pVideoEnc == NULL) {
1560 ret = OMX_ErrorBadParameter;
1561 goto EXIT;
1562 }
1563 pPortDef = &(pExynosComponent->pExynosPort[nPortIndex].portDefinition);
c6f4bc34 1564
e4e150b8
HK		 1565 pVideoEnc->eControlRate[nPortIndex] = pVideoBitrate->eControlRate;
1566 pPortDef->format.video.nBitrate = pVideoBitrate->nTargetBitrate;
c6f4bc34
YK		 1567 }
1568 ret = OMX_ErrorNone;
1569 }
1570 break;
1571 case OMX_IndexParamVideoQuantization:
1572 {
e4e150b8
HK		 1573 OMX_VIDEO_PARAM_QUANTIZATIONTYPE *pVideoQuantization = (OMX_VIDEO_PARAM_QUANTIZATIONTYPE *)pComponentParameterStructure;
1574 OMX_U32 nPortIndex = pVideoQuantization->nPortIndex;
1575 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
1576 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1577 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = NULL;
c6f4bc34 1578
e4e150b8 1579 if (nPortIndex != OUTPUT_PORT_INDEX) {
c6f4bc34
YK		 1580 ret = OMX_ErrorBadPortIndex;
1581 goto EXIT;
1582 } else {
1583 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
e4e150b8
HK		 1584 if (pVideoEnc == NULL) {
1585 ret = OMX_ErrorBadParameter;
1586 goto EXIT;
1587 }
1588 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1589 pPortDef = &pExynosPort->portDefinition;
c6f4bc34 1590
e4e150b8
HK		 1591 pVideoEnc->quantization.nQpI = pVideoQuantization->nQpI;
1592 pVideoEnc->quantization.nQpP = pVideoQuantization->nQpP;
1593 pVideoEnc->quantization.nQpB = pVideoQuantization->nQpB;
c6f4bc34
YK		 1594 }
1595 ret = OMX_ErrorNone;
1596 }
1597 break;
1598 case OMX_IndexParamPortDefinition:
1599 {
e4e150b8
HK		 1600 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = (OMX_PARAM_PORTDEFINITIONTYPE *)pComponentParameterStructure;
1601 OMX_U32 nPortIndex = pPortDef->nPortIndex;
1602 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
c6f4bc34
YK		 1603 OMX_U32 width, height, size;
1604
e4e150b8 1605 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
c6f4bc34
YK		 1606 ret = OMX_ErrorBadPortIndex;
1607 goto EXIT;
1608 }
e4e150b8
HK		 1609
1610 ret = Exynos_OMX_Check_SizeVersion(pPortDef, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
c6f4bc34
YK		 1611 if (ret != OMX_ErrorNone) {
1612 goto EXIT;
1613 }
1614
e4e150b8 1615 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
c6f4bc34 1616
e4e150b8
HK		 1617 if ((pExynosComponent->currentState != OMX_StateLoaded) &&
1618 (pExynosComponent->currentState != OMX_StateWaitForResources)) {
c6f4bc34
YK		 1619 if (pExynosPort->portDefinition.bEnabled == OMX_TRUE) {
1620 ret = OMX_ErrorIncorrectStateOperation;
1621 goto EXIT;
1622 }
1623 }
e4e150b8
HK		 1624
1625 if (pPortDef->nBufferCountActual < pExynosPort->portDefinition.nBufferCountMin) {
c6f4bc34
YK		 1626 ret = OMX_ErrorBadParameter;
1627 goto EXIT;
1628 }
1629
e4e150b8
HK		 1630 Exynos_OSAL_Memcpy(&pExynosPort->portDefinition, pPortDef, pPortDef->nSize);
1631 if (nPortIndex == INPUT_PORT_INDEX) {
1632 pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
c6f4bc34
YK		 1633 Exynos_UpdateFrameSize(pOMXComponent);
1634 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pExynosOutputPort->portDefinition.nBufferSize: %d",
e4e150b8 1635 pExynosPort->portDefinition.nBufferSize);
c6f4bc34
YK		 1636 }
1637 ret = OMX_ErrorNone;
1638 }
1639 break;
1640#ifdef USE_STOREMETADATA
1641 case OMX_IndexParamStoreMetaDataBuffer:
1642 {
298ca87f
TK		 1643 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1644 if (pVideoEnc == NULL) {
1645 ret = OMX_ErrorBadParameter;
1646 goto EXIT;
1647 }
1648
e4e150b8 1649 ret = Exynos_OSAL_SetANBParameter(hComponent, nParamIndex, pComponentParameterStructure);
298ca87f
TK		 1650 if (ret == OMX_ErrorNone)
1651 pVideoEnc->bFirstInput = OMX_TRUE;
c6f4bc34
YK		 1652 }
1653 break;
1654#endif
c31a957e
TK		 1655 case OMX_IndexVendorNeedContigMemory:
1656 {
1657 EXYNOS_OMX_VIDEO_PARAM_PORTMEMTYPE *pPortMemType = (EXYNOS_OMX_VIDEO_PARAM_PORTMEMTYPE *)pComponentParameterStructure;
1658 OMX_U32 nPortIndex = pPortMemType->nPortIndex;
1659 EXYNOS_OMX_BASEPORT *pExynosPort;
1660
1661 if (nPortIndex >= pExynosComponent->portParam.nPorts) {
1662 ret = OMX_ErrorBadPortIndex;
1663 goto EXIT;
1664 }
1665
1666 ret = Exynos_OMX_Check_SizeVersion(pPortMemType, sizeof(EXYNOS_OMX_VIDEO_PARAM_PORTMEMTYPE));
1667 if (ret != OMX_ErrorNone)
1668 goto EXIT;
1669
1670 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1671
1672 if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1673 if (pExynosPort->portDefinition.bEnabled == OMX_TRUE) {
1674 ret = OMX_ErrorIncorrectStateOperation;
1675 goto EXIT;
1676 }
1677 }
1678
1679 pExynosPort->bNeedContigMem = pPortMemType->bNeedContigMem;
1680 }
1681 break;
aa4a2b3e
TK		 1682 case OMX_IndexParamVideoIntraRefresh:
1683 {
1684 OMX_VIDEO_PARAM_INTRAREFRESHTYPE *pIntraRefresh = (OMX_VIDEO_PARAM_INTRAREFRESHTYPE *)pComponentParameterStructure;
1685 OMX_U32 nPortIndex = pIntraRefresh->nPortIndex;
1686 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1687
1688 ret = Exynos_OMX_Check_SizeVersion(pIntraRefresh, sizeof(OMX_VIDEO_PARAM_INTRAREFRESHTYPE));
1689 if (ret != OMX_ErrorNone)
1690 goto EXIT;
1691
1692 if (nPortIndex != OUTPUT_PORT_INDEX) {
1693 ret = OMX_ErrorBadPortIndex;
1694 goto EXIT;
1695 }
1696
1697 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1698 if (pIntraRefresh->eRefreshMode == OMX_VIDEO_IntraRefreshCyclic) {
1699 pVideoEnc->intraRefresh.eRefreshMode = pIntraRefresh->eRefreshMode;
1700 pVideoEnc->intraRefresh.nCirMBs = pIntraRefresh->nCirMBs;
1701 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "OMX_VIDEO_IntraRefreshCyclic Enable, nCirMBs: %d",
1702 pVideoEnc->intraRefresh.nCirMBs);
1703 } else {
1704 ret = OMX_ErrorUnsupportedSetting;
1705 goto EXIT;
1706 }
1707
1708 ret = OMX_ErrorNone;
1709 }
1710 break;
c6f4bc34
YK		 1711 default:
1712 {
e4e150b8 1713 ret = Exynos_OMX_SetParameter(hComponent, nParamIndex, pComponentParameterStructure);
c6f4bc34
YK		 1714 }
1715 break;
1716 }
c6f4bc34
YK		 1717EXIT:
1718 FunctionOut();
1719
1720 return ret;
1721}
1722
1723OMX_ERRORTYPE Exynos_OMX_VideoEncodeGetConfig(
e4e150b8
HK		 1724 OMX_HANDLETYPE hComponent,
1725 OMX_INDEXTYPE nParamIndex,
1726 OMX_PTR pComponentConfigStructure)
c6f4bc34 1727{
e4e150b8
HK		 1728 OMX_ERRORTYPE ret = OMX_ErrorNone;
1729 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1730 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
c6f4bc34
YK		 1731
1732 FunctionIn();
1733
e4e150b8
HK		 1734 if ((hComponent == NULL) ||
1735 (pComponentConfigStructure == NULL)) {
c6f4bc34
YK		 1736 ret = OMX_ErrorBadParameter;
1737 goto EXIT;
1738 }
1739 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
e4e150b8 1740
c6f4bc34
YK		 1741 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1742 if (ret != OMX_ErrorNone) {
1743 goto EXIT;
1744 }
e4e150b8 1745
c6f4bc34
YK		 1746 if (pOMXComponent->pComponentPrivate == NULL) {
1747 ret = OMX_ErrorBadParameter;
1748 goto EXIT;
1749 }
1750 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
e4e150b8 1751
c6f4bc34
YK		 1752 if (pExynosComponent->currentState == OMX_StateInvalid) {
1753 ret = OMX_ErrorInvalidState;
1754 goto EXIT;
1755 }
1756
e4e150b8 1757 switch (nParamIndex) {
c6f4bc34
YK		 1758 case OMX_IndexConfigVideoBitrate:
1759 {
e4e150b8
HK		 1760 OMX_VIDEO_CONFIG_BITRATETYPE *pConfigBitrate = (OMX_VIDEO_CONFIG_BITRATETYPE *)pComponentConfigStructure;
1761 OMX_U32 nPortIndex = pConfigBitrate->nPortIndex;
1762 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
c6f4bc34 1763
e4e150b8 1764 if (nPortIndex != OUTPUT_PORT_INDEX) {
c6f4bc34
YK		 1765 ret = OMX_ErrorBadPortIndex;
1766 goto EXIT;
1767 } else {
e4e150b8
HK		 1768 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1769 pConfigBitrate->nEncodeBitrate = pExynosPort->portDefinition.format.video.nBitrate;
c6f4bc34
YK		 1770 }
1771 }
1772 break;
1773 case OMX_IndexConfigVideoFramerate:
1774 {
e4e150b8
HK		 1775 OMX_CONFIG_FRAMERATETYPE *pConfigFramerate = (OMX_CONFIG_FRAMERATETYPE *)pComponentConfigStructure;
1776 OMX_U32 nPortIndex = pConfigFramerate->nPortIndex;
1777 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
c6f4bc34 1778
e4e150b8 1779 if (nPortIndex != OUTPUT_PORT_INDEX) {
c6f4bc34
YK		 1780 ret = OMX_ErrorBadPortIndex;
1781 goto EXIT;
1782 } else {
e4e150b8
HK		 1783 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1784 pConfigFramerate->xEncodeFramerate = pExynosPort->portDefinition.format.video.xFramerate;
c6f4bc34
YK		 1785 }
1786 }
1787 break;
ea1234c8
TK		 1788 case OMX_IndexVendorGetBufferFD:
1789 {
1790 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1791 EXYNOS_OMX_VIDEO_CONFIG_BUFFERINFO *pBufferInfo = (EXYNOS_OMX_VIDEO_CONFIG_BUFFERINFO *)pComponentConfigStructure;
1792
1793 ret = Exynos_OMX_Check_SizeVersion(pBufferInfo, sizeof(EXYNOS_OMX_VIDEO_CONFIG_BUFFERINFO));
1794 if (ret != OMX_ErrorNone)
1795 goto EXIT;
1796
1797 pBufferInfo->fd = Exynos_OSAL_SharedMemory_VirtToION(pVideoEnc->hSharedMemory, pBufferInfo->pVirAddr);
1798 }
1799 break;
c6f4bc34 1800 default:
e4e150b8
HK		 1801 {
1802 ret = Exynos_OMX_GetConfig(hComponent, nParamIndex, pComponentConfigStructure);
1803 }
c6f4bc34
YK		 1804 break;
1805 }
c6f4bc34
YK		 1806EXIT:
1807 FunctionOut();
1808
1809 return ret;
1810}
1811
1812OMX_ERRORTYPE Exynos_OMX_VideoEncodeSetConfig(
e4e150b8
HK		 1813 OMX_HANDLETYPE hComponent,
1814 OMX_INDEXTYPE nParamIndex,
1815 OMX_PTR pComponentConfigStructure)
c6f4bc34 1816 {
e4e150b8
HK		 1817 OMX_ERRORTYPE ret = OMX_ErrorNone;
1818 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1819 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
c6f4bc34
YK		 1820
1821 FunctionIn();
1822
e4e150b8
HK		 1823 if ((hComponent == NULL) ||
1824 (pComponentConfigStructure == NULL)) {
c6f4bc34
YK		 1825 ret = OMX_ErrorBadParameter;
1826 goto EXIT;
1827 }
1828 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
e4e150b8 1829
c6f4bc34
YK		 1830 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1831 if (ret != OMX_ErrorNone) {
1832 goto EXIT;
1833 }
e4e150b8 1834
c6f4bc34
YK		 1835 if (pOMXComponent->pComponentPrivate == NULL) {
1836 ret = OMX_ErrorBadParameter;
1837 goto EXIT;
1838 }
1839 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
e4e150b8 1840
c6f4bc34
YK		 1841 if (pExynosComponent->currentState == OMX_StateInvalid) {
1842 ret = OMX_ErrorInvalidState;
1843 goto EXIT;
1844 }
1845
e4e150b8 1846 switch (nParamIndex) {
c6f4bc34
YK		 1847 case OMX_IndexConfigVideoBitrate:
1848 {
e4e150b8
HK		 1849 OMX_VIDEO_CONFIG_BITRATETYPE *pConfigBitrate = (OMX_VIDEO_CONFIG_BITRATETYPE *)pComponentConfigStructure;
1850 OMX_U32 nPortIndex = pConfigBitrate->nPortIndex;
1851 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
c6f4bc34 1852
e4e150b8 1853 if (nPortIndex != OUTPUT_PORT_INDEX) {
c6f4bc34
YK		 1854 ret = OMX_ErrorBadPortIndex;
1855 goto EXIT;
1856 } else {
e4e150b8
HK		 1857 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1858 pExynosPort->portDefinition.format.video.nBitrate = pConfigBitrate->nEncodeBitrate;
c6f4bc34
YK		 1859 }
1860 }
1861 break;
1862 case OMX_IndexConfigVideoFramerate:
1863 {
e4e150b8
HK		 1864 OMX_CONFIG_FRAMERATETYPE *pConfigFramerate = (OMX_CONFIG_FRAMERATETYPE *)pComponentConfigStructure;
1865 OMX_U32 nPortIndex = pConfigFramerate->nPortIndex;
1866 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
c6f4bc34 1867
e4e150b8 1868 if (nPortIndex != OUTPUT_PORT_INDEX) {
c6f4bc34
YK		 1869 ret = OMX_ErrorBadPortIndex;
1870 goto EXIT;
1871 } else {
e4e150b8
HK		 1872 pExynosPort = &pExynosComponent->pExynosPort[nPortIndex];
1873 pExynosPort->portDefinition.format.video.xFramerate = pConfigFramerate->xEncodeFramerate;
c6f4bc34
YK		 1874 }
1875 }
1876 break;
1877 case OMX_IndexConfigVideoIntraVOPRefresh:
1878 {
1879 OMX_CONFIG_INTRAREFRESHVOPTYPE *pIntraRefreshVOP = (OMX_CONFIG_INTRAREFRESHVOPTYPE *)pComponentConfigStructure;
e4e150b8
HK		 1880 EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1881 OMX_U32 nPortIndex = pIntraRefreshVOP->nPortIndex;
1882
1883 if (pExynosComponent->hComponentHandle == NULL) {
1884 ret = OMX_ErrorBadParameter;
1885 goto EXIT;
1886 }
1887 pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
c6f4bc34 1888
e4e150b8 1889 if (nPortIndex != OUTPUT_PORT_INDEX) {
c6f4bc34
YK		 1890 ret = OMX_ErrorBadPortIndex;
1891 goto EXIT;
1892 } else {
e4e150b8 1893 pVideoEnc->IntraRefreshVOP = pIntraRefreshVOP->IntraRefreshVOP;
c6f4bc34
YK		 1894 }
1895 }
1896 break;
1897 default:
e4e150b8
HK		 1898 {
1899 ret = Exynos_OMX_SetConfig(hComponent, nParamIndex, pComponentConfigStructure);
1900 }
c6f4bc34
YK		 1901 break;
1902 }
c6f4bc34
YK		 1903EXIT:
1904 FunctionOut();
1905
1906 return ret;
1907}
1908
1909OMX_ERRORTYPE Exynos_OMX_VideoEncodeGetExtensionIndex(
1910 OMX_IN OMX_HANDLETYPE hComponent,
e4e150b8 1911 OMX_IN OMX_STRING szParamName,
c6f4bc34
YK		 1912 OMX_OUT OMX_INDEXTYPE *pIndexType)
1913{
e4e150b8
HK		 1914 OMX_ERRORTYPE ret = OMX_ErrorNone;
1915 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1916 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
c6f4bc34
YK		 1917
1918 FunctionIn();
1919
1920 if (hComponent == NULL) {
1921 ret = OMX_ErrorBadParameter;
1922 goto EXIT;
1923 }
1924 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
e4e150b8 1925
c6f4bc34
YK		 1926 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1927 if (ret != OMX_ErrorNone) {
1928 goto EXIT;
1929 }
1930
1931 if (pOMXComponent->pComponentPrivate == NULL) {
1932 ret = OMX_ErrorBadParameter;
1933 goto EXIT;
1934 }
1935 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1936
e4e150b8 1937 if ((szParamName == NULL) || (pIndexType == NULL)) {
c6f4bc34
YK		 1938 ret = OMX_ErrorBadParameter;
1939 goto EXIT;
1940 }
e4e150b8 1941
c6f4bc34
YK		 1942 if (pExynosComponent->currentState == OMX_StateInvalid) {
1943 ret = OMX_ErrorInvalidState;
1944 goto EXIT;
1945 }
1946
c31a957e
TK		 1947 if (Exynos_OSAL_Strcmp(szParamName, EXYNOS_INDEX_PARAM_NEED_CONTIG_MEMORY) == 0) {
1948 *pIndexType = (OMX_INDEXTYPE) OMX_IndexVendorNeedContigMemory;
1949 ret = OMX_ErrorNone;
1950 goto EXIT;
ea1234c8
TK		 1951 } else if (Exynos_OSAL_Strcmp(szParamName, EXYNOS_INDEX_CONFIG_GET_BUFFER_FD) == 0) {
1952 *pIndexType = (OMX_INDEXTYPE) OMX_IndexVendorGetBufferFD;
1953 ret = OMX_ErrorNone;
1954 goto EXIT;
c31a957e
TK		 1955 }
1956
c6f4bc34 1957#ifdef USE_STOREMETADATA
e4e150b8
HK		 1958 if (Exynos_OSAL_Strcmp(szParamName, EXYNOS_INDEX_PARAM_STORE_METADATA_BUFFER) == 0) {
1959 *pIndexType = (OMX_INDEXTYPE)OMX_IndexParamStoreMetaDataBuffer;
c6f4bc34 1960 } else {
e4e150b8 1961 ret = Exynos_OMX_GetExtensionIndex(hComponent, szParamName, pIndexType);
c6f4bc34
YK		 1962 }
1963#else
e4e150b8 1964 ret = Exynos_OMX_GetExtensionIndex(hComponent, szParamName, pIndexType);
c6f4bc34 1965#endif
c6f4bc34
YK		 1966EXIT:
1967 FunctionOut();
1968
1969 return ret;
1970}
323488ff
SK		 1971
1972OMX_ERRORTYPE Exynos_Shared_DataToBuffer(EXYNOS_OMX_DATA *pData, EXYNOS_OMX_DATABUFFER *pUseBuffer, OMX_BOOL bNeedUnlock)
1973{
1974 OMX_ERRORTYPE ret = OMX_ErrorNone;
1975
1976 pUseBuffer->bufferHeader = pData->bufferHeader;
1977 pUseBuffer->allocSize = pData->allocSize;
1978 pUseBuffer->dataLen = pData->dataLen;
1979 pUseBuffer->usedDataLen = pData->usedDataLen;
1980 pUseBuffer->remainDataLen = pData->remainDataLen;
1981 pUseBuffer->timeStamp = pData->timeStamp;
1982 pUseBuffer->nFlags = pData->nFlags;
1983 pUseBuffer->pPrivate = pData->pPrivate;
1984
1985 if ((bNeedUnlock == OMX_TRUE) && (pUseBuffer->bufferHeader != NULL)) {
1986 OMX_PTR ppBuf[MAX_BUFFER_PLANE];
1987 Exynos_OSAL_GetInfoFromMetaData((OMX_BYTE)pUseBuffer->bufferHeader->pBuffer, ppBuf);
1988 Exynos_OSAL_UnlockANBHandle(ppBuf[0]);
1989 }
1990
1991 return ret;
1992}