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