3 * Copyright 2012 Samsung Electronics S.LSI Co. LTD
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
9 * http://www.apache.org/licenses/LICENSE-2.0
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
19 * @file Exynos_OMX_H264dec.c
21 * @author SeungBeom Kim (sbcrux.kim@samsung.com)
32 #include "Exynos_OMX_Macros.h"
33 #include "Exynos_OMX_Basecomponent.h"
34 #include "Exynos_OMX_Baseport.h"
35 #include "Exynos_OMX_Vdec.h"
36 #include "Exynos_OSAL_ETC.h"
37 #include "Exynos_OSAL_Semaphore.h"
38 #include "Exynos_OSAL_Thread.h"
39 #include "library_register.h"
40 #include "Exynos_OMX_H264dec.h"
41 #include "ExynosVideoApi.h"
42 #include "Exynos_OSAL_SharedMemory.h"
43 #include "Exynos_OSAL_Event.h"
48 #include "Exynos_OSAL_Platform_Specific.h"
51 /* To use CSC_METHOD_HW in EXYNOS OMX, gralloc should allocate physical memory using FIMC */
52 /* It means GRALLOC_USAGE_HW_FIMC1 should be set on Native Window usage */
56 #define EXYNOS_LOG_TAG "EXYNOS_H264_DEC"
57 #define EXYNOS_LOG_OFF
58 //#define EXYNOS_TRACE_ON
59 #include "Exynos_OSAL_Log.h"
61 #define H264_DEC_NUM_OF_EXTRA_BUFFERS 7
63 //#define ADD_SPS_PPS_I_FRAME
64 //#define FULL_FRAME_SEARCH
66 /* H.264 Decoder Supported Levels & profiles */
67 EXYNOS_OMX_VIDEO_PROFILELEVEL supportedAVCProfileLevels[] ={
68 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel1},
69 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel1b},
70 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel11},
71 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel12},
72 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel13},
73 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel2},
74 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel21},
75 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel22},
76 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel3},
77 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel31},
78 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel32},
79 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel4},
80 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel41},
81 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel42},
83 {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel1},
84 {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel1b},
85 {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel11},
86 {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel12},
87 {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel13},
88 {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel2},
89 {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel21},
90 {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel22},
91 {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel3},
92 {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel31},
93 {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel32},
94 {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel4},
95 {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel41},
96 {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel42},
98 {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel1},
99 {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel1b},
100 {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel11},
101 {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel12},
102 {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel13},
103 {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel2},
104 {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel21},
105 {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel22},
106 {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel3},
107 {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel31},
108 {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel32},
109 {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel4},
110 {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel41},
111 {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel42}};
113 static OMX_ERRORTYPE GetCodecInputPrivateData(OMX_PTR codecBuffer, void *pVirtAddr, OMX_U32 *dataSize)
115 OMX_ERRORTYPE ret = OMX_ErrorNone;
121 static OMX_ERRORTYPE GetCodecOutputPrivateData(OMX_PTR codecBuffer, void *addr[], int size[])
123 OMX_ERRORTYPE ret = OMX_ErrorNone;
124 ExynosVideoBuffer *pCodecBuffer;
126 if (codecBuffer == NULL) {
127 ret = OMX_ErrorBadParameter;
131 pCodecBuffer = (ExynosVideoBuffer *)codecBuffer;
134 addr[0] = pCodecBuffer->planes[0].addr;
135 addr[1] = pCodecBuffer->planes[1].addr;
136 addr[2] = pCodecBuffer->planes[2].addr;
140 size[0] = pCodecBuffer->planes[0].allocSize;
141 size[1] = pCodecBuffer->planes[1].allocSize;
142 size[2] = pCodecBuffer->planes[2].allocSize;
149 int Check_H264_Frame(
150 OMX_U8 *pInputStream,
153 OMX_BOOL bPreviousFrameEOF,
154 OMX_BOOL *pbEndOfFrame)
156 OMX_U32 preFourByte = (OMX_U32)-1;
157 int accessUnitSize = 0;
158 int frameTypeBoundary = 0;
159 int nextNaluSize = 0;
162 if (bPreviousFrameEOF == OMX_TRUE)
168 int inputOneByte = 0;
170 if (accessUnitSize == (int)buffSize)
173 inputOneByte = *(pInputStream++);
176 if (preFourByte == 0x00000001 || (preFourByte << 8) == 0x00000100) {
177 int naluType = inputOneByte & 0x1F;
179 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "NaluType : %d", naluType);
180 if (naluStart == 0) {
181 #ifdef ADD_SPS_PPS_I_FRAME
182 if (naluType == 1 || naluType == 5)
184 if (naluType == 1 || naluType == 5 || naluType == 7 || naluType == 8)
189 frameTypeBoundary = (8 - naluType) & (naluType - 10); //AUD(9)
192 frameTypeBoundary = -2;
194 if (naluType == 1 || naluType == 5) {
195 if (accessUnitSize == (int)buffSize) {
199 inputOneByte = *pInputStream++;
202 if (inputOneByte >= 0x80)
203 frameTypeBoundary = -1;
205 if (frameTypeBoundary < 0) {
211 preFourByte = (preFourByte << 8) + inputOneByte;
214 *pbEndOfFrame = OMX_TRUE;
216 if (frameTypeBoundary == -1)
218 if (preFourByte != 0x00000001)
220 return (accessUnitSize + nextNaluSize);
223 *pbEndOfFrame = OMX_FALSE;
225 return accessUnitSize;
228 static OMX_BOOL Check_H264_StartCode(
229 OMX_U8 *pInputStream,
232 if (streamSize < 4) {
236 if ((pInputStream[0] == 0x00) &&
237 (pInputStream[1] == 0x00) &&
238 (pInputStream[2] == 0x00) &&
239 (pInputStream[3] != 0x00) &&
240 ((pInputStream[3] >> 3) == 0x00)) {
241 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "NaluType : %d, 0x%x, 0x%x, 0x%x", (pInputStream[4] & 0x1F), pInputStream[3], pInputStream[4], pInputStream[5]);
243 } else if ((pInputStream[0] == 0x00) &&
244 (pInputStream[1] == 0x00) &&
245 (pInputStream[2] != 0x00) &&
246 ((pInputStream[2] >> 3) == 0x00)) {
247 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "NaluType : %d, 0x%x, 0x%x, 0x%x", (pInputStream[3] & 0x1F), pInputStream[2], pInputStream[3], pInputStream[4]);
254 OMX_ERRORTYPE H264CodecOpen(EXYNOS_H264DEC_HANDLE *pH264Dec)
256 OMX_ERRORTYPE ret = OMX_ErrorNone;
257 ExynosVideoDecOps *pDecOps = NULL;
258 ExynosVideoDecBufferOps *pInbufOps = NULL;
259 ExynosVideoDecBufferOps *pOutbufOps = NULL;
263 if (pH264Dec == NULL) {
264 ret = OMX_ErrorBadParameter;
265 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
269 /* alloc ops structure */
270 pDecOps = (ExynosVideoDecOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoDecOps));
271 pInbufOps = (ExynosVideoDecBufferOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoDecBufferOps));
272 pOutbufOps = (ExynosVideoDecBufferOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoDecBufferOps));
274 if ((pDecOps == NULL) || (pInbufOps == NULL) || (pOutbufOps == NULL)) {
275 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to allocate decoder ops buffer");
276 ret = OMX_ErrorInsufficientResources;
280 pH264Dec->hMFCH264Handle.pDecOps = pDecOps;
281 pH264Dec->hMFCH264Handle.pInbufOps = pInbufOps;
282 pH264Dec->hMFCH264Handle.pOutbufOps = pOutbufOps;
284 /* function pointer mapping */
285 pDecOps->nSize = sizeof(ExynosVideoDecOps);
286 pInbufOps->nSize = sizeof(ExynosVideoDecBufferOps);
287 pOutbufOps->nSize = sizeof(ExynosVideoDecBufferOps);
289 Exynos_Video_Register_Decoder(pDecOps, pInbufOps, pOutbufOps);
291 /* check mandatory functions for decoder ops */
292 if ((pDecOps->Init == NULL) || (pDecOps->Finalize == NULL) ||
293 (pDecOps->Get_ActualBufferCount == NULL) || (pDecOps->Set_FrameTag == NULL) ||
294 #ifdef USE_S3D_SUPPORT
295 (pDecOps->Enable_SEIParsing == NULL) || (pDecOps->Get_FramePackingInfo == NULL) ||
297 (pDecOps->Get_FrameTag == NULL)) {
298 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Mandatory functions must be supplied");
299 ret = OMX_ErrorInsufficientResources;
303 /* check mandatory functions for buffer ops */
304 if ((pInbufOps->Setup == NULL) || (pOutbufOps->Setup == NULL) ||
305 (pInbufOps->Run == NULL) || (pOutbufOps->Run == NULL) ||
306 (pInbufOps->Stop == NULL) || (pOutbufOps->Stop == NULL) ||
307 (pInbufOps->Enqueue == NULL) || (pOutbufOps->Enqueue == NULL) ||
308 (pInbufOps->Dequeue == NULL) || (pOutbufOps->Dequeue == NULL)) {
309 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Mandatory functions must be supplied");
310 ret = OMX_ErrorInsufficientResources;
314 /* alloc context, open, querycap */
315 if (pH264Dec->hMFCH264Handle.bShareableBuf == OMX_TRUE) {
317 pH264Dec->hMFCH264Handle.hMFCHandle = pH264Dec->hMFCH264Handle.pDecOps->Init(V4L2_MEMORY_DMABUF);
319 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "%s :%d V4L2_MEMORY_USERPTR", __FUNCTION__, __LINE__);
320 pH264Dec->hMFCH264Handle.hMFCHandle = pH264Dec->hMFCH264Handle.pDecOps->Init(V4L2_MEMORY_USERPTR);
323 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "%s :%d V4L2_MEMORY_DMABUF", __FUNCTION__, __LINE__);
324 pH264Dec->hMFCH264Handle.hMFCHandle = pH264Dec->hMFCH264Handle.pDecOps->Init(V4L2_MEMORY_DMABUF);
326 if (pH264Dec->hMFCH264Handle.hMFCHandle == NULL) {
327 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to allocate context buffer");
328 ret = OMX_ErrorInsufficientResources;
332 #ifdef USE_S3D_SUPPORT
333 /*S3D: Enable SEI parsing to check Frame Packing */
334 if (pDecOps->Enable_SEIParsing(pH264Dec->hMFCH264Handle.hMFCHandle) != VIDEO_ERROR_NONE) {
335 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Enable SEI Parsing");
336 ret = OMX_ErrorInsufficientResources;
344 if (ret != OMX_ErrorNone) {
345 if (pDecOps != NULL) {
346 Exynos_OSAL_Free(pDecOps);
347 pH264Dec->hMFCH264Handle.pDecOps = NULL;
349 if (pInbufOps != NULL) {
350 Exynos_OSAL_Free(pInbufOps);
351 pH264Dec->hMFCH264Handle.pInbufOps = NULL;
353 if (pOutbufOps != NULL) {
354 Exynos_OSAL_Free(pOutbufOps);
355 pH264Dec->hMFCH264Handle.pOutbufOps = NULL;
364 OMX_ERRORTYPE H264CodecClose(EXYNOS_H264DEC_HANDLE *pH264Dec)
366 OMX_ERRORTYPE ret = OMX_ErrorNone;
367 void *hMFCHandle = NULL;
368 ExynosVideoDecOps *pDecOps = NULL;
369 ExynosVideoDecBufferOps *pInbufOps = NULL;
370 ExynosVideoDecBufferOps *pOutbufOps = NULL;
374 if (pH264Dec == NULL) {
375 ret = OMX_ErrorBadParameter;
379 hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
380 pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
381 pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
382 pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
384 if (hMFCHandle != NULL) {
385 pDecOps->Finalize(hMFCHandle);
386 pH264Dec->hMFCH264Handle.hMFCHandle = NULL;
388 if (pOutbufOps != NULL) {
389 Exynos_OSAL_Free(pOutbufOps);
390 pH264Dec->hMFCH264Handle.pOutbufOps = NULL;
392 if (pInbufOps != NULL) {
393 Exynos_OSAL_Free(pInbufOps);
394 pH264Dec->hMFCH264Handle.pInbufOps = NULL;
396 if (pDecOps != NULL) {
397 Exynos_OSAL_Free(pDecOps);
398 pH264Dec->hMFCH264Handle.pDecOps = NULL;
409 OMX_ERRORTYPE H264CodecStart(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
411 OMX_ERRORTYPE ret = OMX_ErrorNone;
412 void *hMFCHandle = NULL;
413 ExynosVideoDecOps *pDecOps = NULL;
414 ExynosVideoDecBufferOps *pInbufOps = NULL;
415 ExynosVideoDecBufferOps *pOutbufOps = NULL;
416 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
417 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
421 if (pOMXComponent == NULL) {
422 ret = OMX_ErrorBadParameter;
426 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
427 if (pVideoDec == NULL) {
428 ret = OMX_ErrorBadParameter;
432 pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
433 if (pH264Dec == NULL) {
434 ret = OMX_ErrorBadParameter;
438 hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
439 pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
440 pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
441 pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
443 if (nPortIndex == INPUT_PORT_INDEX)
444 pInbufOps->Run(hMFCHandle);
445 else if (nPortIndex == OUTPUT_PORT_INDEX)
446 pOutbufOps->Run(hMFCHandle);
456 OMX_ERRORTYPE H264CodecStop(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
458 OMX_ERRORTYPE ret = OMX_ErrorNone;
459 void *hMFCHandle = NULL;
460 ExynosVideoDecOps *pDecOps = NULL;
461 ExynosVideoDecBufferOps *pInbufOps = NULL;
462 ExynosVideoDecBufferOps *pOutbufOps = NULL;
463 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
464 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
468 if (pOMXComponent == NULL) {
469 ret = OMX_ErrorBadParameter;
473 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
474 if (pVideoDec == NULL) {
475 ret = OMX_ErrorBadParameter;
478 pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
479 if (pH264Dec == NULL) {
480 ret = OMX_ErrorBadParameter;
484 hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
485 pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
486 pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
487 pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
489 if ((nPortIndex == INPUT_PORT_INDEX) && (pInbufOps != NULL))
490 pInbufOps->Stop(hMFCHandle);
491 else if ((nPortIndex == OUTPUT_PORT_INDEX) && (pOutbufOps != NULL))
492 pOutbufOps->Stop(hMFCHandle);
502 OMX_ERRORTYPE H264CodecSrcInit(OMX_COMPONENTTYPE *pOMXComponent)
504 OMX_ERRORTYPE ret = OMX_ErrorNone;
505 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
506 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
507 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
508 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
509 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
510 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
512 ExynosVideoDecOps *pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
513 ExynosVideoDecBufferOps *pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
514 ExynosVideoDecBufferOps *pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
515 ExynosVideoGeometry bufferConf;
516 OMX_U32 inputBufferNumber = 0;
520 if (pVideoDec->bThumbnailMode == OMX_TRUE)
521 pDecOps->Set_DisplayDelay(hMFCHandle, 0);
523 /* input buffer info */
524 Exynos_OSAL_Memset(&bufferConf, 0, sizeof(bufferConf));
525 bufferConf.eCompressionFormat = VIDEO_CODING_AVC;
527 if (pExynosInputPort->bufferProcessType & BUFFER_SHARE
528 ||pH264Dec->hMFCH264Handle.bShareableBuf == OMX_TRUE)
529 pInbufOps->Set_Shareable(hMFCHandle);
531 if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
532 bufferConf.nSizeImage = pExynosInputPort->portDefinition.format.video.nFrameWidth
533 * pExynosInputPort->portDefinition.format.video.nFrameHeight * 3 / 2;
534 inputBufferNumber = MAX_VIDEO_INPUTBUFFER_NUM;
535 } else if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
536 bufferConf.nSizeImage = DEFAULT_MFC_INPUT_BUFFER_SIZE;
537 inputBufferNumber = MFC_INPUT_BUFFER_NUM_MAX;
540 /* should be done before prepare input buffer */
541 if (pInbufOps->Enable_Cacheable(hMFCHandle) != VIDEO_ERROR_NONE) {
542 ret = OMX_ErrorInsufficientResources;
546 /* set input buffer geometry */
547 if (pInbufOps->Set_Geometry(hMFCHandle, &bufferConf) != VIDEO_ERROR_NONE) {
548 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to set geometry for input buffer");
549 ret = OMX_ErrorInsufficientResources;
553 /* setup input buffer */
554 if (pInbufOps->Setup(hMFCHandle, inputBufferNumber) != VIDEO_ERROR_NONE) {
555 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to setup input buffer");
556 ret = OMX_ErrorInsufficientResources;
560 if ((pExynosInputPort->bufferProcessType & BUFFER_COPY) &&
561 pH264Dec->hMFCH264Handle.bShareableBuf == OMX_TRUE) {
562 /* Register input buffer */
563 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
564 ExynosVideoPlane plane;
565 plane.addr = pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[0];
566 plane.allocSize = pVideoDec->pMFCDecInputBuffer[i]->bufferSize[0];
567 plane.fd = pVideoDec->pMFCDecInputBuffer[i]->fd[0];
568 if (pInbufOps->Register(hMFCHandle, &plane, MFC_INPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
569 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register input buffer");
570 ret = OMX_ErrorInsufficientResources;
574 } else if ((pExynosInputPort->bufferProcessType & BUFFER_COPY) &&
575 pH264Dec->hMFCH264Handle.bShareableBuf == OMX_FALSE) {
576 ExynosVideoBuffer *pBuffer = NULL;
578 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
579 pVideoDec->pMFCDecInputBuffer[i] = Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
580 Exynos_OSAL_Memset(pVideoDec->pMFCDecInputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
581 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "@pVideoDec->pMFCDecInputBuffer[%d]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]);
582 /* get input buffer info */
583 if (pInbufOps->Get_Buffer) {
584 if (pInbufOps->Get_Buffer(pH264Dec->hMFCH264Handle.hMFCHandle, i, &pBuffer) != VIDEO_ERROR_NONE) {
585 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get input buffer info");
586 ret = OMX_ErrorInsufficientResources;
591 for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
592 /* Use ION Allocator */
593 pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] = (void *)pBuffer->planes[plane].addr;
594 pVideoDec->pMFCDecInputBuffer[i]->fd[plane] = pBuffer->planes[plane].fd;
595 pVideoDec->pMFCDecInputBuffer[i]->bufferSize[plane] = pBuffer->planes[plane].allocSize;
596 pVideoDec->pMFCDecInputBuffer[i]->dataSize = 0;
597 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "@pVideoDec->pMFCDecInputBuffer[%d]->pVirAddr[%d]: 0x%x", i, plane, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
600 #ifdef TIZEN_FEATURE_E3250
601 if (pExynosInputPort == NULL || pExynosOutputPort == NULL || pOMXComponent == NULL) {
602 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "invalid param: pExynosInputPort= %p pExynosOutputPort= %p pOMXComponent= %p", pExynosInputPort, pExynosOutputPort, pOMXComponent);
605 Exynos_CodecBufferEnQueue(pExynosComponent, INPUT_PORT_INDEX, pVideoDec->pMFCDecInputBuffer[i]);
607 } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
608 /* Register input buffer */
609 for (i = 0; i < pExynosInputPort->portDefinition.nBufferCountActual; i++) {
610 ExynosVideoPlane plane;
611 if (pVideoDec->bDRMPlayerMode == OMX_TRUE) {
612 #ifdef TIZEN_FEATURE_E3250
613 /* IL Client assigns FD value in pBuffer */
614 plane.addr = pExynosInputPort->extendBufferHeader[i].OMXBufferHeader->pBuffer;
616 plane.addr = Exynos_OSAL_SharedMemory_IONToVirt(pVideoDec->hSharedMemory, pExynosInputPort->extendBufferHeader[i].OMXBufferHeader->pBuffer);
619 plane.addr = pExynosInputPort->extendBufferHeader[i].OMXBufferHeader->pBuffer;
621 plane.allocSize = pExynosInputPort->extendBufferHeader[i].OMXBufferHeader->nAllocLen;
622 plane.fd = pExynosInputPort->extendBufferHeader[i].buf_fd[0];
623 if (pInbufOps->Register(hMFCHandle, &plane, MFC_INPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
624 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register input buffer");
625 ret = OMX_ErrorInsufficientResources;
638 OMX_ERRORTYPE H264CodecOutputBufferProcessRun(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
640 OMX_ERRORTYPE ret = OMX_ErrorNone;
641 void *hMFCHandle = NULL;
642 ExynosVideoDecOps *pDecOps = NULL;
643 ExynosVideoDecBufferOps *pInbufOps = NULL;
644 ExynosVideoDecBufferOps *pOutbufOps = NULL;
645 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
646 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
650 if (pOMXComponent == NULL) {
651 ret = OMX_ErrorBadParameter;
655 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
656 if (pVideoDec == NULL) {
657 ret = OMX_ErrorBadParameter;
660 pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
661 if (pH264Dec == NULL) {
662 ret = OMX_ErrorBadParameter;
666 hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
667 pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
668 pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
669 pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
671 if (nPortIndex == INPUT_PORT_INDEX) {
672 if (pH264Dec->bSourceStart == OMX_FALSE) {
673 Exynos_OSAL_SignalSet(pH264Dec->hSourceStartEvent);
674 Exynos_OSAL_SleepMillisec(0);
678 if (nPortIndex == OUTPUT_PORT_INDEX) {
679 if (pH264Dec->bDestinationStart == OMX_FALSE) {
680 Exynos_OSAL_SignalSet(pH264Dec->hDestinationStartEvent);
681 Exynos_OSAL_SleepMillisec(0);
693 OMX_ERRORTYPE H264CodecEnQueueAllBuffer(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
695 OMX_ERRORTYPE ret = OMX_ErrorNone;
696 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
697 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
698 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
699 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
700 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
701 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
704 ExynosVideoDecOps *pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
705 ExynosVideoDecBufferOps *pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
706 ExynosVideoDecBufferOps *pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
710 if ((nPortIndex != INPUT_PORT_INDEX) && (nPortIndex != OUTPUT_PORT_INDEX)) {
711 ret = OMX_ErrorBadPortIndex;
715 if ((nPortIndex == INPUT_PORT_INDEX) &&
716 (pH264Dec->bSourceStart == OMX_TRUE)) {
717 Exynos_CodecBufferReset(pExynosComponent, INPUT_PORT_INDEX);
719 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
720 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]);
721 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]->pVirAddr[0]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[0]);
723 Exynos_CodecBufferEnQueue(pExynosComponent, INPUT_PORT_INDEX, pVideoDec->pMFCDecInputBuffer[i]);
726 pInbufOps->Clear_Queue(hMFCHandle);
727 } else if ((nPortIndex == OUTPUT_PORT_INDEX) &&
728 (pH264Dec->bDestinationStart == OMX_TRUE)) {
729 OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
730 ExynosVideoBuffer *pBuffer = NULL;
732 Exynos_CodecBufferReset(pExynosComponent, OUTPUT_PORT_INDEX);
734 nOutbufs = pDecOps->Get_ActualBufferCount(hMFCHandle);
735 nOutbufs += EXTRA_DPB_NUM;
736 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "EXTRA_DPB_NUM = %d, nOutbufs =%d", EXTRA_DPB_NUM, nOutbufs);
737 for (i = 0; i < nOutbufs; i++) {
738 pOutbufOps->Get_Buffer(hMFCHandle, i, &pBuffer);
739 Exynos_CodecBufferEnQueue(pExynosComponent, OUTPUT_PORT_INDEX, (OMX_PTR)pBuffer);
741 pOutbufOps->Clear_Queue(hMFCHandle);
750 #ifdef USE_S3D_SUPPORT
751 OMX_BOOL H264CodecCheckFramePacking(OMX_COMPONENTTYPE *pOMXComponent)
753 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
754 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
755 ExynosVideoDecOps *pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
756 ExynosVideoFramePacking framePacking;
757 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
758 OMX_BOOL ret = OMX_FALSE;
760 /* Get Frame packing information*/
761 if (pDecOps->Get_FramePackingInfo(pH264Dec->hMFCH264Handle.hMFCHandle, &framePacking) != VIDEO_ERROR_NONE) {
762 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Get Frame Packing Information");
767 if (framePacking.available) {
768 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "arrangement ID: 0x%08x", framePacking.arrangement_id);
769 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "arrangement_type: %d", framePacking.arrangement_type);
770 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "content_interpretation_type: %d", framePacking.content_interpretation_type);
771 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "current_frame_is_frame0_flag: %d", framePacking.current_frame_is_frame0_flag);
772 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "spatial_flipping_flag: %d", framePacking.spatial_flipping_flag);
773 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "fr0X:%d fr0Y:%d fr0X:%d fr0Y:%d", framePacking.frame0_grid_pos_x,
774 framePacking.frame0_grid_pos_y, framePacking.frame1_grid_pos_x, framePacking.frame1_grid_pos_y);
776 pH264Dec->hMFCH264Handle.S3DFPArgmtType = (EXYNOS_OMX_FPARGMT_TYPE) framePacking.arrangement_type;
777 /** Send Port Settings changed call back - output color format change */
778 (*(pExynosComponent->pCallbacks->EventHandler))
780 pExynosComponent->callbackData,
781 OMX_EventPortSettingsChanged, /* The command was completed */
782 OMX_DirOutput, /* This is the port index */
786 Exynos_OSAL_SleepMillisec(0);
795 OMX_ERRORTYPE H264CodecDstFreeCodecBuffers(
796 OMX_COMPONENTTYPE *pOMXComponent)
798 OMX_ERRORTYPE ret = OMX_ErrorNone;
799 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
800 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
801 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
807 for (i = 0; i < MFC_OUTPUT_BUFFER_NUM_MAX; i++) {
808 if (pVideoDec->pMFCDecOutputBuffer[i] != NULL) {
809 for (j = 0; j < MFC_OUTPUT_BUFFER_PLANE; j++) {
810 if (pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j] != NULL &&
811 pH264Dec->hMFCH264Handle.bShareableBuf == OMX_TRUE)
812 Exynos_OSAL_SharedMemory_Free(pVideoDec->hSharedMemory, pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j]);
815 Exynos_OSAL_Free(pVideoDec->pMFCDecOutputBuffer[i]);
819 Exynos_OSAL_Memset(pVideoDec->pMFCDecOutputBuffer, 0, sizeof(pVideoDec->pMFCDecOutputBuffer));
823 return OMX_ErrorNone;
826 OMX_ERRORTYPE H264CodecDstAllocCodecBuffers(
827 OMX_COMPONENTTYPE *pOMXComponent,
830 OMX_ERRORTYPE ret = OMX_ErrorNone;
831 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
832 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
833 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
835 MEMORY_TYPE eMemoryType = NORMAL_MEMORY;
836 OMX_U32 nAllocLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
841 nAllocLen[0] = calc_plane(pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth,
842 pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight);
843 nAllocLen[1] = calc_plane(pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth,
844 pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight >> 1);
846 if (pVideoDec->bDRMPlayerMode == OMX_TRUE)
847 eMemoryType = SECURE_MEMORY;
849 for (i = 0; i < nOutbufs; i++) {
850 pVideoDec->pMFCDecOutputBuffer[i] = (CODEC_DEC_BUFFER *)Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
851 if (pVideoDec->pMFCDecOutputBuffer[i] == NULL) {
852 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Alloc codec buffer");
853 ret = OMX_ErrorInsufficientResources;
856 Exynos_OSAL_Memset(pVideoDec->pMFCDecOutputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
858 for (j = 0; j < MFC_OUTPUT_BUFFER_PLANE; j++) {
859 pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j] =
860 (void *)Exynos_OSAL_SharedMemory_Alloc(pVideoDec->hSharedMemory, nAllocLen[j], eMemoryType);
861 if (pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j] == NULL) {
862 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Alloc output buffer");
863 ret = OMX_ErrorInsufficientResources;
867 pVideoDec->pMFCDecOutputBuffer[i]->fd[j] =
868 Exynos_OSAL_SharedMemory_VirtToION(pVideoDec->hSharedMemory,
869 pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j]);
870 pVideoDec->pMFCDecOutputBuffer[i]->bufferSize[j] = nAllocLen[j];
874 return OMX_ErrorNone;
877 H264CodecDstFreeCodecBuffers(pOMXComponent);
884 OMX_ERRORTYPE H264CodecDstRegistCodecBuffers(
885 OMX_COMPONENTTYPE *pOMXComponent,
888 OMX_ERRORTYPE ret = OMX_ErrorNone;
889 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
890 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
891 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
892 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
893 ExynosVideoDecBufferOps *pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
895 ExynosVideoPlane planes[MFC_OUTPUT_BUFFER_PLANE];
896 OMX_U32 nDataLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
901 /* Register output buffer */
902 for (i = 0; i < nOutbufs; i++) {
903 for (j = 0; j < MFC_OUTPUT_BUFFER_PLANE; j++) {
904 planes[j].addr = pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j];
905 planes[j].fd = pVideoDec->pMFCDecOutputBuffer[i]->fd[j];
906 planes[j].allocSize = pVideoDec->pMFCDecOutputBuffer[i]->bufferSize[j];
909 if (pOutbufOps->Register(hMFCHandle, planes, MFC_OUTPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
910 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register output buffer");
911 ret = OMX_ErrorInsufficientResources;
915 pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr,
916 (unsigned int *)nDataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
927 OMX_ERRORTYPE H264CodecResetupAllElement(
928 OMX_COMPONENTTYPE *pOMXComponent,
931 OMX_ERRORTYPE ret = OMX_ErrorNone;
932 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
933 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
934 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
935 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
936 EXYNOS_OMX_BASEPORT *pOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
937 ExynosVideoDecBufferOps *pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
943 if ((nPortIndex == INPUT_PORT_INDEX) &&
944 (pH264Dec->bSourceStart == OMX_TRUE)) {
945 ret = OMX_ErrorNotImplemented;
947 } else if ((nPortIndex == OUTPUT_PORT_INDEX) &&
948 (pH264Dec->bDestinationStart == OMX_TRUE)) {
949 if (pOutputPort->bufferProcessType & BUFFER_COPY) {
951 /**********************************/
952 /* Codec Buffer Free & Unregister */
953 /**********************************/
954 H264CodecDstFreeCodecBuffers(pOMXComponent);
955 Exynos_CodecBufferReset(pExynosComponent, OUTPUT_PORT_INDEX);
957 if (pH264Dec->hMFCH264Handle.bShareableBuf == OMX_TRUE)
958 pOutbufOps->Clear_RegisteredBuffer(hMFCHandle);
960 pOutbufOps->Cleanup(hMFCHandle);
961 /******************************************************/
962 /* V4L2 Destnation Setup for DPB Buffer Number Change */
963 /******************************************************/
964 H264CodecDstSetup(pOMXComponent);
966 pVideoDec->bDRCProcessing = OMX_FALSE;
967 } else if (pOutputPort->bufferProcessType & BUFFER_SHARE) {
969 /**********************************/
970 /* Codec Buffer Unregister */
971 /**********************************/
972 pOutbufOps->Clear_RegisteredBuffer(hMFCHandle);
973 pOutbufOps->Cleanup(hMFCHandle);
976 ret = OMX_ErrorBadParameter;
986 OMX_ERRORTYPE H264CodecSrcSetup(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
988 OMX_ERRORTYPE ret = OMX_ErrorNone;
989 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
990 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
991 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
992 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
993 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
994 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
995 OMX_U32 oneFrameSize = pSrcInputData->dataLen;
997 ExynosVideoDecOps *pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
998 ExynosVideoDecBufferOps *pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
999 ExynosVideoDecBufferOps *pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
1000 ExynosVideoGeometry bufferConf;
1001 OMX_U32 inputBufferNumber = 0;
1006 if ((oneFrameSize <= 0) && (pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
1007 OMX_BUFFERHEADERTYPE *OMXBuffer = NULL;
1008 OMXBuffer = Exynos_OutputBufferGetQueue_Direct(pExynosComponent);
1009 if (OMXBuffer == NULL) {
1010 ret = OMX_ErrorUndefined;
1014 OMXBuffer->nTimeStamp = pSrcInputData->timeStamp;
1015 OMXBuffer->nFlags = pSrcInputData->nFlags;
1016 Exynos_OMX_OutputBufferReturn(pOMXComponent, OMXBuffer);
1018 ret = OMX_ErrorNone;
1022 if (!((pExynosInputPort->bufferProcessType & BUFFER_COPY) &&
1023 pH264Dec->hMFCH264Handle.bShareableBuf == OMX_FALSE)) {
1024 ret = H264CodecSrcInit(pOMXComponent);
1025 if (ret != OMX_ErrorNone)
1029 /* set output geometry */
1030 Exynos_OSAL_Memset(&bufferConf, 0, sizeof(bufferConf));
1031 pH264Dec->hMFCH264Handle.MFCOutputColorType = bufferConf.eColorFormat = VIDEO_COLORFORMAT_NV12;
1032 if (pOutbufOps->Set_Geometry(hMFCHandle, &bufferConf) != VIDEO_ERROR_NONE) {
1033 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to set geometry for output buffer");
1034 ret = OMX_ErrorInsufficientResources;
1038 /* input buffer enqueue for header parsing */
1039 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "oneFrameSize: %d", oneFrameSize);
1040 if (pInbufOps->Enqueue(hMFCHandle, (unsigned char **)&pSrcInputData->buffer.singlePlaneBuffer.dataBuffer,
1041 (unsigned int *)&oneFrameSize, MFC_INPUT_BUFFER_PLANE, pSrcInputData->bufferHeader) != VIDEO_ERROR_NONE) {
1042 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to enqueue input buffer for header parsing");
1043 // ret = OMX_ErrorInsufficientResources;
1044 ret = (OMX_ERRORTYPE)OMX_ErrorCodecInit;
1048 /* start header parsing */
1049 if (pInbufOps->Run(hMFCHandle) != VIDEO_ERROR_NONE) {
1050 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to run input buffer for header parsing");
1051 ret = OMX_ErrorCodecInit;
1055 ret = H264CodecCheckResolutionChange(pOMXComponent);
1056 if (ret != OMX_ErrorNone) {
1057 ret = OMX_ErrorCodecInit;
1061 Exynos_OSAL_SleepMillisec(0);
1062 ret = OMX_ErrorInputDataDecodeYet;
1064 #ifdef USE_IMMEDIATE_DISPLAY
1065 /* Set Immediately display for I Frame*/
1066 pDecOps->Set_ImmediateDisplay(hMFCHandle);
1070 H264CodecStop(pOMXComponent, INPUT_PORT_INDEX);
1076 OMX_ERRORTYPE H264CodecDstSetup(OMX_COMPONENTTYPE *pOMXComponent)
1078 OMX_ERRORTYPE ret = OMX_ErrorNone;
1079 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1080 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1081 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
1082 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
1083 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1084 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1086 ExynosVideoDecOps *pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
1087 ExynosVideoDecBufferOps *pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
1088 ExynosVideoDecBufferOps *pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
1095 nOutbufs = pH264Dec->hMFCH264Handle.maxDPBNum;
1097 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1098 /* should be done before prepare output buffer */
1099 if (pOutbufOps->Enable_Cacheable(hMFCHandle) != VIDEO_ERROR_NONE) {
1100 ret = OMX_ErrorInsufficientResources;
1105 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE
1106 ||pH264Dec->hMFCH264Handle.bShareableBuf == OMX_TRUE)
1107 pOutbufOps->Set_Shareable(hMFCHandle);
1109 if (pOutbufOps->Setup(hMFCHandle, nOutbufs) != VIDEO_ERROR_NONE) {
1110 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to setup output buffer");
1111 ret = OMX_ErrorInsufficientResources;
1115 ExynosVideoPlane planes[MFC_OUTPUT_BUFFER_PLANE];
1116 OMX_U32 nAllocLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
1117 OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
1120 nAllocLen[0] = calc_plane(pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth,
1121 pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight);
1122 nAllocLen[1] = calc_plane(pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth,
1123 pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight >> 1);
1125 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY &&
1126 pH264Dec->hMFCH264Handle.bShareableBuf == OMX_TRUE) {
1127 H264CodecDstAllocCodecBuffers(pOMXComponent, nOutbufs);
1128 H264CodecDstRegistCodecBuffers(pOMXComponent, nOutbufs);
1129 } else if (pExynosOutputPort->bufferProcessType & BUFFER_COPY &&
1130 pH264Dec->hMFCH264Handle.bShareableBuf == OMX_FALSE) {
1132 /* Register output buffer */
1133 for (i = 0; i < nOutbufs; i++) {
1135 OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
1136 ExynosVideoBuffer *pBuffer = NULL;
1137 pVideoDec->pMFCDecOutputBuffer[i] = (CODEC_DEC_BUFFER *)Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
1138 Exynos_OSAL_Memset(pVideoDec->pMFCDecOutputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
1140 if (pOutbufOps->Get_Buffer) {
1141 if (pOutbufOps->Get_Buffer(pH264Dec->hMFCH264Handle.hMFCHandle, i, &pBuffer) != VIDEO_ERROR_NONE) {
1142 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get Output buffer info");
1143 ret = OMX_ErrorInsufficientResources;
1148 for (plane = 0; plane < MFC_OUTPUT_BUFFER_PLANE; plane++) {
1149 pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[plane] = (void *)pBuffer->planes[plane].addr;
1150 pVideoDec->pMFCDecOutputBuffer[i]->fd[plane] = pBuffer->planes[plane].fd;
1151 pVideoDec->pMFCDecOutputBuffer[i]->bufferSize[plane] = pBuffer->planes[plane].allocSize;
1154 pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr,
1155 (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
1157 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1159 if (pExynosOutputPort->bIsPBEnabled == OMX_TRUE) {
1160 for (i = 0; i < pExynosOutputPort->assignedBufferNum; i++) {
1161 for (plane = 0; plane < MFC_OUTPUT_BUFFER_PLANE; plane++) {
1162 planes[plane].fd = pExynosOutputPort->extendBufferHeader[i].buf_fd[plane];
1163 planes[plane].addr = pExynosOutputPort->extendBufferHeader[i].pYUVBuf[plane];
1164 planes[plane].tbm_bo = pExynosOutputPort->extendBufferHeader[i].tbm_bo[plane];
1165 planes[plane].allocSize = nAllocLen[plane];
1168 if (pOutbufOps->Register(hMFCHandle, planes, MFC_OUTPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
1169 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register output buffer");
1170 ret = OMX_ErrorInsufficientResources;
1173 pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pExynosOutputPort->extendBufferHeader[i].pYUVBuf,
1174 (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
1177 ret = OMX_ErrorNotImplemented;
1181 ret = OMX_ErrorNotImplemented;
1184 /* Waiting for DPB buffer setup to be completed,
1185 * valid only for share mode
1187 if (pDecOps->Enable_DecodeWait != NULL)
1188 pDecOps->Enable_DecodeWait(hMFCHandle);
1192 if (pOutbufOps->Run(hMFCHandle) != VIDEO_ERROR_NONE) {
1193 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to run output buffer");
1194 ret = OMX_ErrorInsufficientResources;
1198 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1199 H264CodecStop(pOMXComponent, OUTPUT_PORT_INDEX);
1201 pH264Dec->hMFCH264Handle.bConfiguredMFCDst = OMX_TRUE;
1203 ret = OMX_ErrorNone;
1211 OMX_ERRORTYPE H264CodecCheckResolutionChange(OMX_COMPONENTTYPE *pOMXComponent)
1213 OMX_ERRORTYPE ret = OMX_ErrorNone;
1214 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1215 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1216 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1217 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
1218 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1219 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1221 ExynosVideoDecOps *pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
1222 ExynosVideoDecBufferOps *pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
1223 ExynosVideoDecBufferOps *pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
1224 ExynosVideoGeometry bufferConf;
1229 /* get geometry for output */
1230 Exynos_OSAL_Memset(&pH264Dec->hMFCH264Handle.codecOutbufConf, 0, sizeof(ExynosVideoGeometry));
1231 if (pOutbufOps->Get_Geometry(hMFCHandle, &pH264Dec->hMFCH264Handle.codecOutbufConf) != VIDEO_ERROR_NONE) {
1232 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get geometry for parsed header info");
1233 ret = OMX_ErrorInsufficientResources;
1238 pH264Dec->hMFCH264Handle.maxDPBNum = pDecOps->Get_ActualBufferCount(hMFCHandle);
1239 if (pVideoDec->bThumbnailMode == OMX_FALSE)
1240 pH264Dec->hMFCH264Handle.maxDPBNum += EXTRA_DPB_NUM;
1241 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "H264CodecCheckResolutionChange H264CodecSetup nOutbufs: %d", pH264Dec->hMFCH264Handle.maxDPBNum);
1243 pH264Dec->hMFCH264Handle.bConfiguredMFCSrc = OMX_TRUE;
1245 pExynosOutputPort->cropRectangle.nTop = pH264Dec->hMFCH264Handle.codecOutbufConf.cropRect.nTop;
1246 pExynosOutputPort->cropRectangle.nLeft = pH264Dec->hMFCH264Handle.codecOutbufConf.cropRect.nLeft;
1247 pExynosOutputPort->cropRectangle.nWidth = pH264Dec->hMFCH264Handle.codecOutbufConf.cropRect.nWidth;
1248 pExynosOutputPort->cropRectangle.nHeight = pH264Dec->hMFCH264Handle.codecOutbufConf.cropRect.nHeight;
1250 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1251 if ((pVideoDec->bDRCProcessing) ||
1252 (pExynosInputPort->portDefinition.format.video.nFrameWidth != pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth) ||
1253 (pExynosInputPort->portDefinition.format.video.nFrameHeight != pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight)) {
1254 pExynosInputPort->portDefinition.format.video.nFrameWidth = pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth;
1255 pExynosInputPort->portDefinition.format.video.nFrameHeight = pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight;
1256 pExynosInputPort->portDefinition.format.video.nStride = ((pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth + 15) & (~15));
1257 pExynosInputPort->portDefinition.format.video.nSliceHeight = ((pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight + 15) & (~15));
1259 if (pVideoDec->bDRCProcessing == OMX_TRUE) {
1260 pVideoDec->nDRCSavedBufferCount = pExynosOutputPort->portDefinition.nBufferCountActual;
1262 Exynos_UpdateFrameSize(pOMXComponent);
1263 pExynosOutputPort->exceptionFlag = NEED_PORT_DISABLE;
1265 /** Send Port Settings changed call back **/
1266 (*(pExynosComponent->pCallbacks->EventHandler))
1268 pExynosComponent->callbackData,
1269 OMX_EventPortSettingsChanged, /* The command was completed */
1270 OMX_DirOutput, /* This is the port index */
1274 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1275 #ifndef TIZEN_FEATURE_E3250
1276 /* The input port information has already been updated */
1277 if ((pExynosInputPort->portDefinition.format.video.nFrameWidth != pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth) ||
1278 (pExynosInputPort->portDefinition.format.video.nFrameHeight != pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight) ||
1279 (pExynosOutputPort->portDefinition.nBufferCountActual != pH264Dec->hMFCH264Handle.maxDPBNum)) {
1280 pExynosInputPort->portDefinition.format.video.nFrameWidth = pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth;
1281 pExynosInputPort->portDefinition.format.video.nFrameHeight = pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight;
1282 pExynosInputPort->portDefinition.format.video.nStride = ((pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth + 15) & (~15));
1283 pExynosInputPort->portDefinition.format.video.nSliceHeight = ((pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight + 15) & (~15));
1285 if (pVideoDec->bDRCProcessing == OMX_TRUE) {
1286 pVideoDec->nDRCSavedBufferCount = pExynosOutputPort->portDefinition.nBufferCountActual;
1288 #ifdef TIZEN_FEATURE_E3250
1289 pExynosOutputPort->portDefinition.nBufferCountActual = pH264Dec->hMFCH264Handle.maxDPBNum;
1290 pExynosOutputPort->portDefinition.nBufferCountMin = pH264Dec->hMFCH264Handle.maxDPBNum;
1292 pExynosOutputPort->portDefinition.nBufferCountActual = pH264Dec->hMFCH264Handle.maxDPBNum - 4;
1293 pExynosOutputPort->portDefinition.nBufferCountMin = pH264Dec->hMFCH264Handle.maxDPBNum - 4;
1295 Exynos_UpdateFrameSize(pOMXComponent);
1296 pExynosOutputPort->exceptionFlag = NEED_PORT_DISABLE;
1298 /** Send Port Settings changed call back **/
1299 (*(pExynosComponent->pCallbacks->EventHandler))
1301 pExynosComponent->callbackData,
1302 OMX_EventPortSettingsChanged, /* The command was completed */
1303 OMX_DirOutput, /* This is the port index */
1306 #ifndef TIZEN_FEATURE_E3250
1311 if (((pVideoDec->bDRCProcessing) && (pExynosOutputPort->bufferProcessType & BUFFER_COPY)) ||
1312 (pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth != pH264Dec->hMFCH264Handle.codecOutbufConf.cropRect.nWidth) ||
1313 (pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight != pH264Dec->hMFCH264Handle.codecOutbufConf.cropRect.nHeight)) {
1315 pExynosInputPort->portDefinition.format.video.nFrameWidth = pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth;
1316 pExynosInputPort->portDefinition.format.video.nFrameHeight = pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight;
1317 pExynosInputPort->portDefinition.format.video.nStride = ((pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth + 15) & (~15));
1318 pExynosInputPort->portDefinition.format.video.nSliceHeight = ((pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight + 15) & (~15));
1319 Exynos_UpdateFrameSize(pOMXComponent);
1321 /** Send crop info call back **/
1322 (*(pExynosComponent->pCallbacks->EventHandler))
1324 pExynosComponent->callbackData,
1325 OMX_EventPortSettingsChanged, /* The command was completed */
1326 OMX_DirOutput, /* This is the port index */
1327 OMX_IndexConfigCommonOutputCrop,
1331 ret = OMX_ErrorNone;
1339 OMX_ERRORTYPE Exynos_H264Dec_GetParameter(
1340 OMX_IN OMX_HANDLETYPE hComponent,
1341 OMX_IN OMX_INDEXTYPE nParamIndex,
1342 OMX_INOUT OMX_PTR pComponentParameterStructure)
1344 OMX_ERRORTYPE ret = OMX_ErrorNone;
1345 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1346 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1350 if (hComponent == NULL || pComponentParameterStructure == NULL) {
1351 ret = OMX_ErrorBadParameter;
1354 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1355 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1356 if (ret != OMX_ErrorNone) {
1359 if (pOMXComponent->pComponentPrivate == NULL) {
1360 ret = OMX_ErrorBadParameter;
1364 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1365 if (pExynosComponent->currentState == OMX_StateInvalid ) {
1366 ret = OMX_ErrorInvalidState;
1370 switch (nParamIndex) {
1371 case OMX_IndexParamVideoAvc:
1373 OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = (OMX_VIDEO_PARAM_AVCTYPE *)pComponentParameterStructure;
1374 OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent = NULL;
1375 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
1377 ret = Exynos_OMX_Check_SizeVersion(pDstAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
1378 if (ret != OMX_ErrorNone) {
1382 if (pDstAVCComponent->nPortIndex >= ALL_PORT_NUM) {
1383 ret = OMX_ErrorBadPortIndex;
1387 pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1388 pSrcAVCComponent = &pH264Dec->AVCComponent[pDstAVCComponent->nPortIndex];
1390 Exynos_OSAL_Memcpy(pDstAVCComponent, pSrcAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
1393 case OMX_IndexParamStandardComponentRole:
1395 OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE *)pComponentParameterStructure;
1396 ret = Exynos_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1397 if (ret != OMX_ErrorNone) {
1401 Exynos_OSAL_Strcpy((char *)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_H264_DEC_ROLE);
1404 case OMX_IndexParamVideoProfileLevelQuerySupported:
1406 OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE*)pComponentParameterStructure;
1407 EXYNOS_OMX_VIDEO_PROFILELEVEL *pProfileLevel = NULL;
1408 OMX_U32 maxProfileLevelNum = 0;
1410 ret = Exynos_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
1411 if (ret != OMX_ErrorNone) {
1415 if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
1416 ret = OMX_ErrorBadPortIndex;
1420 pProfileLevel = supportedAVCProfileLevels;
1421 maxProfileLevelNum = sizeof(supportedAVCProfileLevels) / sizeof(EXYNOS_OMX_VIDEO_PROFILELEVEL);
1423 if (pDstProfileLevel->nProfileIndex >= maxProfileLevelNum) {
1424 ret = OMX_ErrorNoMore;
1428 pProfileLevel += pDstProfileLevel->nProfileIndex;
1429 pDstProfileLevel->eProfile = pProfileLevel->profile;
1430 pDstProfileLevel->eLevel = pProfileLevel->level;
1433 case OMX_IndexParamVideoProfileLevelCurrent:
1435 OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE*)pComponentParameterStructure;
1436 OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent = NULL;
1437 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
1439 ret = Exynos_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
1440 if (ret != OMX_ErrorNone) {
1444 if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
1445 ret = OMX_ErrorBadPortIndex;
1449 pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1450 pSrcAVCComponent = &pH264Dec->AVCComponent[pDstProfileLevel->nPortIndex];
1452 pDstProfileLevel->eProfile = pSrcAVCComponent->eProfile;
1453 pDstProfileLevel->eLevel = pSrcAVCComponent->eLevel;
1456 case OMX_IndexParamVideoErrorCorrection:
1458 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
1459 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = NULL;
1460 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
1462 ret = Exynos_OMX_Check_SizeVersion(pDstErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
1463 if (ret != OMX_ErrorNone) {
1467 if (pDstErrorCorrectionType->nPortIndex != INPUT_PORT_INDEX) {
1468 ret = OMX_ErrorBadPortIndex;
1472 pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1473 pSrcErrorCorrectionType = &pH264Dec->errorCorrectionType[INPUT_PORT_INDEX];
1475 pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
1476 pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
1477 pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
1478 pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
1479 pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
1483 ret = Exynos_OMX_VideoDecodeGetParameter(hComponent, nParamIndex, pComponentParameterStructure);
1492 OMX_ERRORTYPE Exynos_H264Dec_SetParameter(
1493 OMX_IN OMX_HANDLETYPE hComponent,
1494 OMX_IN OMX_INDEXTYPE nIndex,
1495 OMX_IN OMX_PTR pComponentParameterStructure)
1497 OMX_ERRORTYPE ret = OMX_ErrorNone;
1498 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1499 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1503 if (hComponent == NULL || pComponentParameterStructure == NULL) {
1504 ret = OMX_ErrorBadParameter;
1507 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1508 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1509 if (ret != OMX_ErrorNone) {
1512 if (pOMXComponent->pComponentPrivate == NULL) {
1513 ret = OMX_ErrorBadParameter;
1517 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1518 if (pExynosComponent->currentState == OMX_StateInvalid ) {
1519 ret = OMX_ErrorInvalidState;
1524 case OMX_IndexParamVideoAvc:
1526 OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = NULL;
1527 OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent = (OMX_VIDEO_PARAM_AVCTYPE *)pComponentParameterStructure;
1528 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
1530 ret = Exynos_OMX_Check_SizeVersion(pSrcAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
1531 if (ret != OMX_ErrorNone) {
1535 if (pSrcAVCComponent->nPortIndex >= ALL_PORT_NUM) {
1536 ret = OMX_ErrorBadPortIndex;
1540 pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1541 pDstAVCComponent = &pH264Dec->AVCComponent[pSrcAVCComponent->nPortIndex];
1543 Exynos_OSAL_Memcpy(pDstAVCComponent, pSrcAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
1546 case OMX_IndexParamStandardComponentRole:
1548 OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE*)pComponentParameterStructure;
1550 ret = Exynos_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1551 if (ret != OMX_ErrorNone) {
1555 if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1556 ret = OMX_ErrorIncorrectStateOperation;
1560 if (!Exynos_OSAL_Strcmp((char*)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_H264_DEC_ROLE)) {
1561 pExynosComponent->pExynosPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
1563 ret = OMX_ErrorBadParameter;
1568 case OMX_IndexParamPortDefinition:
1570 OMX_PARAM_PORTDEFINITIONTYPE *pPortDefinition = (OMX_PARAM_PORTDEFINITIONTYPE *)pComponentParameterStructure;
1571 OMX_U32 portIndex = pPortDefinition->nPortIndex;
1572 EXYNOS_OMX_BASEPORT *pExynosPort;
1573 OMX_U32 width, height, size;
1574 OMX_U32 realWidth, realHeight;
1575 OMX_PARAM_PORTDEFINITIONTYPE portDefinition_backup;
1577 if (portIndex >= pExynosComponent->portParam.nPorts) {
1578 ret = OMX_ErrorBadPortIndex;
1581 ret = Exynos_OMX_Check_SizeVersion(pPortDefinition, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1582 if (ret != OMX_ErrorNone) {
1586 pExynosPort = &pExynosComponent->pExynosPort[portIndex];
1588 if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1589 if (pExynosPort->portDefinition.bEnabled == OMX_TRUE) {
1590 ret = OMX_ErrorIncorrectStateOperation;
1594 if (pPortDefinition->nBufferCountActual < pExynosPort->portDefinition.nBufferCountMin) {
1595 ret = OMX_ErrorBadParameter;
1599 Exynos_OSAL_Memcpy(&portDefinition_backup, &pExynosPort->portDefinition, pPortDefinition->nSize);
1600 Exynos_OSAL_Memcpy(&pExynosPort->portDefinition, pPortDefinition, pPortDefinition->nSize);
1601 RESTORE_READONLYPARAMETERS_OMX_PARAM_PORTDEFINITIONTYPE(&pExynosPort->portDefinition,&portDefinition_backup);
1603 realWidth = pExynosPort->portDefinition.format.video.nFrameWidth;
1604 realHeight = pExynosPort->portDefinition.format.video.nFrameHeight;
1605 width = ((realWidth + 15) & (~15));
1606 height = ((realHeight + 15) & (~15));
1607 size = (width * height * 3) / 2;
1608 pExynosPort->portDefinition.format.video.nStride = width;
1609 pExynosPort->portDefinition.format.video.nSliceHeight = height;
1610 pExynosPort->portDefinition.nBufferSize = (size > pExynosPort->portDefinition.nBufferSize) ? size : pExynosPort->portDefinition.nBufferSize;
1612 if (portIndex == INPUT_PORT_INDEX) {
1613 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1614 pExynosOutputPort->portDefinition.format.video.nFrameWidth = pExynosPort->portDefinition.format.video.nFrameWidth;
1615 pExynosOutputPort->portDefinition.format.video.nFrameHeight = pExynosPort->portDefinition.format.video.nFrameHeight;
1616 pExynosOutputPort->portDefinition.format.video.nStride = width;
1617 pExynosOutputPort->portDefinition.format.video.nSliceHeight = height;
1619 switch (pExynosOutputPort->portDefinition.format.video.eColorFormat) {
1620 case OMX_COLOR_FormatYUV420Planar:
1621 case OMX_COLOR_FormatYUV420SemiPlanar:
1622 pExynosOutputPort->portDefinition.nBufferSize = (width * height * 3) / 2;
1624 #ifdef TIZEN_FEATURE_E3250 /* NV12 fd */
1625 case OMX_SEC_COLOR_FormatNV12L_DmaBuf_Fd:
1626 case OMX_SEC_COLOR_FormatNV12T_DmaBuf_Fd:
1627 pExynosOutputPort->portDefinition.nBufferSize = sizeof(MMVideoBuffer);
1630 case OMX_SEC_COLOR_FormatNV12Tiled:
1631 pExynosOutputPort->portDefinition.nBufferSize =
1632 calc_plane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight) +
1633 calc_plane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight >> 1);
1636 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Color format is not support!! use default YUV size!!");
1637 ret = OMX_ErrorUnsupportedSetting;
1641 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1642 pExynosOutputPort->portDefinition.nBufferSize =
1643 calc_plane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight) +
1644 calc_plane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight >> 1);
1649 case OMX_IndexParamVideoProfileLevelCurrent:
1651 OMX_VIDEO_PARAM_PROFILELEVELTYPE *pSrcProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
1652 OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = NULL;
1653 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
1655 ret = Exynos_OMX_Check_SizeVersion(pSrcProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
1656 if (ret != OMX_ErrorNone)
1659 if (pSrcProfileLevel->nPortIndex >= ALL_PORT_NUM) {
1660 ret = OMX_ErrorBadPortIndex;
1664 pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1666 pDstAVCComponent = &pH264Dec->AVCComponent[pSrcProfileLevel->nPortIndex];
1667 pDstAVCComponent->eProfile = pSrcProfileLevel->eProfile;
1668 pDstAVCComponent->eLevel = pSrcProfileLevel->eLevel;
1671 case OMX_IndexParamVideoErrorCorrection:
1673 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
1674 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = NULL;
1675 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
1677 ret = Exynos_OMX_Check_SizeVersion(pSrcErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
1678 if (ret != OMX_ErrorNone) {
1682 if (pSrcErrorCorrectionType->nPortIndex != INPUT_PORT_INDEX) {
1683 ret = OMX_ErrorBadPortIndex;
1687 pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1688 pDstErrorCorrectionType = &pH264Dec->errorCorrectionType[INPUT_PORT_INDEX];
1690 pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
1691 pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
1692 pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
1693 pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
1694 pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
1698 ret = Exynos_OMX_VideoDecodeSetParameter(hComponent, nIndex, pComponentParameterStructure);
1707 OMX_ERRORTYPE Exynos_H264Dec_GetConfig(
1708 OMX_HANDLETYPE hComponent,
1709 OMX_INDEXTYPE nIndex,
1710 OMX_PTR pComponentConfigStructure)
1712 OMX_ERRORTYPE ret = OMX_ErrorNone;
1713 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1714 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1718 if (hComponent == NULL) {
1719 ret = OMX_ErrorBadParameter;
1722 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1723 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1724 if (ret != OMX_ErrorNone) {
1727 if (pOMXComponent->pComponentPrivate == NULL) {
1728 ret = OMX_ErrorBadParameter;
1731 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1732 if (pComponentConfigStructure == NULL) {
1733 ret = OMX_ErrorBadParameter;
1736 if (pExynosComponent->currentState == OMX_StateInvalid) {
1737 ret = OMX_ErrorInvalidState;
1742 case OMX_IndexConfigCommonOutputCrop:
1744 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
1745 OMX_CONFIG_RECTTYPE *pSrcRectType = NULL;
1746 OMX_CONFIG_RECTTYPE *pDstRectType = NULL;
1747 pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1749 if (pH264Dec->hMFCH264Handle.bConfiguredMFCSrc == OMX_FALSE) {
1750 ret = OMX_ErrorNotReady;
1754 pDstRectType = (OMX_CONFIG_RECTTYPE *)pComponentConfigStructure;
1756 if ((pDstRectType->nPortIndex != INPUT_PORT_INDEX) &&
1757 (pDstRectType->nPortIndex != OUTPUT_PORT_INDEX)) {
1758 ret = OMX_ErrorBadPortIndex;
1762 EXYNOS_OMX_BASEPORT *pExynosPort = &pExynosComponent->pExynosPort[pDstRectType->nPortIndex];
1764 pSrcRectType = &(pExynosPort->cropRectangle);
1766 pDstRectType->nTop = pSrcRectType->nTop;
1767 pDstRectType->nLeft = pSrcRectType->nLeft;
1768 pDstRectType->nHeight = pSrcRectType->nHeight;
1769 pDstRectType->nWidth = pSrcRectType->nWidth;
1772 #ifdef USE_S3D_SUPPORT
1773 case OMX_IndexVendorS3DMode:
1775 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
1776 OMX_U32 *pS3DMode = NULL;
1777 pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1779 pS3DMode = (OMX_U32 *)pComponentConfigStructure;
1780 *pS3DMode = (OMX_U32) pH264Dec->hMFCH264Handle.S3DFPArgmtType;
1785 ret = Exynos_OMX_VideoDecodeGetConfig(hComponent, nIndex, pComponentConfigStructure);
1795 OMX_ERRORTYPE Exynos_H264Dec_SetConfig(
1796 OMX_HANDLETYPE hComponent,
1797 OMX_INDEXTYPE nIndex,
1798 OMX_PTR pComponentConfigStructure)
1800 OMX_ERRORTYPE ret = OMX_ErrorNone;
1801 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1802 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1806 if (hComponent == NULL) {
1807 ret = OMX_ErrorBadParameter;
1810 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1811 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1812 if (ret != OMX_ErrorNone) {
1815 if (pOMXComponent->pComponentPrivate == NULL) {
1816 ret = OMX_ErrorBadParameter;
1819 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1820 if (pComponentConfigStructure == NULL) {
1821 ret = OMX_ErrorBadParameter;
1824 if (pExynosComponent->currentState == OMX_StateInvalid) {
1825 ret = OMX_ErrorInvalidState;
1831 ret = Exynos_OMX_VideoDecodeSetConfig(hComponent, nIndex, pComponentConfigStructure);
1841 OMX_ERRORTYPE Exynos_H264Dec_GetExtensionIndex(
1842 OMX_IN OMX_HANDLETYPE hComponent,
1843 OMX_IN OMX_STRING cParameterName,
1844 OMX_OUT OMX_INDEXTYPE *pIndexType)
1846 OMX_ERRORTYPE ret = OMX_ErrorNone;
1847 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1848 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1852 if (hComponent == NULL) {
1853 ret = OMX_ErrorBadParameter;
1856 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1857 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1858 if (ret != OMX_ErrorNone) {
1861 if (pOMXComponent->pComponentPrivate == NULL) {
1862 ret = OMX_ErrorBadParameter;
1865 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1866 if ((cParameterName == NULL) || (pIndexType == NULL)) {
1867 ret = OMX_ErrorBadParameter;
1870 if (pExynosComponent->currentState == OMX_StateInvalid) {
1871 ret = OMX_ErrorInvalidState;
1875 if (Exynos_OSAL_Strcmp(cParameterName, EXYNOS_INDEX_PARAM_ENABLE_THUMBNAIL) == 0) {
1876 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1877 *pIndexType = OMX_IndexVendorThumbnailMode;
1878 ret = OMX_ErrorNone;
1880 #ifdef USE_S3D_SUPPORT
1881 else if (Exynos_OSAL_Strcmp(cParameterName, EXYNOS_INDEX_PARAM_GET_S3D) == 0) {
1882 *pIndexType = OMX_IndexVendorS3DMode;
1883 ret = OMX_ErrorNone;
1887 ret = Exynos_OMX_VideoDecodeGetExtensionIndex(hComponent, cParameterName, pIndexType);
1896 OMX_ERRORTYPE Exynos_H264Dec_ComponentRoleEnum(
1897 OMX_HANDLETYPE hComponent,
1901 OMX_ERRORTYPE ret = OMX_ErrorNone;
1902 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1903 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1907 if ((hComponent == NULL) || (cRole == NULL)) {
1908 ret = OMX_ErrorBadParameter;
1911 if (nIndex == (MAX_COMPONENT_ROLE_NUM-1)) {
1912 Exynos_OSAL_Strcpy((char *)cRole, EXYNOS_OMX_COMPONENT_H264_DEC_ROLE);
1913 ret = OMX_ErrorNone;
1915 ret = OMX_ErrorNoMore;
1925 OMX_ERRORTYPE Exynos_H264Dec_Init(OMX_COMPONENTTYPE *pOMXComponent)
1927 OMX_ERRORTYPE ret = OMX_ErrorNone;
1928 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1929 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1930 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1931 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1932 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
1933 OMX_PTR hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
1935 ExynosVideoDecOps *pDecOps = NULL;
1936 ExynosVideoDecBufferOps *pInbufOps = NULL;
1937 ExynosVideoDecBufferOps *pOutbufOps = NULL;
1939 CSC_METHOD csc_method = CSC_METHOD_SW;
1944 pH264Dec->hMFCH264Handle.bConfiguredMFCSrc = OMX_FALSE;
1945 pH264Dec->hMFCH264Handle.bConfiguredMFCDst = OMX_FALSE;
1946 pExynosComponent->bUseFlagEOF = OMX_TRUE;
1947 pExynosComponent->bSaveFlagEOS = OMX_FALSE;
1949 /* H.264 Codec Open */
1950 ret = H264CodecOpen(pH264Dec);
1951 if (ret != OMX_ErrorNone) {
1955 pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
1956 pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
1957 pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
1959 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
1960 Exynos_OSAL_SemaphoreCreate(&pExynosInputPort->codecSemID);
1961 Exynos_OSAL_QueueCreate(&pExynosInputPort->codecBufferQ, MAX_QUEUE_ELEMENTS);
1963 if (pH264Dec->hMFCH264Handle.bShareableBuf == OMX_TRUE) {
1964 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
1965 pVideoDec->pMFCDecInputBuffer[i] = Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
1966 Exynos_OSAL_Memset(pVideoDec->pMFCDecInputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
1967 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]);
1969 for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
1970 /* Use ION Allocator */
1971 pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] = (void *)Exynos_OSAL_SharedMemory_Alloc(pVideoDec->hSharedMemory, DEFAULT_MFC_INPUT_BUFFER_SIZE, NORMAL_MEMORY);
1972 pVideoDec->pMFCDecInputBuffer[i]->fd[plane] = Exynos_OSAL_SharedMemory_VirtToION(pVideoDec->hSharedMemory, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
1973 pVideoDec->pMFCDecInputBuffer[i]->bufferSize[plane] = DEFAULT_MFC_INPUT_BUFFER_SIZE;
1974 pVideoDec->pMFCDecInputBuffer[i]->dataSize = 0;
1975 if (pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] == NULL) {
1976 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Fail input buffer");
1977 ret = OMX_ErrorInsufficientResources;
1980 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]->pVirAddr[%d]: 0x%x", i, plane, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
1983 Exynos_CodecBufferEnQueue(pExynosComponent, INPUT_PORT_INDEX, pVideoDec->pMFCDecInputBuffer[i]);
1986 #ifdef TIZEN_FEATURE_E3250
1987 if (pOMXComponent == NULL) {
1988 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s : %d: invalid parm: pOMXComponent = %p", __FUNCTION__, __LINE__, pOMXComponent);
1991 ret = H264CodecSrcInit(pOMXComponent);
1992 if (ret != OMX_ErrorNone)
1995 } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
1999 /* Does not require any actions. */
2002 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
2003 Exynos_OSAL_SemaphoreCreate(&pExynosOutputPort->codecSemID);
2004 Exynos_OSAL_QueueCreate(&pExynosOutputPort->codecBufferQ, MAX_QUEUE_ELEMENTS);
2005 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
2009 /* Does not require any actions. */
2012 pH264Dec->bSourceStart = OMX_FALSE;
2013 Exynos_OSAL_SignalCreate(&pH264Dec->hSourceStartEvent);
2014 pH264Dec->bDestinationStart = OMX_FALSE;
2015 Exynos_OSAL_SignalCreate(&pH264Dec->hDestinationStartEvent);
2017 Exynos_OSAL_Memset(pExynosComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
2018 Exynos_OSAL_Memset(pExynosComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
2019 pH264Dec->hMFCH264Handle.indexTimestamp = 0;
2020 pH264Dec->hMFCH264Handle.outputIndexTimestamp = 0;
2022 pExynosComponent->getAllDelayBuffer = OMX_FALSE;
2024 #if 0//defined(USE_CSC_GSCALER)
2025 csc_method = CSC_METHOD_HW; //in case of Use ION buffer.
2027 if (pVideoDec->bDRMPlayerMode == OMX_TRUE) {
2028 pVideoDec->csc_handle = csc_init(CSC_METHOD_HW);
2029 csc_set_hw_property(pVideoDec->csc_handle, CSC_HW_PROPERTY_FIXED_NODE, 2);
2030 csc_set_hw_property(pVideoDec->csc_handle, CSC_HW_PROPERTY_MODE_DRM, pVideoDec->bDRMPlayerMode);
2032 pVideoDec->csc_handle = csc_init(csc_method);
2035 if (pVideoDec->csc_handle == NULL) {
2036 ret = OMX_ErrorInsufficientResources;
2039 pVideoDec->csc_set_format = OMX_FALSE;
2048 OMX_ERRORTYPE Exynos_H264Dec_Terminate(OMX_COMPONENTTYPE *pOMXComponent)
2050 OMX_ERRORTYPE ret = OMX_ErrorNone;
2051 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2052 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2053 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2054 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2055 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2056 OMX_PTR hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
2058 ExynosVideoDecOps *pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
2059 ExynosVideoDecBufferOps *pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
2060 ExynosVideoDecBufferOps *pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
2066 if (pVideoDec->csc_handle != NULL) {
2067 csc_deinit(pVideoDec->csc_handle);
2068 pVideoDec->csc_handle = NULL;
2071 Exynos_OSAL_SignalTerminate(pH264Dec->hDestinationStartEvent);
2072 pH264Dec->hDestinationStartEvent = NULL;
2073 pH264Dec->bDestinationStart = OMX_FALSE;
2074 Exynos_OSAL_SignalTerminate(pH264Dec->hSourceStartEvent);
2075 pH264Dec->hSourceStartEvent = NULL;
2076 pH264Dec->bSourceStart = OMX_FALSE;
2078 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
2079 H264CodecDstFreeCodecBuffers(pOMXComponent);
2081 Exynos_OSAL_QueueTerminate(&pExynosOutputPort->codecBufferQ);
2082 Exynos_OSAL_SemaphoreTerminate(pExynosOutputPort->codecSemID);
2083 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
2087 /* Does not require any actions. */
2090 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2091 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
2092 if (pVideoDec->pMFCDecInputBuffer[i] != NULL) {
2093 #ifndef TIZEN_FEATURE_E3250 /* do not use ion */
2094 for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
2095 if (pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] != NULL)
2096 Exynos_OSAL_SharedMemory_Free(pVideoDec->hSharedMemory, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
2099 Exynos_OSAL_Free(pVideoDec->pMFCDecInputBuffer[i]);
2100 pVideoDec->pMFCDecInputBuffer[i] = NULL;
2104 Exynos_OSAL_QueueTerminate(&pExynosInputPort->codecBufferQ);
2105 Exynos_OSAL_SemaphoreTerminate(pExynosInputPort->codecSemID);
2106 } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
2110 /* Does not require any actions. */
2112 H264CodecClose(pH264Dec);
2120 OMX_ERRORTYPE Exynos_H264Dec_SrcIn(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
2122 OMX_ERRORTYPE ret = OMX_ErrorNone;
2123 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2124 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2125 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2126 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
2127 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2128 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2129 OMX_U32 oneFrameSize = pSrcInputData->dataLen;
2130 OMX_BOOL bInStartCode = OMX_FALSE;
2131 ExynosVideoDecOps *pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
2132 ExynosVideoDecBufferOps *pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
2133 ExynosVideoDecBufferOps *pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
2134 ExynosVideoErrorType codecReturn = VIDEO_ERROR_NONE;
2139 if (pH264Dec->hMFCH264Handle.bConfiguredMFCSrc == OMX_FALSE) {
2140 ret = H264CodecSrcSetup(pOMXComponent, pSrcInputData);
2143 if (pH264Dec->hMFCH264Handle.bConfiguredMFCDst == OMX_FALSE) {
2144 ret = H264CodecDstSetup(pOMXComponent);
2147 if (((pVideoDec->bDRMPlayerMode == OMX_TRUE) ||
2148 ((bInStartCode = Check_H264_StartCode(pSrcInputData->buffer.singlePlaneBuffer.dataBuffer, oneFrameSize)) == OMX_TRUE)) ||
2149 ((pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)) {
2150 pExynosComponent->timeStamp[pH264Dec->hMFCH264Handle.indexTimestamp] = pSrcInputData->timeStamp;
2151 pExynosComponent->nFlags[pH264Dec->hMFCH264Handle.indexTimestamp] = pSrcInputData->nFlags;
2152 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);
2153 pDecOps->Set_FrameTag(hMFCHandle, pH264Dec->hMFCH264Handle.indexTimestamp);
2154 pH264Dec->hMFCH264Handle.indexTimestamp++;
2155 pH264Dec->hMFCH264Handle.indexTimestamp %= MAX_TIMESTAMP;
2157 #ifdef USE_IMMEDIATE_DISPLAY
2158 /* Set Immediately display for I Frame*/
2160 if (pExynosComponent->checkTimeStamp.needCheckStartTimeStamp == OMX_TRUE) {
2161 if ( pExynosComponent->checkTimeStamp.bImmediateDisplay == OMX_FALSE) {
2162 /* Enable Immediately display After seek*/
2163 pDecOps->Set_ImmediateDisplay(hMFCHandle);
2164 pExynosComponent->checkTimeStamp.bImmediateDisplay = OMX_TRUE;
2169 /*Add First Frame check : */
2170 if((pSrcInputData->nFlags & OMX_BUFFERFLAG_CODECCONFIG) == OMX_BUFFERFLAG_CODECCONFIG)
2172 Exynos_OSAL_Log(EXYNOS_LOG_TRACE,"Video First Frame Coming");
2175 /* queue work for input buffer */
2176 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "oneFrameSize: %d, bufferHeader: 0x%x, dataBuffer: 0x%x", oneFrameSize, pSrcInputData->bufferHeader, pSrcInputData->buffer.singlePlaneBuffer.dataBuffer);
2177 codecReturn = pInbufOps->Enqueue(hMFCHandle, (unsigned char **)&pSrcInputData->buffer.singlePlaneBuffer.dataBuffer,
2178 (unsigned int *)&oneFrameSize, MFC_INPUT_BUFFER_PLANE, pSrcInputData->bufferHeader);
2179 if (codecReturn != VIDEO_ERROR_NONE) {
2180 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2181 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s : %d", __FUNCTION__, __LINE__);
2184 H264CodecStart(pOMXComponent, INPUT_PORT_INDEX);
2185 if (pH264Dec->bSourceStart == OMX_FALSE) {
2186 pH264Dec->bSourceStart = OMX_TRUE;
2187 Exynos_OSAL_SignalSet(pH264Dec->hSourceStartEvent);
2188 Exynos_OSAL_SleepMillisec(0);
2190 if (pH264Dec->bDestinationStart == OMX_FALSE) {
2191 pH264Dec->bDestinationStart = OMX_TRUE;
2192 Exynos_OSAL_SignalSet(pH264Dec->hDestinationStartEvent);
2193 Exynos_OSAL_SleepMillisec(0);
2195 } else if (bInStartCode == OMX_FALSE) {
2196 ret = OMX_ErrorCorruptedFrame;
2200 ret = OMX_ErrorNone;
2208 OMX_ERRORTYPE Exynos_H264Dec_SrcOut(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcOutputData)
2210 OMX_ERRORTYPE ret = OMX_ErrorNone;
2211 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2212 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2213 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2214 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
2215 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2216 ExynosVideoDecOps *pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
2217 ExynosVideoDecBufferOps *pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
2218 ExynosVideoBuffer *pVideoBuffer;
2222 pVideoBuffer = pInbufOps->Dequeue(hMFCHandle);
2224 pSrcOutputData->dataLen = 0;
2225 pSrcOutputData->usedDataLen = 0;
2226 pSrcOutputData->remainDataLen = 0;
2227 pSrcOutputData->nFlags = 0;
2228 pSrcOutputData->timeStamp = 0;
2230 if (pVideoBuffer == NULL) {
2231 pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer = NULL;
2232 pSrcOutputData->allocSize = 0;
2233 pSrcOutputData->pPrivate = NULL;
2234 pSrcOutputData->bufferHeader = NULL;
2236 pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer = pVideoBuffer->planes[0].addr;
2237 pSrcOutputData->buffer.singlePlaneBuffer.fd = pVideoBuffer->planes[0].fd;
2238 pSrcOutputData->allocSize = pVideoBuffer->planes[0].allocSize;
2240 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2242 while (pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer != pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[0]) {
2243 if (i >= MFC_INPUT_BUFFER_NUM_MAX) {
2244 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Can not find buffer");
2245 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2250 pVideoDec->pMFCDecInputBuffer[i]->dataSize = 0;
2251 pSrcOutputData->pPrivate = pVideoDec->pMFCDecInputBuffer[i];
2254 /* For Share Buffer */
2255 pSrcOutputData->bufferHeader = (OMX_BUFFERHEADERTYPE*)pVideoBuffer->pPrivate;
2258 ret = OMX_ErrorNone;
2266 OMX_ERRORTYPE Exynos_H264Dec_DstIn(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstInputData)
2268 OMX_ERRORTYPE ret = OMX_ErrorNone;
2269 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2270 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2271 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2272 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
2273 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2274 ExynosVideoDecOps *pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
2275 ExynosVideoDecBufferOps *pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
2276 OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0,};
2277 ExynosVideoErrorType codecReturn = VIDEO_ERROR_NONE;
2281 if (pDstInputData->buffer.multiPlaneBuffer.dataBuffer[0] == NULL) {
2282 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to find input buffer");
2283 ret = OMX_ErrorBadParameter;
2287 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "%s : %d => ADDR[0]: 0x%x, ADDR[1]: 0x%x", __FUNCTION__, __LINE__,
2288 pDstInputData->buffer.multiPlaneBuffer.dataBuffer[0],
2289 pDstInputData->buffer.multiPlaneBuffer.dataBuffer[1]);
2291 if ((pVideoDec->bDRCProcessing == OMX_TRUE) &&
2292 (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) &&
2293 (pExynosOutputPort->exceptionFlag == GENERAL_STATE)) {
2294 ret = H264CodecDstSetup(pOMXComponent);
2295 if (ret != OMX_ErrorNone) {
2296 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "DRC Reconfig H264CodecDstSetup Failed");
2299 pVideoDec->bDRCProcessing = OMX_FALSE;
2302 codecReturn = pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pDstInputData->buffer.multiPlaneBuffer.dataBuffer,
2303 (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, pDstInputData->bufferHeader);
2305 if (codecReturn != VIDEO_ERROR_NONE) {
2306 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s : %d", __FUNCTION__, __LINE__);
2307 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2310 H264CodecStart(pOMXComponent, OUTPUT_PORT_INDEX);
2312 ret = OMX_ErrorNone;
2320 OMX_ERRORTYPE Exynos_H264Dec_DstOut(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstOutputData)
2322 OMX_ERRORTYPE ret = OMX_ErrorNone;
2323 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2324 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2325 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
2326 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
2327 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2328 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2329 ExynosVideoDecOps *pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
2330 ExynosVideoDecBufferOps *pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
2331 ExynosVideoBuffer *pVideoBuffer;
2332 ExynosVideoFrameStatusType displayStatus = VIDEO_FRAME_STATUS_UNKNOWN;
2333 ExynosVideoGeometry *bufferGeometry;
2334 DECODE_CODEC_EXTRA_BUFFERINFO *pBufferInfo = NULL;
2335 OMX_S32 indexTimestamp = 0;
2340 if (pH264Dec->bDestinationStart == OMX_FALSE) {
2341 ret = OMX_ErrorNone;
2346 pVideoBuffer = pOutbufOps->Dequeue(hMFCHandle);
2347 if (pVideoBuffer == (ExynosVideoBuffer *)VIDEO_ERROR_DQBUF_EIO) {
2348 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "HW is not available");
2349 ret = OMX_ErrorHardware;
2353 if (pVideoBuffer == NULL) {
2354 ret = OMX_ErrorNone;
2357 displayStatus = pVideoBuffer->displayStatus;
2358 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "displayStatus: 0x%x", displayStatus);
2360 if ((displayStatus == VIDEO_FRAME_STATUS_DISPLAY_DECODING) ||
2361 (displayStatus == VIDEO_FRAME_STATUS_DISPLAY_ONLY) ||
2362 (displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) ||
2363 (displayStatus == VIDEO_FRAME_STATUS_DECODING_FINISHED) ||
2364 (CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2365 if (pVideoBuffer != NULL) {
2366 ret = OMX_ErrorNone;
2369 ret = OMX_ErrorUndefined;
2375 if (displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) {
2376 if (pVideoDec->bDRCProcessing != OMX_TRUE) {
2377 pExynosOutputPort->exceptionFlag = NEED_PORT_FLUSH;
2378 pVideoDec->bDRCProcessing = OMX_TRUE;
2379 H264CodecCheckResolutionChange(pOMXComponent);
2380 pVideoDec->csc_set_format = OMX_FALSE;
2382 ret = OMX_ErrorNone;
2386 pH264Dec->hMFCH264Handle.outputIndexTimestamp++;
2387 pH264Dec->hMFCH264Handle.outputIndexTimestamp %= MAX_TIMESTAMP;
2389 pDstOutputData->allocSize = pDstOutputData->dataLen = 0;
2390 for (plane = 0; plane < MFC_OUTPUT_BUFFER_PLANE; plane++) {
2391 pDstOutputData->buffer.multiPlaneBuffer.dataBuffer[plane] = pVideoBuffer->planes[plane].addr;
2392 pDstOutputData->buffer.multiPlaneBuffer.fd[plane] = pVideoBuffer->planes[plane].fd;
2393 pDstOutputData->buffer.multiPlaneBuffer.tbm_bo[plane] = pVideoBuffer->planes[plane].tbm_bo;
2394 pDstOutputData->allocSize += pVideoBuffer->planes[plane].allocSize;
2395 pDstOutputData->dataLen += pVideoBuffer->planes[plane].dataSize;
2397 pDstOutputData->usedDataLen = 0;
2398 pDstOutputData->pPrivate = pVideoBuffer;
2399 /* For Share Buffer */
2400 pDstOutputData->bufferHeader = (OMX_BUFFERHEADERTYPE *)pVideoBuffer->pPrivate;
2402 pBufferInfo = (DECODE_CODEC_EXTRA_BUFFERINFO *)pDstOutputData->extInfo;
2403 bufferGeometry = &pH264Dec->hMFCH264Handle.codecOutbufConf;
2404 pBufferInfo->imageWidth = bufferGeometry->nFrameWidth;
2405 pBufferInfo->imageHeight = bufferGeometry->nFrameHeight;
2406 switch (bufferGeometry->eColorFormat) {
2407 case VIDEO_COLORFORMAT_NV12:
2408 #ifdef TIZEN_FEATURE_E3250 /* NV12 fd */
2409 pBufferInfo->ColorFormat = OMX_SEC_COLOR_FormatNV12L_DmaBuf_Fd;
2411 pBufferInfo->ColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
2414 case VIDEO_COLORFORMAT_NV12_TILED:
2416 pBufferInfo->ColorFormat = OMX_SEC_COLOR_FormatNV12Tiled;
2420 #ifdef USE_S3D_SUPPORT
2421 /* Check Whether frame packing information is available */
2422 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY &&
2423 pVideoDec->bThumbnailMode == OMX_FALSE &&
2424 pH264Dec->hMFCH264Handle.S3DFPArgmtType == OMX_SEC_FPARGMT_NONE) {
2425 H264CodecCheckFramePacking(pOMXComponent);
2429 indexTimestamp = pDecOps->Get_FrameTag(hMFCHandle);
2430 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "out indexTimestamp: %d", indexTimestamp);
2431 if ((indexTimestamp < 0) || (indexTimestamp >= MAX_TIMESTAMP)) {
2432 if ((pExynosComponent->checkTimeStamp.needSetStartTimeStamp != OMX_TRUE) &&
2433 (pExynosComponent->checkTimeStamp.needCheckStartTimeStamp != OMX_TRUE)) {
2434 pDstOutputData->timeStamp = pExynosComponent->timeStamp[pH264Dec->hMFCH264Handle.outputIndexTimestamp];
2435 pDstOutputData->nFlags = pExynosComponent->nFlags[pH264Dec->hMFCH264Handle.outputIndexTimestamp];
2436 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "missing out indexTimestamp: %d", indexTimestamp);
2438 pDstOutputData->timeStamp = 0x00;
2439 pDstOutputData->nFlags = 0x00;
2442 /* For timestamp correction. if mfc support frametype detect */
2443 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "disp_pic_frame_type: %d", pVideoBuffer->frameType);
2444 //#ifdef NEED_TIMESTAMP_REORDER
2445 /* TIZEN_FEATURE_E3250 */
2446 if (pVideoDec->bNeedTimestampReorder == OMX_TRUE) {
2447 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "NEED_TIMESTAMP_REORDER ON");
2448 if ((pVideoBuffer->frameType == VIDEO_FRAME_I)) {
2449 pDstOutputData->timeStamp = pExynosComponent->timeStamp[indexTimestamp];
2450 pDstOutputData->nFlags = pExynosComponent->nFlags[indexTimestamp];
2451 pH264Dec->hMFCH264Handle.outputIndexTimestamp = indexTimestamp;
2453 pDstOutputData->timeStamp = pExynosComponent->timeStamp[pH264Dec->hMFCH264Handle.outputIndexTimestamp];
2454 pDstOutputData->nFlags = pExynosComponent->nFlags[pH264Dec->hMFCH264Handle.outputIndexTimestamp];
2458 pDstOutputData->timeStamp = pExynosComponent->timeStamp[indexTimestamp];
2459 pDstOutputData->nFlags = pExynosComponent->nFlags[indexTimestamp];
2462 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "timestamp %lld us (%.2f secs), indexTimestamp: %d, nFlags: 0x%x", pDstOutputData->timeStamp, pDstOutputData->timeStamp / 1E6, indexTimestamp, pDstOutputData->nFlags);
2465 if ((displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) ||
2466 (displayStatus == VIDEO_FRAME_STATUS_DECODING_FINISHED) ||
2467 ((pDstOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)) {
2468 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "displayStatus:%d, nFlags0x%x", displayStatus, pDstOutputData->nFlags);
2469 pDstOutputData->remainDataLen = 0;
2471 pDstOutputData->remainDataLen = bufferGeometry->nFrameWidth * bufferGeometry->nFrameHeight * 3 / 2;
2474 ret = OMX_ErrorNone;
2482 OMX_ERRORTYPE Exynos_H264Dec_srcInputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
2484 OMX_ERRORTYPE ret = OMX_ErrorNone;
2485 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2486 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2487 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2491 if ((!CHECK_PORT_ENABLED(pExynosInputPort)) || (!CHECK_PORT_POPULATED(pExynosInputPort))) {
2492 ret = OMX_ErrorNone;
2495 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, INPUT_PORT_INDEX)) {
2496 ret = OMX_ErrorNone;
2500 ret = Exynos_H264Dec_SrcIn(pOMXComponent, pSrcInputData);
2501 if ((ret != OMX_ErrorNone) &&
2502 (ret != OMX_ErrorInputDataDecodeYet) &&
2503 (ret != OMX_ErrorCorruptedFrame)) {
2504 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2505 pExynosComponent->callbackData,
2506 OMX_EventError, ret, 0, NULL);
2515 OMX_ERRORTYPE Exynos_H264Dec_srcOutputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcOutputData)
2517 OMX_ERRORTYPE ret = OMX_ErrorNone;
2518 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2519 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2520 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2524 if ((!CHECK_PORT_ENABLED(pExynosInputPort)) || (!CHECK_PORT_POPULATED(pExynosInputPort))) {
2525 ret = OMX_ErrorNone;
2529 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2530 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, INPUT_PORT_INDEX)) {
2531 ret = OMX_ErrorNone;
2535 if ((pH264Dec->bSourceStart == OMX_FALSE) &&
2536 (!CHECK_PORT_BEING_FLUSHED(pExynosInputPort))) {
2537 Exynos_OSAL_SignalWait(pH264Dec->hSourceStartEvent, DEF_MAX_WAIT_TIME);
2538 Exynos_OSAL_SignalReset(pH264Dec->hSourceStartEvent);
2541 ret = Exynos_H264Dec_SrcOut(pOMXComponent, pSrcOutputData);
2542 if ((ret != OMX_ErrorNone) && (pExynosComponent->currentState == OMX_StateExecuting)) {
2543 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2544 pExynosComponent->callbackData,
2545 OMX_EventError, ret, 0, NULL);
2554 OMX_ERRORTYPE Exynos_H264Dec_dstInputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstInputData)
2556 OMX_ERRORTYPE ret = OMX_ErrorNone;
2557 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2558 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2559 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2563 if ((!CHECK_PORT_ENABLED(pExynosOutputPort)) || (!CHECK_PORT_POPULATED(pExynosOutputPort))) {
2564 ret = OMX_ErrorNone;
2567 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, OUTPUT_PORT_INDEX)) {
2568 ret = OMX_ErrorNone;
2571 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
2572 if ((pH264Dec->bDestinationStart == OMX_FALSE) &&
2573 (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2574 Exynos_OSAL_SignalWait(pH264Dec->hDestinationStartEvent, DEF_MAX_WAIT_TIME);
2575 Exynos_OSAL_SignalReset(pH264Dec->hDestinationStartEvent);
2578 if (pH264Dec->hMFCH264Handle.bConfiguredMFCDst == OMX_TRUE) {
2579 ret = Exynos_H264Dec_DstIn(pOMXComponent, pDstInputData);
2580 if (ret != OMX_ErrorNone) {
2581 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2582 pExynosComponent->callbackData,
2583 OMX_EventError, ret, 0, NULL);
2593 OMX_ERRORTYPE Exynos_H264Dec_dstOutputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstOutputData)
2595 OMX_ERRORTYPE ret = OMX_ErrorNone;
2596 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2597 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2598 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2602 if ((!CHECK_PORT_ENABLED(pExynosOutputPort)) || (!CHECK_PORT_POPULATED(pExynosOutputPort))) {
2603 ret = OMX_ErrorNone;
2606 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, OUTPUT_PORT_INDEX)) {
2607 ret = OMX_ErrorNone;
2611 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
2612 if ((pH264Dec->bDestinationStart == OMX_FALSE) &&
2613 (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2614 Exynos_OSAL_SignalWait(pH264Dec->hDestinationStartEvent, DEF_MAX_WAIT_TIME);
2615 Exynos_OSAL_SignalReset(pH264Dec->hDestinationStartEvent);
2618 ret = Exynos_H264Dec_DstOut(pOMXComponent, pDstOutputData);
2619 if ((ret != OMX_ErrorNone) && (pExynosComponent->currentState == OMX_StateExecuting)) {
2620 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2621 pExynosComponent->callbackData,
2622 OMX_EventError, ret, 0, NULL);
2631 OSCL_EXPORT_REF OMX_ERRORTYPE Exynos_OMX_ComponentInit(OMX_HANDLETYPE hComponent, OMX_STRING componentName)
2633 OMX_ERRORTYPE ret = OMX_ErrorNone;
2634 OMX_COMPONENTTYPE *pOMXComponent = NULL;
2635 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
2636 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
2637 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
2638 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
2639 OMX_BOOL bDRMPlayerMode = OMX_FALSE;
2644 if ((hComponent == NULL) || (componentName == NULL)) {
2645 ret = OMX_ErrorBadParameter;
2646 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
2649 if (Exynos_OSAL_Strcmp(EXYNOS_OMX_COMPONENT_H264_DEC, componentName) == 0) {
2650 bDRMPlayerMode = OMX_FALSE;
2651 } else if (Exynos_OSAL_Strcmp(EXYNOS_OMX_COMPONENT_H264_DRM_DEC, componentName) == 0) {
2652 bDRMPlayerMode = OMX_TRUE;
2654 ret = OMX_ErrorBadParameter;
2655 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, componentName:%s, Line:%d", componentName, __LINE__);
2659 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2660 ret = Exynos_OMX_VideoDecodeComponentInit(pOMXComponent);
2661 if (ret != OMX_ErrorNone) {
2662 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_Error, Line:%d", __LINE__);
2665 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2666 pExynosComponent->codecType = HW_VIDEO_DEC_CODEC;
2668 pExynosComponent->componentName = (OMX_STRING)Exynos_OSAL_Malloc(MAX_OMX_COMPONENT_NAME_SIZE);
2669 if (pExynosComponent->componentName == NULL) {
2670 Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2671 ret = OMX_ErrorInsufficientResources;
2672 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2675 Exynos_OSAL_Memset(pExynosComponent->componentName, 0, MAX_OMX_COMPONENT_NAME_SIZE);
2677 pH264Dec = Exynos_OSAL_Malloc(sizeof(EXYNOS_H264DEC_HANDLE));
2678 if (pH264Dec == NULL) {
2679 Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2680 ret = OMX_ErrorInsufficientResources;
2681 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2684 Exynos_OSAL_Memset(pH264Dec, 0, sizeof(EXYNOS_H264DEC_HANDLE));
2685 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2686 pVideoDec->hCodecHandle = (OMX_HANDLETYPE)pH264Dec;
2688 if (bDRMPlayerMode == OMX_TRUE)
2689 Exynos_OSAL_Strcpy(pExynosComponent->componentName, EXYNOS_OMX_COMPONENT_H264_DRM_DEC);
2691 Exynos_OSAL_Strcpy(pExynosComponent->componentName, EXYNOS_OMX_COMPONENT_H264_DEC);
2693 pVideoDec->bDRMPlayerMode = bDRMPlayerMode;
2694 /* In case of BUFFER_COPY mode
2695 bShareableBuf = TRUE means MemoryType is V4L2_MEMORY_USERPTR
2696 bShareableBuf = FALSE means MemoryType is V4L2_MEMORY_MMAP
2697 In case of BUFFER_SHARE
2698 bShareableBuf should be TRUE, FALSE is ignored
2700 pH264Dec->hMFCH264Handle.bShareableBuf = OMX_FALSE;
2701 #ifdef USE_S3D_SUPPORT
2702 pH264Dec->hMFCH264Handle.S3DFPArgmtType = OMX_SEC_FPARGMT_NONE;
2705 /* Set componentVersion */
2706 pExynosComponent->componentVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
2707 pExynosComponent->componentVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
2708 pExynosComponent->componentVersion.s.nRevision = REVISION_NUMBER;
2709 pExynosComponent->componentVersion.s.nStep = STEP_NUMBER;
2710 /* Set specVersion */
2711 pExynosComponent->specVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
2712 pExynosComponent->specVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
2713 pExynosComponent->specVersion.s.nRevision = REVISION_NUMBER;
2714 pExynosComponent->specVersion.s.nStep = STEP_NUMBER;
2717 pExynosPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2718 pExynosPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
2719 pExynosPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
2720 pExynosPort->portDefinition.format.video.nStride = 0; /*DEFAULT_FRAME_WIDTH;*/
2721 pExynosPort->portDefinition.format.video.nSliceHeight = 0;
2722 pExynosPort->portDefinition.nBufferSize = DEFAULT_VIDEO_INPUT_BUFFER_SIZE;
2723 pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
2724 Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2725 Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "video/avc");
2726 pExynosPort->portDefinition.format.video.pNativeRender = 0;
2727 pExynosPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
2728 pExynosPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatUnused;
2729 pExynosPort->portDefinition.bEnabled = OMX_TRUE;
2730 pExynosPort->bufferProcessType = BUFFER_COPY;
2731 if (bDRMPlayerMode == OMX_TRUE)
2732 pExynosPort->bufferProcessType = BUFFER_SHARE;
2733 pExynosPort->portWayType = WAY2_PORT;
2736 pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2737 pExynosPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
2738 pExynosPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
2739 pExynosPort->portDefinition.format.video.nStride = 0; /*DEFAULT_FRAME_WIDTH;*/
2740 pExynosPort->portDefinition.format.video.nSliceHeight = 0;
2741 pExynosPort->portDefinition.nBufferSize = DEFAULT_VIDEO_OUTPUT_BUFFER_SIZE;
2742 pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused;
2743 Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2744 Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "raw/video");
2745 pExynosPort->portDefinition.format.video.pNativeRender = 0;
2746 pExynosPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
2747 #ifdef TIZEN_FEATURE_E3250
2748 pExynosPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatNV12L_DmaBuf_Fd;
2750 pExynosPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
2752 pExynosPort->portDefinition.bEnabled = OMX_TRUE;
2753 #ifdef TIZEN_FEATURE_E3250
2754 pExynosPort->bufferProcessType = BUFFER_SHARE;
2756 pExynosPort->bufferProcessType = BUFFER_COPY;
2758 pExynosPort->portWayType = WAY2_PORT;
2760 for(i = 0; i < ALL_PORT_NUM; i++) {
2761 INIT_SET_SIZE_VERSION(&pH264Dec->AVCComponent[i], OMX_VIDEO_PARAM_AVCTYPE);
2762 pH264Dec->AVCComponent[i].nPortIndex = i;
2763 pH264Dec->AVCComponent[i].eProfile = OMX_VIDEO_AVCProfileBaseline;
2764 pH264Dec->AVCComponent[i].eLevel = OMX_VIDEO_AVCLevel4;
2767 pOMXComponent->GetParameter = &Exynos_H264Dec_GetParameter;
2768 pOMXComponent->SetParameter = &Exynos_H264Dec_SetParameter;
2769 pOMXComponent->GetConfig = &Exynos_H264Dec_GetConfig;
2770 pOMXComponent->SetConfig = &Exynos_H264Dec_SetConfig;
2771 pOMXComponent->GetExtensionIndex = &Exynos_H264Dec_GetExtensionIndex;
2772 pOMXComponent->ComponentRoleEnum = &Exynos_H264Dec_ComponentRoleEnum;
2773 pOMXComponent->ComponentDeInit = &Exynos_OMX_ComponentDeinit;
2775 pExynosComponent->exynos_codec_componentInit = &Exynos_H264Dec_Init;
2776 pExynosComponent->exynos_codec_componentTerminate = &Exynos_H264Dec_Terminate;
2778 pVideoDec->exynos_codec_srcInputProcess = &Exynos_H264Dec_srcInputBufferProcess;
2779 pVideoDec->exynos_codec_srcOutputProcess = &Exynos_H264Dec_srcOutputBufferProcess;
2780 pVideoDec->exynos_codec_dstInputProcess = &Exynos_H264Dec_dstInputBufferProcess;
2781 pVideoDec->exynos_codec_dstOutputProcess = &Exynos_H264Dec_dstOutputBufferProcess;
2783 pVideoDec->exynos_codec_start = &H264CodecStart;
2784 pVideoDec->exynos_codec_stop = &H264CodecStop;
2785 pVideoDec->exynos_codec_bufferProcessRun = &H264CodecOutputBufferProcessRun;
2786 pVideoDec->exynos_codec_enqueueAllBuffer = &H264CodecEnQueueAllBuffer;
2787 pVideoDec->exynos_codec_resetupAllElement = &H264CodecResetupAllElement;
2789 pVideoDec->exynos_checkInputFrame = &Check_H264_Frame;
2790 pVideoDec->exynos_codec_getCodecInputPrivateData = &GetCodecInputPrivateData;
2791 pVideoDec->exynos_codec_getCodecOutputPrivateData = &GetCodecOutputPrivateData;
2793 #ifndef TIZEN_FEATURE_E3250 /* do not use ion */
2794 pVideoDec->hSharedMemory = Exynos_OSAL_SharedMemory_Open();
2795 if (pVideoDec->hSharedMemory == NULL) {
2796 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2797 Exynos_OSAL_Free(pH264Dec);
2798 pH264Dec = ((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle = NULL;
2799 Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2800 ret = OMX_ErrorInsufficientResources;
2804 pExynosComponent->currentState = OMX_StateLoaded;
2806 ret = OMX_ErrorNone;
2814 OMX_ERRORTYPE Exynos_OMX_ComponentDeinit(OMX_HANDLETYPE hComponent)
2816 OMX_ERRORTYPE ret = OMX_ErrorNone;
2817 OMX_COMPONENTTYPE *pOMXComponent = NULL;
2818 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
2819 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
2820 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
2824 if (hComponent == NULL) {
2825 ret = OMX_ErrorBadParameter;
2828 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2829 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2830 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2832 #ifndef TIZEN_FEATURE_E3250 /* do not use ion */
2833 Exynos_OSAL_SharedMemory_Close(pVideoDec->hSharedMemory);
2835 Exynos_OSAL_Free(pExynosComponent->componentName);
2836 pExynosComponent->componentName = NULL;
2838 pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
2839 if (pH264Dec != NULL) {
2840 Exynos_OSAL_Free(pH264Dec);
2841 pH264Dec = pVideoDec->hCodecHandle = NULL;
2844 ret = Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2845 if (ret != OMX_ErrorNone) {
2849 ret = OMX_ErrorNone;