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 #ifndef TIZEN_FEATURE_E3250
150 int Check_H264_Frame(
151 OMX_U8 *pInputStream,
154 OMX_BOOL bPreviousFrameEOF,
155 OMX_BOOL *pbEndOfFrame)
157 OMX_U32 preFourByte = (OMX_U32)-1;
158 int accessUnitSize = 0;
159 int frameTypeBoundary = 0;
160 int nextNaluSize = 0;
163 if (bPreviousFrameEOF == OMX_TRUE)
169 int inputOneByte = 0;
171 if (accessUnitSize == (int)buffSize)
174 inputOneByte = *(pInputStream++);
177 if (preFourByte == 0x00000001 || (preFourByte << 8) == 0x00000100) {
178 int naluType = inputOneByte & 0x1F;
180 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "NaluType : %d", naluType);
181 if (naluStart == 0) {
182 #ifdef ADD_SPS_PPS_I_FRAME
183 if (naluType == 1 || naluType == 5)
185 if (naluType == 1 || naluType == 5 || naluType == 7 || naluType == 8)
190 frameTypeBoundary = (8 - naluType) & (naluType - 10); //AUD(9)
193 frameTypeBoundary = -2;
195 if (naluType == 1 || naluType == 5) {
196 if (accessUnitSize == (int)buffSize) {
200 inputOneByte = *pInputStream++;
203 if (inputOneByte >= 0x80)
204 frameTypeBoundary = -1;
206 if (frameTypeBoundary < 0) {
212 preFourByte = (preFourByte << 8) + inputOneByte;
215 *pbEndOfFrame = OMX_TRUE;
217 if (frameTypeBoundary == -1)
219 if (preFourByte != 0x00000001)
221 return (accessUnitSize + nextNaluSize);
224 *pbEndOfFrame = OMX_FALSE;
226 return accessUnitSize;
230 static OMX_BOOL Check_H264_StartCode(
231 OMX_U8 *pInputStream,
234 if (streamSize < 4) {
238 if ((pInputStream[0] == 0x00) &&
239 (pInputStream[1] == 0x00) &&
240 (pInputStream[2] == 0x00) &&
241 (pInputStream[3] != 0x00) &&
242 ((pInputStream[3] >> 3) == 0x00)) {
243 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "NaluType : %d, 0x%x, 0x%x, 0x%x", (pInputStream[4] & 0x1F), pInputStream[3], pInputStream[4], pInputStream[5]);
245 } else if ((pInputStream[0] == 0x00) &&
246 (pInputStream[1] == 0x00) &&
247 (pInputStream[2] != 0x00) &&
248 ((pInputStream[2] >> 3) == 0x00)) {
249 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "NaluType : %d, 0x%x, 0x%x, 0x%x", (pInputStream[3] & 0x1F), pInputStream[2], pInputStream[3], pInputStream[4]);
256 OMX_ERRORTYPE H264CodecOpen(EXYNOS_H264DEC_HANDLE *pH264Dec)
258 OMX_ERRORTYPE ret = OMX_ErrorNone;
259 ExynosVideoDecOps *pDecOps = NULL;
260 ExynosVideoDecBufferOps *pInbufOps = NULL;
261 ExynosVideoDecBufferOps *pOutbufOps = NULL;
265 if (pH264Dec == NULL) {
266 ret = OMX_ErrorBadParameter;
267 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
271 /* alloc ops structure */
272 pDecOps = (ExynosVideoDecOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoDecOps));
273 pInbufOps = (ExynosVideoDecBufferOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoDecBufferOps));
274 pOutbufOps = (ExynosVideoDecBufferOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoDecBufferOps));
276 if ((pDecOps == NULL) || (pInbufOps == NULL) || (pOutbufOps == NULL)) {
277 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to allocate decoder ops buffer");
278 ret = OMX_ErrorInsufficientResources;
282 pH264Dec->hMFCH264Handle.pDecOps = pDecOps;
283 pH264Dec->hMFCH264Handle.pInbufOps = pInbufOps;
284 pH264Dec->hMFCH264Handle.pOutbufOps = pOutbufOps;
286 /* function pointer mapping */
287 pDecOps->nSize = sizeof(ExynosVideoDecOps);
288 pInbufOps->nSize = sizeof(ExynosVideoDecBufferOps);
289 pOutbufOps->nSize = sizeof(ExynosVideoDecBufferOps);
291 Exynos_Video_Register_Decoder(pDecOps, pInbufOps, pOutbufOps);
293 /* check mandatory functions for decoder ops */
294 if ((pDecOps->Init == NULL) || (pDecOps->Finalize == NULL) ||
295 (pDecOps->Get_ActualBufferCount == NULL) || (pDecOps->Set_FrameTag == NULL) ||
296 #ifdef USE_S3D_SUPPORT
297 (pDecOps->Enable_SEIParsing == NULL) || (pDecOps->Get_FramePackingInfo == NULL) ||
299 (pDecOps->Get_FrameTag == NULL)) {
300 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Mandatory functions must be supplied");
301 ret = OMX_ErrorInsufficientResources;
305 /* check mandatory functions for buffer ops */
306 if ((pInbufOps->Setup == NULL) || (pOutbufOps->Setup == NULL) ||
307 (pInbufOps->Run == NULL) || (pOutbufOps->Run == NULL) ||
308 (pInbufOps->Stop == NULL) || (pOutbufOps->Stop == NULL) ||
309 (pInbufOps->Enqueue == NULL) || (pOutbufOps->Enqueue == NULL) ||
310 (pInbufOps->Dequeue == NULL) || (pOutbufOps->Dequeue == NULL)) {
311 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Mandatory functions must be supplied");
312 ret = OMX_ErrorInsufficientResources;
316 /* alloc context, open, querycap */
317 if (pH264Dec->hMFCH264Handle.bShareableBuf == OMX_TRUE) {
319 pH264Dec->hMFCH264Handle.hMFCHandle = pH264Dec->hMFCH264Handle.pDecOps->Init(V4L2_MEMORY_DMABUF);
321 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "%s :%d V4L2_MEMORY_USERPTR", __FUNCTION__, __LINE__);
322 pH264Dec->hMFCH264Handle.hMFCHandle = pH264Dec->hMFCH264Handle.pDecOps->Init(V4L2_MEMORY_USERPTR);
325 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "%s :%d V4L2_MEMORY_DMABUF", __FUNCTION__, __LINE__);
326 pH264Dec->hMFCH264Handle.hMFCHandle = pH264Dec->hMFCH264Handle.pDecOps->Init(V4L2_MEMORY_DMABUF);
328 if (pH264Dec->hMFCH264Handle.hMFCHandle == NULL) {
329 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to allocate context buffer");
330 ret = OMX_ErrorInsufficientResources;
334 #ifdef USE_S3D_SUPPORT
335 /*S3D: Enable SEI parsing to check Frame Packing */
336 if (pDecOps->Enable_SEIParsing(pH264Dec->hMFCH264Handle.hMFCHandle) != VIDEO_ERROR_NONE) {
337 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Enable SEI Parsing");
338 ret = OMX_ErrorInsufficientResources;
346 if (ret != OMX_ErrorNone) {
347 if (pDecOps != NULL) {
348 Exynos_OSAL_Free(pDecOps);
349 pH264Dec->hMFCH264Handle.pDecOps = NULL;
351 if (pInbufOps != NULL) {
352 Exynos_OSAL_Free(pInbufOps);
353 pH264Dec->hMFCH264Handle.pInbufOps = NULL;
355 if (pOutbufOps != NULL) {
356 Exynos_OSAL_Free(pOutbufOps);
357 pH264Dec->hMFCH264Handle.pOutbufOps = NULL;
366 OMX_ERRORTYPE H264CodecClose(EXYNOS_H264DEC_HANDLE *pH264Dec)
368 OMX_ERRORTYPE ret = OMX_ErrorNone;
369 void *hMFCHandle = NULL;
370 ExynosVideoDecOps *pDecOps = NULL;
371 ExynosVideoDecBufferOps *pInbufOps = NULL;
372 ExynosVideoDecBufferOps *pOutbufOps = NULL;
376 if (pH264Dec == NULL) {
377 ret = OMX_ErrorBadParameter;
381 hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
382 pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
383 pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
384 pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
386 if (hMFCHandle != NULL) {
387 pDecOps->Finalize(hMFCHandle);
388 pH264Dec->hMFCH264Handle.hMFCHandle = NULL;
390 if (pOutbufOps != NULL) {
391 Exynos_OSAL_Free(pOutbufOps);
392 pH264Dec->hMFCH264Handle.pOutbufOps = NULL;
394 if (pInbufOps != NULL) {
395 Exynos_OSAL_Free(pInbufOps);
396 pH264Dec->hMFCH264Handle.pInbufOps = NULL;
398 if (pDecOps != NULL) {
399 Exynos_OSAL_Free(pDecOps);
400 pH264Dec->hMFCH264Handle.pDecOps = NULL;
411 OMX_ERRORTYPE H264CodecStart(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
413 OMX_ERRORTYPE ret = OMX_ErrorNone;
414 void *hMFCHandle = NULL;
415 ExynosVideoDecOps *pDecOps = NULL;
416 ExynosVideoDecBufferOps *pInbufOps = NULL;
417 ExynosVideoDecBufferOps *pOutbufOps = NULL;
418 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
419 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
423 if (pOMXComponent == NULL) {
424 ret = OMX_ErrorBadParameter;
428 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
429 if (pVideoDec == NULL) {
430 ret = OMX_ErrorBadParameter;
434 pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
435 if (pH264Dec == NULL) {
436 ret = OMX_ErrorBadParameter;
440 hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
441 pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
442 pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
443 pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
445 if (nPortIndex == INPUT_PORT_INDEX)
446 pInbufOps->Run(hMFCHandle);
447 else if (nPortIndex == OUTPUT_PORT_INDEX)
448 pOutbufOps->Run(hMFCHandle);
458 OMX_ERRORTYPE H264CodecStop(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
460 OMX_ERRORTYPE ret = OMX_ErrorNone;
461 void *hMFCHandle = NULL;
462 ExynosVideoDecOps *pDecOps = NULL;
463 ExynosVideoDecBufferOps *pInbufOps = NULL;
464 ExynosVideoDecBufferOps *pOutbufOps = NULL;
465 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
466 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
470 if (pOMXComponent == NULL) {
471 ret = OMX_ErrorBadParameter;
475 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
476 if (pVideoDec == NULL) {
477 ret = OMX_ErrorBadParameter;
480 pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
481 if (pH264Dec == NULL) {
482 ret = OMX_ErrorBadParameter;
486 hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
487 pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
488 pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
489 pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
491 if ((nPortIndex == INPUT_PORT_INDEX) && (pInbufOps != NULL))
492 pInbufOps->Stop(hMFCHandle);
493 else if ((nPortIndex == OUTPUT_PORT_INDEX) && (pOutbufOps != NULL))
494 pOutbufOps->Stop(hMFCHandle);
504 OMX_ERRORTYPE H264CodecSrcInit(OMX_COMPONENTTYPE *pOMXComponent)
506 OMX_ERRORTYPE ret = OMX_ErrorNone;
507 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
508 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
509 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
510 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
511 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
512 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
514 ExynosVideoDecOps *pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
515 ExynosVideoDecBufferOps *pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
516 ExynosVideoDecBufferOps *pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
517 ExynosVideoGeometry bufferConf;
518 OMX_U32 inputBufferNumber = 0;
522 if (pVideoDec->bThumbnailMode == OMX_TRUE)
523 pDecOps->Set_DisplayDelay(hMFCHandle, 0);
525 /* input buffer info */
526 Exynos_OSAL_Memset(&bufferConf, 0, sizeof(bufferConf));
527 bufferConf.eCompressionFormat = VIDEO_CODING_AVC;
529 if (pExynosInputPort->bufferProcessType & BUFFER_SHARE
530 ||pH264Dec->hMFCH264Handle.bShareableBuf == OMX_TRUE)
531 pInbufOps->Set_Shareable(hMFCHandle);
533 if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
534 bufferConf.nSizeImage = pExynosInputPort->portDefinition.format.video.nFrameWidth
535 * pExynosInputPort->portDefinition.format.video.nFrameHeight * 3 / 2;
536 inputBufferNumber = MAX_VIDEO_INPUTBUFFER_NUM;
537 } else if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
538 bufferConf.nSizeImage = DEFAULT_MFC_INPUT_BUFFER_SIZE;
539 inputBufferNumber = MFC_INPUT_BUFFER_NUM_MAX;
542 /* should be done before prepare input buffer */
543 if (pInbufOps->Enable_Cacheable(hMFCHandle) != VIDEO_ERROR_NONE) {
544 ret = OMX_ErrorInsufficientResources;
548 /* set input buffer geometry */
549 if (pInbufOps->Set_Geometry(hMFCHandle, &bufferConf) != VIDEO_ERROR_NONE) {
550 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to set geometry for input buffer");
551 ret = OMX_ErrorInsufficientResources;
555 /* setup input buffer */
556 if (pInbufOps->Setup(hMFCHandle, inputBufferNumber) != VIDEO_ERROR_NONE) {
557 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to setup input buffer");
558 ret = OMX_ErrorInsufficientResources;
562 if ((pExynosInputPort->bufferProcessType & BUFFER_COPY) &&
563 pH264Dec->hMFCH264Handle.bShareableBuf == OMX_TRUE) {
564 /* Register input buffer */
565 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
566 ExynosVideoPlane plane;
567 plane.addr = pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[0];
568 plane.allocSize = pVideoDec->pMFCDecInputBuffer[i]->bufferSize[0];
569 plane.fd = pVideoDec->pMFCDecInputBuffer[i]->fd[0];
570 if (pInbufOps->Register(hMFCHandle, &plane, MFC_INPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
571 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register input buffer");
572 ret = OMX_ErrorInsufficientResources;
576 } else if ((pExynosInputPort->bufferProcessType & BUFFER_COPY) &&
577 pH264Dec->hMFCH264Handle.bShareableBuf == OMX_FALSE) {
578 ExynosVideoBuffer *pBuffer = NULL;
580 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
581 pVideoDec->pMFCDecInputBuffer[i] = Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
582 Exynos_OSAL_Memset(pVideoDec->pMFCDecInputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
583 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "@pVideoDec->pMFCDecInputBuffer[%d]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]);
584 /* get input buffer info */
585 if (pInbufOps->Get_Buffer) {
586 if (pInbufOps->Get_Buffer(pH264Dec->hMFCH264Handle.hMFCHandle, i, &pBuffer) != VIDEO_ERROR_NONE) {
587 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get input buffer info");
588 ret = OMX_ErrorInsufficientResources;
593 for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
594 /* Use ION Allocator */
595 pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] = (void *)pBuffer->planes[plane].addr;
596 pVideoDec->pMFCDecInputBuffer[i]->fd[plane] = pBuffer->planes[plane].fd;
597 pVideoDec->pMFCDecInputBuffer[i]->bufferSize[plane] = pBuffer->planes[plane].allocSize;
598 pVideoDec->pMFCDecInputBuffer[i]->dataSize = 0;
599 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "@pVideoDec->pMFCDecInputBuffer[%d]->pVirAddr[%d]: 0x%x", i, plane, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
602 #ifdef TIZEN_FEATURE_E3250
603 if (pExynosInputPort == NULL || pExynosOutputPort == NULL || pOMXComponent == NULL) {
604 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "invalid param: pExynosInputPort= %p pExynosOutputPort= %p pOMXComponent= %p", pExynosInputPort, pExynosOutputPort, pOMXComponent);
607 Exynos_CodecBufferEnQueue(pExynosComponent, INPUT_PORT_INDEX, pVideoDec->pMFCDecInputBuffer[i]);
609 } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
610 /* Register input buffer */
611 for (i = 0; i < pExynosInputPort->portDefinition.nBufferCountActual; i++) {
612 ExynosVideoPlane plane;
613 if (pVideoDec->bDRMPlayerMode == OMX_TRUE) {
614 #ifdef TIZEN_FEATURE_E3250
615 /* IL Client assigns FD value in pBuffer */
616 plane.addr = pExynosInputPort->extendBufferHeader[i].OMXBufferHeader->pBuffer;
618 plane.addr = Exynos_OSAL_SharedMemory_IONToVirt(pVideoDec->hSharedMemory, pExynosInputPort->extendBufferHeader[i].OMXBufferHeader->pBuffer);
621 plane.addr = pExynosInputPort->extendBufferHeader[i].OMXBufferHeader->pBuffer;
623 plane.allocSize = pExynosInputPort->extendBufferHeader[i].OMXBufferHeader->nAllocLen;
624 plane.fd = pExynosInputPort->extendBufferHeader[i].buf_fd[0];
625 if (pInbufOps->Register(hMFCHandle, &plane, MFC_INPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
626 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register input buffer");
627 ret = OMX_ErrorInsufficientResources;
640 OMX_ERRORTYPE H264CodecOutputBufferProcessRun(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
642 OMX_ERRORTYPE ret = OMX_ErrorNone;
643 void *hMFCHandle = NULL;
644 ExynosVideoDecOps *pDecOps = NULL;
645 ExynosVideoDecBufferOps *pInbufOps = NULL;
646 ExynosVideoDecBufferOps *pOutbufOps = NULL;
647 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
648 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
652 if (pOMXComponent == NULL) {
653 ret = OMX_ErrorBadParameter;
657 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
658 if (pVideoDec == NULL) {
659 ret = OMX_ErrorBadParameter;
662 pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
663 if (pH264Dec == NULL) {
664 ret = OMX_ErrorBadParameter;
668 hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
669 pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
670 pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
671 pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
673 if (nPortIndex == INPUT_PORT_INDEX) {
674 if (pH264Dec->bSourceStart == OMX_FALSE) {
675 Exynos_OSAL_SignalSet(pH264Dec->hSourceStartEvent);
676 Exynos_OSAL_SleepMillisec(0);
680 if (nPortIndex == OUTPUT_PORT_INDEX) {
681 if (pH264Dec->bDestinationStart == OMX_FALSE) {
682 Exynos_OSAL_SignalSet(pH264Dec->hDestinationStartEvent);
683 Exynos_OSAL_SleepMillisec(0);
695 OMX_ERRORTYPE H264CodecEnQueueAllBuffer(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
697 OMX_ERRORTYPE ret = OMX_ErrorNone;
698 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
699 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
700 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
701 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
702 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
703 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
706 ExynosVideoDecOps *pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
707 ExynosVideoDecBufferOps *pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
708 ExynosVideoDecBufferOps *pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
712 if ((nPortIndex != INPUT_PORT_INDEX) && (nPortIndex != OUTPUT_PORT_INDEX)) {
713 ret = OMX_ErrorBadPortIndex;
717 if ((nPortIndex == INPUT_PORT_INDEX) &&
718 (pH264Dec->bSourceStart == OMX_TRUE)) {
719 Exynos_CodecBufferReset(pExynosComponent, INPUT_PORT_INDEX);
721 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
722 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]);
723 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]->pVirAddr[0]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[0]);
725 Exynos_CodecBufferEnQueue(pExynosComponent, INPUT_PORT_INDEX, pVideoDec->pMFCDecInputBuffer[i]);
728 pInbufOps->Clear_Queue(hMFCHandle);
729 } else if ((nPortIndex == OUTPUT_PORT_INDEX) &&
730 (pH264Dec->bDestinationStart == OMX_TRUE)) {
731 OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
732 ExynosVideoBuffer *pBuffer = NULL;
734 Exynos_CodecBufferReset(pExynosComponent, OUTPUT_PORT_INDEX);
736 nOutbufs = pDecOps->Get_ActualBufferCount(hMFCHandle);
737 nOutbufs += EXTRA_DPB_NUM;
738 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "EXTRA_DPB_NUM = %d, nOutbufs =%d", EXTRA_DPB_NUM, nOutbufs);
739 for (i = 0; i < nOutbufs; i++) {
740 pOutbufOps->Get_Buffer(hMFCHandle, i, &pBuffer);
741 Exynos_CodecBufferEnQueue(pExynosComponent, OUTPUT_PORT_INDEX, (OMX_PTR)pBuffer);
743 pOutbufOps->Clear_Queue(hMFCHandle);
752 #ifdef USE_S3D_SUPPORT
753 OMX_BOOL H264CodecCheckFramePacking(OMX_COMPONENTTYPE *pOMXComponent)
755 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
756 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
757 ExynosVideoDecOps *pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
758 ExynosVideoFramePacking framePacking;
759 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
760 OMX_BOOL ret = OMX_FALSE;
762 /* Get Frame packing information*/
763 if (pDecOps->Get_FramePackingInfo(pH264Dec->hMFCH264Handle.hMFCHandle, &framePacking) != VIDEO_ERROR_NONE) {
764 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Get Frame Packing Information");
769 if (framePacking.available) {
770 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "arrangement ID: 0x%08x", framePacking.arrangement_id);
771 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "arrangement_type: %d", framePacking.arrangement_type);
772 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "content_interpretation_type: %d", framePacking.content_interpretation_type);
773 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "current_frame_is_frame0_flag: %d", framePacking.current_frame_is_frame0_flag);
774 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "spatial_flipping_flag: %d", framePacking.spatial_flipping_flag);
775 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "fr0X:%d fr0Y:%d fr0X:%d fr0Y:%d", framePacking.frame0_grid_pos_x,
776 framePacking.frame0_grid_pos_y, framePacking.frame1_grid_pos_x, framePacking.frame1_grid_pos_y);
778 pH264Dec->hMFCH264Handle.S3DFPArgmtType = (EXYNOS_OMX_FPARGMT_TYPE) framePacking.arrangement_type;
779 /** Send Port Settings changed call back - output color format change */
780 (*(pExynosComponent->pCallbacks->EventHandler))
782 pExynosComponent->callbackData,
783 OMX_EventPortSettingsChanged, /* The command was completed */
784 OMX_DirOutput, /* This is the port index */
788 Exynos_OSAL_SleepMillisec(0);
797 OMX_ERRORTYPE H264CodecDstFreeCodecBuffers(
798 OMX_COMPONENTTYPE *pOMXComponent)
800 OMX_ERRORTYPE ret = OMX_ErrorNone;
801 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
802 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
803 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
809 for (i = 0; i < MFC_OUTPUT_BUFFER_NUM_MAX; i++) {
810 if (pVideoDec->pMFCDecOutputBuffer[i] != NULL) {
811 for (j = 0; j < MFC_OUTPUT_BUFFER_PLANE; j++) {
812 if (pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j] != NULL &&
813 pH264Dec->hMFCH264Handle.bShareableBuf == OMX_TRUE)
814 Exynos_OSAL_SharedMemory_Free(pVideoDec->hSharedMemory, pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j]);
817 Exynos_OSAL_Free(pVideoDec->pMFCDecOutputBuffer[i]);
821 Exynos_OSAL_Memset(pVideoDec->pMFCDecOutputBuffer, 0, sizeof(pVideoDec->pMFCDecOutputBuffer));
825 return OMX_ErrorNone;
828 OMX_ERRORTYPE H264CodecDstAllocCodecBuffers(
829 OMX_COMPONENTTYPE *pOMXComponent,
832 OMX_ERRORTYPE ret = OMX_ErrorNone;
833 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
834 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
835 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
837 MEMORY_TYPE eMemoryType = NORMAL_MEMORY;
838 OMX_U32 nAllocLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
843 nAllocLen[0] = calc_plane(pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth,
844 pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight);
845 nAllocLen[1] = calc_plane(pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth,
846 pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight >> 1);
848 if (pVideoDec->bDRMPlayerMode == OMX_TRUE)
849 eMemoryType = SECURE_MEMORY;
851 for (i = 0; i < nOutbufs; i++) {
852 pVideoDec->pMFCDecOutputBuffer[i] = (CODEC_DEC_BUFFER *)Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
853 if (pVideoDec->pMFCDecOutputBuffer[i] == NULL) {
854 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Alloc codec buffer");
855 ret = OMX_ErrorInsufficientResources;
858 Exynos_OSAL_Memset(pVideoDec->pMFCDecOutputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
860 for (j = 0; j < MFC_OUTPUT_BUFFER_PLANE; j++) {
861 pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j] =
862 (void *)Exynos_OSAL_SharedMemory_Alloc(pVideoDec->hSharedMemory, nAllocLen[j], eMemoryType);
863 if (pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j] == NULL) {
864 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Alloc output buffer");
865 ret = OMX_ErrorInsufficientResources;
869 pVideoDec->pMFCDecOutputBuffer[i]->fd[j] =
870 Exynos_OSAL_SharedMemory_VirtToION(pVideoDec->hSharedMemory,
871 pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j]);
872 pVideoDec->pMFCDecOutputBuffer[i]->bufferSize[j] = nAllocLen[j];
876 return OMX_ErrorNone;
879 H264CodecDstFreeCodecBuffers(pOMXComponent);
886 OMX_ERRORTYPE H264CodecDstRegistCodecBuffers(
887 OMX_COMPONENTTYPE *pOMXComponent,
890 OMX_ERRORTYPE ret = OMX_ErrorNone;
891 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
892 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
893 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
894 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
895 ExynosVideoDecBufferOps *pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
897 ExynosVideoPlane planes[MFC_OUTPUT_BUFFER_PLANE];
898 OMX_U32 nDataLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
903 /* Register output buffer */
904 for (i = 0; i < nOutbufs; i++) {
905 for (j = 0; j < MFC_OUTPUT_BUFFER_PLANE; j++) {
906 planes[j].addr = pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j];
907 planes[j].fd = pVideoDec->pMFCDecOutputBuffer[i]->fd[j];
908 planes[j].allocSize = pVideoDec->pMFCDecOutputBuffer[i]->bufferSize[j];
911 if (pOutbufOps->Register(hMFCHandle, planes, MFC_OUTPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
912 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register output buffer");
913 ret = OMX_ErrorInsufficientResources;
917 pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr,
918 (unsigned int *)nDataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
929 OMX_ERRORTYPE H264CodecResetupAllElement(
930 OMX_COMPONENTTYPE *pOMXComponent,
933 OMX_ERRORTYPE ret = OMX_ErrorNone;
934 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
935 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
936 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
937 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
938 EXYNOS_OMX_BASEPORT *pOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
939 ExynosVideoDecBufferOps *pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
945 if ((nPortIndex == INPUT_PORT_INDEX) &&
946 (pH264Dec->bSourceStart == OMX_TRUE)) {
947 ret = OMX_ErrorNotImplemented;
949 } else if ((nPortIndex == OUTPUT_PORT_INDEX) &&
950 (pH264Dec->bDestinationStart == OMX_TRUE)) {
951 if (pOutputPort->bufferProcessType & BUFFER_COPY) {
953 /**********************************/
954 /* Codec Buffer Free & Unregister */
955 /**********************************/
956 H264CodecDstFreeCodecBuffers(pOMXComponent);
957 Exynos_CodecBufferReset(pExynosComponent, OUTPUT_PORT_INDEX);
959 if (pH264Dec->hMFCH264Handle.bShareableBuf == OMX_TRUE)
960 pOutbufOps->Clear_RegisteredBuffer(hMFCHandle);
962 pOutbufOps->Cleanup(hMFCHandle);
963 /******************************************************/
964 /* V4L2 Destnation Setup for DPB Buffer Number Change */
965 /******************************************************/
966 H264CodecDstSetup(pOMXComponent);
968 pVideoDec->bDRCProcessing = OMX_FALSE;
969 } else if (pOutputPort->bufferProcessType & BUFFER_SHARE) {
971 /**********************************/
972 /* Codec Buffer Unregister */
973 /**********************************/
974 pOutbufOps->Clear_RegisteredBuffer(hMFCHandle);
975 pOutbufOps->Cleanup(hMFCHandle);
978 ret = OMX_ErrorBadParameter;
988 OMX_ERRORTYPE H264CodecSrcSetup(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
990 OMX_ERRORTYPE ret = OMX_ErrorNone;
991 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
992 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
993 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
994 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
995 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
996 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
997 OMX_U32 oneFrameSize = pSrcInputData->dataLen;
999 ExynosVideoDecOps *pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
1000 ExynosVideoDecBufferOps *pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
1001 ExynosVideoDecBufferOps *pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
1002 ExynosVideoGeometry bufferConf;
1003 OMX_U32 inputBufferNumber = 0;
1008 if ((oneFrameSize <= 0) && (pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
1009 OMX_BUFFERHEADERTYPE *OMXBuffer = NULL;
1010 OMXBuffer = Exynos_OutputBufferGetQueue_Direct(pExynosComponent);
1011 if (OMXBuffer == NULL) {
1012 ret = OMX_ErrorUndefined;
1016 OMXBuffer->nTimeStamp = pSrcInputData->timeStamp;
1017 OMXBuffer->nFlags = pSrcInputData->nFlags;
1018 Exynos_OMX_OutputBufferReturn(pOMXComponent, OMXBuffer);
1020 ret = OMX_ErrorNone;
1024 if (!((pExynosInputPort->bufferProcessType & BUFFER_COPY) &&
1025 pH264Dec->hMFCH264Handle.bShareableBuf == OMX_FALSE)) {
1026 ret = H264CodecSrcInit(pOMXComponent);
1027 if (ret != OMX_ErrorNone)
1031 /* set output geometry */
1032 Exynos_OSAL_Memset(&bufferConf, 0, sizeof(bufferConf));
1033 pH264Dec->hMFCH264Handle.MFCOutputColorType = bufferConf.eColorFormat = VIDEO_COLORFORMAT_NV12;
1034 if (pOutbufOps->Set_Geometry(hMFCHandle, &bufferConf) != VIDEO_ERROR_NONE) {
1035 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to set geometry for output buffer");
1036 ret = OMX_ErrorInsufficientResources;
1040 /* input buffer enqueue for header parsing */
1041 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "oneFrameSize: %d", oneFrameSize);
1042 if (pInbufOps->Enqueue(hMFCHandle, (unsigned char **)&pSrcInputData->buffer.singlePlaneBuffer.dataBuffer,
1043 (unsigned int *)&oneFrameSize, MFC_INPUT_BUFFER_PLANE, pSrcInputData->bufferHeader) != VIDEO_ERROR_NONE) {
1044 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to enqueue input buffer for header parsing");
1045 // ret = OMX_ErrorInsufficientResources;
1046 ret = (OMX_ERRORTYPE)OMX_ErrorCodecInit;
1050 /* start header parsing */
1051 if (pInbufOps->Run(hMFCHandle) != VIDEO_ERROR_NONE) {
1052 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to run input buffer for header parsing");
1053 ret = OMX_ErrorCodecInit;
1057 ret = H264CodecCheckResolutionChange(pOMXComponent);
1058 if (ret != OMX_ErrorNone) {
1059 ret = OMX_ErrorCodecInit;
1063 Exynos_OSAL_SleepMillisec(0);
1064 ret = OMX_ErrorInputDataDecodeYet;
1066 #ifdef USE_IMMEDIATE_DISPLAY
1067 /* Set Immediately display for I Frame*/
1068 pDecOps->Set_ImmediateDisplay(hMFCHandle);
1072 H264CodecStop(pOMXComponent, INPUT_PORT_INDEX);
1078 OMX_ERRORTYPE H264CodecDstSetup(OMX_COMPONENTTYPE *pOMXComponent)
1080 OMX_ERRORTYPE ret = OMX_ErrorNone;
1081 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1082 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1083 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
1084 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
1085 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1086 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1088 ExynosVideoDecOps *pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
1089 ExynosVideoDecBufferOps *pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
1090 ExynosVideoDecBufferOps *pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
1097 nOutbufs = pH264Dec->hMFCH264Handle.maxDPBNum;
1099 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1100 /* should be done before prepare output buffer */
1101 if (pOutbufOps->Enable_Cacheable(hMFCHandle) != VIDEO_ERROR_NONE) {
1102 ret = OMX_ErrorInsufficientResources;
1107 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE
1108 ||pH264Dec->hMFCH264Handle.bShareableBuf == OMX_TRUE)
1109 pOutbufOps->Set_Shareable(hMFCHandle);
1111 if (pOutbufOps->Setup(hMFCHandle, nOutbufs) != VIDEO_ERROR_NONE) {
1112 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to setup output buffer");
1113 ret = OMX_ErrorInsufficientResources;
1117 ExynosVideoPlane planes[MFC_OUTPUT_BUFFER_PLANE];
1118 OMX_U32 nAllocLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
1119 OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
1122 nAllocLen[0] = calc_plane(pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth,
1123 pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight);
1124 nAllocLen[1] = calc_plane(pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth,
1125 pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight >> 1);
1127 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY &&
1128 pH264Dec->hMFCH264Handle.bShareableBuf == OMX_TRUE) {
1129 H264CodecDstAllocCodecBuffers(pOMXComponent, nOutbufs);
1130 H264CodecDstRegistCodecBuffers(pOMXComponent, nOutbufs);
1131 } else if (pExynosOutputPort->bufferProcessType & BUFFER_COPY &&
1132 pH264Dec->hMFCH264Handle.bShareableBuf == OMX_FALSE) {
1134 /* Register output buffer */
1135 for (i = 0; i < nOutbufs; i++) {
1137 OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
1138 ExynosVideoBuffer *pBuffer = NULL;
1139 pVideoDec->pMFCDecOutputBuffer[i] = (CODEC_DEC_BUFFER *)Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
1140 Exynos_OSAL_Memset(pVideoDec->pMFCDecOutputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
1142 if (pOutbufOps->Get_Buffer) {
1143 if (pOutbufOps->Get_Buffer(pH264Dec->hMFCH264Handle.hMFCHandle, i, &pBuffer) != VIDEO_ERROR_NONE) {
1144 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get Output buffer info");
1145 ret = OMX_ErrorInsufficientResources;
1150 for (plane = 0; plane < MFC_OUTPUT_BUFFER_PLANE; plane++) {
1151 pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[plane] = (void *)pBuffer->planes[plane].addr;
1152 pVideoDec->pMFCDecOutputBuffer[i]->fd[plane] = pBuffer->planes[plane].fd;
1153 pVideoDec->pMFCDecOutputBuffer[i]->bufferSize[plane] = pBuffer->planes[plane].allocSize;
1156 pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr,
1157 (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
1159 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1161 if (pExynosOutputPort->bIsPBEnabled == OMX_TRUE) {
1162 for (i = 0; i < pExynosOutputPort->assignedBufferNum; i++) {
1163 for (plane = 0; plane < MFC_OUTPUT_BUFFER_PLANE; plane++) {
1164 planes[plane].fd = pExynosOutputPort->extendBufferHeader[i].buf_fd[plane];
1165 planes[plane].addr = pExynosOutputPort->extendBufferHeader[i].pYUVBuf[plane];
1166 planes[plane].tbm_bo = pExynosOutputPort->extendBufferHeader[i].tbm_bo[plane];
1167 planes[plane].allocSize = nAllocLen[plane];
1170 if (pOutbufOps->Register(hMFCHandle, planes, MFC_OUTPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
1171 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register output buffer");
1172 ret = OMX_ErrorInsufficientResources;
1175 pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pExynosOutputPort->extendBufferHeader[i].pYUVBuf,
1176 (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
1179 ret = OMX_ErrorNotImplemented;
1183 ret = OMX_ErrorNotImplemented;
1186 /* Waiting for DPB buffer setup to be completed,
1187 * valid only for share mode
1189 if (pDecOps->Enable_DecodeWait != NULL)
1190 pDecOps->Enable_DecodeWait(hMFCHandle);
1194 if (pOutbufOps->Run(hMFCHandle) != VIDEO_ERROR_NONE) {
1195 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to run output buffer");
1196 ret = OMX_ErrorInsufficientResources;
1200 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1201 H264CodecStop(pOMXComponent, OUTPUT_PORT_INDEX);
1203 pH264Dec->hMFCH264Handle.bConfiguredMFCDst = OMX_TRUE;
1205 ret = OMX_ErrorNone;
1213 OMX_ERRORTYPE H264CodecCheckResolutionChange(OMX_COMPONENTTYPE *pOMXComponent)
1215 OMX_ERRORTYPE ret = OMX_ErrorNone;
1216 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1217 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1218 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1219 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
1220 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1221 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1223 ExynosVideoDecOps *pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
1224 ExynosVideoDecBufferOps *pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
1225 ExynosVideoDecBufferOps *pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
1226 ExynosVideoGeometry bufferConf;
1231 /* get geometry for output */
1232 Exynos_OSAL_Memset(&pH264Dec->hMFCH264Handle.codecOutbufConf, 0, sizeof(ExynosVideoGeometry));
1233 if (pOutbufOps->Get_Geometry(hMFCHandle, &pH264Dec->hMFCH264Handle.codecOutbufConf) != VIDEO_ERROR_NONE) {
1234 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get geometry for parsed header info");
1235 ret = OMX_ErrorInsufficientResources;
1240 pH264Dec->hMFCH264Handle.maxDPBNum = pDecOps->Get_ActualBufferCount(hMFCHandle);
1241 if (pVideoDec->bThumbnailMode == OMX_FALSE)
1242 pH264Dec->hMFCH264Handle.maxDPBNum += EXTRA_DPB_NUM;
1243 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "H264CodecCheckResolutionChange H264CodecSetup nOutbufs: %d", pH264Dec->hMFCH264Handle.maxDPBNum);
1245 pH264Dec->hMFCH264Handle.bConfiguredMFCSrc = OMX_TRUE;
1247 pExynosOutputPort->cropRectangle.nTop = pH264Dec->hMFCH264Handle.codecOutbufConf.cropRect.nTop;
1248 pExynosOutputPort->cropRectangle.nLeft = pH264Dec->hMFCH264Handle.codecOutbufConf.cropRect.nLeft;
1249 pExynosOutputPort->cropRectangle.nWidth = pH264Dec->hMFCH264Handle.codecOutbufConf.cropRect.nWidth;
1250 pExynosOutputPort->cropRectangle.nHeight = pH264Dec->hMFCH264Handle.codecOutbufConf.cropRect.nHeight;
1252 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1253 if ((pVideoDec->bDRCProcessing) ||
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.nFrameWidth = pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth;
1257 pExynosInputPort->portDefinition.format.video.nFrameHeight = pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight;
1258 pExynosInputPort->portDefinition.format.video.nStride = ((pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth + 15) & (~15));
1259 pExynosInputPort->portDefinition.format.video.nSliceHeight = ((pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight + 15) & (~15));
1261 if (pVideoDec->bDRCProcessing == OMX_TRUE) {
1262 pVideoDec->nDRCSavedBufferCount = pExynosOutputPort->portDefinition.nBufferCountActual;
1264 Exynos_UpdateFrameSize(pOMXComponent);
1265 pExynosOutputPort->exceptionFlag = NEED_PORT_DISABLE;
1267 /** Send Port Settings changed call back **/
1268 (*(pExynosComponent->pCallbacks->EventHandler))
1270 pExynosComponent->callbackData,
1271 OMX_EventPortSettingsChanged, /* The command was completed */
1272 OMX_DirOutput, /* This is the port index */
1276 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1277 #ifndef TIZEN_FEATURE_E3250
1278 /* The input port information has already been updated */
1279 if ((pExynosInputPort->portDefinition.format.video.nFrameWidth != pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth) ||
1280 (pExynosInputPort->portDefinition.format.video.nFrameHeight != pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight) ||
1281 (pExynosOutputPort->portDefinition.nBufferCountActual != pH264Dec->hMFCH264Handle.maxDPBNum)) {
1282 pExynosInputPort->portDefinition.format.video.nFrameWidth = pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth;
1283 pExynosInputPort->portDefinition.format.video.nFrameHeight = pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight;
1284 pExynosInputPort->portDefinition.format.video.nStride = ((pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth + 15) & (~15));
1285 pExynosInputPort->portDefinition.format.video.nSliceHeight = ((pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight + 15) & (~15));
1287 if (pVideoDec->bDRCProcessing == OMX_TRUE) {
1288 pVideoDec->nDRCSavedBufferCount = pExynosOutputPort->portDefinition.nBufferCountActual;
1290 #ifdef TIZEN_FEATURE_E3250
1291 pExynosOutputPort->portDefinition.nBufferCountActual = pH264Dec->hMFCH264Handle.maxDPBNum;
1292 pExynosOutputPort->portDefinition.nBufferCountMin = pH264Dec->hMFCH264Handle.maxDPBNum;
1294 pExynosOutputPort->portDefinition.nBufferCountActual = pH264Dec->hMFCH264Handle.maxDPBNum - 4;
1295 pExynosOutputPort->portDefinition.nBufferCountMin = pH264Dec->hMFCH264Handle.maxDPBNum - 4;
1297 Exynos_UpdateFrameSize(pOMXComponent);
1298 pExynosOutputPort->exceptionFlag = NEED_PORT_DISABLE;
1300 /** Send Port Settings changed call back **/
1301 (*(pExynosComponent->pCallbacks->EventHandler))
1303 pExynosComponent->callbackData,
1304 OMX_EventPortSettingsChanged, /* The command was completed */
1305 OMX_DirOutput, /* This is the port index */
1308 #ifndef TIZEN_FEATURE_E3250
1313 if (((pVideoDec->bDRCProcessing) && (pExynosOutputPort->bufferProcessType & BUFFER_COPY)) ||
1314 (pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth != pH264Dec->hMFCH264Handle.codecOutbufConf.cropRect.nWidth) ||
1315 (pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight != pH264Dec->hMFCH264Handle.codecOutbufConf.cropRect.nHeight)) {
1317 pExynosInputPort->portDefinition.format.video.nFrameWidth = pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth;
1318 pExynosInputPort->portDefinition.format.video.nFrameHeight = pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight;
1319 pExynosInputPort->portDefinition.format.video.nStride = ((pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth + 15) & (~15));
1320 pExynosInputPort->portDefinition.format.video.nSliceHeight = ((pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight + 15) & (~15));
1321 Exynos_UpdateFrameSize(pOMXComponent);
1323 /** Send crop info call back **/
1324 (*(pExynosComponent->pCallbacks->EventHandler))
1326 pExynosComponent->callbackData,
1327 OMX_EventPortSettingsChanged, /* The command was completed */
1328 OMX_DirOutput, /* This is the port index */
1329 OMX_IndexConfigCommonOutputCrop,
1333 ret = OMX_ErrorNone;
1341 OMX_ERRORTYPE Exynos_H264Dec_GetParameter(
1342 OMX_IN OMX_HANDLETYPE hComponent,
1343 OMX_IN OMX_INDEXTYPE nParamIndex,
1344 OMX_INOUT OMX_PTR pComponentParameterStructure)
1346 OMX_ERRORTYPE ret = OMX_ErrorNone;
1347 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1348 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1352 if (hComponent == NULL || pComponentParameterStructure == NULL) {
1353 ret = OMX_ErrorBadParameter;
1356 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1357 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1358 if (ret != OMX_ErrorNone) {
1361 if (pOMXComponent->pComponentPrivate == NULL) {
1362 ret = OMX_ErrorBadParameter;
1366 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1367 if (pExynosComponent->currentState == OMX_StateInvalid ) {
1368 ret = OMX_ErrorInvalidState;
1372 switch (nParamIndex) {
1373 case OMX_IndexParamVideoAvc:
1375 OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = (OMX_VIDEO_PARAM_AVCTYPE *)pComponentParameterStructure;
1376 OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent = NULL;
1377 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
1379 ret = Exynos_OMX_Check_SizeVersion(pDstAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
1380 if (ret != OMX_ErrorNone) {
1384 if (pDstAVCComponent->nPortIndex >= ALL_PORT_NUM) {
1385 ret = OMX_ErrorBadPortIndex;
1389 pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1390 pSrcAVCComponent = &pH264Dec->AVCComponent[pDstAVCComponent->nPortIndex];
1392 Exynos_OSAL_Memcpy(pDstAVCComponent, pSrcAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
1395 case OMX_IndexParamStandardComponentRole:
1397 OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE *)pComponentParameterStructure;
1398 ret = Exynos_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1399 if (ret != OMX_ErrorNone) {
1403 Exynos_OSAL_Strcpy((char *)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_H264_DEC_ROLE);
1406 case OMX_IndexParamVideoProfileLevelQuerySupported:
1408 OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE*)pComponentParameterStructure;
1409 EXYNOS_OMX_VIDEO_PROFILELEVEL *pProfileLevel = NULL;
1410 OMX_U32 maxProfileLevelNum = 0;
1412 ret = Exynos_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
1413 if (ret != OMX_ErrorNone) {
1417 if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
1418 ret = OMX_ErrorBadPortIndex;
1422 pProfileLevel = supportedAVCProfileLevels;
1423 maxProfileLevelNum = sizeof(supportedAVCProfileLevels) / sizeof(EXYNOS_OMX_VIDEO_PROFILELEVEL);
1425 if (pDstProfileLevel->nProfileIndex >= maxProfileLevelNum) {
1426 ret = OMX_ErrorNoMore;
1430 pProfileLevel += pDstProfileLevel->nProfileIndex;
1431 pDstProfileLevel->eProfile = pProfileLevel->profile;
1432 pDstProfileLevel->eLevel = pProfileLevel->level;
1435 case OMX_IndexParamVideoProfileLevelCurrent:
1437 OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE*)pComponentParameterStructure;
1438 OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent = NULL;
1439 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
1441 ret = Exynos_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
1442 if (ret != OMX_ErrorNone) {
1446 if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
1447 ret = OMX_ErrorBadPortIndex;
1451 pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1452 pSrcAVCComponent = &pH264Dec->AVCComponent[pDstProfileLevel->nPortIndex];
1454 pDstProfileLevel->eProfile = pSrcAVCComponent->eProfile;
1455 pDstProfileLevel->eLevel = pSrcAVCComponent->eLevel;
1458 case OMX_IndexParamVideoErrorCorrection:
1460 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
1461 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = NULL;
1462 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
1464 ret = Exynos_OMX_Check_SizeVersion(pDstErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
1465 if (ret != OMX_ErrorNone) {
1469 if (pDstErrorCorrectionType->nPortIndex != INPUT_PORT_INDEX) {
1470 ret = OMX_ErrorBadPortIndex;
1474 pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1475 pSrcErrorCorrectionType = &pH264Dec->errorCorrectionType[INPUT_PORT_INDEX];
1477 pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
1478 pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
1479 pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
1480 pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
1481 pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
1485 ret = Exynos_OMX_VideoDecodeGetParameter(hComponent, nParamIndex, pComponentParameterStructure);
1494 OMX_ERRORTYPE Exynos_H264Dec_SetParameter(
1495 OMX_IN OMX_HANDLETYPE hComponent,
1496 OMX_IN OMX_INDEXTYPE nIndex,
1497 OMX_IN OMX_PTR pComponentParameterStructure)
1499 OMX_ERRORTYPE ret = OMX_ErrorNone;
1500 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1501 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1505 if (hComponent == NULL || pComponentParameterStructure == NULL) {
1506 ret = OMX_ErrorBadParameter;
1509 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1510 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1511 if (ret != OMX_ErrorNone) {
1514 if (pOMXComponent->pComponentPrivate == NULL) {
1515 ret = OMX_ErrorBadParameter;
1519 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1520 if (pExynosComponent->currentState == OMX_StateInvalid ) {
1521 ret = OMX_ErrorInvalidState;
1526 case OMX_IndexParamVideoAvc:
1528 OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = NULL;
1529 OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent = (OMX_VIDEO_PARAM_AVCTYPE *)pComponentParameterStructure;
1530 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
1532 ret = Exynos_OMX_Check_SizeVersion(pSrcAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
1533 if (ret != OMX_ErrorNone) {
1537 if (pSrcAVCComponent->nPortIndex >= ALL_PORT_NUM) {
1538 ret = OMX_ErrorBadPortIndex;
1542 pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1543 pDstAVCComponent = &pH264Dec->AVCComponent[pSrcAVCComponent->nPortIndex];
1545 Exynos_OSAL_Memcpy(pDstAVCComponent, pSrcAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
1548 case OMX_IndexParamStandardComponentRole:
1550 OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE*)pComponentParameterStructure;
1552 ret = Exynos_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1553 if (ret != OMX_ErrorNone) {
1557 if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1558 ret = OMX_ErrorIncorrectStateOperation;
1562 if (!Exynos_OSAL_Strcmp((char*)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_H264_DEC_ROLE)) {
1563 pExynosComponent->pExynosPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
1565 ret = OMX_ErrorBadParameter;
1570 case OMX_IndexParamPortDefinition:
1572 OMX_PARAM_PORTDEFINITIONTYPE *pPortDefinition = (OMX_PARAM_PORTDEFINITIONTYPE *)pComponentParameterStructure;
1573 OMX_U32 portIndex = pPortDefinition->nPortIndex;
1574 EXYNOS_OMX_BASEPORT *pExynosPort;
1575 OMX_U32 width, height, size;
1576 OMX_U32 realWidth, realHeight;
1577 OMX_PARAM_PORTDEFINITIONTYPE portDefinition_backup;
1579 if (portIndex >= pExynosComponent->portParam.nPorts) {
1580 ret = OMX_ErrorBadPortIndex;
1583 ret = Exynos_OMX_Check_SizeVersion(pPortDefinition, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1584 if (ret != OMX_ErrorNone) {
1588 pExynosPort = &pExynosComponent->pExynosPort[portIndex];
1590 if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1591 if (pExynosPort->portDefinition.bEnabled == OMX_TRUE) {
1592 ret = OMX_ErrorIncorrectStateOperation;
1596 if (pPortDefinition->nBufferCountActual < pExynosPort->portDefinition.nBufferCountMin) {
1597 ret = OMX_ErrorBadParameter;
1601 Exynos_OSAL_Memcpy(&portDefinition_backup, &pExynosPort->portDefinition, pPortDefinition->nSize);
1602 Exynos_OSAL_Memcpy(&pExynosPort->portDefinition, pPortDefinition, pPortDefinition->nSize);
1603 RESTORE_READONLYPARAMETERS_OMX_PARAM_PORTDEFINITIONTYPE(&pExynosPort->portDefinition,&portDefinition_backup);
1605 realWidth = pExynosPort->portDefinition.format.video.nFrameWidth;
1606 realHeight = pExynosPort->portDefinition.format.video.nFrameHeight;
1607 width = ((realWidth + 15) & (~15));
1608 height = ((realHeight + 15) & (~15));
1609 size = (width * height * 3) / 2;
1610 pExynosPort->portDefinition.format.video.nStride = width;
1611 pExynosPort->portDefinition.format.video.nSliceHeight = height;
1612 pExynosPort->portDefinition.nBufferSize = (size > pExynosPort->portDefinition.nBufferSize) ? size : pExynosPort->portDefinition.nBufferSize;
1614 if (portIndex == INPUT_PORT_INDEX) {
1615 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1616 pExynosOutputPort->portDefinition.format.video.nFrameWidth = pExynosPort->portDefinition.format.video.nFrameWidth;
1617 pExynosOutputPort->portDefinition.format.video.nFrameHeight = pExynosPort->portDefinition.format.video.nFrameHeight;
1618 pExynosOutputPort->portDefinition.format.video.nStride = width;
1619 pExynosOutputPort->portDefinition.format.video.nSliceHeight = height;
1621 switch (pExynosOutputPort->portDefinition.format.video.eColorFormat) {
1622 case OMX_COLOR_FormatYUV420Planar:
1623 case OMX_COLOR_FormatYUV420SemiPlanar:
1624 pExynosOutputPort->portDefinition.nBufferSize = (width * height * 3) / 2;
1626 #ifdef TIZEN_FEATURE_E3250 /* NV12 fd */
1627 case OMX_SEC_COLOR_FormatNV12L_DmaBuf_Fd:
1628 case OMX_SEC_COLOR_FormatNV12T_DmaBuf_Fd:
1629 pExynosOutputPort->portDefinition.nBufferSize = sizeof(MMVideoBuffer);
1632 case OMX_SEC_COLOR_FormatNV12Tiled:
1633 pExynosOutputPort->portDefinition.nBufferSize =
1634 calc_plane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight) +
1635 calc_plane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight >> 1);
1638 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Color format is not support!! use default YUV size!!");
1639 ret = OMX_ErrorUnsupportedSetting;
1643 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1644 pExynosOutputPort->portDefinition.nBufferSize =
1645 calc_plane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight) +
1646 calc_plane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight >> 1);
1651 case OMX_IndexParamVideoProfileLevelCurrent:
1653 OMX_VIDEO_PARAM_PROFILELEVELTYPE *pSrcProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
1654 OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = NULL;
1655 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
1657 ret = Exynos_OMX_Check_SizeVersion(pSrcProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
1658 if (ret != OMX_ErrorNone)
1661 if (pSrcProfileLevel->nPortIndex >= ALL_PORT_NUM) {
1662 ret = OMX_ErrorBadPortIndex;
1666 pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1668 pDstAVCComponent = &pH264Dec->AVCComponent[pSrcProfileLevel->nPortIndex];
1669 pDstAVCComponent->eProfile = pSrcProfileLevel->eProfile;
1670 pDstAVCComponent->eLevel = pSrcProfileLevel->eLevel;
1673 case OMX_IndexParamVideoErrorCorrection:
1675 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
1676 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = NULL;
1677 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
1679 ret = Exynos_OMX_Check_SizeVersion(pSrcErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
1680 if (ret != OMX_ErrorNone) {
1684 if (pSrcErrorCorrectionType->nPortIndex != INPUT_PORT_INDEX) {
1685 ret = OMX_ErrorBadPortIndex;
1689 pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1690 pDstErrorCorrectionType = &pH264Dec->errorCorrectionType[INPUT_PORT_INDEX];
1692 pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
1693 pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
1694 pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
1695 pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
1696 pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
1700 ret = Exynos_OMX_VideoDecodeSetParameter(hComponent, nIndex, pComponentParameterStructure);
1709 OMX_ERRORTYPE Exynos_H264Dec_GetConfig(
1710 OMX_HANDLETYPE hComponent,
1711 OMX_INDEXTYPE nIndex,
1712 OMX_PTR pComponentConfigStructure)
1714 OMX_ERRORTYPE ret = OMX_ErrorNone;
1715 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1716 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1720 if (hComponent == NULL) {
1721 ret = OMX_ErrorBadParameter;
1724 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1725 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1726 if (ret != OMX_ErrorNone) {
1729 if (pOMXComponent->pComponentPrivate == NULL) {
1730 ret = OMX_ErrorBadParameter;
1733 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1734 if (pComponentConfigStructure == NULL) {
1735 ret = OMX_ErrorBadParameter;
1738 if (pExynosComponent->currentState == OMX_StateInvalid) {
1739 ret = OMX_ErrorInvalidState;
1744 case OMX_IndexConfigCommonOutputCrop:
1746 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
1747 OMX_CONFIG_RECTTYPE *pSrcRectType = NULL;
1748 OMX_CONFIG_RECTTYPE *pDstRectType = NULL;
1749 pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1751 if (pH264Dec->hMFCH264Handle.bConfiguredMFCSrc == OMX_FALSE) {
1752 ret = OMX_ErrorNotReady;
1756 pDstRectType = (OMX_CONFIG_RECTTYPE *)pComponentConfigStructure;
1758 if ((pDstRectType->nPortIndex != INPUT_PORT_INDEX) &&
1759 (pDstRectType->nPortIndex != OUTPUT_PORT_INDEX)) {
1760 ret = OMX_ErrorBadPortIndex;
1764 EXYNOS_OMX_BASEPORT *pExynosPort = &pExynosComponent->pExynosPort[pDstRectType->nPortIndex];
1766 pSrcRectType = &(pExynosPort->cropRectangle);
1768 pDstRectType->nTop = pSrcRectType->nTop;
1769 pDstRectType->nLeft = pSrcRectType->nLeft;
1770 pDstRectType->nHeight = pSrcRectType->nHeight;
1771 pDstRectType->nWidth = pSrcRectType->nWidth;
1774 #ifdef USE_S3D_SUPPORT
1775 case OMX_IndexVendorS3DMode:
1777 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
1778 OMX_U32 *pS3DMode = NULL;
1779 pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1781 pS3DMode = (OMX_U32 *)pComponentConfigStructure;
1782 *pS3DMode = (OMX_U32) pH264Dec->hMFCH264Handle.S3DFPArgmtType;
1787 ret = Exynos_OMX_VideoDecodeGetConfig(hComponent, nIndex, pComponentConfigStructure);
1797 OMX_ERRORTYPE Exynos_H264Dec_SetConfig(
1798 OMX_HANDLETYPE hComponent,
1799 OMX_INDEXTYPE nIndex,
1800 OMX_PTR pComponentConfigStructure)
1802 OMX_ERRORTYPE ret = OMX_ErrorNone;
1803 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1804 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1808 if (hComponent == NULL) {
1809 ret = OMX_ErrorBadParameter;
1812 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1813 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1814 if (ret != OMX_ErrorNone) {
1817 if (pOMXComponent->pComponentPrivate == NULL) {
1818 ret = OMX_ErrorBadParameter;
1821 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1822 if (pComponentConfigStructure == NULL) {
1823 ret = OMX_ErrorBadParameter;
1826 if (pExynosComponent->currentState == OMX_StateInvalid) {
1827 ret = OMX_ErrorInvalidState;
1833 ret = Exynos_OMX_VideoDecodeSetConfig(hComponent, nIndex, pComponentConfigStructure);
1843 OMX_ERRORTYPE Exynos_H264Dec_GetExtensionIndex(
1844 OMX_IN OMX_HANDLETYPE hComponent,
1845 OMX_IN OMX_STRING cParameterName,
1846 OMX_OUT OMX_INDEXTYPE *pIndexType)
1848 OMX_ERRORTYPE ret = OMX_ErrorNone;
1849 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1850 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1854 if (hComponent == NULL) {
1855 ret = OMX_ErrorBadParameter;
1858 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1859 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1860 if (ret != OMX_ErrorNone) {
1863 if (pOMXComponent->pComponentPrivate == NULL) {
1864 ret = OMX_ErrorBadParameter;
1867 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1868 if ((cParameterName == NULL) || (pIndexType == NULL)) {
1869 ret = OMX_ErrorBadParameter;
1872 if (pExynosComponent->currentState == OMX_StateInvalid) {
1873 ret = OMX_ErrorInvalidState;
1877 if (Exynos_OSAL_Strcmp(cParameterName, EXYNOS_INDEX_PARAM_ENABLE_THUMBNAIL) == 0) {
1878 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1879 *pIndexType = OMX_IndexVendorThumbnailMode;
1880 ret = OMX_ErrorNone;
1882 #ifdef USE_S3D_SUPPORT
1883 else if (Exynos_OSAL_Strcmp(cParameterName, EXYNOS_INDEX_PARAM_GET_S3D) == 0) {
1884 *pIndexType = OMX_IndexVendorS3DMode;
1885 ret = OMX_ErrorNone;
1889 ret = Exynos_OMX_VideoDecodeGetExtensionIndex(hComponent, cParameterName, pIndexType);
1898 OMX_ERRORTYPE Exynos_H264Dec_ComponentRoleEnum(
1899 OMX_HANDLETYPE hComponent,
1903 OMX_ERRORTYPE ret = OMX_ErrorNone;
1904 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1905 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1909 if ((hComponent == NULL) || (cRole == NULL)) {
1910 ret = OMX_ErrorBadParameter;
1913 if (nIndex == (MAX_COMPONENT_ROLE_NUM-1)) {
1914 Exynos_OSAL_Strcpy((char *)cRole, EXYNOS_OMX_COMPONENT_H264_DEC_ROLE);
1915 ret = OMX_ErrorNone;
1917 ret = OMX_ErrorNoMore;
1927 OMX_ERRORTYPE Exynos_H264Dec_Init(OMX_COMPONENTTYPE *pOMXComponent)
1929 OMX_ERRORTYPE ret = OMX_ErrorNone;
1930 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1931 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1932 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1933 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1934 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
1935 OMX_PTR hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
1937 ExynosVideoDecOps *pDecOps = NULL;
1938 ExynosVideoDecBufferOps *pInbufOps = NULL;
1939 ExynosVideoDecBufferOps *pOutbufOps = NULL;
1941 CSC_METHOD csc_method = CSC_METHOD_SW;
1946 pH264Dec->hMFCH264Handle.bConfiguredMFCSrc = OMX_FALSE;
1947 pH264Dec->hMFCH264Handle.bConfiguredMFCDst = OMX_FALSE;
1948 pExynosComponent->bUseFlagEOF = OMX_TRUE;
1949 pExynosComponent->bSaveFlagEOS = OMX_FALSE;
1951 /* H.264 Codec Open */
1952 ret = H264CodecOpen(pH264Dec);
1953 if (ret != OMX_ErrorNone) {
1957 pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
1958 pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
1959 pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
1961 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
1962 Exynos_OSAL_SemaphoreCreate(&pExynosInputPort->codecSemID);
1963 Exynos_OSAL_QueueCreate(&pExynosInputPort->codecBufferQ, MAX_QUEUE_ELEMENTS);
1965 if (pH264Dec->hMFCH264Handle.bShareableBuf == OMX_TRUE) {
1966 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
1967 pVideoDec->pMFCDecInputBuffer[i] = Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
1968 Exynos_OSAL_Memset(pVideoDec->pMFCDecInputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
1969 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]);
1971 for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
1972 /* Use ION Allocator */
1973 pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] = (void *)Exynos_OSAL_SharedMemory_Alloc(pVideoDec->hSharedMemory, DEFAULT_MFC_INPUT_BUFFER_SIZE, NORMAL_MEMORY);
1974 pVideoDec->pMFCDecInputBuffer[i]->fd[plane] = Exynos_OSAL_SharedMemory_VirtToION(pVideoDec->hSharedMemory, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
1975 pVideoDec->pMFCDecInputBuffer[i]->bufferSize[plane] = DEFAULT_MFC_INPUT_BUFFER_SIZE;
1976 pVideoDec->pMFCDecInputBuffer[i]->dataSize = 0;
1977 if (pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] == NULL) {
1978 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Fail input buffer");
1979 ret = OMX_ErrorInsufficientResources;
1982 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]->pVirAddr[%d]: 0x%x", i, plane, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
1985 Exynos_CodecBufferEnQueue(pExynosComponent, INPUT_PORT_INDEX, pVideoDec->pMFCDecInputBuffer[i]);
1988 #ifdef TIZEN_FEATURE_E3250
1989 if (pOMXComponent == NULL) {
1990 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s : %d: invalid parm: pOMXComponent = %p", __FUNCTION__, __LINE__, pOMXComponent);
1993 ret = H264CodecSrcInit(pOMXComponent);
1994 if (ret != OMX_ErrorNone)
1997 } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
2001 /* Does not require any actions. */
2004 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
2005 Exynos_OSAL_SemaphoreCreate(&pExynosOutputPort->codecSemID);
2006 Exynos_OSAL_QueueCreate(&pExynosOutputPort->codecBufferQ, MAX_QUEUE_ELEMENTS);
2007 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
2011 /* Does not require any actions. */
2014 pH264Dec->bSourceStart = OMX_FALSE;
2015 Exynos_OSAL_SignalCreate(&pH264Dec->hSourceStartEvent);
2016 pH264Dec->bDestinationStart = OMX_FALSE;
2017 Exynos_OSAL_SignalCreate(&pH264Dec->hDestinationStartEvent);
2019 Exynos_OSAL_Memset(pExynosComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
2020 Exynos_OSAL_Memset(pExynosComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
2021 pH264Dec->hMFCH264Handle.indexTimestamp = 0;
2022 pH264Dec->hMFCH264Handle.outputIndexTimestamp = 0;
2024 pExynosComponent->getAllDelayBuffer = OMX_FALSE;
2026 #if 0//defined(USE_CSC_GSCALER)
2027 csc_method = CSC_METHOD_HW; //in case of Use ION buffer.
2029 if (pVideoDec->bDRMPlayerMode == OMX_TRUE) {
2030 pVideoDec->csc_handle = csc_init(CSC_METHOD_HW);
2031 csc_set_hw_property(pVideoDec->csc_handle, CSC_HW_PROPERTY_FIXED_NODE, 2);
2032 csc_set_hw_property(pVideoDec->csc_handle, CSC_HW_PROPERTY_MODE_DRM, pVideoDec->bDRMPlayerMode);
2034 pVideoDec->csc_handle = csc_init(csc_method);
2037 if (pVideoDec->csc_handle == NULL) {
2038 ret = OMX_ErrorInsufficientResources;
2041 pVideoDec->csc_set_format = OMX_FALSE;
2050 OMX_ERRORTYPE Exynos_H264Dec_Terminate(OMX_COMPONENTTYPE *pOMXComponent)
2052 OMX_ERRORTYPE ret = OMX_ErrorNone;
2053 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2054 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2055 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2056 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2057 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2058 OMX_PTR hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
2060 ExynosVideoDecOps *pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
2061 ExynosVideoDecBufferOps *pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
2062 ExynosVideoDecBufferOps *pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
2068 if (pVideoDec->csc_handle != NULL) {
2069 csc_deinit(pVideoDec->csc_handle);
2070 pVideoDec->csc_handle = NULL;
2073 Exynos_OSAL_SignalTerminate(pH264Dec->hDestinationStartEvent);
2074 pH264Dec->hDestinationStartEvent = NULL;
2075 pH264Dec->bDestinationStart = OMX_FALSE;
2076 Exynos_OSAL_SignalTerminate(pH264Dec->hSourceStartEvent);
2077 pH264Dec->hSourceStartEvent = NULL;
2078 pH264Dec->bSourceStart = OMX_FALSE;
2080 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
2081 H264CodecDstFreeCodecBuffers(pOMXComponent);
2083 Exynos_OSAL_QueueTerminate(&pExynosOutputPort->codecBufferQ);
2084 Exynos_OSAL_SemaphoreTerminate(pExynosOutputPort->codecSemID);
2085 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
2089 /* Does not require any actions. */
2092 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2093 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
2094 if (pVideoDec->pMFCDecInputBuffer[i] != NULL) {
2095 #ifndef TIZEN_FEATURE_E3250 /* do not use ion */
2096 for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
2097 if (pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] != NULL)
2098 Exynos_OSAL_SharedMemory_Free(pVideoDec->hSharedMemory, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
2101 Exynos_OSAL_Free(pVideoDec->pMFCDecInputBuffer[i]);
2102 pVideoDec->pMFCDecInputBuffer[i] = NULL;
2106 Exynos_OSAL_QueueTerminate(&pExynosInputPort->codecBufferQ);
2107 Exynos_OSAL_SemaphoreTerminate(pExynosInputPort->codecSemID);
2108 } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
2112 /* Does not require any actions. */
2114 H264CodecClose(pH264Dec);
2122 OMX_ERRORTYPE Exynos_H264Dec_SrcIn(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
2124 OMX_ERRORTYPE ret = OMX_ErrorNone;
2125 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2126 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2127 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2128 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
2129 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2130 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2131 OMX_U32 oneFrameSize = pSrcInputData->dataLen;
2132 OMX_BOOL bInStartCode = OMX_FALSE;
2133 ExynosVideoDecOps *pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
2134 ExynosVideoDecBufferOps *pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
2135 ExynosVideoDecBufferOps *pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
2136 ExynosVideoErrorType codecReturn = VIDEO_ERROR_NONE;
2141 if (pH264Dec->hMFCH264Handle.bConfiguredMFCSrc == OMX_FALSE) {
2142 ret = H264CodecSrcSetup(pOMXComponent, pSrcInputData);
2145 if (pH264Dec->hMFCH264Handle.bConfiguredMFCDst == OMX_FALSE) {
2146 ret = H264CodecDstSetup(pOMXComponent);
2149 if (((pVideoDec->bDRMPlayerMode == OMX_TRUE) ||
2150 ((bInStartCode = Check_H264_StartCode(pSrcInputData->buffer.singlePlaneBuffer.dataBuffer, oneFrameSize)) == OMX_TRUE)) ||
2151 ((pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)) {
2152 pExynosComponent->timeStamp[pH264Dec->hMFCH264Handle.indexTimestamp] = pSrcInputData->timeStamp;
2153 pExynosComponent->nFlags[pH264Dec->hMFCH264Handle.indexTimestamp] = pSrcInputData->nFlags;
2154 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);
2155 pDecOps->Set_FrameTag(hMFCHandle, pH264Dec->hMFCH264Handle.indexTimestamp);
2156 pH264Dec->hMFCH264Handle.indexTimestamp++;
2157 pH264Dec->hMFCH264Handle.indexTimestamp %= MAX_TIMESTAMP;
2159 #ifdef USE_IMMEDIATE_DISPLAY
2160 /* Set Immediately display for I Frame*/
2162 if (pExynosComponent->checkTimeStamp.needCheckStartTimeStamp == OMX_TRUE) {
2163 if ( pExynosComponent->checkTimeStamp.bImmediateDisplay == OMX_FALSE) {
2164 /* Enable Immediately display After seek*/
2165 pDecOps->Set_ImmediateDisplay(hMFCHandle);
2166 pExynosComponent->checkTimeStamp.bImmediateDisplay = OMX_TRUE;
2171 /*Add First Frame check : */
2172 if((pSrcInputData->nFlags & OMX_BUFFERFLAG_CODECCONFIG) == OMX_BUFFERFLAG_CODECCONFIG)
2174 Exynos_OSAL_Log(EXYNOS_LOG_TRACE,"Video First Frame Coming");
2177 /* queue work for input buffer */
2178 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "oneFrameSize: %d, bufferHeader: 0x%x, dataBuffer: 0x%x", oneFrameSize, pSrcInputData->bufferHeader, pSrcInputData->buffer.singlePlaneBuffer.dataBuffer);
2179 codecReturn = pInbufOps->Enqueue(hMFCHandle, (unsigned char **)&pSrcInputData->buffer.singlePlaneBuffer.dataBuffer,
2180 (unsigned int *)&oneFrameSize, MFC_INPUT_BUFFER_PLANE, pSrcInputData->bufferHeader);
2181 if (codecReturn != VIDEO_ERROR_NONE) {
2182 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2183 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s : %d", __FUNCTION__, __LINE__);
2186 H264CodecStart(pOMXComponent, INPUT_PORT_INDEX);
2187 if (pH264Dec->bSourceStart == OMX_FALSE) {
2188 pH264Dec->bSourceStart = OMX_TRUE;
2189 Exynos_OSAL_SignalSet(pH264Dec->hSourceStartEvent);
2190 Exynos_OSAL_SleepMillisec(0);
2192 if (pH264Dec->bDestinationStart == OMX_FALSE) {
2193 pH264Dec->bDestinationStart = OMX_TRUE;
2194 Exynos_OSAL_SignalSet(pH264Dec->hDestinationStartEvent);
2195 Exynos_OSAL_SleepMillisec(0);
2197 } else if (bInStartCode == OMX_FALSE) {
2198 ret = OMX_ErrorCorruptedFrame;
2202 ret = OMX_ErrorNone;
2210 OMX_ERRORTYPE Exynos_H264Dec_SrcOut(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcOutputData)
2212 OMX_ERRORTYPE ret = OMX_ErrorNone;
2213 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2214 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2215 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2216 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
2217 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2218 ExynosVideoDecOps *pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
2219 ExynosVideoDecBufferOps *pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
2220 ExynosVideoBuffer *pVideoBuffer;
2224 pVideoBuffer = pInbufOps->Dequeue(hMFCHandle);
2226 pSrcOutputData->dataLen = 0;
2227 pSrcOutputData->usedDataLen = 0;
2228 pSrcOutputData->remainDataLen = 0;
2229 pSrcOutputData->nFlags = 0;
2230 pSrcOutputData->timeStamp = 0;
2232 if (pVideoBuffer == NULL) {
2233 pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer = NULL;
2234 pSrcOutputData->allocSize = 0;
2235 pSrcOutputData->pPrivate = NULL;
2236 pSrcOutputData->bufferHeader = NULL;
2238 pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer = pVideoBuffer->planes[0].addr;
2239 pSrcOutputData->buffer.singlePlaneBuffer.fd = pVideoBuffer->planes[0].fd;
2240 pSrcOutputData->allocSize = pVideoBuffer->planes[0].allocSize;
2242 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2244 while (pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer != pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[0]) {
2246 if (i >= MFC_INPUT_BUFFER_NUM_MAX) {
2247 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Can not find buffer");
2248 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2252 pVideoDec->pMFCDecInputBuffer[i]->dataSize = 0;
2253 pSrcOutputData->pPrivate = pVideoDec->pMFCDecInputBuffer[i];
2256 /* For Share Buffer */
2257 pSrcOutputData->bufferHeader = (OMX_BUFFERHEADERTYPE*)pVideoBuffer->pPrivate;
2260 ret = OMX_ErrorNone;
2268 OMX_ERRORTYPE Exynos_H264Dec_DstIn(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstInputData)
2270 OMX_ERRORTYPE ret = OMX_ErrorNone;
2271 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2272 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2273 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2274 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
2275 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2276 ExynosVideoDecOps *pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
2277 ExynosVideoDecBufferOps *pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
2278 OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0,};
2279 ExynosVideoErrorType codecReturn = VIDEO_ERROR_NONE;
2283 if (pDstInputData->buffer.multiPlaneBuffer.dataBuffer[0] == NULL) {
2284 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to find input buffer");
2285 ret = OMX_ErrorBadParameter;
2289 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "%s : %d => ADDR[0]: 0x%x, ADDR[1]: 0x%x", __FUNCTION__, __LINE__,
2290 pDstInputData->buffer.multiPlaneBuffer.dataBuffer[0],
2291 pDstInputData->buffer.multiPlaneBuffer.dataBuffer[1]);
2293 if ((pVideoDec->bDRCProcessing == OMX_TRUE) &&
2294 (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) &&
2295 (pExynosOutputPort->exceptionFlag == GENERAL_STATE)) {
2296 ret = H264CodecDstSetup(pOMXComponent);
2297 if (ret != OMX_ErrorNone) {
2298 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "DRC Reconfig H264CodecDstSetup Failed");
2301 pVideoDec->bDRCProcessing = OMX_FALSE;
2304 codecReturn = pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pDstInputData->buffer.multiPlaneBuffer.dataBuffer,
2305 (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, pDstInputData->bufferHeader);
2307 if (codecReturn != VIDEO_ERROR_NONE) {
2308 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s : %d", __FUNCTION__, __LINE__);
2309 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2312 H264CodecStart(pOMXComponent, OUTPUT_PORT_INDEX);
2314 ret = OMX_ErrorNone;
2322 OMX_ERRORTYPE Exynos_H264Dec_DstOut(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstOutputData)
2324 OMX_ERRORTYPE ret = OMX_ErrorNone;
2325 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2326 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2327 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
2328 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
2329 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2330 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2331 ExynosVideoDecOps *pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
2332 ExynosVideoDecBufferOps *pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
2333 ExynosVideoBuffer *pVideoBuffer;
2334 ExynosVideoFrameStatusType displayStatus = VIDEO_FRAME_STATUS_UNKNOWN;
2335 ExynosVideoGeometry *bufferGeometry;
2336 DECODE_CODEC_EXTRA_BUFFERINFO *pBufferInfo = NULL;
2337 OMX_S32 indexTimestamp = 0;
2342 if (pH264Dec->bDestinationStart == OMX_FALSE) {
2343 ret = OMX_ErrorNone;
2348 pVideoBuffer = pOutbufOps->Dequeue(hMFCHandle);
2349 if (pVideoBuffer == (ExynosVideoBuffer *)VIDEO_ERROR_DQBUF_EIO) {
2350 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "HW is not available");
2351 ret = OMX_ErrorHardware;
2355 if (pVideoBuffer == NULL) {
2356 ret = OMX_ErrorNone;
2359 displayStatus = pVideoBuffer->displayStatus;
2360 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "displayStatus: 0x%x", displayStatus);
2362 if ((displayStatus == VIDEO_FRAME_STATUS_DISPLAY_DECODING) ||
2363 (displayStatus == VIDEO_FRAME_STATUS_DISPLAY_ONLY) ||
2364 (displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) ||
2365 (displayStatus == VIDEO_FRAME_STATUS_DECODING_FINISHED) ||
2366 (CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2367 if (pVideoBuffer != NULL) {
2368 ret = OMX_ErrorNone;
2371 ret = OMX_ErrorUndefined;
2377 if (displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) {
2378 if (pVideoDec->bDRCProcessing != OMX_TRUE) {
2379 pExynosOutputPort->exceptionFlag = NEED_PORT_FLUSH;
2380 pVideoDec->bDRCProcessing = OMX_TRUE;
2381 H264CodecCheckResolutionChange(pOMXComponent);
2382 pVideoDec->csc_set_format = OMX_FALSE;
2384 ret = OMX_ErrorNone;
2388 pH264Dec->hMFCH264Handle.outputIndexTimestamp++;
2389 pH264Dec->hMFCH264Handle.outputIndexTimestamp %= MAX_TIMESTAMP;
2391 pDstOutputData->allocSize = pDstOutputData->dataLen = 0;
2392 for (plane = 0; plane < MFC_OUTPUT_BUFFER_PLANE; plane++) {
2393 pDstOutputData->buffer.multiPlaneBuffer.dataBuffer[plane] = pVideoBuffer->planes[plane].addr;
2394 pDstOutputData->buffer.multiPlaneBuffer.fd[plane] = pVideoBuffer->planes[plane].fd;
2395 pDstOutputData->buffer.multiPlaneBuffer.tbm_bo[plane] = pVideoBuffer->planes[plane].tbm_bo;
2396 pDstOutputData->allocSize += pVideoBuffer->planes[plane].allocSize;
2397 pDstOutputData->dataLen += pVideoBuffer->planes[plane].dataSize;
2399 pDstOutputData->usedDataLen = 0;
2400 pDstOutputData->pPrivate = pVideoBuffer;
2401 /* For Share Buffer */
2402 pDstOutputData->bufferHeader = (OMX_BUFFERHEADERTYPE *)pVideoBuffer->pPrivate;
2404 pBufferInfo = (DECODE_CODEC_EXTRA_BUFFERINFO *)pDstOutputData->extInfo;
2405 bufferGeometry = &pH264Dec->hMFCH264Handle.codecOutbufConf;
2406 pBufferInfo->imageWidth = bufferGeometry->nFrameWidth;
2407 pBufferInfo->imageHeight = bufferGeometry->nFrameHeight;
2408 switch (bufferGeometry->eColorFormat) {
2409 case VIDEO_COLORFORMAT_NV12:
2410 #ifdef TIZEN_FEATURE_E3250 /* NV12 fd */
2411 pBufferInfo->ColorFormat = OMX_SEC_COLOR_FormatNV12L_DmaBuf_Fd;
2413 pBufferInfo->ColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
2416 case VIDEO_COLORFORMAT_NV12_TILED:
2418 pBufferInfo->ColorFormat = OMX_SEC_COLOR_FormatNV12Tiled;
2422 #ifdef USE_S3D_SUPPORT
2423 /* Check Whether frame packing information is available */
2424 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY &&
2425 pVideoDec->bThumbnailMode == OMX_FALSE &&
2426 pH264Dec->hMFCH264Handle.S3DFPArgmtType == OMX_SEC_FPARGMT_NONE) {
2427 H264CodecCheckFramePacking(pOMXComponent);
2431 indexTimestamp = pDecOps->Get_FrameTag(hMFCHandle);
2432 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "out indexTimestamp: %d", indexTimestamp);
2433 if ((indexTimestamp < 0) || (indexTimestamp >= MAX_TIMESTAMP)) {
2434 if ((pExynosComponent->checkTimeStamp.needSetStartTimeStamp != OMX_TRUE) &&
2435 (pExynosComponent->checkTimeStamp.needCheckStartTimeStamp != OMX_TRUE)) {
2436 pDstOutputData->timeStamp = pExynosComponent->timeStamp[pH264Dec->hMFCH264Handle.outputIndexTimestamp];
2437 pDstOutputData->nFlags = pExynosComponent->nFlags[pH264Dec->hMFCH264Handle.outputIndexTimestamp];
2438 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "missing out indexTimestamp: %d", indexTimestamp);
2440 pDstOutputData->timeStamp = 0x00;
2441 pDstOutputData->nFlags = 0x00;
2444 /* For timestamp correction. if mfc support frametype detect */
2445 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "disp_pic_frame_type: %d", pVideoBuffer->frameType);
2446 //#ifdef NEED_TIMESTAMP_REORDER
2447 /* TIZEN_FEATURE_E3250 */
2448 if (pVideoDec->bNeedTimestampReorder == OMX_TRUE) {
2449 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "NEED_TIMESTAMP_REORDER ON");
2450 if ((pVideoBuffer->frameType == VIDEO_FRAME_I)) {
2451 pDstOutputData->timeStamp = pExynosComponent->timeStamp[indexTimestamp];
2452 pDstOutputData->nFlags = pExynosComponent->nFlags[indexTimestamp];
2453 pH264Dec->hMFCH264Handle.outputIndexTimestamp = indexTimestamp;
2455 pDstOutputData->timeStamp = pExynosComponent->timeStamp[pH264Dec->hMFCH264Handle.outputIndexTimestamp];
2456 pDstOutputData->nFlags = pExynosComponent->nFlags[pH264Dec->hMFCH264Handle.outputIndexTimestamp];
2460 pDstOutputData->timeStamp = pExynosComponent->timeStamp[indexTimestamp];
2461 pDstOutputData->nFlags = pExynosComponent->nFlags[indexTimestamp];
2464 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "timestamp %lld us (%.2f secs), indexTimestamp: %d, nFlags: 0x%x", pDstOutputData->timeStamp, pDstOutputData->timeStamp / 1E6, indexTimestamp, pDstOutputData->nFlags);
2467 if ((displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) ||
2468 (displayStatus == VIDEO_FRAME_STATUS_DECODING_FINISHED) ||
2469 ((pDstOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)) {
2470 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "displayStatus:%d, nFlags0x%x", displayStatus, pDstOutputData->nFlags);
2471 pDstOutputData->remainDataLen = 0;
2473 pDstOutputData->remainDataLen = bufferGeometry->nFrameWidth * bufferGeometry->nFrameHeight * 3 / 2;
2476 ret = OMX_ErrorNone;
2484 OMX_ERRORTYPE Exynos_H264Dec_srcInputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
2486 OMX_ERRORTYPE ret = OMX_ErrorNone;
2487 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2488 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2489 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2493 if ((!CHECK_PORT_ENABLED(pExynosInputPort)) || (!CHECK_PORT_POPULATED(pExynosInputPort))) {
2494 ret = OMX_ErrorNone;
2497 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, INPUT_PORT_INDEX)) {
2498 ret = OMX_ErrorNone;
2502 ret = Exynos_H264Dec_SrcIn(pOMXComponent, pSrcInputData);
2503 if ((ret != OMX_ErrorNone) &&
2504 (ret != OMX_ErrorInputDataDecodeYet) &&
2505 (ret != OMX_ErrorCorruptedFrame)) {
2506 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2507 pExynosComponent->callbackData,
2508 OMX_EventError, ret, 0, NULL);
2517 OMX_ERRORTYPE Exynos_H264Dec_srcOutputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcOutputData)
2519 OMX_ERRORTYPE ret = OMX_ErrorNone;
2520 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2521 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2522 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2526 if ((!CHECK_PORT_ENABLED(pExynosInputPort)) || (!CHECK_PORT_POPULATED(pExynosInputPort))) {
2527 ret = OMX_ErrorNone;
2531 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2532 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, INPUT_PORT_INDEX)) {
2533 ret = OMX_ErrorNone;
2537 if ((pH264Dec->bSourceStart == OMX_FALSE) &&
2538 (!CHECK_PORT_BEING_FLUSHED(pExynosInputPort))) {
2539 Exynos_OSAL_SignalWait(pH264Dec->hSourceStartEvent, DEF_MAX_WAIT_TIME);
2540 Exynos_OSAL_SignalReset(pH264Dec->hSourceStartEvent);
2543 ret = Exynos_H264Dec_SrcOut(pOMXComponent, pSrcOutputData);
2544 if ((ret != OMX_ErrorNone) && (pExynosComponent->currentState == OMX_StateExecuting)) {
2545 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2546 pExynosComponent->callbackData,
2547 OMX_EventError, ret, 0, NULL);
2556 OMX_ERRORTYPE Exynos_H264Dec_dstInputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstInputData)
2558 OMX_ERRORTYPE ret = OMX_ErrorNone;
2559 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2560 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2561 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2565 if ((!CHECK_PORT_ENABLED(pExynosOutputPort)) || (!CHECK_PORT_POPULATED(pExynosOutputPort))) {
2566 ret = OMX_ErrorNone;
2569 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, OUTPUT_PORT_INDEX)) {
2570 ret = OMX_ErrorNone;
2573 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
2574 if ((pH264Dec->bDestinationStart == OMX_FALSE) &&
2575 (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2576 Exynos_OSAL_SignalWait(pH264Dec->hDestinationStartEvent, DEF_MAX_WAIT_TIME);
2577 Exynos_OSAL_SignalReset(pH264Dec->hDestinationStartEvent);
2580 if (pH264Dec->hMFCH264Handle.bConfiguredMFCDst == OMX_TRUE) {
2581 ret = Exynos_H264Dec_DstIn(pOMXComponent, pDstInputData);
2582 if (ret != OMX_ErrorNone) {
2583 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2584 pExynosComponent->callbackData,
2585 OMX_EventError, ret, 0, NULL);
2595 OMX_ERRORTYPE Exynos_H264Dec_dstOutputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstOutputData)
2597 OMX_ERRORTYPE ret = OMX_ErrorNone;
2598 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2599 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2600 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2604 if ((!CHECK_PORT_ENABLED(pExynosOutputPort)) || (!CHECK_PORT_POPULATED(pExynosOutputPort))) {
2605 ret = OMX_ErrorNone;
2608 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, OUTPUT_PORT_INDEX)) {
2609 ret = OMX_ErrorNone;
2613 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
2614 if ((pH264Dec->bDestinationStart == OMX_FALSE) &&
2615 (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2616 Exynos_OSAL_SignalWait(pH264Dec->hDestinationStartEvent, DEF_MAX_WAIT_TIME);
2617 Exynos_OSAL_SignalReset(pH264Dec->hDestinationStartEvent);
2620 ret = Exynos_H264Dec_DstOut(pOMXComponent, pDstOutputData);
2621 if ((ret != OMX_ErrorNone) && (pExynosComponent->currentState == OMX_StateExecuting)) {
2622 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2623 pExynosComponent->callbackData,
2624 OMX_EventError, ret, 0, NULL);
2633 OSCL_EXPORT_REF OMX_ERRORTYPE Exynos_OMX_ComponentInit(OMX_HANDLETYPE hComponent, OMX_STRING componentName)
2635 OMX_ERRORTYPE ret = OMX_ErrorNone;
2636 OMX_COMPONENTTYPE *pOMXComponent = NULL;
2637 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
2638 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
2639 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
2640 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
2641 OMX_BOOL bDRMPlayerMode = OMX_FALSE;
2646 if ((hComponent == NULL) || (componentName == NULL)) {
2647 ret = OMX_ErrorBadParameter;
2648 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
2651 if (Exynos_OSAL_Strcmp(EXYNOS_OMX_COMPONENT_H264_DEC, componentName) == 0) {
2652 bDRMPlayerMode = OMX_FALSE;
2653 } else if (Exynos_OSAL_Strcmp(EXYNOS_OMX_COMPONENT_H264_DRM_DEC, componentName) == 0) {
2654 bDRMPlayerMode = OMX_TRUE;
2656 ret = OMX_ErrorBadParameter;
2657 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, componentName:%s, Line:%d", componentName, __LINE__);
2661 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2662 ret = Exynos_OMX_VideoDecodeComponentInit(pOMXComponent);
2663 if (ret != OMX_ErrorNone) {
2664 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_Error, Line:%d", __LINE__);
2667 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2668 pExynosComponent->codecType = HW_VIDEO_DEC_CODEC;
2670 pExynosComponent->componentName = (OMX_STRING)Exynos_OSAL_Malloc(MAX_OMX_COMPONENT_NAME_SIZE);
2671 if (pExynosComponent->componentName == NULL) {
2672 Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2673 ret = OMX_ErrorInsufficientResources;
2674 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2677 Exynos_OSAL_Memset(pExynosComponent->componentName, 0, MAX_OMX_COMPONENT_NAME_SIZE);
2679 pH264Dec = Exynos_OSAL_Malloc(sizeof(EXYNOS_H264DEC_HANDLE));
2680 if (pH264Dec == NULL) {
2681 Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2682 ret = OMX_ErrorInsufficientResources;
2683 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2686 Exynos_OSAL_Memset(pH264Dec, 0, sizeof(EXYNOS_H264DEC_HANDLE));
2687 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2688 pVideoDec->hCodecHandle = (OMX_HANDLETYPE)pH264Dec;
2690 if (bDRMPlayerMode == OMX_TRUE)
2691 Exynos_OSAL_Strcpy(pExynosComponent->componentName, EXYNOS_OMX_COMPONENT_H264_DRM_DEC);
2693 Exynos_OSAL_Strcpy(pExynosComponent->componentName, EXYNOS_OMX_COMPONENT_H264_DEC);
2695 pVideoDec->bDRMPlayerMode = bDRMPlayerMode;
2696 /* In case of BUFFER_COPY mode
2697 bShareableBuf = TRUE means MemoryType is V4L2_MEMORY_USERPTR
2698 bShareableBuf = FALSE means MemoryType is V4L2_MEMORY_MMAP
2699 In case of BUFFER_SHARE
2700 bShareableBuf should be TRUE, FALSE is ignored
2702 pH264Dec->hMFCH264Handle.bShareableBuf = OMX_FALSE;
2703 #ifdef USE_S3D_SUPPORT
2704 pH264Dec->hMFCH264Handle.S3DFPArgmtType = OMX_SEC_FPARGMT_NONE;
2707 /* Set componentVersion */
2708 pExynosComponent->componentVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
2709 pExynosComponent->componentVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
2710 pExynosComponent->componentVersion.s.nRevision = REVISION_NUMBER;
2711 pExynosComponent->componentVersion.s.nStep = STEP_NUMBER;
2712 /* Set specVersion */
2713 pExynosComponent->specVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
2714 pExynosComponent->specVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
2715 pExynosComponent->specVersion.s.nRevision = REVISION_NUMBER;
2716 pExynosComponent->specVersion.s.nStep = STEP_NUMBER;
2719 pExynosPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2720 pExynosPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
2721 pExynosPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
2722 pExynosPort->portDefinition.format.video.nStride = 0; /*DEFAULT_FRAME_WIDTH;*/
2723 pExynosPort->portDefinition.format.video.nSliceHeight = 0;
2724 pExynosPort->portDefinition.nBufferSize = DEFAULT_VIDEO_INPUT_BUFFER_SIZE;
2725 pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
2726 Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2727 Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "video/avc");
2728 pExynosPort->portDefinition.format.video.pNativeRender = 0;
2729 pExynosPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
2730 pExynosPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatUnused;
2731 pExynosPort->portDefinition.bEnabled = OMX_TRUE;
2732 pExynosPort->bufferProcessType = BUFFER_COPY;
2733 if (bDRMPlayerMode == OMX_TRUE)
2734 pExynosPort->bufferProcessType = BUFFER_SHARE;
2735 pExynosPort->portWayType = WAY2_PORT;
2738 pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2739 pExynosPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
2740 pExynosPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
2741 pExynosPort->portDefinition.format.video.nStride = 0; /*DEFAULT_FRAME_WIDTH;*/
2742 pExynosPort->portDefinition.format.video.nSliceHeight = 0;
2743 pExynosPort->portDefinition.nBufferSize = DEFAULT_VIDEO_OUTPUT_BUFFER_SIZE;
2744 pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused;
2745 Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2746 Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "raw/video");
2747 pExynosPort->portDefinition.format.video.pNativeRender = 0;
2748 pExynosPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
2749 #ifdef TIZEN_FEATURE_E3250
2750 pExynosPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatNV12L_DmaBuf_Fd;
2752 pExynosPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
2754 pExynosPort->portDefinition.bEnabled = OMX_TRUE;
2755 #ifdef TIZEN_FEATURE_E3250
2756 pExynosPort->bufferProcessType = BUFFER_SHARE;
2758 pExynosPort->bufferProcessType = BUFFER_COPY;
2760 pExynosPort->portWayType = WAY2_PORT;
2762 for(i = 0; i < ALL_PORT_NUM; i++) {
2763 INIT_SET_SIZE_VERSION(&pH264Dec->AVCComponent[i], OMX_VIDEO_PARAM_AVCTYPE);
2764 pH264Dec->AVCComponent[i].nPortIndex = i;
2765 pH264Dec->AVCComponent[i].eProfile = OMX_VIDEO_AVCProfileBaseline;
2766 pH264Dec->AVCComponent[i].eLevel = OMX_VIDEO_AVCLevel4;
2769 pOMXComponent->GetParameter = &Exynos_H264Dec_GetParameter;
2770 pOMXComponent->SetParameter = &Exynos_H264Dec_SetParameter;
2771 pOMXComponent->GetConfig = &Exynos_H264Dec_GetConfig;
2772 pOMXComponent->SetConfig = &Exynos_H264Dec_SetConfig;
2773 pOMXComponent->GetExtensionIndex = &Exynos_H264Dec_GetExtensionIndex;
2774 pOMXComponent->ComponentRoleEnum = &Exynos_H264Dec_ComponentRoleEnum;
2775 pOMXComponent->ComponentDeInit = &Exynos_OMX_ComponentDeinit;
2777 pExynosComponent->exynos_codec_componentInit = &Exynos_H264Dec_Init;
2778 pExynosComponent->exynos_codec_componentTerminate = &Exynos_H264Dec_Terminate;
2780 pVideoDec->exynos_codec_srcInputProcess = &Exynos_H264Dec_srcInputBufferProcess;
2781 pVideoDec->exynos_codec_srcOutputProcess = &Exynos_H264Dec_srcOutputBufferProcess;
2782 pVideoDec->exynos_codec_dstInputProcess = &Exynos_H264Dec_dstInputBufferProcess;
2783 pVideoDec->exynos_codec_dstOutputProcess = &Exynos_H264Dec_dstOutputBufferProcess;
2785 pVideoDec->exynos_codec_start = &H264CodecStart;
2786 pVideoDec->exynos_codec_stop = &H264CodecStop;
2787 pVideoDec->exynos_codec_bufferProcessRun = &H264CodecOutputBufferProcessRun;
2788 pVideoDec->exynos_codec_enqueueAllBuffer = &H264CodecEnQueueAllBuffer;
2789 pVideoDec->exynos_codec_resetupAllElement = &H264CodecResetupAllElement;
2791 pVideoDec->exynos_checkInputFrame = NULL;
2792 pVideoDec->exynos_codec_getCodecInputPrivateData = &GetCodecInputPrivateData;
2793 pVideoDec->exynos_codec_getCodecOutputPrivateData = &GetCodecOutputPrivateData;
2795 #ifndef TIZEN_FEATURE_E3250 /* do not use ion */
2796 pVideoDec->hSharedMemory = Exynos_OSAL_SharedMemory_Open();
2797 if (pVideoDec->hSharedMemory == NULL) {
2798 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2799 Exynos_OSAL_Free(pH264Dec);
2800 pH264Dec = ((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle = NULL;
2801 Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2802 ret = OMX_ErrorInsufficientResources;
2806 pExynosComponent->currentState = OMX_StateLoaded;
2808 ret = OMX_ErrorNone;
2816 OMX_ERRORTYPE Exynos_OMX_ComponentDeinit(OMX_HANDLETYPE hComponent)
2818 OMX_ERRORTYPE ret = OMX_ErrorNone;
2819 OMX_COMPONENTTYPE *pOMXComponent = NULL;
2820 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
2821 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
2822 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
2826 if (hComponent == NULL) {
2827 ret = OMX_ErrorBadParameter;
2830 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2831 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2832 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2834 #ifndef TIZEN_FEATURE_E3250 /* do not use ion */
2835 Exynos_OSAL_SharedMemory_Close(pVideoDec->hSharedMemory);
2837 Exynos_OSAL_Free(pExynosComponent->componentName);
2838 pExynosComponent->componentName = NULL;
2840 pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
2841 if (pH264Dec != NULL) {
2842 Exynos_OSAL_Free(pH264Dec);
2843 pH264Dec = pVideoDec->hCodecHandle = NULL;
2846 ret = Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2847 if (ret != OMX_ErrorNone) {
2851 ret = OMX_ErrorNone;