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_Wmvdec.c
21 * @author HyeYeon Chung (hyeon.chung@samsung.com)
22 * @author Satish Kumar Reddy (palli.satish@samsung.com)
26 * : Support WMV3 (Vc-1 Simple/Main Profile)
27 * : Support WMvC1 (Vc-1 Advanced Profile)
35 #include "Exynos_OMX_Macros.h"
36 #include "Exynos_OMX_Basecomponent.h"
37 #include "Exynos_OMX_Baseport.h"
38 #include "Exynos_OMX_Vdec.h"
39 #include "Exynos_OSAL_ETC.h"
40 #include "Exynos_OSAL_Semaphore.h"
41 #include "Exynos_OSAL_Thread.h"
42 #include "library_register.h"
43 #include "Exynos_OMX_Wmvdec.h"
44 #include "ExynosVideoApi.h"
45 #include "Exynos_OSAL_SharedMemory.h"
46 #include "Exynos_OSAL_Event.h"
49 #include "Exynos_OSAL_Platform_Specific.h"
52 /* To use CSC_METHOD_HW in EXYNOS OMX, gralloc should allocate physical memory using FIMC */
53 /* It means GRALLOC_USAGE_HW_FIMC1 should be set on Native Window usage */
57 #define EXYNOS_LOG_TAG "EXYNOS_WMV_DEC"
58 #define EXYNOS_LOG_OFF
59 //#define EXYNOS_TRACE_ON
60 #include "Exynos_OSAL_Log.h"
62 #define WMV_DEC_NUM_OF_EXTRA_BUFFERS 7
64 //#define FULL_FRAME_SEARCH
66 /* ASF parser does not send start code on Stagefright */
68 /* Enable or disable "WMV3_ADDITIONAL_START_CODE" based on MFC F/W's need */
69 //#define WMV3_ADDITIONAL_START_CODE
71 const OMX_U32 wmv3 = 0x33564d57;
72 const OMX_U32 wvc1 = 0x31435657;
73 const OMX_U32 wmva = 0x41564d57;
76 static OMX_ERRORTYPE GetCodecInputPrivateData(OMX_PTR codecBuffer, void *pVirtAddr, OMX_U32 *dataSize)
78 OMX_ERRORTYPE ret = OMX_ErrorNone;
84 static OMX_ERRORTYPE GetCodecOutputPrivateData(OMX_PTR codecBuffer, void *addr[], int size[])
86 OMX_ERRORTYPE ret = OMX_ErrorNone;
87 ExynosVideoBuffer *pCodecBuffer;
89 if (codecBuffer == NULL) {
90 ret = OMX_ErrorBadParameter;
94 pCodecBuffer = (ExynosVideoBuffer *)codecBuffer;
97 addr[0] = pCodecBuffer->planes[0].addr;
98 addr[1] = pCodecBuffer->planes[1].addr;
99 addr[2] = pCodecBuffer->planes[2].addr;
103 size[0] = pCodecBuffer->planes[0].allocSize;
104 size[1] = pCodecBuffer->planes[1].allocSize;
105 size[2] = pCodecBuffer->planes[2].allocSize;
113 OMX_U8 *pInputStream,
116 OMX_BOOL bPreviousFrameEOF,
117 OMX_BOOL *pbEndOfFrame)
119 OMX_U32 compressionID;
120 OMX_BOOL bFrameStart;
121 OMX_U32 len, readStream;
123 WMV_FORMAT gWvmFormat = WMV_FORMAT_UNKNOWN;
125 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "buffSize = %d", buffSize);
128 bFrameStart = OMX_FALSE;
130 if (flag & OMX_BUFFERFLAG_CODECCONFIG) {
131 BitmapInfoHhr *pBitmapInfoHeader;
132 pBitmapInfoHeader = (BitmapInfoHhr *)pInputStream;
134 compressionID = pBitmapInfoHeader->BiCompression;
135 if (compressionID == wmv3) {
136 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "WMV_FORMAT_WMV3");
137 gWvmFormat = WMV_FORMAT_WMV3;
139 *pbEndOfFrame = OMX_TRUE;
142 else if ((compressionID == wvc1) || (compressionID == wmva)) {
143 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "WMV_FORMAT_VC1");
144 gWvmFormat = WMV_FORMAT_VC1;
147 /* ASF parser does not send start code on Stagefright */
148 *pbEndOfFrame = OMX_TRUE;
154 if (gWvmFormat == WMV_FORMAT_WMV3) {
155 *pbEndOfFrame = OMX_TRUE;
160 /* ASF parser does not send start code on Stagefright */
161 if (gWvmFormat == WMV_FORMAT_VC1) {
162 *pbEndOfFrame = OMX_TRUE;
166 /* TODO : for comformanc test based on common buffer scheme w/o parser */
168 if (bPreviousFrameEOF == OMX_FALSE)
169 bFrameStart = OMX_TRUE;
171 startCode = 0xFFFFFFFF;
172 if (bFrameStart == OMX_FALSE) {
173 /* find Frame start code */
174 while(startCode != 0x10D) {
175 readStream = *(pInputStream + len);
176 startCode = (startCode << 8) | readStream;
183 /* find next Frame start code */
184 startCode = 0xFFFFFFFF;
185 while ((startCode != 0x10D)) {
186 readStream = *(pInputStream + len);
187 startCode = (startCode << 8) | readStream;
193 *pbEndOfFrame = OMX_TRUE;
195 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "1. Check_Wmv_Frame returned EOF = %d, len = %d, buffSize = %d", *pbEndOfFrame, len - 4, buffSize);
201 *pbEndOfFrame = OMX_FALSE;
203 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "2. Check_Wmv_Frame returned EOF = %d, len = %d, buffSize = %d", *pbEndOfFrame, len - 1, buffSize);
208 static OMX_BOOL Check_Stream_PrefixCode(
209 OMX_U8 *pInputStream,
211 WMV_FORMAT wmvFormat)
214 case WMV_FORMAT_WMV3:
215 #ifdef WMV3_ADDITIONAL_START_CODE
224 /* TODO : for comformanc test based on common buffer scheme w/o parser */
225 if (streamSize < 3) {
226 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: streamSize is too small (%d)", __FUNCTION__, streamSize);
228 } else if ((pInputStream[0] == 0x00) &&
229 (pInputStream[1] == 0x00) &&
230 (pInputStream[2] == 0x01)) {
233 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: Cannot find prefix", __FUNCTION__);
239 Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "%s: undefined wmvFormat (%d)", __FUNCTION__, wmvFormat);
245 static OMX_BOOL Make_Stream_MetaData(
246 OMX_U8 *pInputStream,
247 OMX_U32 *pStreamSize,
249 #ifdef TIZEN_FEATURE_E3250
250 , OMX_U32 width, OMX_U32 height
254 OMX_U8 *pCurrBuf = pInputStream;
256 #ifndef TIZEN_FEATURE_E3250
257 OMX_U32 width, height;
261 /* Sequence Layer Data Structure */
262 OMX_U8 const_C5[4] = {0x00, 0x00, 0x00, 0xc5};
263 OMX_U8 const_04[4] = {0x04, 0x00, 0x00, 0x00};
264 OMX_U8 const_0C[4] = {0x0C, 0x00, 0x00, 0x00};
265 OMX_U8 struct_B_1[4] = {0xB3, 0x19, 0x00, 0x00};
266 OMX_U8 struct_B_2[4] = {0x44, 0x62, 0x05, 0x00};
267 OMX_U8 struct_B_3[4] = {0x0F, 0x00, 0x00, 0x00};
268 OMX_U8 struct_C[4] = {0x30, 0x00, 0x00, 0x00};
271 case WMV_FORMAT_WMV3:
272 if (*pStreamSize >= BITMAPINFOHEADER_SIZE) {
273 #ifndef TIZEN_FEATURE_E3250
274 BitmapInfoHhr *pBitmapInfoHeader;
275 pBitmapInfoHeader = (BitmapInfoHhr *)pInputStream;
277 width = pBitmapInfoHeader->BiWidth;
278 height = pBitmapInfoHeader->BiHeight;
280 if (*pStreamSize > BITMAPINFOHEADER_SIZE)
281 Exynos_OSAL_Memcpy(struct_C, pInputStream+BITMAPINFOHEADER_SIZE, 4);
283 Exynos_OSAL_Memcpy(pCurrBuf + currPos, const_C5, 4);
286 Exynos_OSAL_Memcpy(pCurrBuf + currPos, const_04, 4);
289 Exynos_OSAL_Memcpy(pCurrBuf + currPos, struct_C, 4);
292 /* struct_A : VERT_SIZE */
293 pCurrBuf[currPos] = height & 0xFF;
294 pCurrBuf[currPos+1] = (height>>8) & 0xFF;
295 pCurrBuf[currPos+2] = (height>>16) & 0xFF;
296 pCurrBuf[currPos+3] = (height>>24) & 0xFF;
299 /* struct_A : HORIZ_SIZE */
300 pCurrBuf[currPos] = width & 0xFF;
301 pCurrBuf[currPos+1] = (width>>8) & 0xFF;
302 pCurrBuf[currPos+2] = (width>>16) & 0xFF;
303 pCurrBuf[currPos+3] = (width>>24) & 0xFF;
306 Exynos_OSAL_Memcpy(pCurrBuf + currPos,const_0C, 4);
309 Exynos_OSAL_Memcpy(pCurrBuf + currPos, struct_B_1, 4);
312 Exynos_OSAL_Memcpy(pCurrBuf + currPos, struct_B_2, 4);
315 Exynos_OSAL_Memcpy(pCurrBuf + currPos, struct_B_3, 4);
318 *pStreamSize = currPos;
321 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: *pStreamSize is too small to contain metadata(%d)", __FUNCTION__, *pStreamSize);
326 if (*pStreamSize >= BITMAPINFOHEADER_ASFBINDING_SIZE) {
327 Exynos_OSAL_Memcpy(pCurrBuf, pInputStream + BITMAPINFOHEADER_ASFBINDING_SIZE, *pStreamSize - BITMAPINFOHEADER_ASFBINDING_SIZE);
328 *pStreamSize -= BITMAPINFOHEADER_ASFBINDING_SIZE;
331 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: *pStreamSize is too small to contain metadata(%d)", __FUNCTION__, *pStreamSize);
336 Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "%s: It is not necessary to make bitstream metadata for wmvFormat (%d)", __FUNCTION__, wmvFormat);
342 static OMX_BOOL Make_Stream_StartCode(
343 OMX_U8 *pInputStream,
344 OMX_U32 *pStreamSize,
345 WMV_FORMAT wmvFormat)
347 OMX_U8 frameStartCode[4] = {0x00, 0x00, 0x01, 0x0d};
348 #ifdef WMV3_ADDITIONAL_START_CODE
349 /* first 4 bytes : size of Frame, second 4 bytes : present Time stamp */
350 OMX_U8 frameStartCode2[8] = {0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00};
355 case WMV_FORMAT_WMV3:
356 #ifdef WMV3_ADDITIONAL_START_CODE
357 Exynos_OSAL_Memmove(pInputStream+8, pInputStream, *pStreamSize);
358 Exynos_OSAL_Memcpy(pInputStream, frameStartCode2, 8);
365 /* Should find better way to shift data */
366 Exynos_OSAL_Memmove(pInputStream+4, pInputStream, *pStreamSize);
367 Exynos_OSAL_Memcpy(pInputStream, frameStartCode, 4);
373 Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "%s: undefined wmvFormat (%d)", __FUNCTION__, wmvFormat);
379 OMX_ERRORTYPE Process_Wmv_CodecConfigData(OMX_COMPONENTTYPE *pOMXComponent, void *pConfig)
381 OMX_ERRORTYPE ret = OMX_ErrorNone;
382 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
383 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
384 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
385 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
386 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
387 OMX_PTR hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
388 #ifdef TIZEN_FEATURE_E3250
389 EXYNOS_OMX_DATABUFFER *pSrcInputData = (EXYNOS_OMX_DATA *)pConfig;
390 OMX_U8 *pInputStream = pSrcInputData->bufferHeader->pBuffer;
395 #ifdef TIZEN_FEATURE_E3250
396 if (pWmvDec->wmvFormat == WMV_FORMAT_UNKNOWN) {
397 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Process_Wmv_CodecConfigData. dataLen = %d", pSrcInputData->dataLen);
398 if (pSrcInputData->dataLen < 4) {
399 pWmvDec->wmvFormat = WMV_FORMAT_UNKNOWN;
400 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "WMV_FORMAT_UNKNOWN");
401 } else if ((pInputStream[1] == 0x00) &&
402 (pInputStream[2] == 0x00) &&
403 (pInputStream[3] == 0x01)) {
404 pWmvDec->wmvFormat = WMV_FORMAT_VC1;
405 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "WMV_FORMAT_VC1");
407 pWmvDec->wmvFormat = WMV_FORMAT_WMV3;
408 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "WMV_FORMAT_WMV3");
412 pWmvDec->hMFCWmvHandle.wmvFormat = pWmvDec->wmvFormat;
414 BitmapInfoHhr *pBitmapInfoHeader;
415 pBitmapInfoHeader = (BitmapInfoHhr *)pConfig;
416 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "OMX_BUFFERFLAG_CODECCONFIG");
417 if (pBitmapInfoHeader->BiCompression == wmv3) {
418 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "WMV_FORMAT_WMV3");
419 pWmvDec->hMFCWmvHandle.wmvFormat = WMV_FORMAT_WMV3;
420 } else if ((pBitmapInfoHeader->BiCompression == wvc1) || (pBitmapInfoHeader->BiCompression == wmva)) {
421 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "WMV_FORMAT_VC1");
422 pWmvDec->hMFCWmvHandle.wmvFormat = WMV_FORMAT_VC1;
424 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "WMV_FORMAT_UNKNOWN (0x%x), default value will be used", pBitmapInfoHeader->BiCompression);
427 ret = WmvCodecSrcInit(pOMXComponent);
428 if (ret != OMX_ErrorNone) {
429 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to WmvCodecSrcInit");
441 OMX_ERRORTYPE WmvCodecOpen(EXYNOS_WMVDEC_HANDLE *pWmvDec)
443 OMX_ERRORTYPE ret = OMX_ErrorNone;
444 ExynosVideoDecOps *pDecOps = NULL;
445 ExynosVideoDecBufferOps *pInbufOps = NULL;
446 ExynosVideoDecBufferOps *pOutbufOps = NULL;
447 enum v4l2_memory v4l2MemoryType = V4L2_MEMORY_USERPTR;
451 if (pWmvDec == NULL) {
452 ret = OMX_ErrorBadParameter;
453 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
457 /* alloc ops structure */
458 pDecOps = (ExynosVideoDecOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoDecOps));
459 pInbufOps = (ExynosVideoDecBufferOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoDecBufferOps));
460 pOutbufOps = (ExynosVideoDecBufferOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoDecBufferOps));
462 if ((pDecOps == NULL) || (pInbufOps == NULL) || (pOutbufOps == NULL)) {
463 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to allocate decoder ops buffer");
464 ret = OMX_ErrorInsufficientResources;
468 pWmvDec->hMFCWmvHandle.pDecOps = pDecOps;
469 pWmvDec->hMFCWmvHandle.pInbufOps = pInbufOps;
470 pWmvDec->hMFCWmvHandle.pOutbufOps = pOutbufOps;
472 /* function pointer mapping */
473 pDecOps->nSize = sizeof(ExynosVideoDecOps);
474 pInbufOps->nSize = sizeof(ExynosVideoDecBufferOps);
475 pOutbufOps->nSize = sizeof(ExynosVideoDecBufferOps);
477 Exynos_Video_Register_Decoder(pDecOps, pInbufOps, pOutbufOps);
479 /* check mandatory functions for decoder ops */
480 if ((pDecOps->Init == NULL) || (pDecOps->Finalize == NULL) ||
481 (pDecOps->Get_ActualBufferCount == NULL) || (pDecOps->Set_FrameTag == NULL) ||
482 (pDecOps->Get_FrameTag == NULL)) {
483 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Mandatory functions must be supplied");
484 ret = OMX_ErrorInsufficientResources;
488 /* check mandatory functions for buffer ops */
489 if ((pInbufOps->Setup == NULL) || (pOutbufOps->Setup == NULL) ||
490 (pInbufOps->Run == NULL) || (pOutbufOps->Run == NULL) ||
491 (pInbufOps->Stop == NULL) || (pOutbufOps->Stop == NULL) ||
492 (pInbufOps->Enqueue == NULL) || (pOutbufOps->Enqueue == NULL) ||
493 (pInbufOps->Dequeue == NULL) || (pOutbufOps->Dequeue == NULL)) {
494 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Mandatory functions must be supplied");
495 ret = OMX_ErrorInsufficientResources;
500 if (pWmvDec->hMFCWmvHandle.bShareableBuf == OMX_TRUE) {
502 v4l2MemoryType = V4L2_MEMORY_DMABUF;
503 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "using Dec V4L2_MEMORY_DMABUF");
505 v4l2MemoryType = V4L2_MEMORY_USERPTR;
506 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "using Dec V4L2_MEMORY_USEPTR");
509 v4l2MemoryType = V4L2_MEMORY_DMABUF;
510 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "using Dec V4L2_MEMORY_DMABUF");
513 /* alloc context, open, querycap */
514 pWmvDec->hMFCWmvHandle.hMFCHandle = pWmvDec->hMFCWmvHandle.pDecOps->Init(v4l2MemoryType);
515 if (pWmvDec->hMFCWmvHandle.hMFCHandle == NULL) {
516 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to allocate context buffer");
517 ret = OMX_ErrorInsufficientResources;
524 if (ret != OMX_ErrorNone) {
525 if (pDecOps != NULL) {
526 Exynos_OSAL_Free(pDecOps);
527 pWmvDec->hMFCWmvHandle.pDecOps = NULL;
529 if (pInbufOps != NULL) {
530 Exynos_OSAL_Free(pInbufOps);
531 pWmvDec->hMFCWmvHandle.pInbufOps = NULL;
533 if (pOutbufOps != NULL) {
534 Exynos_OSAL_Free(pOutbufOps);
535 pWmvDec->hMFCWmvHandle.pOutbufOps = NULL;
544 OMX_ERRORTYPE WmvCodecClose(EXYNOS_WMVDEC_HANDLE *pWmvDec)
546 OMX_ERRORTYPE ret = OMX_ErrorNone;
547 void *hMFCHandle = NULL;
548 ExynosVideoDecOps *pDecOps = NULL;
549 ExynosVideoDecBufferOps *pInbufOps = NULL;
550 ExynosVideoDecBufferOps *pOutbufOps = NULL;
554 if (pWmvDec == NULL) {
555 ret = OMX_ErrorBadParameter;
559 hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
560 pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
561 pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
562 pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
564 if (hMFCHandle != NULL) {
565 pDecOps->Finalize(hMFCHandle);
566 pWmvDec->hMFCWmvHandle.hMFCHandle = NULL;
568 if (pOutbufOps != NULL) {
569 Exynos_OSAL_Free(pOutbufOps);
570 pWmvDec->hMFCWmvHandle.pOutbufOps = NULL;
572 if (pInbufOps != NULL) {
573 Exynos_OSAL_Free(pInbufOps);
574 pWmvDec->hMFCWmvHandle.pInbufOps = NULL;
576 if (pDecOps != NULL) {
577 Exynos_OSAL_Free(pDecOps);
578 pWmvDec->hMFCWmvHandle.pDecOps = NULL;
589 OMX_ERRORTYPE WmvCodecStart(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
591 OMX_ERRORTYPE ret = OMX_ErrorNone;
592 void *hMFCHandle = NULL;
593 ExynosVideoDecOps *pDecOps = NULL;
594 ExynosVideoDecBufferOps *pInbufOps = NULL;
595 ExynosVideoDecBufferOps *pOutbufOps = NULL;
596 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
597 EXYNOS_WMVDEC_HANDLE *pWmvDec = NULL;
601 if (pOMXComponent == NULL) {
602 ret = OMX_ErrorBadParameter;
606 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
607 if (pVideoDec == NULL) {
608 ret = OMX_ErrorBadParameter;
612 pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
613 if (pWmvDec == NULL) {
614 ret = OMX_ErrorBadParameter;
618 hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
619 pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
620 pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
621 pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
623 if (nPortIndex == INPUT_PORT_INDEX)
624 pInbufOps->Run(hMFCHandle);
625 else if (nPortIndex == OUTPUT_PORT_INDEX)
626 pOutbufOps->Run(hMFCHandle);
636 OMX_ERRORTYPE WmvCodecStop(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
638 OMX_ERRORTYPE ret = OMX_ErrorNone;
639 void *hMFCHandle = NULL;
640 ExynosVideoDecOps *pDecOps = NULL;
641 ExynosVideoDecBufferOps *pInbufOps = NULL;
642 ExynosVideoDecBufferOps *pOutbufOps = NULL;
643 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
644 EXYNOS_WMVDEC_HANDLE *pWmvDec = NULL;
648 if (pOMXComponent == NULL) {
649 ret = OMX_ErrorBadParameter;
653 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
654 if (pVideoDec == NULL) {
655 ret = OMX_ErrorBadParameter;
658 pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
659 if (pWmvDec == NULL) {
660 ret = OMX_ErrorBadParameter;
664 hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
665 pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
666 pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
667 pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
669 if ((nPortIndex == INPUT_PORT_INDEX) && (pInbufOps != NULL))
670 pInbufOps->Stop(hMFCHandle);
671 else if ((nPortIndex == OUTPUT_PORT_INDEX) && (pOutbufOps != NULL))
672 pOutbufOps->Stop(hMFCHandle);
683 OMX_ERRORTYPE WmvCodecSrcInit(OMX_COMPONENTTYPE *pOMXComponent)
685 OMX_ERRORTYPE ret = OMX_ErrorNone;
686 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
687 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
688 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
689 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
690 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
691 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
693 ExynosVideoDecOps *pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
694 ExynosVideoDecBufferOps *pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
695 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
696 ExynosVideoGeometry bufferConf;
697 OMX_U32 inputBufferNumber = 0;
702 if (pVideoDec->bThumbnailMode == OMX_TRUE)
703 pDecOps->Set_DisplayDelay(hMFCHandle, 0);
705 /* input buffer info */
706 Exynos_OSAL_Memset(&bufferConf, 0, sizeof(bufferConf));
707 if (pWmvDec->hMFCWmvHandle.wmvFormat == WMV_FORMAT_WMV3) {
708 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "VIDEO_CODING_VC1_RCV");
709 bufferConf.eCompressionFormat = VIDEO_CODING_VC1_RCV;
710 } else if (pWmvDec->hMFCWmvHandle.wmvFormat == WMV_FORMAT_VC1) {
711 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "VIDEO_CODING_VC1");
712 bufferConf.eCompressionFormat = VIDEO_CODING_VC1;
714 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Unsupported WMV Codec Format Type");
715 ret = OMX_ErrorUndefined;
719 if (pExynosInputPort->bufferProcessType & BUFFER_SHARE
720 ||pWmvDec->hMFCWmvHandle.bShareableBuf == OMX_TRUE)
721 pInbufOps->Set_Shareable(hMFCHandle);
723 if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
724 bufferConf.nSizeImage = pExynosInputPort->portDefinition.format.video.nFrameWidth
725 * pExynosInputPort->portDefinition.format.video.nFrameHeight * 3 / 2;
726 inputBufferNumber = MAX_VIDEO_INPUTBUFFER_NUM;
727 } else if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
728 bufferConf.nSizeImage = DEFAULT_MFC_INPUT_BUFFER_SIZE;
729 inputBufferNumber = MFC_INPUT_BUFFER_NUM_MAX;
732 /* should be done before prepare input buffer */
733 if (pInbufOps->Enable_Cacheable(hMFCHandle) != VIDEO_ERROR_NONE) {
734 ret = OMX_ErrorInsufficientResources;
738 /* set input buffer geometry */
739 if (pInbufOps->Set_Geometry(hMFCHandle, &bufferConf) != VIDEO_ERROR_NONE) {
740 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to set geometry for input buffer");
741 ret = OMX_ErrorInsufficientResources;
745 /* setup input buffer */
746 if (pInbufOps->Setup(hMFCHandle, inputBufferNumber) != VIDEO_ERROR_NONE) {
747 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to setup input buffer");
748 ret = OMX_ErrorInsufficientResources;
752 if ((pExynosInputPort->bufferProcessType & BUFFER_COPY) &&
753 pWmvDec->hMFCWmvHandle.bShareableBuf == OMX_TRUE) {
754 /* Register input buffer */
755 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
756 ExynosVideoPlane plane;
757 plane.addr = pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[0];
758 plane.allocSize = pVideoDec->pMFCDecInputBuffer[i]->bufferSize[0];
759 plane.fd = pVideoDec->pMFCDecInputBuffer[i]->fd[0];
760 if (pInbufOps->Register(hMFCHandle, &plane, MFC_INPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
761 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register input buffer");
762 ret = OMX_ErrorInsufficientResources;
766 } else if ((pExynosInputPort->bufferProcessType & BUFFER_COPY) &&
767 pWmvDec->hMFCWmvHandle.bShareableBuf == OMX_FALSE) {
768 ExynosVideoBuffer *pBuffer = NULL;
770 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
771 pVideoDec->pMFCDecInputBuffer[i] = Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
772 Exynos_OSAL_Memset(pVideoDec->pMFCDecInputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
773 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "@pVideoDec->pMFCDecInputBuffer[%d]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]);
774 /* get input buffer info */
775 if (pInbufOps->Get_Buffer) {
776 if (pInbufOps->Get_Buffer(pWmvDec->hMFCWmvHandle.hMFCHandle, i, &pBuffer) != VIDEO_ERROR_NONE) {
777 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get input buffer info");
778 ret = OMX_ErrorInsufficientResources;
783 for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
784 /* Use ION Allocator */
785 pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] = (void *)pBuffer->planes[plane].addr;
786 pVideoDec->pMFCDecInputBuffer[i]->fd[plane] = pBuffer->planes[plane].fd;
787 pVideoDec->pMFCDecInputBuffer[i]->bufferSize[plane] = pBuffer->planes[plane].allocSize;
788 pVideoDec->pMFCDecInputBuffer[i]->dataSize = 0;
789 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "@pVideoDec->pMFCDecInputBuffer[%d]->pVirAddr[%d]: 0x%x", i, plane, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
792 Exynos_CodecBufferEnQueue(pExynosComponent, INPUT_PORT_INDEX, pVideoDec->pMFCDecInputBuffer[i]);
794 } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
795 /* Register input buffer */
796 for (i = 0; i < pExynosInputPort->portDefinition.nBufferCountActual; i++) {
797 ExynosVideoPlane plane;
798 plane.addr = pExynosInputPort->extendBufferHeader[i].OMXBufferHeader->pBuffer;
799 plane.allocSize = pExynosInputPort->extendBufferHeader[i].OMXBufferHeader->nAllocLen;
800 plane.fd = pExynosInputPort->extendBufferHeader[i].buf_fd[0];
801 if (pInbufOps->Register(hMFCHandle, &plane, MFC_INPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
802 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register input buffer");
803 ret = OMX_ErrorInsufficientResources;
815 OMX_ERRORTYPE WmvCodecOutputBufferProcessRun(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
817 OMX_ERRORTYPE ret = OMX_ErrorNone;
818 void *hMFCHandle = NULL;
819 ExynosVideoDecOps *pDecOps = NULL;
820 ExynosVideoDecBufferOps *pInbufOps = NULL;
821 ExynosVideoDecBufferOps *pOutbufOps = NULL;
822 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
823 EXYNOS_WMVDEC_HANDLE *pWmvDec = NULL;
827 if (pOMXComponent == NULL) {
828 ret = OMX_ErrorBadParameter;
832 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
833 if (pVideoDec == NULL) {
834 ret = OMX_ErrorBadParameter;
837 pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
838 if (pWmvDec == NULL) {
839 ret = OMX_ErrorBadParameter;
843 hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
844 pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
845 pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
846 pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
848 if (nPortIndex == INPUT_PORT_INDEX) {
849 if (pWmvDec->bSourceStart == OMX_FALSE) {
850 Exynos_OSAL_SignalSet(pWmvDec->hSourceStartEvent);
851 Exynos_OSAL_SleepMillisec(0);
855 if (nPortIndex == OUTPUT_PORT_INDEX) {
856 if (pWmvDec->bDestinationStart == OMX_FALSE) {
857 Exynos_OSAL_SignalSet(pWmvDec->hDestinationStartEvent);
858 Exynos_OSAL_SleepMillisec(0);
870 OMX_ERRORTYPE WmvCodecEnQueueAllBuffer(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
872 OMX_ERRORTYPE ret = OMX_ErrorNone;
873 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
874 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
875 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
876 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
877 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
878 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
881 ExynosVideoDecOps *pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
882 ExynosVideoDecBufferOps *pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
883 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
887 if ((nPortIndex != INPUT_PORT_INDEX) && (nPortIndex != OUTPUT_PORT_INDEX)) {
888 ret = OMX_ErrorBadPortIndex;
892 if ((nPortIndex == INPUT_PORT_INDEX) &&
893 (pWmvDec->bSourceStart == OMX_TRUE)) {
894 Exynos_CodecBufferReset(pExynosComponent, INPUT_PORT_INDEX);
896 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
897 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]);
898 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]->pVirAddr[0]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[0]);
900 Exynos_CodecBufferEnQueue(pExynosComponent, INPUT_PORT_INDEX, pVideoDec->pMFCDecInputBuffer[i]);
903 pInbufOps->Clear_Queue(hMFCHandle);
904 } else if ((nPortIndex == OUTPUT_PORT_INDEX) &&
905 (pWmvDec->bDestinationStart == OMX_TRUE)) {
906 OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
907 ExynosVideoBuffer *pBuffer = NULL;
909 Exynos_CodecBufferReset(pExynosComponent, OUTPUT_PORT_INDEX);
911 nOutbufs = pDecOps->Get_ActualBufferCount(hMFCHandle);
912 nOutbufs += EXTRA_DPB_NUM;
913 for (i = 0; i < nOutbufs; i++) {
914 pOutbufOps->Get_Buffer(hMFCHandle, i, &pBuffer);
915 Exynos_CodecBufferEnQueue(pExynosComponent, OUTPUT_PORT_INDEX, (OMX_PTR)pBuffer);
917 pOutbufOps->Clear_Queue(hMFCHandle);
926 OMX_ERRORTYPE WmvCodecDstFreeCodecBuffers(
927 OMX_COMPONENTTYPE *pOMXComponent)
929 OMX_ERRORTYPE ret = OMX_ErrorNone;
930 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
931 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
932 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
938 for (i = 0; i < MFC_OUTPUT_BUFFER_NUM_MAX; i++) {
939 if (pVideoDec->pMFCDecOutputBuffer[i] != NULL) {
940 for (j = 0; j < MFC_OUTPUT_BUFFER_PLANE; j++) {
941 if (pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j] != NULL &&
942 pWmvDec->hMFCWmvHandle.bShareableBuf == OMX_TRUE)
943 Exynos_OSAL_SharedMemory_Free(pVideoDec->hSharedMemory, pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j]);
946 Exynos_OSAL_Free(pVideoDec->pMFCDecOutputBuffer[i]);
950 Exynos_OSAL_Memset(pVideoDec->pMFCDecOutputBuffer, 0, sizeof(pVideoDec->pMFCDecOutputBuffer));
954 return OMX_ErrorNone;
957 OMX_ERRORTYPE WmvCodecDstAllocCodecBuffers(
958 OMX_COMPONENTTYPE *pOMXComponent,
961 OMX_ERRORTYPE ret = OMX_ErrorNone;
962 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
963 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
964 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
966 MEMORY_TYPE eMemoryType = NORMAL_MEMORY;
967 OMX_U32 nAllocLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
972 nAllocLen[0] = calc_yplane(pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth,
973 pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight);
974 nAllocLen[1] = calc_uvplane(pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth,
975 pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight >> 1);
977 for (i = 0; i < nOutbufs; i++) {
978 pVideoDec->pMFCDecOutputBuffer[i] = (CODEC_DEC_BUFFER *)Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
979 if (pVideoDec->pMFCDecOutputBuffer[i] == NULL) {
980 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Alloc codec buffer");
981 ret = OMX_ErrorInsufficientResources;
984 Exynos_OSAL_Memset(pVideoDec->pMFCDecOutputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
986 for (j = 0; j < MFC_OUTPUT_BUFFER_PLANE; j++) {
987 pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j] =
988 (void *)Exynos_OSAL_SharedMemory_Alloc(pVideoDec->hSharedMemory, nAllocLen[j], eMemoryType);
989 if (pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j] == NULL) {
990 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Alloc output buffer");
991 ret = OMX_ErrorInsufficientResources;
995 pVideoDec->pMFCDecOutputBuffer[i]->fd[j] =
996 Exynos_OSAL_SharedMemory_VirtToION(pVideoDec->hSharedMemory,
997 pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j]);
998 pVideoDec->pMFCDecOutputBuffer[i]->bufferSize[j] = nAllocLen[j];
1002 return OMX_ErrorNone;
1005 WmvCodecDstFreeCodecBuffers(pOMXComponent);
1012 OMX_ERRORTYPE WmvCodecDstRegistCodecBuffers(
1013 OMX_COMPONENTTYPE *pOMXComponent,
1016 OMX_ERRORTYPE ret = OMX_ErrorNone;
1017 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1018 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1019 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
1020 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
1021 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
1023 ExynosVideoPlane planes[MFC_OUTPUT_BUFFER_PLANE];
1024 OMX_U32 nDataLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
1029 /* Register output buffer */
1030 for (i = 0; i < nOutbufs; i++) {
1031 for (j = 0; j < MFC_OUTPUT_BUFFER_PLANE; j++) {
1032 planes[j].addr = pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j];
1033 planes[j].fd = pVideoDec->pMFCDecOutputBuffer[i]->fd[j];
1034 planes[j].allocSize = pVideoDec->pMFCDecOutputBuffer[i]->bufferSize[j];
1037 if (pOutbufOps->Register(hMFCHandle, planes, MFC_OUTPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
1038 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register output buffer");
1039 ret = OMX_ErrorInsufficientResources;
1043 pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr,
1044 (unsigned int *)nDataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
1047 ret = OMX_ErrorNone;
1055 OMX_ERRORTYPE WmvCodecResetupAllElement(
1056 OMX_COMPONENTTYPE *pOMXComponent,
1059 OMX_ERRORTYPE ret = OMX_ErrorNone;
1060 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1061 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1062 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
1063 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
1064 EXYNOS_OMX_BASEPORT *pOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1065 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
1071 if ((nPortIndex == INPUT_PORT_INDEX) &&
1072 (pWmvDec->bSourceStart == OMX_TRUE)) {
1073 ret = OMX_ErrorNotImplemented;
1075 } else if ((nPortIndex == OUTPUT_PORT_INDEX) &&
1076 (pWmvDec->bDestinationStart == OMX_TRUE)) {
1077 if (pOutputPort->bufferProcessType & BUFFER_COPY) {
1079 /**********************************/
1080 /* Codec Buffer Free & Unregister */
1081 /**********************************/
1082 WmvCodecDstFreeCodecBuffers(pOMXComponent);
1083 Exynos_CodecBufferReset(pExynosComponent, OUTPUT_PORT_INDEX);
1085 if (pWmvDec->hMFCWmvHandle.bShareableBuf == OMX_TRUE)
1086 pOutbufOps->Clear_RegisteredBuffer(hMFCHandle);
1088 pOutbufOps->Cleanup(hMFCHandle);
1089 /******************************************************/
1090 /* V4L2 Destnation Setup for DPB Buffer Number Change */
1091 /******************************************************/
1092 WmvCodecDstSetup(pOMXComponent);
1094 pVideoDec->bDRCProcessing = OMX_FALSE;
1095 } else if (pOutputPort->bufferProcessType & BUFFER_SHARE) {
1097 /**********************************/
1098 /* Codec Buffer Unregister */
1099 /**********************************/
1100 pOutbufOps->Clear_RegisteredBuffer(hMFCHandle);
1101 pOutbufOps->Cleanup(hMFCHandle);
1104 ret = OMX_ErrorBadParameter;
1114 OMX_ERRORTYPE WmvCodecSrcSetup(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
1116 OMX_ERRORTYPE ret = OMX_ErrorNone;
1117 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1118 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1119 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1120 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
1121 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1122 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1123 OMX_U32 oneFrameSize = pSrcInputData->dataLen;
1124 OMX_BOOL bMetaData = OMX_FALSE;
1126 ExynosVideoDecOps *pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
1127 ExynosVideoDecBufferOps *pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
1128 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
1129 ExynosVideoGeometry bufferConf;
1130 OMX_U32 inputBufferNumber = 0;
1135 if ((oneFrameSize <= 0) && (pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
1136 OMX_BUFFERHEADERTYPE *OMXBuffer = NULL;
1137 OMXBuffer = Exynos_OutputBufferGetQueue_Direct(pExynosComponent);
1138 if (OMXBuffer == NULL) {
1139 ret = OMX_ErrorUndefined;
1143 OMXBuffer->nTimeStamp = pSrcInputData->timeStamp;
1144 OMXBuffer->nFlags = pSrcInputData->nFlags;
1145 Exynos_OMX_OutputBufferReturn(pOMXComponent, OMXBuffer);
1147 ret = OMX_ErrorNone;
1151 if (!((pExynosInputPort->bufferProcessType & BUFFER_COPY) &&
1152 pWmvDec->hMFCWmvHandle.bShareableBuf == OMX_FALSE)) {
1153 if (pSrcInputData->nFlags & OMX_BUFFERFLAG_CODECCONFIG) {
1154 BitmapInfoHhr *pBitmapInfoHeader;
1155 pBitmapInfoHeader = (BitmapInfoHhr *)pSrcInputData->buffer.singlePlaneBuffer.dataBuffer;
1156 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "OMX_BUFFERFLAG_CODECCONFIG");
1157 if (pBitmapInfoHeader->BiCompression == wmv3) {
1158 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "WMV_FORMAT_WMV3");
1159 pWmvDec->hMFCWmvHandle.wmvFormat = WMV_FORMAT_WMV3;
1160 } else if ((pBitmapInfoHeader->BiCompression == wvc1) || (pBitmapInfoHeader->BiCompression == wmva)) {
1161 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "WMV_FORMAT_VC1");
1162 pWmvDec->hMFCWmvHandle.wmvFormat = WMV_FORMAT_VC1;
1166 ret = WmvCodecSrcInit(pOMXComponent);
1167 if (ret != OMX_ErrorNone)
1171 /* set output geometry */
1172 Exynos_OSAL_Memset(&bufferConf, 0, sizeof(bufferConf));
1173 pWmvDec->hMFCWmvHandle.MFCOutputColorType = bufferConf.eColorFormat = VIDEO_COLORFORMAT_NV12_TILED;
1174 if (pOutbufOps->Set_Geometry(hMFCHandle, &bufferConf) != VIDEO_ERROR_NONE) {
1175 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to set geometry for output buffer");
1176 ret = OMX_ErrorInsufficientResources;
1180 bMetaData = Make_Stream_MetaData(pSrcInputData->buffer.singlePlaneBuffer.dataBuffer, &oneFrameSize, pWmvDec->hMFCWmvHandle.wmvFormat
1181 #ifdef TIZEN_FEATURE_E3250
1182 , pExynosComponent->pExynosPort[INPUT_PORT_INDEX].portDefinition.format.video.nFrameWidth
1183 , pExynosComponent->pExynosPort[INPUT_PORT_INDEX].portDefinition.format.video.nFrameHeight
1186 if (bMetaData == OMX_FALSE) {
1187 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Fail to Make Stream MetaData");
1188 ret = OMX_ErrorInsufficientResources;
1192 /* input buffer enqueue for header parsing */
1193 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "oneFrameSize: %d", oneFrameSize);
1194 if (pInbufOps->Enqueue(hMFCHandle, (unsigned char **)&pSrcInputData->buffer.singlePlaneBuffer.dataBuffer,
1195 (unsigned int *)&oneFrameSize, MFC_INPUT_BUFFER_PLANE, pSrcInputData->bufferHeader) != VIDEO_ERROR_NONE) {
1196 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to enqueue input buffer for header parsing");
1197 // ret = OMX_ErrorInsufficientResources;
1198 ret = (OMX_ERRORTYPE)OMX_ErrorCodecInit;
1202 /* start header parsing */
1203 if (pInbufOps->Run(hMFCHandle) != VIDEO_ERROR_NONE) {
1204 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to run input buffer for header parsing");
1205 ret = OMX_ErrorCodecInit;
1209 ret = WmvCodecCheckResolutionChange(pOMXComponent);
1210 if (ret != OMX_ErrorNone) {
1211 ret = OMX_ErrorCodecInit;
1215 Exynos_OSAL_SleepMillisec(0);
1216 ret = OMX_ErrorInputDataDecodeYet;
1218 #ifdef USE_IMMEDIATE_DISPLAY
1219 /* Set Immediately display for I Frame*/
1220 pDecOps->Set_ImmediateDisplay(hMFCHandle);
1223 WmvCodecStop(pOMXComponent, INPUT_PORT_INDEX);
1229 OMX_ERRORTYPE WmvCodecDstSetup(OMX_COMPONENTTYPE *pOMXComponent)
1231 OMX_ERRORTYPE ret = OMX_ErrorNone;
1232 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1233 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1234 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1235 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
1236 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1237 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1239 ExynosVideoDecOps *pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
1240 ExynosVideoDecBufferOps *pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
1241 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
1248 nOutbufs = pWmvDec->hMFCWmvHandle.maxDPBNum;
1250 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1251 /* should be done before prepare output buffer */
1252 if (pOutbufOps->Enable_Cacheable(hMFCHandle) != VIDEO_ERROR_NONE) {
1253 ret = OMX_ErrorInsufficientResources;
1258 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE
1259 ||pWmvDec->hMFCWmvHandle.bShareableBuf == OMX_TRUE)
1260 pOutbufOps->Set_Shareable(hMFCHandle);
1262 if (pOutbufOps->Setup(hMFCHandle, nOutbufs) != VIDEO_ERROR_NONE) {
1263 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to setup output buffer");
1264 ret = OMX_ErrorInsufficientResources;
1268 ExynosVideoPlane planes[MFC_OUTPUT_BUFFER_PLANE];
1269 OMX_U32 nAllocLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
1270 OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
1273 nAllocLen[0] = calc_yplane(pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth,
1274 pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight);
1275 nAllocLen[1] = calc_uvplane(pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth,
1276 pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight >> 1);
1278 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY &&
1279 pWmvDec->hMFCWmvHandle.bShareableBuf == OMX_TRUE) {
1280 WmvCodecDstAllocCodecBuffers(pOMXComponent, nOutbufs);
1281 WmvCodecDstRegistCodecBuffers(pOMXComponent, nOutbufs);
1282 } else if (pExynosOutputPort->bufferProcessType & BUFFER_COPY &&
1283 pWmvDec->hMFCWmvHandle.bShareableBuf == OMX_FALSE) {
1284 /* Register output buffer */
1285 for (i = 0; i < nOutbufs; i++) {
1287 OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
1288 ExynosVideoBuffer *pBuffer = NULL;
1289 pVideoDec->pMFCDecOutputBuffer[i] = (CODEC_DEC_BUFFER *)Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
1290 Exynos_OSAL_Memset(pVideoDec->pMFCDecOutputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
1292 if (pOutbufOps->Get_Buffer) {
1293 if (pOutbufOps->Get_Buffer(pWmvDec->hMFCWmvHandle.hMFCHandle, i, &pBuffer) != VIDEO_ERROR_NONE) {
1294 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get Output buffer info");
1295 ret = OMX_ErrorInsufficientResources;
1300 for (plane = 0; plane < MFC_OUTPUT_BUFFER_PLANE; plane++) {
1301 pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[plane] = (void *)pBuffer->planes[plane].addr;
1302 pVideoDec->pMFCDecOutputBuffer[i]->fd[plane] = pBuffer->planes[plane].fd;
1303 pVideoDec->pMFCDecOutputBuffer[i]->bufferSize[plane] = pBuffer->planes[plane].allocSize;
1306 pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr,
1307 (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
1310 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1312 if (pExynosOutputPort->bIsPBEnabled == OMX_TRUE) {
1313 for (i = 0; i < pExynosOutputPort->assignedBufferNum; i++) {
1314 for (plane = 0; plane < MFC_OUTPUT_BUFFER_PLANE; plane++) {
1315 planes[plane].fd = pExynosOutputPort->extendBufferHeader[i].buf_fd[plane];
1316 planes[plane].addr = pExynosOutputPort->extendBufferHeader[i].pYUVBuf[plane];
1317 planes[plane].allocSize = nAllocLen[plane];
1320 if (pOutbufOps->Register(hMFCHandle, planes, MFC_OUTPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
1321 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register output buffer");
1322 ret = OMX_ErrorInsufficientResources;
1325 pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pExynosOutputPort->extendBufferHeader[i].pYUVBuf,
1326 (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
1329 ret = OMX_ErrorNotImplemented;
1333 ret = OMX_ErrorNotImplemented;
1338 if (pOutbufOps->Run(hMFCHandle) != VIDEO_ERROR_NONE) {
1339 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to run output buffer");
1340 ret = OMX_ErrorInsufficientResources;
1344 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1345 WmvCodecStop (pOMXComponent, OUTPUT_PORT_INDEX);
1347 pWmvDec->hMFCWmvHandle.bConfiguredMFCDst = OMX_TRUE;
1349 ret = OMX_ErrorNone;
1357 OMX_ERRORTYPE WmvCodecCheckResolutionChange(OMX_COMPONENTTYPE *pOMXComponent)
1359 OMX_ERRORTYPE ret = OMX_ErrorNone;
1360 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1361 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1362 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1363 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
1364 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1365 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1367 ExynosVideoDecOps *pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
1368 ExynosVideoDecBufferOps *pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
1369 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
1370 ExynosVideoGeometry bufferConf;
1375 /* get geometry for output */
1376 Exynos_OSAL_Memset(&pWmvDec->hMFCWmvHandle.codecOutbufConf, 0, sizeof(ExynosVideoGeometry));
1377 if (pOutbufOps->Get_Geometry(hMFCHandle, &pWmvDec->hMFCWmvHandle.codecOutbufConf) != VIDEO_ERROR_NONE) {
1378 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get geometry for parsed header info");
1379 ret = OMX_ErrorInsufficientResources;
1384 pWmvDec->hMFCWmvHandle.maxDPBNum = pDecOps->Get_ActualBufferCount(hMFCHandle);
1385 if (pVideoDec->bThumbnailMode == OMX_FALSE)
1386 pWmvDec->hMFCWmvHandle.maxDPBNum += EXTRA_DPB_NUM;
1387 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "WmvCodecCheckResolutionChange WmvCodecSetup nOutbufs: %d", pWmvDec->hMFCWmvHandle.maxDPBNum);
1389 pWmvDec->hMFCWmvHandle.bConfiguredMFCSrc = OMX_TRUE;
1391 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1392 if ((pVideoDec->bDRCProcessing) ||
1393 (pExynosInputPort->portDefinition.format.video.nFrameWidth != pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth) ||
1394 (pExynosInputPort->portDefinition.format.video.nFrameHeight != pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight)) {
1395 pExynosInputPort->portDefinition.format.video.nFrameWidth = pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth;
1396 pExynosInputPort->portDefinition.format.video.nFrameHeight = pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight;
1397 pExynosInputPort->portDefinition.format.video.nStride = ((pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth + 15) & (~15));
1398 pExynosInputPort->portDefinition.format.video.nSliceHeight = ((pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight + 15) & (~15));
1400 if (pVideoDec->bDRCProcessing == OMX_TRUE) {
1401 pVideoDec->nDRCSavedBufferCount = pExynosOutputPort->portDefinition.nBufferCountActual;
1403 Exynos_UpdateFrameSize(pOMXComponent);
1404 pExynosOutputPort->exceptionFlag = NEED_PORT_DISABLE;
1406 /** Send Port Settings changed call back **/
1407 (*(pExynosComponent->pCallbacks->EventHandler))
1409 pExynosComponent->callbackData,
1410 OMX_EventPortSettingsChanged, /* The command was completed */
1411 OMX_DirOutput, /* This is the port index */
1415 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1416 if ((pExynosInputPort->portDefinition.format.video.nFrameWidth != pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth) ||
1417 (pExynosInputPort->portDefinition.format.video.nFrameHeight != pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight) ||
1418 (pExynosOutputPort->portDefinition.nBufferCountActual != pWmvDec->hMFCWmvHandle.maxDPBNum)) {
1419 pExynosInputPort->portDefinition.format.video.nFrameWidth = pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth;
1420 pExynosInputPort->portDefinition.format.video.nFrameHeight = pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight;
1421 pExynosInputPort->portDefinition.format.video.nStride = ((pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth + 15) & (~15));
1422 pExynosInputPort->portDefinition.format.video.nSliceHeight = ((pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight + 15) & (~15));
1424 if (pVideoDec->bDRCProcessing == OMX_TRUE) {
1425 pVideoDec->nDRCSavedBufferCount = pExynosOutputPort->portDefinition.nBufferCountActual;
1427 #ifdef TIZEN_FEATURE_E3250
1428 pExynosOutputPort->portDefinition.nBufferCountActual = pWmvDec->hMFCWmvHandle.maxDPBNum;
1429 pExynosOutputPort->portDefinition.nBufferCountMin = pWmvDec->hMFCWmvHandle.maxDPBNum;
1431 pExynosOutputPort->portDefinition.nBufferCountActual = pWmvDec->hMFCWmvHandle.maxDPBNum - 4;
1432 pExynosOutputPort->portDefinition.nBufferCountMin = pWmvDec->hMFCWmvHandle.maxDPBNum - 4;
1434 Exynos_UpdateFrameSize(pOMXComponent);
1435 pExynosOutputPort->exceptionFlag = NEED_PORT_DISABLE;
1437 /** Send Port Settings changed call back **/
1438 (*(pExynosComponent->pCallbacks->EventHandler))
1440 pExynosComponent->callbackData,
1441 OMX_EventPortSettingsChanged, /* The command was completed */
1442 OMX_DirOutput, /* This is the port index */
1448 ret = OMX_ErrorNone;
1456 OMX_ERRORTYPE Exynos_WmvDec_GetParameter(
1457 OMX_IN OMX_HANDLETYPE hComponent,
1458 OMX_IN OMX_INDEXTYPE nParamIndex,
1459 OMX_INOUT OMX_PTR pComponentParameterStructure)
1461 OMX_ERRORTYPE ret = OMX_ErrorNone;
1462 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1463 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1467 if (hComponent == NULL || pComponentParameterStructure == NULL) {
1468 ret = OMX_ErrorBadParameter;
1471 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1472 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1473 if (ret != OMX_ErrorNone) {
1476 if (pOMXComponent->pComponentPrivate == NULL) {
1477 ret = OMX_ErrorBadParameter;
1481 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1482 if (pExynosComponent->currentState == OMX_StateInvalid ) {
1483 ret = OMX_ErrorInvalidState;
1487 switch (nParamIndex) {
1488 case OMX_IndexParamVideoWmv:
1490 OMX_VIDEO_PARAM_WMVTYPE *pDstWmvParam = (OMX_VIDEO_PARAM_WMVTYPE *)pComponentParameterStructure;
1491 OMX_VIDEO_PARAM_WMVTYPE *pSrcWmvParam = NULL;
1492 EXYNOS_WMVDEC_HANDLE *pWmvDec = NULL;
1493 ret = Exynos_OMX_Check_SizeVersion(pDstWmvParam, sizeof(OMX_VIDEO_PARAM_WMVTYPE));
1494 if (ret != OMX_ErrorNone) {
1498 if (pDstWmvParam->nPortIndex > OUTPUT_PORT_INDEX) {
1499 ret = OMX_ErrorBadPortIndex;
1502 pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1503 pSrcWmvParam = &pWmvDec->WmvComponent[pDstWmvParam->nPortIndex];
1505 Exynos_OSAL_Memcpy(pDstWmvParam, pSrcWmvParam, sizeof(OMX_VIDEO_PARAM_WMVTYPE));
1509 case OMX_IndexParamStandardComponentRole:
1511 OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE *)pComponentParameterStructure;
1512 ret = Exynos_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1513 if (ret != OMX_ErrorNone) {
1517 Exynos_OSAL_Strcpy((char *)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_WMV_DEC_ROLE);
1520 case OMX_IndexParamVideoErrorCorrection:
1522 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
1523 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = NULL;
1524 EXYNOS_WMVDEC_HANDLE *pWmvDec = NULL;
1526 ret = Exynos_OMX_Check_SizeVersion(pDstErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
1527 if (ret != OMX_ErrorNone) {
1531 if (pDstErrorCorrectionType->nPortIndex != INPUT_PORT_INDEX) {
1532 ret = OMX_ErrorBadPortIndex;
1536 pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1537 pSrcErrorCorrectionType = &pWmvDec->errorCorrectionType[INPUT_PORT_INDEX];
1539 pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
1540 pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
1541 pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
1542 pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
1543 pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
1547 ret = Exynos_OMX_VideoDecodeGetParameter(hComponent, nParamIndex, pComponentParameterStructure);
1556 OMX_ERRORTYPE Exynos_WmvDec_SetParameter(
1557 OMX_IN OMX_HANDLETYPE hComponent,
1558 OMX_IN OMX_INDEXTYPE nIndex,
1559 OMX_IN OMX_PTR pComponentParameterStructure)
1561 OMX_ERRORTYPE ret = OMX_ErrorNone;
1562 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1563 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1567 if (hComponent == NULL || pComponentParameterStructure == NULL) {
1568 ret = OMX_ErrorBadParameter;
1571 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1572 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1573 if (ret != OMX_ErrorNone) {
1576 if (pOMXComponent->pComponentPrivate == NULL) {
1577 ret = OMX_ErrorBadParameter;
1581 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1582 if (pExynosComponent->currentState == OMX_StateInvalid ) {
1583 ret = OMX_ErrorInvalidState;
1588 case OMX_IndexParamVideoWmv:
1590 OMX_VIDEO_PARAM_WMVTYPE *pDstWmvParam = NULL;
1591 OMX_VIDEO_PARAM_WMVTYPE *pSrcWmvParam = (OMX_VIDEO_PARAM_WMVTYPE *)pComponentParameterStructure;
1592 EXYNOS_WMVDEC_HANDLE *pWmvDec = NULL;
1593 ret = Exynos_OMX_Check_SizeVersion(pSrcWmvParam, sizeof(OMX_VIDEO_PARAM_WMVTYPE));
1594 if (ret != OMX_ErrorNone) {
1598 if (pSrcWmvParam->nPortIndex > OUTPUT_PORT_INDEX) {
1599 ret = OMX_ErrorBadPortIndex;
1603 pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1604 pDstWmvParam = &pWmvDec->WmvComponent[pSrcWmvParam->nPortIndex];
1606 Exynos_OSAL_Memcpy(pDstWmvParam, pSrcWmvParam, sizeof(OMX_VIDEO_PARAM_WMVTYPE));
1609 case OMX_IndexParamStandardComponentRole:
1611 OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE*)pComponentParameterStructure;
1613 ret = Exynos_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1614 if (ret != OMX_ErrorNone) {
1618 if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1619 ret = OMX_ErrorIncorrectStateOperation;
1623 if (!Exynos_OSAL_Strcmp((char*)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_WMV_DEC_ROLE)) {
1624 pExynosComponent->pExynosPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingWMV;
1626 ret = OMX_ErrorBadParameter;
1631 case OMX_IndexParamPortDefinition:
1633 OMX_PARAM_PORTDEFINITIONTYPE *pPortDefinition = (OMX_PARAM_PORTDEFINITIONTYPE *)pComponentParameterStructure;
1634 OMX_U32 portIndex = pPortDefinition->nPortIndex;
1635 EXYNOS_OMX_BASEPORT *pExynosPort;
1636 OMX_U32 width, height, size;
1637 OMX_U32 realWidth, realHeight;
1638 OMX_PARAM_PORTDEFINITIONTYPE portDefinition_backup;
1640 if (portIndex >= pExynosComponent->portParam.nPorts) {
1641 ret = OMX_ErrorBadPortIndex;
1644 ret = Exynos_OMX_Check_SizeVersion(pPortDefinition, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1645 if (ret != OMX_ErrorNone) {
1649 pExynosPort = &pExynosComponent->pExynosPort[portIndex];
1651 if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1652 if (pExynosPort->portDefinition.bEnabled == OMX_TRUE) {
1653 ret = OMX_ErrorIncorrectStateOperation;
1657 if (pPortDefinition->nBufferCountActual < pExynosPort->portDefinition.nBufferCountMin) {
1658 ret = OMX_ErrorBadParameter;
1662 Exynos_OSAL_Memcpy(&portDefinition_backup, &pExynosPort->portDefinition, pPortDefinition->nSize);
1663 Exynos_OSAL_Memcpy(&pExynosPort->portDefinition, pPortDefinition, pPortDefinition->nSize);
1664 RESTORE_READONLYPARAMETERS_OMX_PARAM_PORTDEFINITIONTYPE(&pExynosPort->portDefinition,&portDefinition_backup);
1666 realWidth = pExynosPort->portDefinition.format.video.nFrameWidth;
1667 realHeight = pExynosPort->portDefinition.format.video.nFrameHeight;
1668 width = ((realWidth + 15) & (~15));
1669 height = ((realHeight + 15) & (~15));
1670 size = (width * height * 3) / 2;
1671 pExynosPort->portDefinition.format.video.nStride = width;
1672 pExynosPort->portDefinition.format.video.nSliceHeight = height;
1673 pExynosPort->portDefinition.nBufferSize = (size > pExynosPort->portDefinition.nBufferSize) ? size : pExynosPort->portDefinition.nBufferSize;
1675 if (portIndex == INPUT_PORT_INDEX) {
1676 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1677 pExynosOutputPort->portDefinition.format.video.nFrameWidth = pExynosPort->portDefinition.format.video.nFrameWidth;
1678 pExynosOutputPort->portDefinition.format.video.nFrameHeight = pExynosPort->portDefinition.format.video.nFrameHeight;
1679 pExynosOutputPort->portDefinition.format.video.nStride = width;
1680 pExynosOutputPort->portDefinition.format.video.nSliceHeight = height;
1682 switch (pExynosOutputPort->portDefinition.format.video.eColorFormat) {
1683 case OMX_COLOR_FormatYUV420Planar:
1684 case OMX_COLOR_FormatYUV420SemiPlanar:
1685 pExynosOutputPort->portDefinition.nBufferSize = (width * height * 3) / 2;
1687 #ifdef TIZEN_FEATURE_E3250 /* NV12T fd */
1688 case OMX_SEC_COLOR_FormatNV12T_DmaBuf_Fd:
1689 pExynosOutputPort->portDefinition.nBufferSize = sizeof(MMVideoBuffer);
1692 case OMX_SEC_COLOR_FormatNV12Tiled:
1693 pExynosOutputPort->portDefinition.nBufferSize =
1694 calc_yplane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight) +
1695 calc_uvplane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight >> 1);
1698 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Color format is not support!! use default YUV size!!");
1699 ret = OMX_ErrorUnsupportedSetting;
1703 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1704 pExynosOutputPort->portDefinition.nBufferSize =
1705 calc_yplane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight) +
1706 calc_uvplane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight >> 1);
1711 case OMX_IndexParamVideoErrorCorrection:
1713 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
1714 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = NULL;
1715 EXYNOS_WMVDEC_HANDLE *pWmvDec = NULL;
1717 ret = Exynos_OMX_Check_SizeVersion(pSrcErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
1718 if (ret != OMX_ErrorNone) {
1722 if (pSrcErrorCorrectionType->nPortIndex != INPUT_PORT_INDEX) {
1723 ret = OMX_ErrorBadPortIndex;
1727 pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1728 pDstErrorCorrectionType = &pWmvDec->errorCorrectionType[INPUT_PORT_INDEX];
1730 pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
1731 pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
1732 pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
1733 pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
1734 pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
1738 ret = Exynos_OMX_VideoDecodeSetParameter(hComponent, nIndex, pComponentParameterStructure);
1747 OMX_ERRORTYPE Exynos_WmvDec_GetConfig(
1748 OMX_HANDLETYPE hComponent,
1749 OMX_INDEXTYPE nIndex,
1750 OMX_PTR pComponentConfigStructure)
1752 OMX_ERRORTYPE ret = OMX_ErrorNone;
1753 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1754 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1758 if (hComponent == NULL || pComponentConfigStructure == NULL) {
1759 ret = OMX_ErrorBadParameter;
1762 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1763 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1764 if (ret != OMX_ErrorNone) {
1767 if (pOMXComponent->pComponentPrivate == NULL) {
1768 ret = OMX_ErrorBadParameter;
1771 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1772 if (pExynosComponent->currentState == OMX_StateInvalid) {
1773 ret = OMX_ErrorInvalidState;
1779 ret = Exynos_OMX_VideoDecodeGetConfig(hComponent, nIndex, pComponentConfigStructure);
1789 OMX_ERRORTYPE Exynos_WmvDec_SetConfig(
1790 OMX_HANDLETYPE hComponent,
1791 OMX_INDEXTYPE nIndex,
1792 OMX_PTR pComponentConfigStructure)
1794 OMX_ERRORTYPE ret = OMX_ErrorNone;
1795 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1796 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1800 if (hComponent == NULL || pComponentConfigStructure == NULL) {
1801 ret = OMX_ErrorBadParameter;
1804 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1805 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1806 if (ret != OMX_ErrorNone) {
1809 if (pOMXComponent->pComponentPrivate == NULL) {
1810 ret = OMX_ErrorBadParameter;
1813 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1814 if (pExynosComponent->currentState == OMX_StateInvalid) {
1815 ret = OMX_ErrorInvalidState;
1821 ret = Exynos_OMX_VideoDecodeSetConfig(hComponent, nIndex, pComponentConfigStructure);
1831 OMX_ERRORTYPE Exynos_WmvDec_GetExtensionIndex(
1832 OMX_IN OMX_HANDLETYPE hComponent,
1833 OMX_IN OMX_STRING cParameterName,
1834 OMX_OUT OMX_INDEXTYPE *pIndexType)
1836 OMX_ERRORTYPE ret = OMX_ErrorNone;
1837 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1838 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1842 if (hComponent == NULL) {
1843 ret = OMX_ErrorBadParameter;
1846 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1847 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1848 if (ret != OMX_ErrorNone) {
1851 if (pOMXComponent->pComponentPrivate == NULL) {
1852 ret = OMX_ErrorBadParameter;
1855 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1856 if ((cParameterName == NULL) || (pIndexType == NULL)) {
1857 ret = OMX_ErrorBadParameter;
1860 if (pExynosComponent->currentState == OMX_StateInvalid) {
1861 ret = OMX_ErrorInvalidState;
1865 if (Exynos_OSAL_Strcmp(cParameterName, EXYNOS_INDEX_PARAM_ENABLE_THUMBNAIL) == 0) {
1866 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1867 *pIndexType = OMX_IndexVendorThumbnailMode;
1868 ret = OMX_ErrorNone;
1870 ret = Exynos_OMX_VideoDecodeGetExtensionIndex(hComponent, cParameterName, pIndexType);
1879 OMX_ERRORTYPE Exynos_WmvDec_ComponentRoleEnum(
1880 OMX_HANDLETYPE hComponent,
1884 OMX_ERRORTYPE ret = OMX_ErrorNone;
1885 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1886 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1890 if ((hComponent == NULL) || (cRole == NULL)) {
1891 ret = OMX_ErrorBadParameter;
1894 if (nIndex == (MAX_COMPONENT_ROLE_NUM-1)) {
1895 Exynos_OSAL_Strcpy((char *)cRole, EXYNOS_OMX_COMPONENT_WMV_DEC_ROLE);
1896 ret = OMX_ErrorNone;
1898 ret = OMX_ErrorNoMore;
1908 OMX_ERRORTYPE Exynos_WmvDec_Init(OMX_COMPONENTTYPE *pOMXComponent)
1910 OMX_ERRORTYPE ret = OMX_ErrorNone;
1911 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1912 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1913 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1914 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1915 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
1916 OMX_PTR hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
1918 ExynosVideoDecOps *pDecOps = NULL;
1919 ExynosVideoDecBufferOps *pInbufOps = NULL;
1920 ExynosVideoDecBufferOps *pOutbufOps = NULL;
1922 CSC_METHOD csc_method = CSC_METHOD_SW;
1927 pWmvDec->hMFCWmvHandle.bConfiguredMFCSrc = OMX_FALSE;
1928 pWmvDec->hMFCWmvHandle.bConfiguredMFCDst = OMX_FALSE;
1929 pExynosComponent->bUseFlagEOF = OMX_TRUE;
1930 pExynosComponent->bSaveFlagEOS = OMX_FALSE;
1932 /* WMV Codec Open */
1933 ret = WmvCodecOpen(pWmvDec);
1934 if (ret != OMX_ErrorNone) {
1938 pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
1939 pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
1940 pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
1942 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
1943 Exynos_OSAL_SemaphoreCreate(&pExynosInputPort->codecSemID);
1944 Exynos_OSAL_QueueCreate(&pExynosInputPort->codecBufferQ, MAX_QUEUE_ELEMENTS);
1946 if (pWmvDec->hMFCWmvHandle.bShareableBuf == OMX_TRUE) {
1947 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
1948 pVideoDec->pMFCDecInputBuffer[i] = Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
1949 Exynos_OSAL_Memset(pVideoDec->pMFCDecInputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
1950 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]);
1952 for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
1953 /* Use ION Allocator */
1954 pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] = (void *)Exynos_OSAL_SharedMemory_Alloc(pVideoDec->hSharedMemory, DEFAULT_MFC_INPUT_BUFFER_SIZE, NORMAL_MEMORY);
1955 pVideoDec->pMFCDecInputBuffer[i]->fd[plane] = Exynos_OSAL_SharedMemory_VirtToION(pVideoDec->hSharedMemory, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
1956 pVideoDec->pMFCDecInputBuffer[i]->bufferSize[plane] = DEFAULT_MFC_INPUT_BUFFER_SIZE;
1957 pVideoDec->pMFCDecInputBuffer[i]->dataSize = 0;
1958 if (pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] == NULL) {
1959 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Fail input buffer");
1960 ret = OMX_ErrorInsufficientResources;
1963 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]->pVirAddr[%d]: 0x%x", i, plane, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
1965 Exynos_CodecBufferEnQueue(pExynosComponent, INPUT_PORT_INDEX, pVideoDec->pMFCDecInputBuffer[i]);
1971 /* Does not require any actions. */
1973 } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
1977 /* Does not require any actions. */
1980 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1981 Exynos_OSAL_SemaphoreCreate(&pExynosOutputPort->codecSemID);
1982 Exynos_OSAL_QueueCreate(&pExynosOutputPort->codecBufferQ, MAX_QUEUE_ELEMENTS);
1983 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1987 /* Does not require any actions. */
1990 pWmvDec->bSourceStart = OMX_FALSE;
1991 Exynos_OSAL_SignalCreate(&pWmvDec->hSourceStartEvent);
1992 pWmvDec->bDestinationStart = OMX_FALSE;
1993 Exynos_OSAL_SignalCreate(&pWmvDec->hDestinationStartEvent);
1995 Exynos_OSAL_Memset(pExynosComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
1996 Exynos_OSAL_Memset(pExynosComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
1997 pWmvDec->hMFCWmvHandle.indexTimestamp = 0;
1998 pWmvDec->hMFCWmvHandle.outputIndexTimestamp = 0;
1999 /* Default WMV codec format is set as VC1*/
2000 pWmvDec->hMFCWmvHandle.wmvFormat = WMV_FORMAT_WMV3;//WMV_FORMAT_VC1;
2002 pExynosComponent->getAllDelayBuffer = OMX_FALSE;
2004 #if 0//defined(USE_CSC_GSCALER)
2005 csc_method = CSC_METHOD_HW; //in case of Use ION buffer.
2007 pVideoDec->csc_handle = csc_init(csc_method);
2008 if (pVideoDec->csc_handle == NULL) {
2009 ret = OMX_ErrorInsufficientResources;
2012 pVideoDec->csc_set_format = OMX_FALSE;
2021 OMX_ERRORTYPE Exynos_WmvDec_Terminate(OMX_COMPONENTTYPE *pOMXComponent)
2023 OMX_ERRORTYPE ret = OMX_ErrorNone;
2024 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2025 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2026 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2027 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2028 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2029 OMX_PTR hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
2031 ExynosVideoDecOps *pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
2032 ExynosVideoDecBufferOps *pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
2033 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
2039 if (pVideoDec->csc_handle != NULL) {
2040 csc_deinit(pVideoDec->csc_handle);
2041 pVideoDec->csc_handle = NULL;
2044 Exynos_OSAL_SignalTerminate(pWmvDec->hDestinationStartEvent);
2045 pWmvDec->hDestinationStartEvent = NULL;
2046 pWmvDec->bDestinationStart = OMX_FALSE;
2047 Exynos_OSAL_SignalTerminate(pWmvDec->hSourceStartEvent);
2048 pWmvDec->hSourceStartEvent = NULL;
2049 pWmvDec->bSourceStart = OMX_FALSE;
2051 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
2052 WmvCodecDstFreeCodecBuffers(pOMXComponent);
2054 Exynos_OSAL_QueueTerminate(&pExynosOutputPort->codecBufferQ);
2055 Exynos_OSAL_SemaphoreTerminate(pExynosOutputPort->codecSemID);
2056 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
2060 /* Does not require any actions. */
2063 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2064 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
2065 if (pVideoDec->pMFCDecInputBuffer[i] != NULL) {
2066 for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
2067 if (pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] != NULL)
2068 Exynos_OSAL_SharedMemory_Free(pVideoDec->hSharedMemory, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
2071 Exynos_OSAL_Free(pVideoDec->pMFCDecInputBuffer[i]);
2072 pVideoDec->pMFCDecInputBuffer[i] = NULL;
2076 Exynos_OSAL_QueueTerminate(&pExynosInputPort->codecBufferQ);
2077 Exynos_OSAL_SemaphoreTerminate(pExynosInputPort->codecSemID);
2078 } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
2082 /* Does not require any actions. */
2084 WmvCodecClose(pWmvDec);
2092 OMX_ERRORTYPE Exynos_WmvDec_SrcIn(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
2094 OMX_ERRORTYPE ret = OMX_ErrorNone;
2095 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2096 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2097 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2098 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
2099 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2100 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2101 OMX_U32 oneFrameSize = pSrcInputData->dataLen;
2102 OMX_BOOL bStartCode = OMX_FALSE;
2103 ExynosVideoDecOps *pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
2104 ExynosVideoDecBufferOps *pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
2105 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
2106 ExynosVideoErrorType codecReturn = VIDEO_ERROR_NONE;
2111 if (pWmvDec->hMFCWmvHandle.bConfiguredMFCSrc == OMX_FALSE) {
2112 ret = WmvCodecSrcSetup(pOMXComponent, pSrcInputData);
2115 if (pWmvDec->hMFCWmvHandle.bConfiguredMFCDst == OMX_FALSE) {
2116 ret = WmvCodecDstSetup(pOMXComponent);
2119 bStartCode = Check_Stream_PrefixCode(pSrcInputData->buffer.singlePlaneBuffer.dataBuffer, oneFrameSize, pWmvDec->hMFCWmvHandle.wmvFormat);
2120 if (bStartCode == OMX_FALSE && ((pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS)) {
2121 if (pSrcInputData->allocSize < oneFrameSize+4) {
2122 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Can't attach startcode due to lack of buffer space");
2123 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2127 bStartCode = Make_Stream_StartCode(pSrcInputData->buffer.singlePlaneBuffer.dataBuffer, &oneFrameSize, pWmvDec->hMFCWmvHandle.wmvFormat);
2128 if (bStartCode == OMX_FALSE) {
2129 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Fail to Make Stream Start Code");
2130 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2135 if ((bStartCode == OMX_TRUE) || ((pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)){
2136 pExynosComponent->timeStamp[pWmvDec->hMFCWmvHandle.indexTimestamp] = pSrcInputData->timeStamp;
2137 pExynosComponent->nFlags[pWmvDec->hMFCWmvHandle.indexTimestamp] = pSrcInputData->nFlags;
2138 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "input timestamp %lld us (%.2f secs), Tag: %d, nFlags: 0x%x", pSrcInputData->timeStamp, pSrcInputData->timeStamp / 1E6, pWmvDec->hMFCWmvHandle.indexTimestamp, pSrcInputData->nFlags);
2139 pDecOps->Set_FrameTag(hMFCHandle, pWmvDec->hMFCWmvHandle.indexTimestamp);
2140 pWmvDec->hMFCWmvHandle.indexTimestamp++;
2141 pWmvDec->hMFCWmvHandle.indexTimestamp %= MAX_TIMESTAMP;
2143 #ifdef USE_IMMEDIATE_DISPLAY
2144 /* Set Immediately display for I Frame*/
2145 if (pExynosComponent->checkTimeStamp.needCheckStartTimeStamp == OMX_TRUE) {
2146 if ( pExynosComponent->checkTimeStamp.bImmediateDisplay == OMX_FALSE) {
2147 /* Enable Immediately display After seek*/
2148 pDecOps->Set_ImmediateDisplay(hMFCHandle);
2149 pExynosComponent->checkTimeStamp.bImmediateDisplay = OMX_TRUE;
2154 /* queue work for input buffer */
2155 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "oneFrameSize: %d, bufferHeader: 0x%x, dataBuffer: 0x%x", oneFrameSize, pSrcInputData->bufferHeader, pSrcInputData->buffer.singlePlaneBuffer.dataBuffer);
2156 codecReturn = pInbufOps->Enqueue(hMFCHandle, (unsigned char **)&pSrcInputData->buffer.singlePlaneBuffer.dataBuffer,
2157 (unsigned int *)&oneFrameSize, MFC_INPUT_BUFFER_PLANE, pSrcInputData->bufferHeader);
2158 if (codecReturn != VIDEO_ERROR_NONE) {
2159 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2160 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s : %d", __FUNCTION__, __LINE__);
2163 WmvCodecStart(pOMXComponent, INPUT_PORT_INDEX);
2164 if (pWmvDec->bSourceStart == OMX_FALSE) {
2165 pWmvDec->bSourceStart = OMX_TRUE;
2166 Exynos_OSAL_SignalSet(pWmvDec->hSourceStartEvent);
2167 Exynos_OSAL_SleepMillisec(0);
2169 if (pWmvDec->bDestinationStart == OMX_FALSE) {
2170 pWmvDec->bDestinationStart = OMX_TRUE;
2171 Exynos_OSAL_SignalSet(pWmvDec->hDestinationStartEvent);
2172 Exynos_OSAL_SleepMillisec(0);
2176 ret = OMX_ErrorNone;
2184 OMX_ERRORTYPE Exynos_WmvDec_SrcOut(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcOutputData)
2186 OMX_ERRORTYPE ret = OMX_ErrorNone;
2187 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2188 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2189 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2190 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
2191 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2192 ExynosVideoDecOps *pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
2193 ExynosVideoDecBufferOps *pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
2194 ExynosVideoBuffer *pVideoBuffer;
2198 pVideoBuffer = pInbufOps->Dequeue(hMFCHandle);
2200 pSrcOutputData->dataLen = 0;
2201 pSrcOutputData->usedDataLen = 0;
2202 pSrcOutputData->remainDataLen = 0;
2203 pSrcOutputData->nFlags = 0;
2204 pSrcOutputData->timeStamp = 0;
2206 if (pVideoBuffer == NULL) {
2207 pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer = NULL;
2208 pSrcOutputData->allocSize = 0;
2209 pSrcOutputData->pPrivate = NULL;
2210 pSrcOutputData->bufferHeader = NULL;
2212 pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer = pVideoBuffer->planes[0].addr;
2213 pSrcOutputData->buffer.singlePlaneBuffer.fd = pVideoBuffer->planes[0].fd;
2214 pSrcOutputData->allocSize = pVideoBuffer->planes[0].allocSize;
2216 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2218 while (pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer != pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[0]) {
2219 if (i >= MFC_INPUT_BUFFER_NUM_MAX) {
2220 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Can not find buffer");
2221 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2226 pVideoDec->pMFCDecInputBuffer[i]->dataSize = 0;
2227 pSrcOutputData->pPrivate = pVideoDec->pMFCDecInputBuffer[i];
2230 /* For Share Buffer */
2231 pSrcOutputData->bufferHeader = (OMX_BUFFERHEADERTYPE*)pVideoBuffer->pPrivate;
2234 ret = OMX_ErrorNone;
2242 OMX_ERRORTYPE Exynos_WmvDec_DstIn(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstInputData)
2244 OMX_ERRORTYPE ret = OMX_ErrorNone;
2245 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2246 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2247 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2248 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
2249 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2250 ExynosVideoDecOps *pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
2251 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
2252 OMX_U32 dataLen[2] = {0,};
2253 ExynosVideoErrorType codecReturn = VIDEO_ERROR_NONE;
2257 if (pDstInputData->buffer.multiPlaneBuffer.dataBuffer[0] == NULL) {
2258 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to find input buffer");
2259 ret = OMX_ErrorBadParameter;
2263 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "%s : %d => ADDR[0]: 0x%x, ADDR[1]: 0x%x", __FUNCTION__, __LINE__,
2264 pDstInputData->buffer.multiPlaneBuffer.dataBuffer[0],
2265 pDstInputData->buffer.multiPlaneBuffer.dataBuffer[1]);
2267 if ((pVideoDec->bDRCProcessing == OMX_TRUE) &&
2268 (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) &&
2269 (pExynosOutputPort->exceptionFlag == GENERAL_STATE)) {
2270 ret = WmvCodecDstSetup(pOMXComponent);
2271 if (ret != OMX_ErrorNone) {
2272 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "DRC Reconfig CodecDstSetup Failed");
2275 pVideoDec->bDRCProcessing = OMX_FALSE;
2278 codecReturn = pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pDstInputData->buffer.multiPlaneBuffer.dataBuffer,
2279 (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, pDstInputData->bufferHeader);
2282 if (codecReturn != VIDEO_ERROR_NONE) {
2283 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s : %d", __FUNCTION__, __LINE__);
2284 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2287 WmvCodecStart(pOMXComponent, OUTPUT_PORT_INDEX);
2289 ret = OMX_ErrorNone;
2297 OMX_ERRORTYPE Exynos_WmvDec_DstOut(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstOutputData)
2299 OMX_ERRORTYPE ret = OMX_ErrorNone;
2300 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2301 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2302 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2303 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
2304 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2305 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2306 ExynosVideoDecOps *pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
2307 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
2308 ExynosVideoBuffer *pVideoBuffer;
2309 ExynosVideoFrameStatusType displayStatus = VIDEO_FRAME_STATUS_UNKNOWN;
2310 ExynosVideoGeometry *bufferGeometry;
2311 DECODE_CODEC_EXTRA_BUFFERINFO *pBufferInfo = NULL;
2312 OMX_S32 indexTimestamp = 0;
2317 if (pWmvDec->bDestinationStart == OMX_FALSE) {
2318 ret = OMX_ErrorNone;
2323 pVideoBuffer = pOutbufOps->Dequeue(hMFCHandle);
2324 if (pVideoBuffer == (ExynosVideoBuffer *)VIDEO_ERROR_DQBUF_EIO) {
2325 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "HW is not available");
2326 ret = OMX_ErrorHardware;
2330 if (pVideoBuffer == NULL) {
2331 ret = OMX_ErrorNone;
2334 displayStatus = pVideoBuffer->displayStatus;
2335 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "displayStatus: 0x%x", displayStatus);
2337 if ((displayStatus == VIDEO_FRAME_STATUS_DISPLAY_DECODING) ||
2338 (displayStatus == VIDEO_FRAME_STATUS_DISPLAY_ONLY) ||
2339 (displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) ||
2340 (displayStatus == VIDEO_FRAME_STATUS_DECODING_FINISHED) ||
2341 (CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2342 if (pVideoBuffer != NULL) {
2343 ret = OMX_ErrorNone;
2346 ret = OMX_ErrorUndefined;
2352 if (displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) {
2353 if (pVideoDec->bDRCProcessing != OMX_TRUE) {
2354 pExynosOutputPort->exceptionFlag = NEED_PORT_FLUSH;
2355 pVideoDec->bDRCProcessing = OMX_TRUE;
2356 WmvCodecCheckResolutionChange(pOMXComponent);
2357 pVideoDec->csc_set_format = OMX_FALSE;
2359 ret = OMX_ErrorNone;
2363 pWmvDec->hMFCWmvHandle.outputIndexTimestamp++;
2364 pWmvDec->hMFCWmvHandle.outputIndexTimestamp %= MAX_TIMESTAMP;
2366 pDstOutputData->allocSize = pDstOutputData->dataLen = 0;
2367 for (plane = 0; plane < MFC_OUTPUT_BUFFER_PLANE; plane++) {
2368 pDstOutputData->buffer.multiPlaneBuffer.dataBuffer[plane] = pVideoBuffer->planes[plane].addr;
2369 pDstOutputData->buffer.multiPlaneBuffer.fd[plane] = pVideoBuffer->planes[plane].fd;
2370 pDstOutputData->allocSize += pVideoBuffer->planes[plane].allocSize;
2371 pDstOutputData->dataLen += pVideoBuffer->planes[plane].dataSize;
2373 pDstOutputData->usedDataLen = 0;
2374 pDstOutputData->pPrivate = pVideoBuffer;
2375 /* For Share Buffer */
2376 pDstOutputData->bufferHeader = (OMX_BUFFERHEADERTYPE *)pVideoBuffer->pPrivate;
2378 pBufferInfo = (DECODE_CODEC_EXTRA_BUFFERINFO *)pDstOutputData->extInfo;
2379 bufferGeometry = &pWmvDec->hMFCWmvHandle.codecOutbufConf;
2380 pBufferInfo->imageWidth = bufferGeometry->nFrameWidth;
2381 pBufferInfo->imageHeight = bufferGeometry->nFrameHeight;
2382 switch (bufferGeometry->eColorFormat) {
2383 case VIDEO_COLORFORMAT_NV12:
2384 #ifdef TIZEN_FEATURE_E3250 /* NV12T fd */
2385 pBufferInfo->ColorFormat = OMX_SEC_COLOR_FormatNV12T_DmaBuf_Fd;
2387 pBufferInfo->ColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
2390 case VIDEO_COLORFORMAT_NV12_TILED:
2392 pBufferInfo->ColorFormat = OMX_SEC_COLOR_FormatNV12Tiled;
2396 indexTimestamp = pDecOps->Get_FrameTag(hMFCHandle);
2397 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "out indexTimestamp: %d", indexTimestamp);
2398 if ((indexTimestamp < 0) || (indexTimestamp >= MAX_TIMESTAMP)) {
2399 if ((pExynosComponent->checkTimeStamp.needSetStartTimeStamp != OMX_TRUE) &&
2400 (pExynosComponent->checkTimeStamp.needCheckStartTimeStamp != OMX_TRUE)) {
2401 pDstOutputData->timeStamp = pExynosComponent->timeStamp[pWmvDec->hMFCWmvHandle.outputIndexTimestamp];
2402 pDstOutputData->nFlags = pExynosComponent->nFlags[pWmvDec->hMFCWmvHandle.outputIndexTimestamp];
2403 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "missing out indexTimestamp: %d", indexTimestamp);
2405 pDstOutputData->timeStamp = 0x00;
2406 pDstOutputData->nFlags = 0x00;
2409 /* For timestamp correction. if mfc support frametype detect */
2410 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "disp_pic_frame_type: %d", pVideoBuffer->frameType);
2412 //#ifdef NEED_TIMESTAMP_REORDER
2413 if (pVideoDec->bNeedTimestampReorder == OMX_TRUE) { /* TIZEN_FEATURE_E3250 */
2414 if ((pVideoBuffer->frameType == VIDEO_FRAME_I)) {
2415 pDstOutputData->timeStamp = pExynosComponent->timeStamp[indexTimestamp];
2416 pDstOutputData->nFlags = pExynosComponent->nFlags[indexTimestamp];
2417 pWmvDec->hMFCWmvHandle.outputIndexTimestamp = indexTimestamp;
2419 pDstOutputData->timeStamp = pExynosComponent->timeStamp[pWmvDec->hMFCWmvHandle.outputIndexTimestamp];
2420 pDstOutputData->nFlags = pExynosComponent->nFlags[pWmvDec->hMFCWmvHandle.outputIndexTimestamp];
2424 pDstOutputData->timeStamp = pExynosComponent->timeStamp[indexTimestamp];
2425 pDstOutputData->nFlags = pExynosComponent->nFlags[indexTimestamp];
2428 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "timestamp %lld us (%.2f secs), indexTimestamp: %d, nFlags: 0x%x", pDstOutputData->timeStamp, pDstOutputData->timeStamp / 1E6, indexTimestamp, pDstOutputData->nFlags);
2431 if ((displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) ||
2432 (displayStatus == VIDEO_FRAME_STATUS_DECODING_FINISHED) ||
2433 ((pDstOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)) {
2434 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "displayStatus:%d, nFlags0x%x", displayStatus, pDstOutputData->nFlags);
2435 pDstOutputData->remainDataLen = 0;
2437 pDstOutputData->remainDataLen = bufferGeometry->nFrameWidth * bufferGeometry->nFrameHeight * 3 / 2;
2440 ret = OMX_ErrorNone;
2448 OMX_ERRORTYPE Exynos_WmvDec_srcInputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
2450 OMX_ERRORTYPE ret = OMX_ErrorNone;
2451 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2452 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2453 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2457 if ((!CHECK_PORT_ENABLED(pExynosInputPort)) || (!CHECK_PORT_POPULATED(pExynosInputPort))) {
2458 ret = OMX_ErrorNone;
2461 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, INPUT_PORT_INDEX)) {
2462 ret = OMX_ErrorNone;
2466 ret = Exynos_WmvDec_SrcIn(pOMXComponent, pSrcInputData);
2467 if ((ret != OMX_ErrorNone) && (ret != OMX_ErrorInputDataDecodeYet)) {
2468 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2469 pExynosComponent->callbackData,
2470 OMX_EventError, ret, 0, NULL);
2479 OMX_ERRORTYPE Exynos_WmvDec_srcOutputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcOutputData)
2481 OMX_ERRORTYPE ret = OMX_ErrorNone;
2482 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2483 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2484 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2488 if ((!CHECK_PORT_ENABLED(pExynosInputPort)) || (!CHECK_PORT_POPULATED(pExynosInputPort))) {
2489 ret = OMX_ErrorNone;
2493 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2494 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, INPUT_PORT_INDEX)) {
2495 ret = OMX_ErrorNone;
2499 if ((pWmvDec->bSourceStart == OMX_FALSE) &&
2500 (!CHECK_PORT_BEING_FLUSHED(pExynosInputPort))) {
2501 Exynos_OSAL_SignalWait(pWmvDec->hSourceStartEvent, DEF_MAX_WAIT_TIME);
2502 Exynos_OSAL_SignalReset(pWmvDec->hSourceStartEvent);
2505 ret = Exynos_WmvDec_SrcOut(pOMXComponent, pSrcOutputData);
2506 if ((ret != OMX_ErrorNone) &&
2507 (pExynosComponent->currentState == OMX_StateExecuting)) {
2508 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2509 pExynosComponent->callbackData,
2510 OMX_EventError, ret, 0, NULL);
2519 OMX_ERRORTYPE Exynos_WmvDec_dstInputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstInputData)
2521 OMX_ERRORTYPE ret = OMX_ErrorNone;
2522 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2523 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2524 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2528 if ((!CHECK_PORT_ENABLED(pExynosOutputPort)) || (!CHECK_PORT_POPULATED(pExynosOutputPort))) {
2529 ret = OMX_ErrorNone;
2532 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, OUTPUT_PORT_INDEX)) {
2533 ret = OMX_ErrorNone;
2536 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
2537 if ((pWmvDec->bDestinationStart == OMX_FALSE) &&
2538 (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2539 Exynos_OSAL_SignalWait(pWmvDec->hDestinationStartEvent, DEF_MAX_WAIT_TIME);
2540 Exynos_OSAL_SignalReset(pWmvDec->hDestinationStartEvent);
2543 if (pWmvDec->hMFCWmvHandle.bConfiguredMFCDst == OMX_TRUE) {
2544 ret = Exynos_WmvDec_DstIn(pOMXComponent, pDstInputData);
2545 if (ret != OMX_ErrorNone) {
2546 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2547 pExynosComponent->callbackData,
2548 OMX_EventError, ret, 0, NULL);
2558 OMX_ERRORTYPE Exynos_WmvDec_dstOutputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstOutputData)
2560 OMX_ERRORTYPE ret = OMX_ErrorNone;
2561 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2562 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2563 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2567 if ((!CHECK_PORT_ENABLED(pExynosOutputPort)) || (!CHECK_PORT_POPULATED(pExynosOutputPort))) {
2568 ret = OMX_ErrorNone;
2571 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, OUTPUT_PORT_INDEX)) {
2572 ret = OMX_ErrorNone;
2576 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
2577 if ((pWmvDec->bDestinationStart == OMX_FALSE) &&
2578 (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2579 Exynos_OSAL_SignalWait(pWmvDec->hDestinationStartEvent, DEF_MAX_WAIT_TIME);
2580 Exynos_OSAL_SignalReset(pWmvDec->hDestinationStartEvent);
2583 ret = Exynos_WmvDec_DstOut(pOMXComponent, pDstOutputData);
2584 if ((ret != OMX_ErrorNone) &&
2585 (pExynosComponent->currentState == OMX_StateExecuting)) {
2586 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2587 pExynosComponent->callbackData,
2588 OMX_EventError, ret, 0, NULL);
2597 OSCL_EXPORT_REF OMX_ERRORTYPE Exynos_OMX_ComponentInit(
2598 OMX_HANDLETYPE hComponent,
2599 OMX_STRING componentName)
2601 OMX_ERRORTYPE ret = OMX_ErrorNone;
2602 OMX_COMPONENTTYPE *pOMXComponent = NULL;
2603 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
2604 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
2605 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
2606 EXYNOS_WMVDEC_HANDLE *pWmvDec = NULL;
2607 OMX_S32 wmvFormat = WMV_FORMAT_UNKNOWN;
2612 if ((hComponent == NULL) || (componentName == NULL)) {
2613 ret = OMX_ErrorBadParameter;
2614 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
2617 if (Exynos_OSAL_Strcmp(EXYNOS_OMX_COMPONENT_WMV_DEC, componentName) != 0) {
2618 ret = OMX_ErrorBadParameter;
2619 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, componentName:%s, Line:%d", componentName, __LINE__);
2623 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2624 ret = Exynos_OMX_VideoDecodeComponentInit(pOMXComponent);
2625 if (ret != OMX_ErrorNone) {
2626 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_Error, Line:%d", __LINE__);
2629 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2630 pExynosComponent->codecType = HW_VIDEO_DEC_CODEC;
2632 pExynosComponent->componentName = (OMX_STRING)Exynos_OSAL_Malloc(MAX_OMX_COMPONENT_NAME_SIZE);
2633 if (pExynosComponent->componentName == NULL) {
2634 Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2635 ret = OMX_ErrorInsufficientResources;
2636 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2639 Exynos_OSAL_Memset(pExynosComponent->componentName, 0, MAX_OMX_COMPONENT_NAME_SIZE);
2641 pWmvDec = Exynos_OSAL_Malloc(sizeof(EXYNOS_WMVDEC_HANDLE));
2642 if (pWmvDec == NULL) {
2643 Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2644 ret = OMX_ErrorInsufficientResources;
2645 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2648 Exynos_OSAL_Memset(pWmvDec, 0, sizeof(EXYNOS_WMVDEC_HANDLE));
2649 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2650 pVideoDec->hCodecHandle = (OMX_HANDLETYPE)pWmvDec;
2651 pWmvDec->hMFCWmvHandle.wmvFormat = wmvFormat;
2653 Exynos_OSAL_Strcpy(pExynosComponent->componentName, EXYNOS_OMX_COMPONENT_WMV_DEC);
2655 /* In case of BUFFER_COPY mode
2656 bShareableBuf = TRUE means MemoryType is V4L2_MEMORY_USERPTR
2657 bShareableBuf = FALSE means MemoryType is V4L2_MEMORY_MMAP
2658 In case of BUFFER_SHARE
2659 bShareableBuf should be TRUE, FALSE is ignored
2661 pWmvDec->hMFCWmvHandle.bShareableBuf = OMX_FALSE;
2663 /* Set componentVersion */
2664 pExynosComponent->componentVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
2665 pExynosComponent->componentVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
2666 pExynosComponent->componentVersion.s.nRevision = REVISION_NUMBER;
2667 pExynosComponent->componentVersion.s.nStep = STEP_NUMBER;
2668 /* Set specVersion */
2669 pExynosComponent->specVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
2670 pExynosComponent->specVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
2671 pExynosComponent->specVersion.s.nRevision = REVISION_NUMBER;
2672 pExynosComponent->specVersion.s.nStep = STEP_NUMBER;
2675 pExynosPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2676 pExynosPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
2677 pExynosPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
2678 pExynosPort->portDefinition.format.video.nStride = 0; /*DEFAULT_FRAME_WIDTH;*/
2679 pExynosPort->portDefinition.format.video.nSliceHeight = 0;
2680 pExynosPort->portDefinition.nBufferSize = DEFAULT_VIDEO_INPUT_BUFFER_SIZE;
2681 pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingWMV;
2682 Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2683 Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "video/wmv");
2684 pExynosPort->portDefinition.format.video.pNativeRender = 0;
2685 pExynosPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
2686 pExynosPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatUnused;
2687 pExynosPort->portDefinition.bEnabled = OMX_TRUE;
2688 pExynosPort->bufferProcessType = BUFFER_COPY;
2689 pExynosPort->portWayType = WAY2_PORT;
2692 pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2693 pExynosPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
2694 pExynosPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
2695 pExynosPort->portDefinition.format.video.nStride = 0; /*DEFAULT_FRAME_WIDTH;*/
2696 pExynosPort->portDefinition.format.video.nSliceHeight = 0;
2697 pExynosPort->portDefinition.nBufferSize = DEFAULT_VIDEO_OUTPUT_BUFFER_SIZE;
2698 pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused;
2699 Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2700 Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "raw/video");
2701 pExynosPort->portDefinition.format.video.pNativeRender = 0;
2702 pExynosPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
2703 #ifdef TIZEN_FEATURE_E3250
2704 pExynosPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatNV12T_DmaBuf_Fd;
2706 pExynosPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
2708 pExynosPort->portDefinition.bEnabled = OMX_TRUE;
2709 #ifdef TIZEN_FEATURE_E3250
2710 pExynosPort->bufferProcessType = BUFFER_SHARE;
2712 pExynosPort->bufferProcessType = BUFFER_COPY;
2714 pExynosPort->portWayType = WAY2_PORT;
2716 for(i = 0; i < ALL_PORT_NUM; i++) {
2717 INIT_SET_SIZE_VERSION(&pWmvDec->WmvComponent[i], OMX_VIDEO_PARAM_WMVTYPE);
2718 pWmvDec->WmvComponent[i].nPortIndex = i;
2719 pWmvDec->WmvComponent[i].eFormat = OMX_VIDEO_WMVFormat9;
2722 #ifdef TIZEN_FEATURE_E3250
2723 pWmvDec->wmvFormat = WMV_FORMAT_UNKNOWN;
2726 pOMXComponent->GetParameter = &Exynos_WmvDec_GetParameter;
2727 pOMXComponent->SetParameter = &Exynos_WmvDec_SetParameter;
2728 pOMXComponent->GetConfig = &Exynos_WmvDec_GetConfig;
2729 pOMXComponent->SetConfig = &Exynos_WmvDec_SetConfig;
2730 pOMXComponent->GetExtensionIndex = &Exynos_WmvDec_GetExtensionIndex;
2731 pOMXComponent->ComponentRoleEnum = &Exynos_WmvDec_ComponentRoleEnum;
2732 pOMXComponent->ComponentDeInit = &Exynos_OMX_ComponentDeinit;
2734 pExynosComponent->exynos_codec_componentInit = &Exynos_WmvDec_Init;
2735 pExynosComponent->exynos_codec_componentTerminate = &Exynos_WmvDec_Terminate;
2737 pVideoDec->exynos_codec_srcInputProcess = &Exynos_WmvDec_srcInputBufferProcess;
2738 pVideoDec->exynos_codec_srcOutputProcess = &Exynos_WmvDec_srcOutputBufferProcess;
2739 pVideoDec->exynos_codec_dstInputProcess = &Exynos_WmvDec_dstInputBufferProcess;
2740 pVideoDec->exynos_codec_dstOutputProcess = &Exynos_WmvDec_dstOutputBufferProcess;
2742 pVideoDec->exynos_codec_start = &WmvCodecStart;
2743 pVideoDec->exynos_codec_stop = &WmvCodecStop;
2744 pVideoDec->exynos_codec_bufferProcessRun = &WmvCodecOutputBufferProcessRun;
2745 pVideoDec->exynos_codec_enqueueAllBuffer = &WmvCodecEnQueueAllBuffer;
2746 pVideoDec->exynos_codec_resetupAllElement = &WmvCodecResetupAllElement;
2748 pVideoDec->exynos_checkInputFrame = &Check_Wmv_Frame;
2749 pVideoDec->exynos_codec_getCodecInputPrivateData = &GetCodecInputPrivateData;
2750 pVideoDec->exynos_codec_getCodecOutputPrivateData = &GetCodecOutputPrivateData;
2752 pVideoDec->exynos_process_codecConfigData = &Process_Wmv_CodecConfigData;
2754 #ifndef TIZEN_FEATURE_E3250 /* do not use ion */
2755 pVideoDec->hSharedMemory = Exynos_OSAL_SharedMemory_Open();
2756 if (pVideoDec->hSharedMemory == NULL) {
2757 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2758 Exynos_OSAL_Free(pWmvDec);
2759 pWmvDec = ((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle = NULL;
2760 Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2761 ret = OMX_ErrorInsufficientResources;
2765 pExynosComponent->currentState = OMX_StateLoaded;
2767 ret = OMX_ErrorNone;
2775 OMX_ERRORTYPE Exynos_OMX_ComponentDeinit(
2776 OMX_HANDLETYPE hComponent)
2778 OMX_ERRORTYPE ret = OMX_ErrorNone;
2779 OMX_COMPONENTTYPE *pOMXComponent = NULL;
2780 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
2781 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
2782 EXYNOS_WMVDEC_HANDLE *pWmvDec = NULL;
2786 if (hComponent == NULL) {
2787 ret = OMX_ErrorBadParameter;
2790 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2791 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2792 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2793 #ifndef TIZEN_FEATURE_E3250 /* do not use ion */
2794 Exynos_OSAL_SharedMemory_Close(pVideoDec->hSharedMemory);
2796 Exynos_OSAL_Free(pExynosComponent->componentName);
2797 pExynosComponent->componentName = NULL;
2799 pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
2800 if (pWmvDec != NULL) {
2801 Exynos_OSAL_Free(pWmvDec);
2802 pWmvDec = pVideoDec->hCodecHandle = NULL;
2805 ret = Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2806 if (ret != OMX_ErrorNone) {
2810 ret = OMX_ErrorNone;