projects / GitHub / LineageOS / android_hardware_samsung_slsi_openmax.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
vdec: cleaned up code
[GitHub/LineageOS/android_hardware_samsung_slsi_openmax.git] / component / video / dec / mpeg4 / Exynos_OMX_Mpeg4dec.c
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_Mpeg4dec.c
20 * @brief
21 * @author Yunji Kim (yunji.kim@samsung.com)
22 * @author SeungBeom Kim (sbcrux.kim@samsung.com)
23 * @version 2.0.0
24 * @history
25 * 2012.02.20 : Create
26 */
27
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <string.h>
31
32 #include "Exynos_OMX_Macros.h"
33 #include "Exynos_OMX_Basecomponent.h"
34 #include "Exynos_OMX_Baseport.h"
35 #include "Exynos_OMX_Vdec.h"
36 #include "Exynos_OSAL_ETC.h"
37 #include "Exynos_OSAL_Semaphore.h"
38 #include "Exynos_OSAL_Thread.h"
39 #include "library_register.h"
40 #include "Exynos_OMX_Mpeg4dec.h"
41 #include "ExynosVideoApi.h"
42 #include "Exynos_OSAL_SharedMemory.h"
43 #include "Exynos_OSAL_Event.h"
44
45 #ifdef USE_ANB
46 #include "Exynos_OSAL_Android.h"
47 #endif
48
49 /* To use CSC_METHOD_HW in EXYNOS OMX, gralloc should allocate physical memory using FIMC */
50 /* It means GRALLOC_USAGE_HW_FIMC1 should be set on Native Window usage */
51 #include "csc.h"
52
53 #undef EXYNOS_LOG_TAG
54 #define EXYNOS_LOG_TAG "EXYNOS_MPEG4_DEC"
55 #define EXYNOS_LOG_OFF
56 //#define EXYNOS_TRACE_ON
57 #include "Exynos_OSAL_Log.h"
58
59 #define MPEG4_DEC_NUM_OF_EXTRA_BUFFERS 7
60
61 //#define FULL_FRAME_SEARCH
62
63 /* MPEG4 Decoder Supported Levels & profiles */
64 EXYNOS_OMX_VIDEO_PROFILELEVEL supportedMPEG4ProfileLevels[] ={
65 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level0},
66 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level0b},
67 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level1},
68 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level2},
69 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level3},
70 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level4},
71 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level4a},
72 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level5},
73 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level0},
74 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level0b},
75 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level1},
76 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level2},
77 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level3},
78 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level4},
79 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level4a},
80 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level5}};
81
82 /* H.263 Decoder Supported Levels & profiles */
83 EXYNOS_OMX_VIDEO_PROFILELEVEL supportedH263ProfileLevels[] = {
84 /* Baseline (Profile 0) */
85 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level10},
86 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level20},
87 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level30},
88 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level40},
89 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level45},
90 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level50},
91 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level60},
92 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level70},
93 /* Profile 1 */
94 {OMX_VIDEO_H263ProfileH320Coding, OMX_VIDEO_H263Level10},
95 {OMX_VIDEO_H263ProfileH320Coding, OMX_VIDEO_H263Level20},
96 {OMX_VIDEO_H263ProfileH320Coding, OMX_VIDEO_H263Level30},
97 {OMX_VIDEO_H263ProfileH320Coding, OMX_VIDEO_H263Level40},
98 {OMX_VIDEO_H263ProfileH320Coding, OMX_VIDEO_H263Level45},
99 {OMX_VIDEO_H263ProfileH320Coding, OMX_VIDEO_H263Level50},
100 {OMX_VIDEO_H263ProfileH320Coding, OMX_VIDEO_H263Level60},
101 {OMX_VIDEO_H263ProfileH320Coding, OMX_VIDEO_H263Level70},
102 /* Profile 2 */
103 {OMX_VIDEO_H263ProfileBackwardCompatible, OMX_VIDEO_H263Level10},
104 {OMX_VIDEO_H263ProfileBackwardCompatible, OMX_VIDEO_H263Level20},
105 {OMX_VIDEO_H263ProfileBackwardCompatible, OMX_VIDEO_H263Level30},
106 {OMX_VIDEO_H263ProfileBackwardCompatible, OMX_VIDEO_H263Level40},
107 {OMX_VIDEO_H263ProfileBackwardCompatible, OMX_VIDEO_H263Level45},
108 {OMX_VIDEO_H263ProfileBackwardCompatible, OMX_VIDEO_H263Level50},
109 {OMX_VIDEO_H263ProfileBackwardCompatible, OMX_VIDEO_H263Level60},
110 {OMX_VIDEO_H263ProfileBackwardCompatible, OMX_VIDEO_H263Level70},
111 /* Profile 3, restricted up to SD resolution */
112 {OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level10},
113 {OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level20},
114 {OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level30},
115 {OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level40},
116 {OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level45},
117 {OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level50},
118 {OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level60},
119 {OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level70}};
120
121
122 static OMX_ERRORTYPE GetCodecInputPrivateData(OMX_PTR codecBuffer, void *pVirtAddr, OMX_U32 *dataSize)
123 {
124 OMX_ERRORTYPE ret = OMX_ErrorNone;
125
126 EXIT:
127 return ret;
128 }
129
130 static OMX_ERRORTYPE GetCodecOutputPrivateData(OMX_PTR codecBuffer, void *addr[], int size[])
131 {
132 OMX_ERRORTYPE ret = OMX_ErrorNone;
133 ExynosVideoBuffer *pCodecBuffer;
134
135 if (codecBuffer == NULL) {
136 ret = OMX_ErrorBadParameter;
137 goto EXIT;
138 }
139
140 pCodecBuffer = (ExynosVideoBuffer *)codecBuffer;
141
142 if (addr != NULL) {
143 addr[0] = pCodecBuffer->planes[0].addr;
144 addr[1] = pCodecBuffer->planes[1].addr;
145 addr[2] = pCodecBuffer->planes[2].addr;
146 }
147
148 if (size != NULL) {
149 size[0] = pCodecBuffer->planes[0].allocSize;
150 size[1] = pCodecBuffer->planes[1].allocSize;
151 size[2] = pCodecBuffer->planes[2].allocSize;
152 }
153
154 EXIT:
155 return ret;
156 }
157
158 static OMX_BOOL gbFIMV1 = OMX_FALSE;
159
160 static int Check_Mpeg4_Frame(
161 OMX_U8 *pInputStream,
162 OMX_U32 buffSize,
163 OMX_U32 flag,
164 OMX_BOOL bPreviousFrameEOF,
165 OMX_BOOL *pbEndOfFrame)
166 {
167 OMX_U32 len;
168 int readStream;
169 unsigned startCode;
170 OMX_BOOL bFrameStart;
171
172 len = 0;
173 bFrameStart = OMX_FALSE;
174
175 if (flag & OMX_BUFFERFLAG_CODECCONFIG) {
176 if (*pInputStream == 0x03) { /* FIMV1 */
177 BitmapInfoHhr *pInfoHeader;
178
179 pInfoHeader = (BitmapInfoHhr *)(pInputStream + 1);
180 /* FIXME */
181 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "############## NOT SUPPORTED #################");
182 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "width(%d), height(%d)", pInfoHeader->BiWidth, pInfoHeader->BiHeight);
183 gbFIMV1 = OMX_TRUE;
184 *pbEndOfFrame = OMX_TRUE;
185 return buffSize;
186 }
187 }
188
189 if (gbFIMV1) {
190 *pbEndOfFrame = OMX_TRUE;
191 return buffSize;
192 }
193
194 if (bPreviousFrameEOF == OMX_FALSE)
195 bFrameStart = OMX_TRUE;
196
197 startCode = 0xFFFFFFFF;
198 if (bFrameStart == OMX_FALSE) {
199 /* find VOP start code */
200 while(startCode != 0x1B6) {
201 readStream = *(pInputStream + len);
202 startCode = (startCode << 8) | readStream;
203 len++;
204 if (len > buffSize)
205 goto EXIT;
206 }
207 }
208
209 /* find next VOP start code */
210 startCode = 0xFFFFFFFF;
211 while ((startCode != 0x1B6)) {
212 readStream = *(pInputStream + len);
213 startCode = (startCode << 8) | readStream;
214 len++;
215 if (len > buffSize)
216 goto EXIT;
217 }
218
219 *pbEndOfFrame = OMX_TRUE;
220
221 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "1. Check_Mpeg4_Frame returned EOF = %d, len = %d, buffSize = %d", *pbEndOfFrame, len - 4, buffSize);
222
223 return len - 4;
224
225 EXIT :
226 *pbEndOfFrame = OMX_FALSE;
227
228 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "2. Check_Mpeg4_Frame returned EOF = %d, len = %d, buffSize = %d", *pbEndOfFrame, len - 1, buffSize);
229
230 return --len;
231 }
232
233 static int Check_H263_Frame(
234 OMX_U8 *pInputStream,
235 OMX_U32 buffSize,
236 OMX_U32 flag,
237 OMX_BOOL bPreviousFrameEOF,
238 OMX_BOOL *pbEndOfFrame)
239 {
240 OMX_U32 len;
241 int readStream;
242 unsigned startCode;
243 OMX_BOOL bFrameStart = 0;
244 unsigned pTypeMask = 0x03;
245 unsigned pType = 0;
246
247 len = 0;
248 bFrameStart = OMX_FALSE;
249
250 if (bPreviousFrameEOF == OMX_FALSE)
251 bFrameStart = OMX_TRUE;
252
253 startCode = 0xFFFFFFFF;
254 if (bFrameStart == OMX_FALSE) {
255 /* find PSC(Picture Start Code) : 0000 0000 0000 0000 1000 00 */
256 while (((startCode << 8 >> 10) != 0x20) || (pType != 0x02)) {
257 readStream = *(pInputStream + len);
258 startCode = (startCode << 8) | readStream;
259
260 readStream = *(pInputStream + len + 1);
261 pType = readStream & pTypeMask;
262
263 len++;
264 if (len > buffSize)
265 goto EXIT;
266 }
267 }
268
269 /* find next PSC */
270 startCode = 0xFFFFFFFF;
271 pType = 0;
272 while (((startCode << 8 >> 10) != 0x20) || (pType != 0x02)) {
273 readStream = *(pInputStream + len);
274 startCode = (startCode << 8) | readStream;
275
276 readStream = *(pInputStream + len + 1);
277 pType = readStream & pTypeMask;
278
279 len++;
280 if (len > buffSize)
281 goto EXIT;
282 }
283
284 *pbEndOfFrame = OMX_TRUE;
285
286 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "1. Check_H263_Frame returned EOF = %d, len = %d, iBuffSize = %d", *pbEndOfFrame, len - 3, buffSize);
287
288 return len - 3;
289
290 EXIT :
291
292 *pbEndOfFrame = OMX_FALSE;
293
294 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "2. Check_H263_Frame returned EOF = %d, len = %d, iBuffSize = %d", *pbEndOfFrame, len - 1, buffSize);
295
296 return --len;
297 }
298
299 static OMX_BOOL Check_Stream_StartCode(
300 OMX_U8 *pInputStream,
301 OMX_U32 streamSize,
302 CODEC_TYPE codecType)
303 {
304 switch (codecType) {
305 case CODEC_TYPE_MPEG4:
306 if (gbFIMV1) {
307 return OMX_TRUE;
308 } else {
309 if (streamSize < 3) {
310 return OMX_FALSE;
311 } else if ((pInputStream[0] == 0x00) &&
312 (pInputStream[1] == 0x00) &&
313 (pInputStream[2] == 0x01)) {
314 return OMX_TRUE;
315 } else {
316 return OMX_FALSE;
317 }
318 }
319 break;
320 case CODEC_TYPE_H263:
321 if (streamSize > 0) {
322 unsigned startCode = 0xFFFFFFFF;
323 unsigned pTypeMask = 0x03;
324 unsigned pType = 0;
325 OMX_U32 len = 0;
326 int readStream;
327 /* Check PSC(Picture Start Code) : 0000 0000 0000 0000 1000 00 */
328 while (((startCode << 8 >> 10) != 0x20) || (pType != 0x02)) {
329 readStream = *(pInputStream + len);
330 startCode = (startCode << 8) | readStream;
331
332 readStream = *(pInputStream + len + 1);
333 pType = readStream & pTypeMask;
334
335 len++;
336 if (len > 0x3)
337 break;
338 }
339
340 if (len > 0x3) {
341 Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "[%s] Picture Start Code Missing", __FUNCTION__);
342 return OMX_FALSE;
343 } else {
344 return OMX_TRUE;
345 }
346 } else {
347 return OMX_FALSE;
348 }
349 default:
350 Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "%s: undefined codec type (%d)", __FUNCTION__, codecType);
351 return OMX_FALSE;
352 }
353 }
354
355 OMX_ERRORTYPE Mpeg4CodecOpen(EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec)
356 {
357 OMX_ERRORTYPE ret = OMX_ErrorNone;
358 ExynosVideoDecOps *pDecOps = NULL;
359 ExynosVideoDecBufferOps *pInbufOps = NULL;
360 ExynosVideoDecBufferOps *pOutbufOps = NULL;
361
362 FunctionIn();
363
364 if (pMpeg4Dec == NULL) {
365 ret = OMX_ErrorBadParameter;
366 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
367 goto EXIT;
368 }
369
370 /* alloc ops structure */
371 pDecOps = (ExynosVideoDecOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoDecOps));
372 pInbufOps = (ExynosVideoDecBufferOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoDecBufferOps));
373 pOutbufOps = (ExynosVideoDecBufferOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoDecBufferOps));
374
375 if ((pDecOps == NULL) || (pInbufOps == NULL) || (pOutbufOps == NULL)) {
376 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to allocate decoder ops buffer");
377 ret = OMX_ErrorInsufficientResources;
378 goto EXIT;
379 }
380
381 pMpeg4Dec->hMFCMpeg4Handle.pDecOps = pDecOps;
382 pMpeg4Dec->hMFCMpeg4Handle.pInbufOps = pInbufOps;
383 pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps = pOutbufOps;
384
385 /* function pointer mapping */
386 pDecOps->nSize = sizeof(ExynosVideoDecOps);
387 pInbufOps->nSize = sizeof(ExynosVideoDecBufferOps);
388 pOutbufOps->nSize = sizeof(ExynosVideoDecBufferOps);
389
390 Exynos_Video_Register_Decoder(pDecOps, pInbufOps, pOutbufOps);
391
392 /* check mandatory functions for decoder ops */
393 if ((pDecOps->Init == NULL) || (pDecOps->Finalize == NULL) ||
394 (pDecOps->Get_ActualBufferCount == NULL) || (pDecOps->Set_FrameTag == NULL) ||
395 (pDecOps->Get_FrameTag == NULL)) {
396 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Mandatory functions must be supplied");
397 ret = OMX_ErrorInsufficientResources;
398 goto EXIT;
399 }
400
401 /* check mandatory functions for buffer ops */
402 if ((pInbufOps->Setup == NULL) || (pOutbufOps->Setup == NULL) ||
403 (pInbufOps->Run == NULL) || (pOutbufOps->Run == NULL) ||
404 (pInbufOps->Stop == NULL) || (pOutbufOps->Stop == NULL) ||
405 (pInbufOps->Enqueue == NULL) || (pOutbufOps->Enqueue == NULL) ||
406 (pInbufOps->Dequeue == NULL) || (pOutbufOps->Dequeue == NULL)) {
407 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Mandatory functions must be supplied");
408 ret = OMX_ErrorInsufficientResources;
409 goto EXIT;
410 }
411
412 /* alloc context, open, querycap */
413 #ifdef USE_DMA_BUF
414 pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.pDecOps->Init(V4L2_MEMORY_DMABUF);
415 #else
416 pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.pDecOps->Init(V4L2_MEMORY_USERPTR);
417 #endif
418 if (pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle == NULL) {
419 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to allocate context buffer");
420 ret = OMX_ErrorInsufficientResources;
421 goto EXIT;
422 }
423
424 ret = OMX_ErrorNone;
425
426 EXIT:
427 if (ret != OMX_ErrorNone) {
428 if (pDecOps != NULL) {
429 Exynos_OSAL_Free(pDecOps);
430 pMpeg4Dec->hMFCMpeg4Handle.pDecOps = NULL;
431 }
432 if (pInbufOps != NULL) {
433 Exynos_OSAL_Free(pInbufOps);
434 pMpeg4Dec->hMFCMpeg4Handle.pInbufOps = NULL;
435 }
436 if (pOutbufOps != NULL) {
437 Exynos_OSAL_Free(pOutbufOps);
438 pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps = NULL;
439 }
440 }
441
442 FunctionOut();
443
444 return ret;
445 }
446
447 OMX_ERRORTYPE Mpeg4CodecClose(EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec)
448 {
449 OMX_ERRORTYPE ret = OMX_ErrorNone;
450 void *hMFCHandle = NULL;
451 ExynosVideoDecOps *pDecOps = NULL;
452 ExynosVideoDecBufferOps *pInbufOps = NULL;
453 ExynosVideoDecBufferOps *pOutbufOps = NULL;
454
455 FunctionIn();
456
457 if (pMpeg4Dec == NULL) {
458 ret = OMX_ErrorBadParameter;
459 goto EXIT;
460 }
461
462 hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
463 pDecOps = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
464 pInbufOps = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
465 pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
466
467 if (hMFCHandle != NULL) {
468 pDecOps->Finalize(hMFCHandle);
469 pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle = NULL;
470 }
471 if (pOutbufOps != NULL) {
472 Exynos_OSAL_Free(pOutbufOps);
473 pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps = NULL;
474 }
475 if (pInbufOps != NULL) {
476 Exynos_OSAL_Free(pInbufOps);
477 pMpeg4Dec->hMFCMpeg4Handle.pInbufOps = NULL;
478 }
479 if (pDecOps != NULL) {
480 Exynos_OSAL_Free(pDecOps);
481 pMpeg4Dec->hMFCMpeg4Handle.pDecOps = NULL;
482 }
483
484 ret = OMX_ErrorNone;
485
486 EXIT:
487 FunctionOut();
488
489 return ret;
490 }
491
492 OMX_ERRORTYPE Mpeg4CodecStart(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
493 {
494 OMX_ERRORTYPE ret = OMX_ErrorNone;
495 void *hMFCHandle = NULL;
496 ExynosVideoDecOps *pDecOps = NULL;
497 ExynosVideoDecBufferOps *pInbufOps = NULL;
498 ExynosVideoDecBufferOps *pOutbufOps = NULL;
499 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
500 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = NULL;
501
502 FunctionIn();
503
504 if (pOMXComponent == NULL) {
505 ret = OMX_ErrorBadParameter;
506 goto EXIT;
507 }
508
509 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
510 if (pVideoDec == NULL) {
511 ret = OMX_ErrorBadParameter;
512 goto EXIT;
513 }
514
515 pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)pVideoDec->hCodecHandle;
516 if (pMpeg4Dec == NULL) {
517 ret = OMX_ErrorBadParameter;
518 goto EXIT;
519 }
520
521 hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
522 pDecOps = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
523 pInbufOps = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
524 pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
525
526 if (nPortIndex == INPUT_PORT_INDEX)
527 pInbufOps->Run(hMFCHandle);
528 else if (nPortIndex == OUTPUT_PORT_INDEX)
529 pOutbufOps->Run(hMFCHandle);
530
531 ret = OMX_ErrorNone;
532
533 EXIT:
534 FunctionOut();
535
536 return ret;
537 }
538
539 OMX_ERRORTYPE Mpeg4CodecStop(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
540 {
541 OMX_ERRORTYPE ret = OMX_ErrorNone;
542 void *hMFCHandle = NULL;
543 ExynosVideoDecOps *pDecOps = NULL;
544 ExynosVideoDecBufferOps *pInbufOps = NULL;
545 ExynosVideoDecBufferOps *pOutbufOps = NULL;
546 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
547 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = NULL;
548
549 FunctionIn();
550
551 if (pOMXComponent == NULL) {
552 ret = OMX_ErrorBadParameter;
553 goto EXIT;
554 }
555
556 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
557 if (pVideoDec == NULL) {
558 ret = OMX_ErrorBadParameter;
559 goto EXIT;
560 }
561 pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)pVideoDec->hCodecHandle;
562 if (pMpeg4Dec == NULL) {
563 ret = OMX_ErrorBadParameter;
564 goto EXIT;
565 }
566
567 hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
568 pDecOps = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
569 pInbufOps = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
570 pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
571
572 if ((nPortIndex == INPUT_PORT_INDEX) && (pInbufOps != NULL))
573 pInbufOps->Stop(hMFCHandle);
574 else if ((nPortIndex == OUTPUT_PORT_INDEX) && (pOutbufOps != NULL))
575 pOutbufOps->Stop(hMFCHandle);
576
577 ret = OMX_ErrorNone;
578
579 EXIT:
580 FunctionOut();
581
582 return ret;
583 }
584
585 OMX_ERRORTYPE Mpeg4CodecOutputBufferProcessRun(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
586 {
587 OMX_ERRORTYPE ret = OMX_ErrorNone;
588 void *hMFCHandle = NULL;
589 ExynosVideoDecOps *pDecOps = NULL;
590 ExynosVideoDecBufferOps *pInbufOps = NULL;
591 ExynosVideoDecBufferOps *pOutbufOps = NULL;
592 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
593 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = NULL;
594
595 FunctionIn();
596
597 if (pOMXComponent == NULL) {
598 ret = OMX_ErrorBadParameter;
599 goto EXIT;
600 }
601
602 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
603 if (pVideoDec == NULL) {
604 ret = OMX_ErrorBadParameter;
605 goto EXIT;
606 }
607 pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)pVideoDec->hCodecHandle;
608 if (pMpeg4Dec == NULL) {
609 ret = OMX_ErrorBadParameter;
610 goto EXIT;
611 }
612
613 hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
614 pDecOps = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
615 pInbufOps = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
616 pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
617
618 if (nPortIndex == INPUT_PORT_INDEX) {
619 if (pMpeg4Dec->bSourceStart == OMX_FALSE) {
620 Exynos_OSAL_SignalSet(pMpeg4Dec->hSourceStartEvent);
621 Exynos_OSAL_SleepMillisec(0);
622 }
623 }
624
625 if (nPortIndex == OUTPUT_PORT_INDEX) {
626 if (pMpeg4Dec->bDestinationStart == OMX_FALSE) {
627 Exynos_OSAL_SignalSet(pMpeg4Dec->hDestinationStartEvent);
628 Exynos_OSAL_SleepMillisec(0);
629 }
630 }
631
632 ret = OMX_ErrorNone;
633
634 EXIT:
635 FunctionOut();
636
637 return ret;
638 }
639
640 OMX_ERRORTYPE Mpeg4CodecRegistCodecBuffers(
641 OMX_COMPONENTTYPE *pOMXComponent,
642 OMX_U32 nPortIndex,
643 OMX_U32 nBufferCnt)
644 {
645 OMX_ERRORTYPE ret = OMX_ErrorNone;
646 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
647 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
648 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
649 void *hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
650 CODEC_DEC_BUFFER **ppCodecBuffer = NULL;
651 ExynosVideoDecBufferOps *pBufOps = NULL;
652 ExynosVideoPlane *pPlanes = NULL;
653
654 OMX_U32 nPlaneCnt = 0;
655 int i, j;
656
657 FunctionIn();
658
659 if (nPortIndex == INPUT_PORT_INDEX) {
660 ppCodecBuffer = &(pVideoDec->pMFCDecInputBuffer[0]);
661 nPlaneCnt = MFC_INPUT_BUFFER_PLANE;
662 pBufOps = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
663 } else {
664 ppCodecBuffer = &(pVideoDec->pMFCDecOutputBuffer[0]);
665 nPlaneCnt = MFC_OUTPUT_BUFFER_PLANE;
666 pBufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
667 }
668
669 pPlanes = (ExynosVideoPlane *)Exynos_OSAL_Malloc(sizeof(ExynosVideoPlane) * nPlaneCnt);
670 if (pPlanes == NULL) {
671 ret = OMX_ErrorInsufficientResources;
672 goto EXIT;
673 }
674
675 /* Register buffer */
676 for (i = 0; i < nBufferCnt; i++) {
677 for (j = 0; j < nPlaneCnt; j++) {
678 pPlanes[j].addr = ppCodecBuffer[i]->pVirAddr[j];
679 pPlanes[j].fd = ppCodecBuffer[i]->fd[j];
680 pPlanes[j].allocSize = ppCodecBuffer[i]->bufferSize[j];
681 }
682
683 if (pBufOps->Register(hMFCHandle, pPlanes, nPlaneCnt) != VIDEO_ERROR_NONE) {
684 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "PORT[%d]: Failed to Register buffer", nPortIndex);
685 ret = OMX_ErrorInsufficientResources;
686 Exynos_OSAL_Free(pPlanes);
687 goto EXIT;
688 }
689 }
690
691 Exynos_OSAL_Free(pPlanes);
692
693 ret = OMX_ErrorNone;
694
695 EXIT:
696 FunctionOut();
697
698 return ret;
699 }
700
701 OMX_ERRORTYPE Mpeg4CodecEnQueueAllBuffer(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
702 {
703 OMX_ERRORTYPE ret = OMX_ErrorNone;
704 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
705 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
706 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)pVideoDec->hCodecHandle;
707 void *hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
708 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
709 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
710 int i, nOutbufs;
711
712 ExynosVideoDecOps *pDecOps = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
713 ExynosVideoDecBufferOps *pInbufOps = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
714 ExynosVideoDecBufferOps *pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
715
716 FunctionIn();
717
718 if ((nPortIndex != INPUT_PORT_INDEX) && (nPortIndex != OUTPUT_PORT_INDEX)) {
719 ret = OMX_ErrorBadPortIndex;
720 goto EXIT;
721 }
722
723 if ((nPortIndex == INPUT_PORT_INDEX) &&
724 (pMpeg4Dec->bSourceStart == OMX_TRUE)) {
725 Exynos_CodecBufferReset(pExynosComponent, INPUT_PORT_INDEX);
726
727 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
728 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]);
729 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]->pVirAddr[0]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[0]);
730
731 Exynos_CodecBufferEnQueue(pExynosComponent, INPUT_PORT_INDEX, pVideoDec->pMFCDecInputBuffer[i]);
732 }
733
734 pInbufOps->Clear_Queue(hMFCHandle);
735 } else if ((nPortIndex == OUTPUT_PORT_INDEX) &&
736 (pMpeg4Dec->bDestinationStart == OMX_TRUE)) {
737 Exynos_CodecBufferReset(pExynosComponent, OUTPUT_PORT_INDEX);
738
739 for (i = 0; i < pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum; i++) {
740 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecOutputBuffer[%d]: 0x%x", i, pVideoDec->pMFCDecOutputBuffer[i]);
741 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecOutputBuffer[%d]->pVirAddr[0]: 0x%x", i, pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[0]);
742
743 Exynos_CodecBufferEnQueue(pExynosComponent, OUTPUT_PORT_INDEX, pVideoDec->pMFCDecOutputBuffer[i]);
744 }
745 pOutbufOps->Clear_Queue(hMFCHandle);
746 }
747
748 EXIT:
749 FunctionOut();
750
751 return ret;
752 }
753
754 OMX_ERRORTYPE Mpeg4CodecSrcSetup(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
755 {
756 OMX_ERRORTYPE ret = OMX_ErrorNone;
757 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
758 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
759 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
760 void *hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
761 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
762 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
763 OMX_U32 oneFrameSize = pSrcInputData->dataLen;
764
765 ExynosVideoDecOps *pDecOps = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
766 ExynosVideoDecBufferOps *pInbufOps = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
767 ExynosVideoDecBufferOps *pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
768 ExynosVideoGeometry bufferConf;
769 OMX_U32 inputBufferNumber = 0;
770 int i;
771
772 FunctionIn();
773
774 if ((oneFrameSize <= 0) && (pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
775 OMX_BUFFERHEADERTYPE *OMXBuffer = NULL;
776 OMXBuffer = Exynos_OutputBufferGetQueue_Direct(pExynosComponent);
777 if (OMXBuffer == NULL) {
778 ret = OMX_ErrorUndefined;
779 goto EXIT;
780 }
781
782 OMXBuffer->nTimeStamp = pSrcInputData->timeStamp;
783 OMXBuffer->nFlags = pSrcInputData->nFlags;
784 Exynos_OMX_OutputBufferReturn(pOMXComponent, OMXBuffer);
785
786 ret = OMX_ErrorNone;
787 goto EXIT;
788 }
789
790 if (pVideoDec->bThumbnailMode == OMX_TRUE)
791 pDecOps->Set_DisplayDelay(hMFCHandle, 0);
792
793 /* input buffer info */
794 Exynos_OSAL_Memset(&bufferConf, 0, sizeof(bufferConf));
795 if (pMpeg4Dec->hMFCMpeg4Handle.codecType == CODEC_TYPE_MPEG4)
796 bufferConf.eCompressionFormat = VIDEO_CODING_MPEG4;
797 else
798 bufferConf.eCompressionFormat = VIDEO_CODING_H263;
799
800 pInbufOps->Set_Shareable(hMFCHandle);
801 if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
802 bufferConf.nSizeImage = pExynosInputPort->portDefinition.format.video.nFrameWidth
803 * pExynosInputPort->portDefinition.format.video.nFrameHeight * 3 / 2;
804 inputBufferNumber = MAX_VIDEO_INPUTBUFFER_NUM;
805 } else if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
806 bufferConf.nSizeImage = DEFAULT_MFC_INPUT_BUFFER_SIZE;
807 inputBufferNumber = MFC_INPUT_BUFFER_NUM_MAX;
808 }
809
810 /* should be done before prepare input buffer */
811 if (pInbufOps->Enable_Cacheable(hMFCHandle) != VIDEO_ERROR_NONE) {
812 ret = OMX_ErrorInsufficientResources;
813 goto EXIT;
814 }
815
816 /* set input buffer geometry */
817 if (pInbufOps->Set_Geometry(hMFCHandle, &bufferConf) != VIDEO_ERROR_NONE) {
818 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to set geometry for input buffer");
819 ret = OMX_ErrorInsufficientResources;
820 goto EXIT;
821 }
822
823 /* setup input buffer */
824 if (pInbufOps->Setup(hMFCHandle, inputBufferNumber) != VIDEO_ERROR_NONE) {
825 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to setup input buffer");
826 ret = OMX_ErrorInsufficientResources;
827 goto EXIT;
828 }
829
830 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
831 ret = Mpeg4CodecRegistCodecBuffers(pOMXComponent, INPUT_PORT_INDEX, MFC_INPUT_BUFFER_NUM_MAX);
832 if (ret != OMX_ErrorNone)
833 goto EXIT;
834 } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
835 /* Register input buffer */
836 for (i = 0; i < pExynosInputPort->portDefinition.nBufferCountActual; i++) {
837 ExynosVideoPlane plane;
838 plane.addr = pExynosInputPort->extendBufferHeader[i].OMXBufferHeader->pBuffer;
839 plane.allocSize = pExynosInputPort->extendBufferHeader[i].OMXBufferHeader->nAllocLen;
840 plane.fd = pExynosInputPort->extendBufferHeader[i].buf_fd[0];
841 if (pInbufOps->Register(hMFCHandle, &plane, MFC_INPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
842 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register input buffer");
843 ret = OMX_ErrorInsufficientResources;
844 goto EXIT;
845 }
846 }
847 }
848
849 /* set output geometry */
850 Exynos_OSAL_Memset(&bufferConf, 0, sizeof(bufferConf));
851 pMpeg4Dec->hMFCMpeg4Handle.MFCOutputColorType = bufferConf.eColorFormat = VIDEO_COLORFORMAT_NV12_TILED;
852 if (pOutbufOps->Set_Geometry(hMFCHandle, &bufferConf) != VIDEO_ERROR_NONE) {
853 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to set geometry for output buffer");
854 ret = OMX_ErrorInsufficientResources;
855 goto EXIT;
856 }
857
858 /* input buffer enqueue for header parsing */
859 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "oneFrameSize: %d", oneFrameSize);
860 if (pInbufOps->Enqueue(hMFCHandle, (unsigned char **)&pSrcInputData->buffer.singlePlaneBuffer.dataBuffer,
861 (unsigned int *)&oneFrameSize, MFC_INPUT_BUFFER_PLANE, pSrcInputData->bufferHeader) != VIDEO_ERROR_NONE) {
862 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to enqueue input buffer for header parsing");
863 // ret = OMX_ErrorInsufficientResources;
864 ret = (OMX_ERRORTYPE)OMX_ErrorCodecInit;
865 goto EXIT;
866 }
867
868 /* start header parsing */
869 if (pInbufOps->Run(hMFCHandle) != VIDEO_ERROR_NONE) {
870 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to run input buffer for header parsing");
871 ret = OMX_ErrorCodecInit;
872 goto EXIT;
873 }
874
875 /* get geometry for output */
876 Exynos_OSAL_Memset(&pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf, 0, sizeof(ExynosVideoGeometry));
877 if (pOutbufOps->Get_Geometry(hMFCHandle, &pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf) != VIDEO_ERROR_NONE) {
878 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get geometry for parsed header info");
879 ret = OMX_ErrorInsufficientResources;
880 goto EXIT;
881 }
882
883 /* get dpb count */
884 pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum = pDecOps->Get_ActualBufferCount(hMFCHandle);
885 if (pVideoDec->bThumbnailMode == OMX_FALSE)
886 pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum += EXTRA_DPB_NUM;
887 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Mpeg4CodecSetup nOutbufs: %d", pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum);
888
889 pMpeg4Dec->hMFCMpeg4Handle.bConfiguredMFCSrc = OMX_TRUE;
890
891 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
892 if ((pExynosInputPort->portDefinition.format.video.nFrameWidth != pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameWidth) ||
893 (pExynosInputPort->portDefinition.format.video.nFrameHeight != pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameHeight)) {
894 pExynosOutputPort->exceptionFlag = NEED_PORT_DISABLE;
895
896 pExynosInputPort->portDefinition.format.video.nFrameWidth = pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameWidth;
897 pExynosInputPort->portDefinition.format.video.nFrameHeight = pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameHeight;
898 pExynosInputPort->portDefinition.format.video.nStride = ((pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameWidth + 15) & (~15));
899 pExynosInputPort->portDefinition.format.video.nSliceHeight = ((pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameHeight + 15) & (~15));
900
901 Exynos_UpdateFrameSize(pOMXComponent);
902
903 /** Send Port Settings changed call back **/
904 (*(pExynosComponent->pCallbacks->EventHandler))
905 (pOMXComponent,
906 pExynosComponent->callbackData,
907 OMX_EventPortSettingsChanged, /* The command was completed */
908 OMX_DirOutput, /* This is the port index */
909 0,
910 NULL);
911 }
912 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
913 if ((pExynosInputPort->portDefinition.format.video.nFrameWidth != pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameWidth) ||
914 (pExynosInputPort->portDefinition.format.video.nFrameHeight != pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameHeight) ||
915 (pExynosOutputPort->portDefinition.nBufferCountActual != pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum)) {
916 pExynosOutputPort->exceptionFlag = NEED_PORT_DISABLE;
917
918 pExynosInputPort->portDefinition.format.video.nFrameWidth = pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameWidth;
919 pExynosInputPort->portDefinition.format.video.nFrameHeight = pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameHeight;
920 pExynosInputPort->portDefinition.format.video.nStride = ((pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameWidth + 15) & (~15));
921 pExynosInputPort->portDefinition.format.video.nSliceHeight = ((pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameHeight + 15) & (~15));
922
923 pExynosOutputPort->portDefinition.nBufferCountActual = pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum - 2;
924 pExynosOutputPort->portDefinition.nBufferCountMin = pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum - 2;
925
926 Exynos_UpdateFrameSize(pOMXComponent);
927
928 /** Send Port Settings changed call back **/
929 (*(pExynosComponent->pCallbacks->EventHandler))
930 (pOMXComponent,
931 pExynosComponent->callbackData,
932 OMX_EventPortSettingsChanged, /* The command was completed */
933 OMX_DirOutput, /* This is the port index */
934 0,
935 NULL);
936 }
937 }
938 Exynos_OSAL_SleepMillisec(0);
939 ret = OMX_ErrorInputDataDecodeYet;
940 Mpeg4CodecStop(pOMXComponent, INPUT_PORT_INDEX);
941
942 EXIT:
943 FunctionOut();
944
945 return ret;
946 }
947
948 OMX_ERRORTYPE Mpeg4CodecDstSetup(OMX_COMPONENTTYPE *pOMXComponent)
949 {
950 OMX_ERRORTYPE ret = OMX_ErrorNone;
951 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
952 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
953 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
954 void *hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
955 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
956 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
957
958 ExynosVideoDecOps *pDecOps = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
959 ExynosVideoDecBufferOps *pInbufOps = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
960 ExynosVideoDecBufferOps *pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
961
962 int i, nOutbufs;
963
964 OMX_U32 nAllocLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
965 OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
966
967 FunctionIn();
968
969 nAllocLen[0] = pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nAlignPlaneSize[0];
970 nAllocLen[1] = pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nAlignPlaneSize[1];
971
972 pOutbufOps->Set_Shareable(hMFCHandle);
973
974 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
975 /* should be done before prepare output buffer */
976 if (pOutbufOps->Enable_Cacheable(hMFCHandle) != VIDEO_ERROR_NONE) {
977 ret = OMX_ErrorInsufficientResources;
978 goto EXIT;
979 }
980
981 /* get dpb count */
982 nOutbufs = pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum;
983 if (pOutbufOps->Setup(hMFCHandle, nOutbufs) != VIDEO_ERROR_NONE) {
984 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to setup output buffer");
985 ret = OMX_ErrorInsufficientResources;
986 goto EXIT;
987 }
988
989 ret = Exynos_Allocate_CodecBuffers(pOMXComponent, OUTPUT_PORT_INDEX, nOutbufs, nAllocLen);
990 if (ret != OMX_ErrorNone)
991 goto EXIT;
992
993 ret = Mpeg4CodecRegistCodecBuffers(pOMXComponent, OUTPUT_PORT_INDEX, nOutbufs);
994 if (ret != OMX_ErrorNone)
995 goto EXIT;
996
997 /* Enqueue output buffer */
998 for (i = 0; i < nOutbufs; i++) {
999 pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr,
1000 (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
1001 }
1002 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1003 ExynosVideoPlane planes[MFC_OUTPUT_BUFFER_PLANE];
1004 int plane;
1005
1006 /* get dpb count */
1007 nOutbufs = pExynosOutputPort->portDefinition.nBufferCountActual;
1008 if (pOutbufOps->Setup(hMFCHandle, nOutbufs) != VIDEO_ERROR_NONE) {
1009 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to setup output buffer");
1010 ret = OMX_ErrorInsufficientResources;
1011 goto EXIT;
1012 }
1013
1014 /* Register output buffer */
1015 /*************/
1016 /* TBD */
1017 /*************/
1018 #ifdef USE_ANB
1019 if (pExynosOutputPort->bIsANBEnabled == OMX_TRUE) {
1020 for (i = 0; i < pExynosOutputPort->assignedBufferNum; i++) {
1021 for (plane = 0; plane < MFC_OUTPUT_BUFFER_PLANE; plane++) {
1022 planes[plane].fd = pExynosOutputPort->extendBufferHeader[i].buf_fd[plane];
1023 planes[plane].addr = pExynosOutputPort->extendBufferHeader[i].pYUVBuf[plane];
1024 planes[plane].allocSize = nAllocLen[plane];
1025 }
1026
1027 if (pOutbufOps->Register(hMFCHandle, planes, MFC_OUTPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
1028 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register output buffer");
1029 ret = OMX_ErrorInsufficientResources;
1030 goto EXIT;
1031 }
1032 pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pExynosOutputPort->extendBufferHeader[i].pYUVBuf,
1033 (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
1034 }
1035 } else {
1036 ret = OMX_ErrorNotImplemented;
1037 goto EXIT;
1038 }
1039 #else
1040 ret = OMX_ErrorNotImplemented;
1041 goto EXIT;
1042 #endif
1043 }
1044
1045 if (pOutbufOps->Run(hMFCHandle) != VIDEO_ERROR_NONE) {
1046 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to run output buffer");
1047 ret = OMX_ErrorInsufficientResources;
1048 goto EXIT;
1049 }
1050
1051 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1052 Mpeg4CodecStop(pOMXComponent, OUTPUT_PORT_INDEX);
1053 }
1054 pMpeg4Dec->hMFCMpeg4Handle.bConfiguredMFCDst = OMX_TRUE;
1055
1056 ret = OMX_ErrorNone;
1057
1058 EXIT:
1059 FunctionOut();
1060
1061 return ret;
1062 }
1063
1064 OMX_ERRORTYPE Exynos_Mpeg4Dec_GetParameter(
1065 OMX_IN OMX_HANDLETYPE hComponent,
1066 OMX_IN OMX_INDEXTYPE nParamIndex,
1067 OMX_INOUT OMX_PTR pComponentParameterStructure)
1068 {
1069 OMX_ERRORTYPE ret = OMX_ErrorNone;
1070 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1071 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1072
1073 FunctionIn();
1074
1075 if (hComponent == NULL || pComponentParameterStructure == NULL) {
1076 ret = OMX_ErrorBadParameter;
1077 goto EXIT;
1078 }
1079 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1080 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1081 if (ret != OMX_ErrorNone) {
1082 goto EXIT;
1083 }
1084 if (pOMXComponent->pComponentPrivate == NULL) {
1085 ret = OMX_ErrorBadParameter;
1086 goto EXIT;
1087 }
1088
1089 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1090 if (pExynosComponent->currentState == OMX_StateInvalid ) {
1091 ret = OMX_ErrorInvalidState;
1092 goto EXIT;
1093 }
1094
1095 switch (nParamIndex) {
1096 case OMX_IndexParamVideoMpeg4:
1097 {
1098 OMX_VIDEO_PARAM_MPEG4TYPE *pDstMpeg4Param = (OMX_VIDEO_PARAM_MPEG4TYPE *)pComponentParameterStructure;
1099 OMX_VIDEO_PARAM_MPEG4TYPE *pSrcMpeg4Param = NULL;
1100 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = NULL;
1101
1102 ret = Exynos_OMX_Check_SizeVersion(pDstMpeg4Param, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
1103 if (ret != OMX_ErrorNone) {
1104 goto EXIT;
1105 }
1106
1107 if (pDstMpeg4Param->nPortIndex >= ALL_PORT_NUM) {
1108 ret = OMX_ErrorBadPortIndex;
1109 goto EXIT;
1110 }
1111
1112 pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1113 pSrcMpeg4Param = &pMpeg4Dec->mpeg4Component[pDstMpeg4Param->nPortIndex];
1114
1115 Exynos_OSAL_Memcpy(pDstMpeg4Param, pSrcMpeg4Param, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
1116 }
1117 break;
1118 case OMX_IndexParamVideoH263:
1119 {
1120 OMX_VIDEO_PARAM_H263TYPE *pDstH263Param = (OMX_VIDEO_PARAM_H263TYPE *)pComponentParameterStructure;
1121 OMX_VIDEO_PARAM_H263TYPE *pSrcH263Param = NULL;
1122 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = NULL;
1123
1124 ret = Exynos_OMX_Check_SizeVersion(pDstH263Param, sizeof(OMX_VIDEO_PARAM_H263TYPE));
1125 if (ret != OMX_ErrorNone) {
1126 goto EXIT;
1127 }
1128
1129 if (pDstH263Param->nPortIndex >= ALL_PORT_NUM) {
1130 ret = OMX_ErrorBadPortIndex;
1131 goto EXIT;
1132 }
1133
1134 pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1135 pSrcH263Param = &pMpeg4Dec->h263Component[pDstH263Param->nPortIndex];
1136
1137 Exynos_OSAL_Memcpy(pDstH263Param, pSrcH263Param, sizeof(OMX_VIDEO_PARAM_H263TYPE));
1138 }
1139 break;
1140 case OMX_IndexParamStandardComponentRole:
1141 {
1142 OMX_S32 codecType;
1143 OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE *)pComponentParameterStructure;
1144
1145 ret = Exynos_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1146 if (ret != OMX_ErrorNone) {
1147 goto EXIT;
1148 }
1149
1150 codecType = ((EXYNOS_MPEG4DEC_HANDLE *)(((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle))->hMFCMpeg4Handle.codecType;
1151 if (codecType == CODEC_TYPE_MPEG4)
1152 Exynos_OSAL_Strcpy((char *)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_MPEG4_DEC_ROLE);
1153 else
1154 Exynos_OSAL_Strcpy((char *)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_H263_DEC_ROLE);
1155 }
1156 break;
1157 case OMX_IndexParamVideoProfileLevelQuerySupported:
1158 {
1159 OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
1160 EXYNOS_OMX_VIDEO_PROFILELEVEL *pProfileLevel = NULL;
1161 OMX_U32 maxProfileLevelNum = 0;
1162 OMX_S32 codecType;
1163
1164 ret = Exynos_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
1165 if (ret != OMX_ErrorNone) {
1166 goto EXIT;
1167 }
1168
1169 if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
1170 ret = OMX_ErrorBadPortIndex;
1171 goto EXIT;
1172 }
1173
1174 codecType = ((EXYNOS_MPEG4DEC_HANDLE *)(((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle))->hMFCMpeg4Handle.codecType;
1175 if (codecType == CODEC_TYPE_MPEG4) {
1176 pProfileLevel = supportedMPEG4ProfileLevels;
1177 maxProfileLevelNum = sizeof(supportedMPEG4ProfileLevels) / sizeof(EXYNOS_OMX_VIDEO_PROFILELEVEL);
1178 } else {
1179 pProfileLevel = supportedH263ProfileLevels;
1180 maxProfileLevelNum = sizeof(supportedH263ProfileLevels) / sizeof(EXYNOS_OMX_VIDEO_PROFILELEVEL);
1181 }
1182
1183 if (pDstProfileLevel->nProfileIndex >= maxProfileLevelNum) {
1184 ret = OMX_ErrorNoMore;
1185 goto EXIT;
1186 }
1187
1188 pProfileLevel += pDstProfileLevel->nProfileIndex;
1189 pDstProfileLevel->eProfile = pProfileLevel->profile;
1190 pDstProfileLevel->eLevel = pProfileLevel->level;
1191 }
1192 break;
1193 case OMX_IndexParamVideoProfileLevelCurrent:
1194 {
1195 OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
1196 OMX_VIDEO_PARAM_MPEG4TYPE *pSrcMpeg4Param = NULL;
1197 OMX_VIDEO_PARAM_H263TYPE *pSrcH263Param = NULL;
1198 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = NULL;
1199 OMX_S32 codecType;
1200
1201 ret = Exynos_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
1202 if (ret != OMX_ErrorNone) {
1203 goto EXIT;
1204 }
1205
1206 if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
1207 ret = OMX_ErrorBadPortIndex;
1208 goto EXIT;
1209 }
1210
1211 pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1212 codecType = pMpeg4Dec->hMFCMpeg4Handle.codecType;
1213 if (codecType == CODEC_TYPE_MPEG4) {
1214 pSrcMpeg4Param = &pMpeg4Dec->mpeg4Component[pDstProfileLevel->nPortIndex];
1215 pDstProfileLevel->eProfile = pSrcMpeg4Param->eProfile;
1216 pDstProfileLevel->eLevel = pSrcMpeg4Param->eLevel;
1217 } else {
1218 pSrcH263Param = &pMpeg4Dec->h263Component[pDstProfileLevel->nPortIndex];
1219 pDstProfileLevel->eProfile = pSrcH263Param->eProfile;
1220 pDstProfileLevel->eLevel = pSrcH263Param->eLevel;
1221 }
1222 }
1223 break;
1224 case OMX_IndexParamVideoErrorCorrection:
1225 {
1226 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
1227 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = NULL;
1228 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = NULL;
1229
1230 ret = Exynos_OMX_Check_SizeVersion(pDstErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
1231 if (ret != OMX_ErrorNone) {
1232 goto EXIT;
1233 }
1234
1235 if (pDstErrorCorrectionType->nPortIndex != INPUT_PORT_INDEX) {
1236 ret = OMX_ErrorBadPortIndex;
1237 goto EXIT;
1238 }
1239
1240 pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1241 pSrcErrorCorrectionType = &pMpeg4Dec->errorCorrectionType[INPUT_PORT_INDEX];
1242
1243 pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
1244 pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
1245 pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
1246 pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
1247 pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
1248 }
1249 break;
1250 default:
1251 ret = Exynos_OMX_VideoDecodeGetParameter(hComponent, nParamIndex, pComponentParameterStructure);
1252 break;
1253 }
1254 EXIT:
1255 FunctionOut();
1256
1257 return ret;
1258 }
1259
1260 OMX_ERRORTYPE Exynos_Mpeg4Dec_SetParameter(
1261 OMX_IN OMX_HANDLETYPE hComponent,
1262 OMX_IN OMX_INDEXTYPE nIndex,
1263 OMX_IN OMX_PTR pComponentParameterStructure)
1264 {
1265 OMX_ERRORTYPE ret = OMX_ErrorNone;
1266 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1267 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1268
1269 FunctionIn();
1270
1271 if (hComponent == NULL || pComponentParameterStructure == NULL) {
1272 ret = OMX_ErrorBadParameter;
1273 goto EXIT;
1274 }
1275 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1276 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1277 if (ret != OMX_ErrorNone) {
1278 goto EXIT;
1279 }
1280 if (pOMXComponent->pComponentPrivate == NULL) {
1281 ret = OMX_ErrorBadParameter;
1282 goto EXIT;
1283 }
1284
1285 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1286 if (pExynosComponent->currentState == OMX_StateInvalid ) {
1287 ret = OMX_ErrorInvalidState;
1288 goto EXIT;
1289 }
1290
1291 switch (nIndex) {
1292 case OMX_IndexParamVideoMpeg4:
1293 {
1294 OMX_VIDEO_PARAM_MPEG4TYPE *pDstMpeg4Param = NULL;
1295 OMX_VIDEO_PARAM_MPEG4TYPE *pSrcMpeg4Param = (OMX_VIDEO_PARAM_MPEG4TYPE *)pComponentParameterStructure;
1296 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = NULL;
1297
1298 ret = Exynos_OMX_Check_SizeVersion(pSrcMpeg4Param, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
1299 if (ret != OMX_ErrorNone) {
1300 goto EXIT;
1301 }
1302
1303 if (pSrcMpeg4Param->nPortIndex >= ALL_PORT_NUM) {
1304 ret = OMX_ErrorBadPortIndex;
1305 goto EXIT;
1306 }
1307
1308 pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1309 pDstMpeg4Param = &pMpeg4Dec->mpeg4Component[pSrcMpeg4Param->nPortIndex];
1310
1311 Exynos_OSAL_Memcpy(pDstMpeg4Param, pSrcMpeg4Param, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
1312 }
1313 break;
1314 case OMX_IndexParamVideoH263:
1315 {
1316 OMX_VIDEO_PARAM_H263TYPE *pDstH263Param = NULL;
1317 OMX_VIDEO_PARAM_H263TYPE *pSrcH263Param = (OMX_VIDEO_PARAM_H263TYPE *)pComponentParameterStructure;
1318 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = NULL;
1319
1320 ret = Exynos_OMX_Check_SizeVersion(pSrcH263Param, sizeof(OMX_VIDEO_PARAM_H263TYPE));
1321 if (ret != OMX_ErrorNone) {
1322 goto EXIT;
1323 }
1324
1325 if (pSrcH263Param->nPortIndex >= ALL_PORT_NUM) {
1326 ret = OMX_ErrorBadPortIndex;
1327 goto EXIT;
1328 }
1329
1330 pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1331 pDstH263Param = &pMpeg4Dec->h263Component[pSrcH263Param->nPortIndex];
1332
1333 Exynos_OSAL_Memcpy(pDstH263Param, pSrcH263Param, sizeof(OMX_VIDEO_PARAM_H263TYPE));
1334 }
1335 break;
1336 case OMX_IndexParamStandardComponentRole:
1337 {
1338 OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE*)pComponentParameterStructure;
1339
1340 ret = Exynos_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1341 if (ret != OMX_ErrorNone) {
1342 goto EXIT;
1343 }
1344
1345 if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1346 ret = OMX_ErrorIncorrectStateOperation;
1347 goto EXIT;
1348 }
1349
1350 if (!Exynos_OSAL_Strcmp((char*)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_MPEG4_DEC_ROLE)) {
1351 pExynosComponent->pExynosPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
1352 } else if (!Exynos_OSAL_Strcmp((char*)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_H263_DEC_ROLE)) {
1353 pExynosComponent->pExynosPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingH263;
1354 } else {
1355 ret = OMX_ErrorBadParameter;
1356 goto EXIT;
1357 }
1358 }
1359 break;
1360 case OMX_IndexParamVideoProfileLevelCurrent:
1361 {
1362 OMX_VIDEO_PARAM_PROFILELEVELTYPE *pSrcProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
1363 OMX_VIDEO_PARAM_MPEG4TYPE *pDstMpeg4Param = NULL;
1364 OMX_VIDEO_PARAM_H263TYPE *pDstH263Param = NULL;
1365 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = NULL;
1366 OMX_S32 codecType;
1367
1368 ret = Exynos_OMX_Check_SizeVersion(pSrcProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
1369 if (ret != OMX_ErrorNone)
1370 goto EXIT;
1371
1372 if (pSrcProfileLevel->nPortIndex >= ALL_PORT_NUM) {
1373 ret = OMX_ErrorBadPortIndex;
1374 goto EXIT;
1375 }
1376
1377 pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1378 codecType = pMpeg4Dec->hMFCMpeg4Handle.codecType;
1379 if (codecType == CODEC_TYPE_MPEG4) {
1380 /*
1381 * To do: Check validity of profile & level parameters
1382 */
1383
1384 pDstMpeg4Param = &pMpeg4Dec->mpeg4Component[pSrcProfileLevel->nPortIndex];
1385 pDstMpeg4Param->eProfile = pSrcProfileLevel->eProfile;
1386 pDstMpeg4Param->eLevel = pSrcProfileLevel->eLevel;
1387 } else {
1388 /*
1389 * To do: Check validity of profile & level parameters
1390 */
1391
1392 pDstH263Param = &pMpeg4Dec->h263Component[pSrcProfileLevel->nPortIndex];
1393 pDstH263Param->eProfile = pSrcProfileLevel->eProfile;
1394 pDstH263Param->eLevel = pSrcProfileLevel->eLevel;
1395 }
1396 }
1397 break;
1398 case OMX_IndexParamVideoErrorCorrection:
1399 {
1400 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
1401 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = NULL;
1402 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = NULL;
1403
1404 ret = Exynos_OMX_Check_SizeVersion(pSrcErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
1405 if (ret != OMX_ErrorNone) {
1406 goto EXIT;
1407 }
1408
1409 if (pSrcErrorCorrectionType->nPortIndex != INPUT_PORT_INDEX) {
1410 ret = OMX_ErrorBadPortIndex;
1411 goto EXIT;
1412 }
1413
1414 pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1415 pDstErrorCorrectionType = &pMpeg4Dec->errorCorrectionType[INPUT_PORT_INDEX];
1416
1417 pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
1418 pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
1419 pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
1420 pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
1421 pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
1422 }
1423 break;
1424 default:
1425 ret = Exynos_OMX_VideoDecodeSetParameter(hComponent, nIndex, pComponentParameterStructure);
1426 break;
1427 }
1428 EXIT:
1429 FunctionOut();
1430
1431 return ret;
1432 }
1433
1434 OMX_ERRORTYPE Exynos_Mpeg4Dec_GetConfig(
1435 OMX_IN OMX_HANDLETYPE hComponent,
1436 OMX_IN OMX_INDEXTYPE nIndex,
1437 OMX_IN OMX_PTR pComponentConfigStructure)
1438 {
1439 OMX_ERRORTYPE ret = OMX_ErrorNone;
1440 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1441 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1442
1443 FunctionIn();
1444
1445 if (hComponent == NULL || pComponentConfigStructure == NULL) {
1446 ret = OMX_ErrorBadParameter;
1447 goto EXIT;
1448 }
1449 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1450 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1451 if (ret != OMX_ErrorNone) {
1452 goto EXIT;
1453 }
1454 if (pOMXComponent->pComponentPrivate == NULL) {
1455 ret = OMX_ErrorBadParameter;
1456 goto EXIT;
1457 }
1458 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1459 if (pExynosComponent->currentState == OMX_StateInvalid) {
1460 ret = OMX_ErrorInvalidState;
1461 goto EXIT;
1462 }
1463
1464 switch (nIndex) {
1465 default:
1466 ret = Exynos_OMX_VideoDecodeGetConfig(hComponent, nIndex, pComponentConfigStructure);
1467 break;
1468 }
1469
1470 EXIT:
1471 FunctionOut();
1472
1473 return ret;
1474 }
1475
1476 OMX_ERRORTYPE Exynos_Mpeg4Dec_SetConfig(
1477 OMX_IN OMX_HANDLETYPE hComponent,
1478 OMX_IN OMX_INDEXTYPE nIndex,
1479 OMX_IN OMX_PTR pComponentConfigStructure)
1480 {
1481 OMX_ERRORTYPE ret = OMX_ErrorNone;
1482 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1483 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1484
1485 FunctionIn();
1486
1487 if (hComponent == NULL || pComponentConfigStructure == NULL) {
1488 ret = OMX_ErrorBadParameter;
1489 goto EXIT;
1490 }
1491 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1492 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1493 if (ret != OMX_ErrorNone) {
1494 goto EXIT;
1495 }
1496 if (pOMXComponent->pComponentPrivate == NULL) {
1497 ret = OMX_ErrorBadParameter;
1498 goto EXIT;
1499 }
1500 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1501 if (pExynosComponent->currentState == OMX_StateInvalid) {
1502 ret = OMX_ErrorInvalidState;
1503 goto EXIT;
1504 }
1505
1506 switch (nIndex) {
1507 default:
1508 ret = Exynos_OMX_VideoDecodeSetConfig(hComponent, nIndex, pComponentConfigStructure);
1509 break;
1510 }
1511
1512 EXIT:
1513 FunctionOut();
1514
1515 return ret;
1516 }
1517
1518 OMX_ERRORTYPE Exynos_Mpeg4Dec_GetExtensionIndex(
1519 OMX_IN OMX_HANDLETYPE hComponent,
1520 OMX_IN OMX_STRING cParameterName,
1521 OMX_OUT OMX_INDEXTYPE *pIndexType)
1522 {
1523 OMX_ERRORTYPE ret = OMX_ErrorNone;
1524 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1525 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1526
1527 FunctionIn();
1528
1529 if (hComponent == NULL) {
1530 ret = OMX_ErrorBadParameter;
1531 goto EXIT;
1532 }
1533 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1534 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1535 if (ret != OMX_ErrorNone) {
1536 goto EXIT;
1537 }
1538 if (pOMXComponent->pComponentPrivate == NULL) {
1539 ret = OMX_ErrorBadParameter;
1540 goto EXIT;
1541 }
1542 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1543 if ((cParameterName == NULL) || (pIndexType == NULL)) {
1544 ret = OMX_ErrorBadParameter;
1545 goto EXIT;
1546 }
1547 if (pExynosComponent->currentState == OMX_StateInvalid) {
1548 ret = OMX_ErrorInvalidState;
1549 goto EXIT;
1550 }
1551
1552 if (Exynos_OSAL_Strcmp(cParameterName, EXYNOS_INDEX_PARAM_ENABLE_THUMBNAIL) == 0) {
1553 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1554 *pIndexType = OMX_IndexVendorThumbnailMode;
1555 ret = OMX_ErrorNone;
1556 } else {
1557 ret = Exynos_OMX_VideoDecodeGetExtensionIndex(hComponent, cParameterName, pIndexType);
1558 }
1559
1560 EXIT:
1561 FunctionOut();
1562
1563 return ret;
1564 }
1565
1566 OMX_ERRORTYPE Exynos_Mpeg4Dec_ComponentRoleEnum(
1567 OMX_IN OMX_HANDLETYPE hComponent,
1568 OMX_OUT OMX_U8 *cRole,
1569 OMX_IN OMX_U32 nIndex)
1570 {
1571 OMX_ERRORTYPE ret = OMX_ErrorNone;
1572 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1573 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1574 OMX_S32 codecType;
1575
1576 FunctionIn();
1577
1578 if ((hComponent == NULL) || (cRole == NULL)) {
1579 ret = OMX_ErrorBadParameter;
1580 goto EXIT;
1581 }
1582 if (nIndex != (MAX_COMPONENT_ROLE_NUM - 1)) {
1583 ret = OMX_ErrorNoMore;
1584 goto EXIT;
1585 }
1586 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1587 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1588 if (ret != OMX_ErrorNone) {
1589 goto EXIT;
1590 }
1591 if (pOMXComponent->pComponentPrivate == NULL) {
1592 ret = OMX_ErrorBadParameter;
1593 goto EXIT;
1594 }
1595 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1596 if (pExynosComponent->currentState == OMX_StateInvalid ) {
1597 ret = OMX_ErrorInvalidState;
1598 goto EXIT;
1599 }
1600
1601 codecType = ((EXYNOS_MPEG4DEC_HANDLE *)(((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle))->hMFCMpeg4Handle.codecType;
1602 if (codecType == CODEC_TYPE_MPEG4)
1603 Exynos_OSAL_Strcpy((char *)cRole, EXYNOS_OMX_COMPONENT_MPEG4_DEC_ROLE);
1604 else
1605 Exynos_OSAL_Strcpy((char *)cRole, EXYNOS_OMX_COMPONENT_H263_DEC_ROLE);
1606
1607 EXIT:
1608 FunctionOut();
1609
1610 return ret;
1611 }
1612
1613 /* MFC Init */
1614 OMX_ERRORTYPE Exynos_Mpeg4Dec_Init(OMX_COMPONENTTYPE *pOMXComponent)
1615 {
1616 OMX_ERRORTYPE ret = OMX_ErrorNone;
1617 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1618 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1619 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1620 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1621 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)pVideoDec->hCodecHandle;
1622 OMX_PTR hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
1623
1624 ExynosVideoDecOps *pDecOps = NULL;
1625 ExynosVideoDecBufferOps *pInbufOps = NULL;
1626 ExynosVideoDecBufferOps *pOutbufOps = NULL;
1627
1628 CSC_METHOD csc_method = CSC_METHOD_SW;
1629 int i, plane;
1630
1631 FunctionIn();
1632
1633 pMpeg4Dec->hMFCMpeg4Handle.bConfiguredMFCSrc = OMX_FALSE;
1634 pMpeg4Dec->hMFCMpeg4Handle.bConfiguredMFCDst = OMX_FALSE;
1635 pExynosComponent->bUseFlagEOF = OMX_TRUE;
1636 pExynosComponent->bSaveFlagEOS = OMX_FALSE;
1637
1638 /* Mpeg4 Codec Open */
1639 ret = Mpeg4CodecOpen(pMpeg4Dec);
1640 if (ret != OMX_ErrorNone) {
1641 goto EXIT;
1642 }
1643
1644 pDecOps = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
1645 pInbufOps = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
1646 pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
1647
1648 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
1649 OMX_U32 nPlaneSize[MFC_INPUT_BUFFER_PLANE] = {DEFAULT_MFC_INPUT_BUFFER_SIZE};
1650 Exynos_OSAL_SemaphoreCreate(&pExynosInputPort->codecSemID);
1651 Exynos_OSAL_QueueCreate(&pExynosInputPort->codecBufferQ, MAX_QUEUE_ELEMENTS);
1652 ret = Exynos_Allocate_CodecBuffers(pOMXComponent, INPUT_PORT_INDEX, MFC_INPUT_BUFFER_NUM_MAX, nPlaneSize);
1653 if (ret != OMX_ErrorNone)
1654 goto EXIT;
1655
1656 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++)
1657 Exynos_CodecBufferEnQueue(pExynosComponent, INPUT_PORT_INDEX, pVideoDec->pMFCDecInputBuffer[i]);
1658 } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
1659 /*************/
1660 /* TBD */
1661 /*************/
1662 /* Does not require any actions. */
1663 }
1664
1665 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1666 Exynos_OSAL_SemaphoreCreate(&pExynosOutputPort->codecSemID);
1667 Exynos_OSAL_QueueCreate(&pExynosOutputPort->codecBufferQ, MAX_QUEUE_ELEMENTS);
1668 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1669 /*************/
1670 /* TBD */
1671 /*************/
1672 /* Does not require any actions. */
1673 }
1674
1675 pMpeg4Dec->bSourceStart = OMX_FALSE;
1676 Exynos_OSAL_SignalCreate(&pMpeg4Dec->hSourceStartEvent);
1677 pMpeg4Dec->bDestinationStart = OMX_FALSE;
1678 Exynos_OSAL_SignalCreate(&pMpeg4Dec->hDestinationStartEvent);
1679
1680 Exynos_OSAL_Memset(pExynosComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
1681 Exynos_OSAL_Memset(pExynosComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
1682 pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp = 0;
1683 pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp = 0;
1684
1685 pExynosComponent->getAllDelayBuffer = OMX_FALSE;
1686
1687 #ifdef USE_CSC_HW
1688 csc_method = CSC_METHOD_HW;
1689 #endif
1690 pVideoDec->csc_handle = csc_init(csc_method);
1691 if (pVideoDec->csc_handle == NULL) {
1692 ret = OMX_ErrorInsufficientResources;
1693 goto EXIT;
1694 }
1695 pVideoDec->csc_set_format = OMX_FALSE;
1696
1697 EXIT:
1698 FunctionOut();
1699
1700 return ret;
1701 }
1702
1703 /* MFC Terminate */
1704 OMX_ERRORTYPE Exynos_Mpeg4Dec_Terminate(OMX_COMPONENTTYPE *pOMXComponent)
1705 {
1706 OMX_ERRORTYPE ret = OMX_ErrorNone;
1707 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1708 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1709 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1710 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1711 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1712 OMX_PTR hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
1713
1714 ExynosVideoDecOps *pDecOps = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
1715 ExynosVideoDecBufferOps *pInbufOps = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
1716 ExynosVideoDecBufferOps *pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
1717
1718 int i, plane;
1719
1720 FunctionIn();
1721
1722 if (pVideoDec->csc_handle != NULL) {
1723 csc_deinit(pVideoDec->csc_handle);
1724 pVideoDec->csc_handle = NULL;
1725 }
1726
1727 Exynos_OSAL_SignalTerminate(pMpeg4Dec->hDestinationStartEvent);
1728 pMpeg4Dec->hDestinationStartEvent = NULL;
1729 pMpeg4Dec->bDestinationStart = OMX_FALSE;
1730 Exynos_OSAL_SignalTerminate(pMpeg4Dec->hSourceStartEvent);
1731 pMpeg4Dec->hSourceStartEvent = NULL;
1732 pMpeg4Dec->bSourceStart = OMX_FALSE;
1733
1734 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1735 Exynos_Free_CodecBuffers(pOMXComponent, OUTPUT_PORT_INDEX);
1736 Exynos_OSAL_QueueTerminate(&pExynosOutputPort->codecBufferQ);
1737 Exynos_OSAL_SemaphoreTerminate(pExynosOutputPort->codecSemID);
1738 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1739 /*************/
1740 /* TBD */
1741 /*************/
1742 /* Does not require any actions. */
1743 }
1744
1745 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
1746 Exynos_Free_CodecBuffers(pOMXComponent, INPUT_PORT_INDEX);
1747 Exynos_OSAL_QueueTerminate(&pExynosInputPort->codecBufferQ);
1748 Exynos_OSAL_SemaphoreTerminate(pExynosInputPort->codecSemID);
1749 } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
1750 /*************/
1751 /* TBD */
1752 /*************/
1753 /* Does not require any actions. */
1754 }
1755 Mpeg4CodecClose(pMpeg4Dec);
1756
1757 EXIT:
1758 FunctionOut();
1759
1760 return ret;
1761 }
1762
1763 OMX_ERRORTYPE Exynos_Mpeg4Dec_SrcIn(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
1764 {
1765 OMX_ERRORTYPE ret = OMX_ErrorNone;
1766 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1767 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1768 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1769 void *hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
1770 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1771 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1772 OMX_U32 oneFrameSize = pSrcInputData->dataLen;
1773 OMX_BOOL bInStartCode = OMX_FALSE;
1774 ExynosVideoDecOps *pDecOps = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
1775 ExynosVideoDecBufferOps *pInbufOps = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
1776 ExynosVideoDecBufferOps *pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
1777 ExynosVideoErrorType codecReturn = VIDEO_ERROR_NONE;
1778 int i;
1779
1780 FunctionIn();
1781
1782 if (pMpeg4Dec->hMFCMpeg4Handle.bConfiguredMFCSrc == OMX_FALSE) {
1783 ret = Mpeg4CodecSrcSetup(pOMXComponent, pSrcInputData);
1784 goto EXIT;
1785 }
1786 if (pMpeg4Dec->hMFCMpeg4Handle.bConfiguredMFCDst == OMX_FALSE) {
1787 ret = Mpeg4CodecDstSetup(pOMXComponent);
1788 }
1789
1790 if (((bInStartCode = Check_Stream_StartCode(pSrcInputData->buffer.singlePlaneBuffer.dataBuffer, oneFrameSize, pMpeg4Dec->hMFCMpeg4Handle.codecType)) == OMX_TRUE) ||
1791 ((pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)) {
1792 pExynosComponent->timeStamp[pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp] = pSrcInputData->timeStamp;
1793 pExynosComponent->nFlags[pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp] = pSrcInputData->nFlags;
1794 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "input timestamp %lld us (%.2f secs), Tag: %d, nFlags: 0x%x", pSrcInputData->timeStamp, pSrcInputData->timeStamp / 1E6, pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp, pSrcInputData->nFlags);
1795 pDecOps->Set_FrameTag(hMFCHandle, pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp);
1796 pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp++;
1797 pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp %= MAX_TIMESTAMP;
1798
1799 /* queue work for input buffer */
1800 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "oneFrameSize: %d, bufferHeader: 0x%x, dataBuffer: 0x%x", oneFrameSize, pSrcInputData->bufferHeader, pSrcInputData->buffer.singlePlaneBuffer.dataBuffer);
1801 codecReturn = pInbufOps->Enqueue(hMFCHandle, (unsigned char **)&pSrcInputData->buffer.singlePlaneBuffer.dataBuffer,
1802 (unsigned int *)&oneFrameSize, MFC_INPUT_BUFFER_PLANE, pSrcInputData->bufferHeader);
1803 if (codecReturn != VIDEO_ERROR_NONE) {
1804 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
1805 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s : %d", __FUNCTION__, __LINE__);
1806 goto EXIT;
1807 }
1808 Mpeg4CodecStart(pOMXComponent, INPUT_PORT_INDEX);
1809 if (pMpeg4Dec->bSourceStart == OMX_FALSE) {
1810 pMpeg4Dec->bSourceStart = OMX_TRUE;
1811 Exynos_OSAL_SignalSet(pMpeg4Dec->hSourceStartEvent);
1812 Exynos_OSAL_SleepMillisec(0);
1813 }
1814 if (pMpeg4Dec->bDestinationStart == OMX_FALSE) {
1815 pMpeg4Dec->bDestinationStart = OMX_TRUE;
1816 Exynos_OSAL_SignalSet(pMpeg4Dec->hDestinationStartEvent);
1817 Exynos_OSAL_SleepMillisec(0);
1818 }
1819 } else if (bInStartCode == OMX_FALSE) {
1820 ret = OMX_ErrorCorruptedFrame;
1821 goto EXIT;
1822 }
1823
1824 ret = OMX_ErrorNone;
1825
1826 EXIT:
1827 FunctionOut();
1828
1829 return ret;
1830 }
1831
1832 OMX_ERRORTYPE Exynos_Mpeg4Dec_SrcOut(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcOutputData)
1833 {
1834 OMX_ERRORTYPE ret = OMX_ErrorNone;
1835 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1836 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1837 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1838 void *hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
1839 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1840 ExynosVideoDecOps *pDecOps = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
1841 ExynosVideoDecBufferOps *pInbufOps = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
1842 ExynosVideoBuffer *pVideoBuffer;
1843
1844 FunctionIn();
1845
1846 pVideoBuffer = pInbufOps->Dequeue(hMFCHandle);
1847
1848 pSrcOutputData->dataLen = 0;
1849 pSrcOutputData->usedDataLen = 0;
1850 pSrcOutputData->remainDataLen = 0;
1851 pSrcOutputData->nFlags = 0;
1852 pSrcOutputData->timeStamp = 0;
1853
1854 if (pVideoBuffer == NULL) {
1855 pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer = NULL;
1856 pSrcOutputData->allocSize = 0;
1857 pSrcOutputData->pPrivate = NULL;
1858 pSrcOutputData->bufferHeader = NULL;
1859 } else {
1860 pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer = pVideoBuffer->planes[0].addr;
1861 pSrcOutputData->buffer.singlePlaneBuffer.fd = pVideoBuffer->planes[0].fd;
1862 pSrcOutputData->allocSize = pVideoBuffer->planes[0].allocSize;
1863
1864 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
1865 int i = 0;
1866 while (pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer != pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[0]) {
1867 if (i >= MFC_INPUT_BUFFER_NUM_MAX) {
1868 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Can not find buffer");
1869 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
1870 goto EXIT;
1871 }
1872 i++;
1873 }
1874 pVideoDec->pMFCDecInputBuffer[i]->dataSize = 0;
1875 pSrcOutputData->pPrivate = pVideoDec->pMFCDecInputBuffer[i];
1876 }
1877
1878 /* For Share Buffer */
1879 pSrcOutputData->bufferHeader = (OMX_BUFFERHEADERTYPE*)pVideoBuffer->pPrivate;
1880 }
1881
1882 ret = OMX_ErrorNone;
1883
1884 EXIT:
1885 FunctionOut();
1886
1887 return ret;
1888 }
1889
1890 OMX_ERRORTYPE Exynos_Mpeg4Dec_DstIn(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstInputData)
1891 {
1892 OMX_ERRORTYPE ret = OMX_ErrorNone;
1893 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1894 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1895 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1896 void *hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
1897 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1898 ExynosVideoDecOps *pDecOps = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
1899 ExynosVideoDecBufferOps *pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
1900 OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0,};
1901 ExynosVideoErrorType codecReturn = VIDEO_ERROR_NONE;
1902
1903 FunctionIn();
1904
1905 if (pDstInputData->buffer.multiPlaneBuffer.dataBuffer[0] == NULL) {
1906 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to find input buffer");
1907 ret = OMX_ErrorBadParameter;
1908 goto EXIT;
1909 }
1910
1911 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "%s : %d => ADDR[0]: 0x%x, ADDR[1]: 0x%x", __FUNCTION__, __LINE__,
1912 pDstInputData->buffer.multiPlaneBuffer.dataBuffer[0],
1913 pDstInputData->buffer.multiPlaneBuffer.dataBuffer[1]);
1914
1915 codecReturn = pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pDstInputData->buffer.multiPlaneBuffer.dataBuffer,
1916 (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, pDstInputData->bufferHeader);
1917
1918 if (codecReturn != VIDEO_ERROR_NONE) {
1919 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s : %d", __FUNCTION__, __LINE__);
1920 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
1921 goto EXIT;
1922 }
1923 Mpeg4CodecStart(pOMXComponent, OUTPUT_PORT_INDEX);
1924
1925 ret = OMX_ErrorNone;
1926
1927 EXIT:
1928 FunctionOut();
1929
1930 return ret;
1931 }
1932
1933 OMX_ERRORTYPE Exynos_Mpeg4Dec_DstOut(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstOutputData)
1934 {
1935 OMX_ERRORTYPE ret = OMX_ErrorNone;
1936 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1937 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1938 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1939 void *hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
1940 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1941 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1942 ExynosVideoDecOps *pDecOps = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
1943 ExynosVideoDecBufferOps *pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
1944 ExynosVideoBuffer *pVideoBuffer = NULL;
1945 ExynosVideoFrameStatusType displayStatus = VIDEO_FRAME_STATUS_UNKNOWN;
1946 ExynosVideoGeometry *bufferGeometry;
1947 DECODE_CODEC_EXTRA_BUFFERINFO *pBufferInfo = NULL;
1948 OMX_S32 indexTimestamp = 0;
1949 int plane;
1950
1951 FunctionIn();
1952
1953 if (pMpeg4Dec->bDestinationStart == OMX_FALSE) {
1954 ret = OMX_ErrorNone;
1955 goto EXIT;
1956 }
1957
1958 while (1) {
1959 if ((pVideoBuffer = pOutbufOps->Dequeue(hMFCHandle)) == NULL) {
1960 ret = OMX_ErrorNone;
1961 goto EXIT;
1962 }
1963 displayStatus = pVideoBuffer->displayStatus;
1964 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "displayStatus: 0x%x", displayStatus);
1965
1966 if ((displayStatus == VIDEO_FRAME_STATUS_DISPLAY_DECODING) ||
1967 (displayStatus == VIDEO_FRAME_STATUS_DISPLAY_ONLY) ||
1968 (displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) ||
1969 (displayStatus == VIDEO_FRAME_STATUS_DECODING_FINISHED) ||
1970 (CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
1971 ret = OMX_ErrorNone;
1972 break;
1973 }
1974 }
1975
1976 pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp++;
1977 pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp %= MAX_TIMESTAMP;
1978
1979 pDstOutputData->allocSize = pDstOutputData->dataLen = 0;
1980 for (plane = 0; plane < MFC_OUTPUT_BUFFER_PLANE; plane++) {
1981 pDstOutputData->buffer.multiPlaneBuffer.dataBuffer[plane] = pVideoBuffer->planes[plane].addr;
1982 pDstOutputData->buffer.multiPlaneBuffer.fd[plane] = pVideoBuffer->planes[plane].fd;
1983 pDstOutputData->allocSize += pVideoBuffer->planes[plane].allocSize;
1984 pDstOutputData->dataLen += pVideoBuffer->planes[plane].dataSize;
1985 }
1986 pDstOutputData->usedDataLen = 0;
1987 pDstOutputData->pPrivate = pVideoBuffer;
1988 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1989 int i = 0;
1990 pDstOutputData->pPrivate = NULL;
1991 for (i = 0; i < MFC_OUTPUT_BUFFER_NUM_MAX; i++) {
1992 if (pDstOutputData->buffer.multiPlaneBuffer.dataBuffer[0] ==
1993 pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[0]) {
1994 pDstOutputData->pPrivate = pVideoDec->pMFCDecOutputBuffer[i];
1995 break;
1996 }
1997 }
1998
1999 if (pDstOutputData->pPrivate == NULL) {
2000 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Can not find buffer");
2001 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2002 goto EXIT;
2003 }
2004 }
2005
2006 /* For Share Buffer */
2007 pDstOutputData->bufferHeader = (OMX_BUFFERHEADERTYPE *)pVideoBuffer->pPrivate;
2008
2009 pBufferInfo = (DECODE_CODEC_EXTRA_BUFFERINFO *)pDstOutputData->extInfo;
2010 bufferGeometry = &pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf;
2011 pBufferInfo->imageWidth = bufferGeometry->nFrameWidth;
2012 pBufferInfo->imageHeight = bufferGeometry->nFrameHeight;
2013 switch (bufferGeometry->eColorFormat) {
2014 case VIDEO_COLORFORMAT_NV12:
2015 pBufferInfo->ColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
2016 break;
2017 case VIDEO_COLORFORMAT_NV12_TILED:
2018 default:
2019 pBufferInfo->ColorFormat = OMX_SEC_COLOR_FormatNV12Tiled;
2020 break;
2021 }
2022
2023 indexTimestamp = pDecOps->Get_FrameTag(hMFCHandle);
2024 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "out indexTimestamp: %d", indexTimestamp);
2025 if ((indexTimestamp < 0) || (indexTimestamp >= MAX_TIMESTAMP)) {
2026 if ((pExynosComponent->checkTimeStamp.needSetStartTimeStamp != OMX_TRUE) &&
2027 (pExynosComponent->checkTimeStamp.needCheckStartTimeStamp != OMX_TRUE)) {
2028 pDstOutputData->timeStamp = pExynosComponent->timeStamp[pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp];
2029 pDstOutputData->nFlags = pExynosComponent->nFlags[pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp];
2030 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "missing out indexTimestamp: %d", indexTimestamp);
2031 } else {
2032 pDstOutputData->timeStamp = 0x00;
2033 pDstOutputData->nFlags = 0x00;
2034 }
2035 } else {
2036 /* For timestamp correction. if mfc support frametype detect */
2037 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "disp_pic_frame_type: %d", pVideoBuffer->frameType);
2038 #ifdef NEED_TIMESTAMP_REORDER
2039 if ((pVideoBuffer->frameType == VIDEO_FRAME_I)) {
2040 pDstOutputData->timeStamp = pExynosComponent->timeStamp[indexTimestamp];
2041 pDstOutputData->nFlags = pExynosComponent->nFlags[indexTimestamp];
2042 pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp = indexTimestamp;
2043 } else {
2044 pDstOutputData->timeStamp = pExynosComponent->timeStamp[pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp];
2045 pDstOutputData->nFlags = pExynosComponent->nFlags[pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp];
2046 }
2047 #else
2048 pDstOutputData->timeStamp = pExynosComponent->timeStamp[indexTimestamp];
2049 pDstOutputData->nFlags = pExynosComponent->nFlags[indexTimestamp];
2050 #endif
2051 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "timestamp %lld us (%.2f secs), indexTimestamp: %d, nFlags: 0x%x", pDstOutputData->timeStamp, pDstOutputData->timeStamp / 1E6, indexTimestamp, pDstOutputData->nFlags);
2052 }
2053
2054 if ((displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) ||
2055 (displayStatus == VIDEO_FRAME_STATUS_DECODING_FINISHED) ||
2056 ((pDstOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)) {
2057 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "displayStatus:%d, nFlags0x%x", displayStatus, pDstOutputData->nFlags);
2058 pDstOutputData->remainDataLen = 0;
2059 } else {
2060 pDstOutputData->remainDataLen = bufferGeometry->nFrameWidth * bufferGeometry->nFrameHeight * 3 / 2;
2061 }
2062
2063 ret = OMX_ErrorNone;
2064
2065 EXIT:
2066 FunctionOut();
2067
2068 return ret;
2069 }
2070
2071 OMX_ERRORTYPE Exynos_Mpeg4Dec_srcInputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
2072 {
2073 OMX_ERRORTYPE ret = OMX_ErrorNone;
2074 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2075 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2076 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2077
2078 FunctionIn();
2079
2080 if ((!CHECK_PORT_ENABLED(pExynosInputPort)) || (!CHECK_PORT_POPULATED(pExynosInputPort))) {
2081 ret = OMX_ErrorNone;
2082 goto EXIT;
2083 }
2084 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, INPUT_PORT_INDEX)) {
2085 ret = OMX_ErrorNone;
2086 goto EXIT;
2087 }
2088
2089 ret = Exynos_Mpeg4Dec_SrcIn(pOMXComponent, pSrcInputData);
2090 if ((ret != OMX_ErrorNone) &&
2091 (ret != OMX_ErrorInputDataDecodeYet) &&
2092 (ret != OMX_ErrorCorruptedFrame)) {
2093 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2094 pExynosComponent->callbackData,
2095 OMX_EventError, ret, 0, NULL);
2096 }
2097
2098 EXIT:
2099 FunctionOut();
2100
2101 return ret;
2102 }
2103
2104 OMX_ERRORTYPE Exynos_Mpeg4Dec_srcOutputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcOutputData)
2105 {
2106 OMX_ERRORTYPE ret = OMX_ErrorNone;
2107 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2108 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2109 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2110
2111 FunctionIn();
2112
2113 if ((!CHECK_PORT_ENABLED(pExynosInputPort)) || (!CHECK_PORT_POPULATED(pExynosInputPort))) {
2114 ret = OMX_ErrorNone;
2115 goto EXIT;
2116 }
2117
2118 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2119 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, INPUT_PORT_INDEX)) {
2120 ret = OMX_ErrorNone;
2121 goto EXIT;
2122 }
2123 }
2124 if ((pMpeg4Dec->bSourceStart == OMX_FALSE) &&
2125 (!CHECK_PORT_BEING_FLUSHED(pExynosInputPort))) {
2126 Exynos_OSAL_SignalWait(pMpeg4Dec->hSourceStartEvent, DEF_MAX_WAIT_TIME);
2127 Exynos_OSAL_SignalReset(pMpeg4Dec->hSourceStartEvent);
2128 }
2129
2130 ret = Exynos_Mpeg4Dec_SrcOut(pOMXComponent, pSrcOutputData);
2131 if ((ret != OMX_ErrorNone) &&
2132 (pExynosComponent->currentState == OMX_StateExecuting)) {
2133 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2134 pExynosComponent->callbackData,
2135 OMX_EventError, ret, 0, NULL);
2136 }
2137
2138 EXIT:
2139 FunctionOut();
2140
2141 return ret;
2142 }
2143
2144 OMX_ERRORTYPE Exynos_Mpeg4Dec_dstInputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstInputData)
2145 {
2146 OMX_ERRORTYPE ret = OMX_ErrorNone;
2147 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2148 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2149 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2150
2151 FunctionIn();
2152
2153 if ((!CHECK_PORT_ENABLED(pExynosOutputPort)) || (!CHECK_PORT_POPULATED(pExynosOutputPort))) {
2154 ret = OMX_ErrorNone;
2155 goto EXIT;
2156 }
2157 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, OUTPUT_PORT_INDEX)) {
2158 ret = OMX_ErrorNone;
2159 goto EXIT;
2160 }
2161 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
2162 if ((pMpeg4Dec->bDestinationStart == OMX_FALSE) &&
2163 (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2164 Exynos_OSAL_SignalWait(pMpeg4Dec->hDestinationStartEvent, DEF_MAX_WAIT_TIME);
2165 Exynos_OSAL_SignalReset(pMpeg4Dec->hDestinationStartEvent);
2166 }
2167 }
2168 if (pMpeg4Dec->hMFCMpeg4Handle.bConfiguredMFCDst == OMX_TRUE) {
2169 ret = Exynos_Mpeg4Dec_DstIn(pOMXComponent, pDstInputData);
2170 if (ret != OMX_ErrorNone) {
2171 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2172 pExynosComponent->callbackData,
2173 OMX_EventError, ret, 0, NULL);
2174 }
2175 }
2176
2177 EXIT:
2178 FunctionOut();
2179
2180 return ret;
2181 }
2182
2183 OMX_ERRORTYPE Exynos_Mpeg4Dec_dstOutputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstOutputData)
2184 {
2185 OMX_ERRORTYPE ret = OMX_ErrorNone;
2186 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2187 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2188 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2189
2190 FunctionIn();
2191
2192 if ((!CHECK_PORT_ENABLED(pExynosOutputPort)) || (!CHECK_PORT_POPULATED(pExynosOutputPort))) {
2193 ret = OMX_ErrorNone;
2194 goto EXIT;
2195 }
2196 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, OUTPUT_PORT_INDEX)) {
2197 ret = OMX_ErrorNone;
2198 goto EXIT;
2199 }
2200
2201 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
2202 if ((pMpeg4Dec->bDestinationStart == OMX_FALSE) &&
2203 (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2204 Exynos_OSAL_SignalWait(pMpeg4Dec->hDestinationStartEvent, DEF_MAX_WAIT_TIME);
2205 Exynos_OSAL_SignalReset(pMpeg4Dec->hDestinationStartEvent);
2206 }
2207 }
2208 ret = Exynos_Mpeg4Dec_DstOut(pOMXComponent, pDstOutputData);
2209 if ((ret != OMX_ErrorNone) &&
2210 (pExynosComponent->currentState == OMX_StateExecuting)) {
2211 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2212 pExynosComponent->callbackData,
2213 OMX_EventError, ret, 0, NULL);
2214 }
2215
2216 EXIT:
2217 FunctionOut();
2218
2219 return ret;
2220 }
2221
2222 OSCL_EXPORT_REF OMX_ERRORTYPE Exynos_OMX_ComponentInit(OMX_HANDLETYPE hComponent, OMX_STRING componentName)
2223 {
2224 OMX_ERRORTYPE ret = OMX_ErrorNone;
2225 OMX_COMPONENTTYPE *pOMXComponent = NULL;
2226 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
2227 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
2228 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
2229 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = NULL;
2230 int i = 0;
2231 OMX_S32 codecType = -1;
2232
2233 FunctionIn();
2234
2235 if ((hComponent == NULL) || (componentName == NULL)) {
2236 ret = OMX_ErrorBadParameter;
2237 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
2238 goto EXIT;
2239 }
2240 if (Exynos_OSAL_Strcmp(EXYNOS_OMX_COMPONENT_MPEG4_DEC, componentName) == 0) {
2241 codecType = CODEC_TYPE_MPEG4;
2242 } else if (Exynos_OSAL_Strcmp(EXYNOS_OMX_COMPONENT_H263_DEC, componentName) == 0) {
2243 codecType = CODEC_TYPE_H263;
2244 } else {
2245 ret = OMX_ErrorBadParameter;
2246 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, componentName:%s, Line:%d", componentName, __LINE__);
2247 goto EXIT;
2248 }
2249
2250 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2251 ret = Exynos_OMX_VideoDecodeComponentInit(pOMXComponent);
2252 if (ret != OMX_ErrorNone) {
2253 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_Error, Line:%d", __LINE__);
2254 goto EXIT;
2255 }
2256 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2257 pExynosComponent->codecType = HW_VIDEO_DEC_CODEC;
2258
2259 pExynosComponent->componentName = (OMX_STRING)Exynos_OSAL_Malloc(MAX_OMX_COMPONENT_NAME_SIZE);
2260 if (pExynosComponent->componentName == NULL) {
2261 Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2262 ret = OMX_ErrorInsufficientResources;
2263 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2264 goto EXIT;
2265 }
2266 Exynos_OSAL_Memset(pExynosComponent->componentName, 0, MAX_OMX_COMPONENT_NAME_SIZE);
2267
2268 pMpeg4Dec = Exynos_OSAL_Malloc(sizeof(EXYNOS_MPEG4DEC_HANDLE));
2269 if (pMpeg4Dec == NULL) {
2270 Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2271 ret = OMX_ErrorInsufficientResources;
2272 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2273 goto EXIT;
2274 }
2275 Exynos_OSAL_Memset(pMpeg4Dec, 0, sizeof(EXYNOS_MPEG4DEC_HANDLE));
2276 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2277 pVideoDec->hCodecHandle = (OMX_HANDLETYPE)pMpeg4Dec;
2278 pMpeg4Dec->hMFCMpeg4Handle.codecType = codecType;
2279
2280 if (codecType == CODEC_TYPE_MPEG4)
2281 Exynos_OSAL_Strcpy(pExynosComponent->componentName, EXYNOS_OMX_COMPONENT_MPEG4_DEC);
2282 else
2283 Exynos_OSAL_Strcpy(pExynosComponent->componentName, EXYNOS_OMX_COMPONENT_H263_DEC);
2284
2285 /* Set componentVersion */
2286 pExynosComponent->componentVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
2287 pExynosComponent->componentVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
2288 pExynosComponent->componentVersion.s.nRevision = REVISION_NUMBER;
2289 pExynosComponent->componentVersion.s.nStep = STEP_NUMBER;
2290 /* Set specVersion */
2291 pExynosComponent->specVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
2292 pExynosComponent->specVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
2293 pExynosComponent->specVersion.s.nRevision = REVISION_NUMBER;
2294 pExynosComponent->specVersion.s.nStep = STEP_NUMBER;
2295
2296 /* Input port */
2297 pExynosPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2298 pExynosPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
2299 pExynosPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
2300 pExynosPort->portDefinition.format.video.nStride = 0; /*DEFAULT_FRAME_WIDTH;*/
2301 pExynosPort->portDefinition.format.video.nSliceHeight = 0;
2302 pExynosPort->portDefinition.nBufferSize = DEFAULT_VIDEO_INPUT_BUFFER_SIZE;
2303 if (codecType == CODEC_TYPE_MPEG4) {
2304 pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
2305 Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2306 Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "video/mpeg4");
2307 } else {
2308 pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingH263;
2309 Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2310 Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "video/h263");
2311 }
2312 pExynosPort->portDefinition.format.video.pNativeRender = 0;
2313 pExynosPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
2314 pExynosPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatUnused;
2315 pExynosPort->portDefinition.bEnabled = OMX_TRUE;
2316 pExynosPort->bufferProcessType = BUFFER_SHARE;
2317 pExynosPort->portWayType = WAY2_PORT;
2318
2319 /* Output port */
2320 pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2321 pExynosPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
2322 pExynosPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
2323 pExynosPort->portDefinition.format.video.nStride = 0; /*DEFAULT_FRAME_WIDTH;*/
2324 pExynosPort->portDefinition.format.video.nSliceHeight = 0;
2325 pExynosPort->portDefinition.nBufferSize = DEFAULT_VIDEO_OUTPUT_BUFFER_SIZE;
2326 pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused;
2327 Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2328 Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "raw/video");
2329 pExynosPort->portDefinition.format.video.pNativeRender = 0;
2330 pExynosPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
2331 pExynosPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
2332 pExynosPort->portDefinition.bEnabled = OMX_TRUE;
2333 pExynosPort->bufferProcessType = BUFFER_COPY | BUFFER_ANBSHARE;
2334 pExynosPort->portWayType = WAY2_PORT;
2335
2336 if (codecType == CODEC_TYPE_MPEG4) {
2337 for(i = 0; i < ALL_PORT_NUM; i++) {
2338 INIT_SET_SIZE_VERSION(&pMpeg4Dec->mpeg4Component[i], OMX_VIDEO_PARAM_MPEG4TYPE);
2339 pMpeg4Dec->mpeg4Component[i].nPortIndex = i;
2340 pMpeg4Dec->mpeg4Component[i].eProfile = OMX_VIDEO_MPEG4ProfileSimple;
2341 pMpeg4Dec->mpeg4Component[i].eLevel = OMX_VIDEO_MPEG4Level3;
2342 }
2343 } else {
2344 for(i = 0; i < ALL_PORT_NUM; i++) {
2345 INIT_SET_SIZE_VERSION(&pMpeg4Dec->h263Component[i], OMX_VIDEO_PARAM_H263TYPE);
2346 pMpeg4Dec->h263Component[i].nPortIndex = i;
2347 pMpeg4Dec->h263Component[i].eProfile = OMX_VIDEO_H263ProfileBaseline | OMX_VIDEO_H263ProfileISWV2;
2348 pMpeg4Dec->h263Component[i].eLevel = OMX_VIDEO_H263Level45;
2349 }
2350 }
2351
2352 pOMXComponent->GetParameter = &Exynos_Mpeg4Dec_GetParameter;
2353 pOMXComponent->SetParameter = &Exynos_Mpeg4Dec_SetParameter;
2354 pOMXComponent->GetConfig = &Exynos_Mpeg4Dec_GetConfig;
2355 pOMXComponent->SetConfig = &Exynos_Mpeg4Dec_SetConfig;
2356 pOMXComponent->GetExtensionIndex = &Exynos_Mpeg4Dec_GetExtensionIndex;
2357 pOMXComponent->ComponentRoleEnum = &Exynos_Mpeg4Dec_ComponentRoleEnum;
2358 pOMXComponent->ComponentDeInit = &Exynos_OMX_ComponentDeinit;
2359
2360 pExynosComponent->exynos_codec_componentInit = &Exynos_Mpeg4Dec_Init;
2361 pExynosComponent->exynos_codec_componentTerminate = &Exynos_Mpeg4Dec_Terminate;
2362
2363 pVideoDec->exynos_codec_srcInputProcess = &Exynos_Mpeg4Dec_srcInputBufferProcess;
2364 pVideoDec->exynos_codec_srcOutputProcess = &Exynos_Mpeg4Dec_srcOutputBufferProcess;
2365 pVideoDec->exynos_codec_dstInputProcess = &Exynos_Mpeg4Dec_dstInputBufferProcess;
2366 pVideoDec->exynos_codec_dstOutputProcess = &Exynos_Mpeg4Dec_dstOutputBufferProcess;
2367
2368 pVideoDec->exynos_codec_start = &Mpeg4CodecStart;
2369 pVideoDec->exynos_codec_stop = &Mpeg4CodecStop;
2370 pVideoDec->exynos_codec_bufferProcessRun = &Mpeg4CodecOutputBufferProcessRun;
2371 pVideoDec->exynos_codec_enqueueAllBuffer = &Mpeg4CodecEnQueueAllBuffer;
2372
2373 if (codecType == CODEC_TYPE_MPEG4)
2374 pVideoDec->exynos_checkInputFrame = &Check_Mpeg4_Frame;
2375 else
2376 pVideoDec->exynos_checkInputFrame = &Check_H263_Frame;
2377
2378 pVideoDec->exynos_codec_getCodecInputPrivateData = &GetCodecInputPrivateData;
2379 pVideoDec->exynos_codec_getCodecOutputPrivateData = &GetCodecOutputPrivateData;
2380
2381 pVideoDec->hSharedMemory = Exynos_OSAL_SharedMemory_Open();
2382 if (pVideoDec->hSharedMemory == NULL) {
2383 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2384 Exynos_OSAL_Free(pMpeg4Dec);
2385 pMpeg4Dec = ((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle = NULL;
2386 Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2387 ret = OMX_ErrorInsufficientResources;
2388 goto EXIT;
2389 }
2390
2391 pExynosComponent->currentState = OMX_StateLoaded;
2392
2393 ret = OMX_ErrorNone;
2394
2395 EXIT:
2396 FunctionOut();
2397
2398 return ret;
2399 }
2400
2401 OMX_ERRORTYPE Exynos_OMX_ComponentDeinit(OMX_HANDLETYPE hComponent)
2402 {
2403 OMX_ERRORTYPE ret = OMX_ErrorNone;
2404 OMX_COMPONENTTYPE *pOMXComponent = NULL;
2405 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
2406 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
2407 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = NULL;
2408
2409 FunctionIn();
2410
2411 if (hComponent == NULL) {
2412 ret = OMX_ErrorBadParameter;
2413 goto EXIT;
2414 }
2415 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2416 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2417 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2418
2419 Exynos_OSAL_SharedMemory_Close(pVideoDec->hSharedMemory);
2420
2421 Exynos_OSAL_Free(pExynosComponent->componentName);
2422 pExynosComponent->componentName = NULL;
2423
2424 pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)pVideoDec->hCodecHandle;
2425 if (pMpeg4Dec != NULL) {
2426 Exynos_OSAL_Free(pMpeg4Dec);
2427 pMpeg4Dec = pVideoDec->hCodecHandle = NULL;
2428 }
2429
2430 ret = Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2431 if (ret != OMX_ErrorNone) {
2432 goto EXIT;
2433 }
2434
2435 ret = OMX_ErrorNone;
2436
2437 EXIT:
2438 FunctionOut();
2439
2440 return ret;
2441 }