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"
47 #include "Exynos_OMX_VdecControl.h"
50 #include "Exynos_OSAL_Platform_Specific.h"
53 /* To use CSC_METHOD_HW in EXYNOS OMX, gralloc should allocate physical memory using FIMC */
54 /* It means GRALLOC_USAGE_HW_FIMC1 should be set on Native Window usage */
58 #define EXYNOS_LOG_TAG "EXYNOS_WMV_DEC"
59 #define EXYNOS_LOG_OFF
60 //#define EXYNOS_TRACE_ON
61 #include "Exynos_OSAL_Log.h"
63 #define WMV_DEC_NUM_OF_EXTRA_BUFFERS 7
65 //#define FULL_FRAME_SEARCH
67 /* ASF parser does not send start code on Stagefright */
69 /* Enable or disable "WMV3_ADDITIONAL_START_CODE" based on MFC F/W's need */
70 //#define WMV3_ADDITIONAL_START_CODE
72 const OMX_U32 wmv3 = 0x33564d57;
73 const OMX_U32 wvc1 = 0x31435657;
74 const OMX_U32 wmva = 0x41564d57;
77 static OMX_ERRORTYPE GetCodecInputPrivateData(OMX_PTR codecBuffer, void *pVirtAddr, OMX_U32 *dataSize)
82 static OMX_ERRORTYPE GetCodecOutputPrivateData(OMX_PTR codecBuffer, OMX_PTR addr[], OMX_U32 size[])
84 OMX_ERRORTYPE ret = OMX_ErrorNone;
85 ExynosVideoBuffer *pCodecBuffer = NULL;
87 if (codecBuffer == NULL) {
88 ret = OMX_ErrorBadParameter;
92 pCodecBuffer = (ExynosVideoBuffer *)codecBuffer;
95 addr[0] = pCodecBuffer->planes[0].addr;
96 addr[1] = pCodecBuffer->planes[1].addr;
97 addr[2] = pCodecBuffer->planes[2].addr;
101 size[0] = pCodecBuffer->planes[0].allocSize;
102 size[1] = pCodecBuffer->planes[1].allocSize;
103 size[2] = pCodecBuffer->planes[2].allocSize;
110 #ifndef TIZEN_FEATURE_E3250
112 OMX_U8 *pInputStream,
115 OMX_BOOL bPreviousFrameEOF,
116 OMX_BOOL *pbEndOfFrame)
118 OMX_U32 compressionID;
119 OMX_BOOL bFrameStart;
120 OMX_U32 len, readStream;
122 WMV_FORMAT gWvmFormat = WMV_FORMAT_UNKNOWN;
124 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "buffSize = %d", buffSize);
127 bFrameStart = OMX_FALSE;
129 if (flag & OMX_BUFFERFLAG_CODECCONFIG) {
130 BitmapInfoHhr *pBitmapInfoHeader;
131 pBitmapInfoHeader = (BitmapInfoHhr *)pInputStream;
133 compressionID = pBitmapInfoHeader->BiCompression;
134 if (compressionID == wmv3) {
135 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "WMV_FORMAT_WMV3");
136 gWvmFormat = WMV_FORMAT_WMV3;
138 *pbEndOfFrame = OMX_TRUE;
141 else if ((compressionID == wvc1) || (compressionID == wmva)) {
142 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "WMV_FORMAT_VC1");
143 gWvmFormat = WMV_FORMAT_VC1;
146 /* ASF parser does not send start code on Stagefright */
147 *pbEndOfFrame = OMX_TRUE;
153 if (gWvmFormat == WMV_FORMAT_WMV3) {
154 *pbEndOfFrame = OMX_TRUE;
159 /* ASF parser does not send start code on Stagefright */
160 if (gWvmFormat == WMV_FORMAT_VC1) {
161 *pbEndOfFrame = OMX_TRUE;
165 /* TODO : for comformanc test based on common buffer scheme w/o parser */
167 if (bPreviousFrameEOF == OMX_FALSE)
168 bFrameStart = OMX_TRUE;
170 startCode = 0xFFFFFFFF;
171 if (bFrameStart == OMX_FALSE) {
172 /* find Frame start code */
173 while(startCode != 0x10D) {
174 readStream = *(pInputStream + len);
175 startCode = (startCode << 8) | readStream;
182 /* find next Frame start code */
183 startCode = 0xFFFFFFFF;
184 while ((startCode != 0x10D)) {
185 readStream = *(pInputStream + len);
186 startCode = (startCode << 8) | readStream;
192 *pbEndOfFrame = OMX_TRUE;
194 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "1. Check_Wmv_Frame returned EOF = %d, len = %d, buffSize = %d", *pbEndOfFrame, len - 4, buffSize);
200 *pbEndOfFrame = OMX_FALSE;
202 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:
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;
322 if (*pStreamSize >= BITMAPINFOHEADER_ASFBINDING_SIZE) {
323 Exynos_OSAL_Memcpy(pCurrBuf, pInputStream + BITMAPINFOHEADER_ASFBINDING_SIZE, *pStreamSize - BITMAPINFOHEADER_ASFBINDING_SIZE);
324 *pStreamSize -= BITMAPINFOHEADER_ASFBINDING_SIZE;
327 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: *pStreamSize is too small to contain metadata(%d)", __FUNCTION__, *pStreamSize);
332 Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "%s: It is not necessary to make bitstream metadata for wmvFormat (%d)", __FUNCTION__, wmvFormat);
338 static OMX_BOOL Make_Stream_StartCode(
339 OMX_U8 *pInputStream,
340 OMX_U32 *pStreamSize,
341 WMV_FORMAT wmvFormat)
343 OMX_U8 frameStartCode[4] = {0x00, 0x00, 0x01, 0x0d};
344 #ifdef WMV3_ADDITIONAL_START_CODE
345 /* first 4 bytes : size of Frame, second 4 bytes : present Time stamp */
346 OMX_U8 frameStartCode2[8] = {0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00};
350 case WMV_FORMAT_WMV3:
351 #ifdef WMV3_ADDITIONAL_START_CODE
352 Exynos_OSAL_Memmove(pInputStream+8, pInputStream, *pStreamSize);
353 Exynos_OSAL_Memcpy(pInputStream, frameStartCode2, 8);
360 /* Should find better way to shift data */
361 Exynos_OSAL_Memmove(pInputStream+4, pInputStream, *pStreamSize);
362 Exynos_OSAL_Memcpy(pInputStream, frameStartCode, 4);
368 Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "%s: undefined wmvFormat (%d)", __FUNCTION__, wmvFormat);
374 OMX_ERRORTYPE Process_Wmv_CodecConfigData(OMX_COMPONENTTYPE *pOMXComponent, void *pConfig)
376 OMX_ERRORTYPE ret = OMX_ErrorNone;
377 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
378 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
379 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
381 #ifdef TIZEN_FEATURE_E3250
382 EXYNOS_OMX_DATABUFFER *pSrcInputData = (EXYNOS_OMX_DATA *)pConfig;
383 OMX_U8 *pInputStream = pSrcInputData->bufferHeader->pBuffer;
388 #ifdef TIZEN_FEATURE_E3250
389 if (pWmvDec->wmvFormat == WMV_FORMAT_UNKNOWN) {
390 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Process_Wmv_CodecConfigData. dataLen = %d", pSrcInputData->dataLen);
391 if (pSrcInputData->dataLen < 4) {
392 pWmvDec->wmvFormat = WMV_FORMAT_UNKNOWN;
393 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "WMV_FORMAT_UNKNOWN");
394 } else if ((pInputStream[1] == 0x00) &&
395 (pInputStream[2] == 0x00) &&
396 (pInputStream[3] == 0x01)) {
397 pWmvDec->wmvFormat = WMV_FORMAT_VC1;
398 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "WMV_FORMAT_VC1");
400 pWmvDec->wmvFormat = WMV_FORMAT_WMV3;
401 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "WMV_FORMAT_WMV3");
405 pWmvDec->hMFCWmvHandle.wmvFormat = pWmvDec->wmvFormat;
407 BitmapInfoHhr *pBitmapInfoHeader;
408 pBitmapInfoHeader = (BitmapInfoHhr *)pConfig;
409 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "OMX_BUFFERFLAG_CODECCONFIG");
410 if (pBitmapInfoHeader->BiCompression == wmv3) {
411 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "WMV_FORMAT_WMV3");
412 pWmvDec->hMFCWmvHandle.wmvFormat = WMV_FORMAT_WMV3;
413 } else if ((pBitmapInfoHeader->BiCompression == wvc1) || (pBitmapInfoHeader->BiCompression == wmva)) {
414 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "WMV_FORMAT_VC1");
415 pWmvDec->hMFCWmvHandle.wmvFormat = WMV_FORMAT_VC1;
417 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "WMV_FORMAT_UNKNOWN (0x%x), default value will be used", pBitmapInfoHeader->BiCompression);
420 ret = WmvCodecSrcInit(pOMXComponent);
421 if (ret != OMX_ErrorNone) {
422 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to WmvCodecSrcInit");
434 OMX_ERRORTYPE WmvCodecOpen(EXYNOS_WMVDEC_HANDLE *pWmvDec)
436 OMX_ERRORTYPE ret = OMX_ErrorNone;
437 ExynosVideoDecOps *pDecOps = NULL;
438 ExynosVideoDecBufferOps *pInbufOps = NULL;
439 ExynosVideoDecBufferOps *pOutbufOps = NULL;
440 enum v4l2_memory v4l2MemoryType = V4L2_MEMORY_USERPTR;
444 if (pWmvDec == NULL) {
445 ret = OMX_ErrorBadParameter;
446 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
450 /* alloc ops structure */
451 pDecOps = (ExynosVideoDecOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoDecOps));
452 pInbufOps = (ExynosVideoDecBufferOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoDecBufferOps));
453 pOutbufOps = (ExynosVideoDecBufferOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoDecBufferOps));
455 if ((pDecOps == NULL) || (pInbufOps == NULL) || (pOutbufOps == NULL)) {
456 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to allocate decoder ops buffer");
457 ret = OMX_ErrorInsufficientResources;
461 pWmvDec->hMFCWmvHandle.pDecOps = pDecOps;
462 pWmvDec->hMFCWmvHandle.pInbufOps = pInbufOps;
463 pWmvDec->hMFCWmvHandle.pOutbufOps = pOutbufOps;
465 /* function pointer mapping */
466 pDecOps->nSize = sizeof(ExynosVideoDecOps);
467 pInbufOps->nSize = sizeof(ExynosVideoDecBufferOps);
468 pOutbufOps->nSize = sizeof(ExynosVideoDecBufferOps);
470 Exynos_Video_Register_Decoder(pDecOps, pInbufOps, pOutbufOps);
472 /* check mandatory functions for decoder ops */
473 if ((pDecOps->Init == NULL) || (pDecOps->Finalize == NULL) ||
474 (pDecOps->Get_ActualBufferCount == NULL) || (pDecOps->Set_FrameTag == NULL) ||
475 (pDecOps->Get_FrameTag == NULL)) {
476 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Mandatory functions must be supplied");
477 ret = OMX_ErrorInsufficientResources;
481 /* check mandatory functions for buffer ops */
482 if ((pInbufOps->Setup == NULL) || (pOutbufOps->Setup == NULL) ||
483 (pInbufOps->Run == NULL) || (pOutbufOps->Run == NULL) ||
484 (pInbufOps->Stop == NULL) || (pOutbufOps->Stop == NULL) ||
485 (pInbufOps->Enqueue == NULL) || (pOutbufOps->Enqueue == NULL) ||
486 (pInbufOps->Dequeue == NULL) || (pOutbufOps->Dequeue == NULL)) {
487 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Mandatory functions must be supplied");
488 ret = OMX_ErrorInsufficientResources;
493 if (pWmvDec->hMFCWmvHandle.bShareableBuf == OMX_TRUE) {
495 v4l2MemoryType = V4L2_MEMORY_DMABUF;
496 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "using Dec V4L2_MEMORY_DMABUF");
498 v4l2MemoryType = V4L2_MEMORY_USERPTR;
499 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "using Dec V4L2_MEMORY_USEPTR");
502 v4l2MemoryType = V4L2_MEMORY_DMABUF;
503 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "using Dec V4L2_MEMORY_DMABUF");
506 /* alloc context, open, querycap */
507 pWmvDec->hMFCWmvHandle.hMFCHandle = pWmvDec->hMFCWmvHandle.pDecOps->Init(v4l2MemoryType);
508 if (pWmvDec->hMFCWmvHandle.hMFCHandle == NULL) {
509 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to allocate context buffer");
510 ret = OMX_ErrorInsufficientResources;
517 if (ret != OMX_ErrorNone) {
518 if (pDecOps != NULL) {
519 Exynos_OSAL_Free(pDecOps);
520 pWmvDec->hMFCWmvHandle.pDecOps = NULL;
522 if (pInbufOps != NULL) {
523 Exynos_OSAL_Free(pInbufOps);
524 pWmvDec->hMFCWmvHandle.pInbufOps = NULL;
526 if (pOutbufOps != NULL) {
527 Exynos_OSAL_Free(pOutbufOps);
528 pWmvDec->hMFCWmvHandle.pOutbufOps = NULL;
537 OMX_ERRORTYPE WmvCodecClose(EXYNOS_WMVDEC_HANDLE *pWmvDec)
539 OMX_ERRORTYPE ret = OMX_ErrorNone;
540 void *hMFCHandle = NULL;
541 ExynosVideoDecOps *pDecOps = NULL;
542 ExynosVideoDecBufferOps *pInbufOps = NULL;
543 ExynosVideoDecBufferOps *pOutbufOps = NULL;
547 if (pWmvDec == NULL) {
548 ret = OMX_ErrorBadParameter;
552 hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
553 pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
554 pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
555 pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
557 if (hMFCHandle != NULL) {
558 pDecOps->Finalize(hMFCHandle);
559 pWmvDec->hMFCWmvHandle.hMFCHandle = NULL;
561 if (pOutbufOps != NULL) {
562 Exynos_OSAL_Free(pOutbufOps);
563 pWmvDec->hMFCWmvHandle.pOutbufOps = NULL;
565 if (pInbufOps != NULL) {
566 Exynos_OSAL_Free(pInbufOps);
567 pWmvDec->hMFCWmvHandle.pInbufOps = NULL;
569 if (pDecOps != NULL) {
570 Exynos_OSAL_Free(pDecOps);
571 pWmvDec->hMFCWmvHandle.pDecOps = NULL;
582 OMX_ERRORTYPE WmvCodecStart(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
584 OMX_ERRORTYPE ret = OMX_ErrorNone;
585 void *hMFCHandle = NULL;
586 ExynosVideoDecBufferOps *pInbufOps = NULL;
587 ExynosVideoDecBufferOps *pOutbufOps = NULL;
588 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
589 EXYNOS_WMVDEC_HANDLE *pWmvDec = NULL;
593 if (pOMXComponent == NULL) {
594 ret = OMX_ErrorBadParameter;
598 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
599 if (pVideoDec == NULL) {
600 ret = OMX_ErrorBadParameter;
604 pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
605 if (pWmvDec == NULL) {
606 ret = OMX_ErrorBadParameter;
610 hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
611 pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
612 pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
614 if (nPortIndex == INPUT_PORT_INDEX)
615 pInbufOps->Run(hMFCHandle);
616 else if (nPortIndex == OUTPUT_PORT_INDEX)
617 pOutbufOps->Run(hMFCHandle);
627 OMX_ERRORTYPE WmvCodecStop(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
629 OMX_ERRORTYPE ret = OMX_ErrorNone;
630 void *hMFCHandle = NULL;
631 ExynosVideoDecBufferOps *pInbufOps = NULL;
632 ExynosVideoDecBufferOps *pOutbufOps = NULL;
633 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
634 EXYNOS_WMVDEC_HANDLE *pWmvDec = NULL;
638 if (pOMXComponent == NULL) {
639 ret = OMX_ErrorBadParameter;
643 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
644 if (pVideoDec == NULL) {
645 ret = OMX_ErrorBadParameter;
648 pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
649 if (pWmvDec == NULL) {
650 ret = OMX_ErrorBadParameter;
654 hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
655 pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
656 pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
658 if ((nPortIndex == INPUT_PORT_INDEX) && (pInbufOps != NULL))
659 pInbufOps->Stop(hMFCHandle);
660 else if ((nPortIndex == OUTPUT_PORT_INDEX) && (pOutbufOps != NULL))
661 pOutbufOps->Stop(hMFCHandle);
672 OMX_ERRORTYPE WmvCodecSrcInit(OMX_COMPONENTTYPE *pOMXComponent)
674 OMX_ERRORTYPE ret = OMX_ErrorNone;
675 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
676 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
677 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
678 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
679 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
681 ExynosVideoDecOps *pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
682 ExynosVideoDecBufferOps *pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
683 ExynosVideoGeometry bufferConf;
684 OMX_U32 inputBufferNumber = 0;
689 if (pVideoDec->bThumbnailMode == OMX_TRUE)
690 pDecOps->Set_DisplayDelay(hMFCHandle, 0);
692 /* input buffer info */
693 Exynos_OSAL_Memset(&bufferConf, 0, sizeof(bufferConf));
694 if (pWmvDec->hMFCWmvHandle.wmvFormat == WMV_FORMAT_WMV3) {
695 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "VIDEO_CODING_VC1_RCV");
696 bufferConf.eCompressionFormat = VIDEO_CODING_VC1_RCV;
697 } else if (pWmvDec->hMFCWmvHandle.wmvFormat == WMV_FORMAT_VC1) {
698 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "VIDEO_CODING_VC1");
699 bufferConf.eCompressionFormat = VIDEO_CODING_VC1;
701 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Unsupported WMV Codec Format Type");
702 ret = OMX_ErrorUndefined;
706 if (pExynosInputPort->bufferProcessType & BUFFER_SHARE
707 ||pWmvDec->hMFCWmvHandle.bShareableBuf == OMX_TRUE)
708 pInbufOps->Set_Shareable(hMFCHandle);
710 if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
711 bufferConf.nSizeImage = pExynosInputPort->portDefinition.format.video.nFrameWidth
712 * pExynosInputPort->portDefinition.format.video.nFrameHeight * 3 / 2;
713 inputBufferNumber = MAX_VIDEO_INPUTBUFFER_NUM;
714 } else if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
715 bufferConf.nSizeImage = DEFAULT_MFC_INPUT_BUFFER_SIZE;
716 inputBufferNumber = MFC_INPUT_BUFFER_NUM_MAX;
719 /* should be done before prepare input buffer */
720 if (pInbufOps->Enable_Cacheable(hMFCHandle) != VIDEO_ERROR_NONE) {
721 ret = OMX_ErrorInsufficientResources;
725 /* set input buffer geometry */
726 if (pInbufOps->Set_Geometry(hMFCHandle, &bufferConf) != VIDEO_ERROR_NONE) {
727 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to set geometry for input buffer");
728 ret = OMX_ErrorInsufficientResources;
732 /* setup input buffer */
733 if (pInbufOps->Setup(hMFCHandle, inputBufferNumber) != VIDEO_ERROR_NONE) {
734 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to setup input buffer");
735 ret = OMX_ErrorInsufficientResources;
739 if ((pExynosInputPort->bufferProcessType & BUFFER_COPY) &&
740 pWmvDec->hMFCWmvHandle.bShareableBuf == OMX_TRUE) {
741 /* Register input buffer */
742 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
743 ExynosVideoPlane plane;
744 plane.addr = pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[0];
745 plane.allocSize = pVideoDec->pMFCDecInputBuffer[i]->bufferSize[0];
746 plane.fd = pVideoDec->pMFCDecInputBuffer[i]->fd[0];
747 if (pInbufOps->Register(hMFCHandle, &plane, MFC_INPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
748 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register input buffer");
749 ret = OMX_ErrorInsufficientResources;
753 } else if ((pExynosInputPort->bufferProcessType & BUFFER_COPY) &&
754 pWmvDec->hMFCWmvHandle.bShareableBuf == OMX_FALSE) {
755 ExynosVideoBuffer *pBuffer = NULL;
757 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
758 pVideoDec->pMFCDecInputBuffer[i] = Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
759 Exynos_OSAL_Memset(pVideoDec->pMFCDecInputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
760 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "@pVideoDec->pMFCDecInputBuffer[%d]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]);
761 /* get input buffer info */
762 if (pInbufOps->Get_Buffer) {
763 if (pInbufOps->Get_Buffer(pWmvDec->hMFCWmvHandle.hMFCHandle, i, &pBuffer) != VIDEO_ERROR_NONE) {
764 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get input buffer info");
765 ret = OMX_ErrorInsufficientResources;
770 for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
771 /* Use ION Allocator */
772 pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] = (void *)pBuffer->planes[plane].addr;
773 pVideoDec->pMFCDecInputBuffer[i]->fd[plane] = pBuffer->planes[plane].fd;
774 pVideoDec->pMFCDecInputBuffer[i]->bufferSize[plane] = pBuffer->planes[plane].allocSize;
775 pVideoDec->pMFCDecInputBuffer[i]->dataSize = 0;
776 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "@pVideoDec->pMFCDecInputBuffer[%d]->pVirAddr[%d]: 0x%x", i, plane, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
779 Exynos_CodecBufferEnQueue(pExynosComponent, INPUT_PORT_INDEX, pVideoDec->pMFCDecInputBuffer[i]);
781 } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
782 /* Register input buffer */
783 for (i = 0; i < pExynosInputPort->portDefinition.nBufferCountActual; i++) {
784 ExynosVideoPlane plane;
785 plane.addr = pExynosInputPort->extendBufferHeader[i].OMXBufferHeader->pBuffer;
786 plane.allocSize = pExynosInputPort->extendBufferHeader[i].OMXBufferHeader->nAllocLen;
787 plane.fd = pExynosInputPort->extendBufferHeader[i].buf_fd[0];
788 if (pInbufOps->Register(hMFCHandle, &plane, MFC_INPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
789 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register input buffer");
790 ret = OMX_ErrorInsufficientResources;
802 OMX_ERRORTYPE WmvCodecOutputBufferProcessRun(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
804 OMX_ERRORTYPE ret = OMX_ErrorNone;
805 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
806 EXYNOS_WMVDEC_HANDLE *pWmvDec = NULL;
810 if (pOMXComponent == NULL) {
811 ret = OMX_ErrorBadParameter;
815 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
816 if (pVideoDec == NULL) {
817 ret = OMX_ErrorBadParameter;
820 pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
821 if (pWmvDec == NULL) {
822 ret = OMX_ErrorBadParameter;
826 if (nPortIndex == INPUT_PORT_INDEX) {
827 if (pWmvDec->bSourceStart == OMX_FALSE) {
828 Exynos_OSAL_SignalSet(pWmvDec->hSourceStartEvent);
829 Exynos_OSAL_SleepMillisec(0);
833 if (nPortIndex == OUTPUT_PORT_INDEX) {
834 if (pWmvDec->bDestinationStart == OMX_FALSE) {
835 Exynos_OSAL_SignalSet(pWmvDec->hDestinationStartEvent);
836 Exynos_OSAL_SleepMillisec(0);
848 OMX_ERRORTYPE WmvCodecEnQueueAllBuffer(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
850 OMX_ERRORTYPE ret = OMX_ErrorNone;
851 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
852 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
853 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
854 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
857 ExynosVideoDecOps *pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
858 ExynosVideoDecBufferOps *pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
859 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
863 if ((nPortIndex != INPUT_PORT_INDEX) && (nPortIndex != OUTPUT_PORT_INDEX)) {
864 ret = OMX_ErrorBadPortIndex;
868 if ((nPortIndex == INPUT_PORT_INDEX) &&
869 (pWmvDec->bSourceStart == OMX_TRUE)) {
870 Exynos_CodecBufferReset(pExynosComponent, INPUT_PORT_INDEX);
872 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
873 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]);
874 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]->pVirAddr[0]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[0]);
876 Exynos_CodecBufferEnQueue(pExynosComponent, INPUT_PORT_INDEX, pVideoDec->pMFCDecInputBuffer[i]);
879 pInbufOps->Clear_Queue(hMFCHandle);
880 } else if ((nPortIndex == OUTPUT_PORT_INDEX) &&
881 (pWmvDec->bDestinationStart == OMX_TRUE)) {
882 ExynosVideoBuffer *pBuffer = NULL;
884 Exynos_CodecBufferReset(pExynosComponent, OUTPUT_PORT_INDEX);
886 nOutbufs = pDecOps->Get_ActualBufferCount(hMFCHandle);
887 nOutbufs += EXTRA_DPB_NUM;
888 for (i = 0; i < nOutbufs; i++) {
889 pOutbufOps->Get_Buffer(hMFCHandle, i, &pBuffer);
890 Exynos_CodecBufferEnQueue(pExynosComponent, OUTPUT_PORT_INDEX, (OMX_PTR)pBuffer);
892 pOutbufOps->Clear_Queue(hMFCHandle);
901 OMX_ERRORTYPE WmvCodecDstFreeCodecBuffers(
902 OMX_COMPONENTTYPE *pOMXComponent)
904 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
905 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
906 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
912 for (i = 0; i < MFC_OUTPUT_BUFFER_NUM_MAX; i++) {
913 if (pVideoDec->pMFCDecOutputBuffer[i] != NULL) {
914 for (j = 0; j < MFC_OUTPUT_BUFFER_PLANE; j++) {
915 if (pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j] != NULL &&
916 pWmvDec->hMFCWmvHandle.bShareableBuf == OMX_TRUE)
917 Exynos_OSAL_SharedMemory_Free(pVideoDec->hSharedMemory, pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j]);
920 Exynos_OSAL_Free(pVideoDec->pMFCDecOutputBuffer[i]);
924 Exynos_OSAL_Memset(pVideoDec->pMFCDecOutputBuffer, 0, sizeof(pVideoDec->pMFCDecOutputBuffer));
928 return OMX_ErrorNone;
931 OMX_ERRORTYPE WmvCodecDstAllocCodecBuffers(
932 OMX_COMPONENTTYPE *pOMXComponent,
935 OMX_ERRORTYPE ret = OMX_ErrorNone;
936 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
937 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
938 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
940 MEMORY_TYPE eMemoryType = NORMAL_MEMORY;
941 OMX_U32 nAllocLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
946 nAllocLen[0] = calc_yplane(pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth,
947 pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight);
948 nAllocLen[1] = calc_uvplane(pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth,
949 pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight >> 1);
951 for (i = 0; i < nOutbufs; i++) {
952 pVideoDec->pMFCDecOutputBuffer[i] = (CODEC_DEC_BUFFER *)Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
953 if (pVideoDec->pMFCDecOutputBuffer[i] == NULL) {
954 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Alloc codec buffer");
955 ret = OMX_ErrorInsufficientResources;
958 Exynos_OSAL_Memset(pVideoDec->pMFCDecOutputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
960 for (j = 0; j < MFC_OUTPUT_BUFFER_PLANE; j++) {
961 pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j] =
962 (void *)Exynos_OSAL_SharedMemory_Alloc(pVideoDec->hSharedMemory, nAllocLen[j], eMemoryType);
963 if (pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j] == NULL) {
964 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Alloc output buffer");
965 ret = OMX_ErrorInsufficientResources;
969 pVideoDec->pMFCDecOutputBuffer[i]->fd[j] =
970 Exynos_OSAL_SharedMemory_VirtToION(pVideoDec->hSharedMemory,
971 pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j]);
972 pVideoDec->pMFCDecOutputBuffer[i]->bufferSize[j] = nAllocLen[j];
976 return OMX_ErrorNone;
979 WmvCodecDstFreeCodecBuffers(pOMXComponent);
986 OMX_ERRORTYPE WmvCodecDstRegistCodecBuffers(
987 OMX_COMPONENTTYPE *pOMXComponent,
990 OMX_ERRORTYPE ret = OMX_ErrorNone;
991 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
992 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
993 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
994 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
995 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
997 ExynosVideoPlane planes[MFC_OUTPUT_BUFFER_PLANE];
998 OMX_U32 nDataLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
1003 /* Register output buffer */
1004 for (i = 0; i < nOutbufs; i++) {
1005 for (j = 0; j < MFC_OUTPUT_BUFFER_PLANE; j++) {
1006 planes[j].addr = pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j];
1007 planes[j].fd = pVideoDec->pMFCDecOutputBuffer[i]->fd[j];
1008 planes[j].allocSize = pVideoDec->pMFCDecOutputBuffer[i]->bufferSize[j];
1011 if (pOutbufOps->Register(hMFCHandle, planes, MFC_OUTPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
1012 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register output buffer");
1013 ret = OMX_ErrorInsufficientResources;
1017 pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr,
1018 (unsigned int *)nDataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
1021 ret = OMX_ErrorNone;
1029 OMX_ERRORTYPE WmvCodecResetupAllElement(
1030 OMX_COMPONENTTYPE *pOMXComponent,
1033 OMX_ERRORTYPE ret = OMX_ErrorNone;
1034 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1035 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1036 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
1037 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
1038 EXYNOS_OMX_BASEPORT *pOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1039 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
1043 if ((nPortIndex == INPUT_PORT_INDEX) &&
1044 (pWmvDec->bSourceStart == OMX_TRUE)) {
1045 ret = OMX_ErrorNotImplemented;
1047 } else if ((nPortIndex == OUTPUT_PORT_INDEX) &&
1048 (pWmvDec->bDestinationStart == OMX_TRUE)) {
1049 if (pOutputPort->bufferProcessType & BUFFER_COPY) {
1051 /**********************************/
1052 /* Codec Buffer Free & Unregister */
1053 /**********************************/
1054 WmvCodecDstFreeCodecBuffers(pOMXComponent);
1055 Exynos_CodecBufferReset(pExynosComponent, OUTPUT_PORT_INDEX);
1057 if (pWmvDec->hMFCWmvHandle.bShareableBuf == OMX_TRUE)
1058 pOutbufOps->Clear_RegisteredBuffer(hMFCHandle);
1060 pOutbufOps->Cleanup(hMFCHandle);
1061 /******************************************************/
1062 /* V4L2 Destnation Setup for DPB Buffer Number Change */
1063 /******************************************************/
1064 WmvCodecDstSetup(pOMXComponent);
1066 pVideoDec->bDRCProcessing = OMX_FALSE;
1067 } else if (pOutputPort->bufferProcessType & BUFFER_SHARE) {
1069 /**********************************/
1070 /* Codec Buffer Unregister */
1071 /**********************************/
1072 pOutbufOps->Clear_RegisteredBuffer(hMFCHandle);
1073 pOutbufOps->Cleanup(hMFCHandle);
1076 ret = OMX_ErrorBadParameter;
1086 OMX_ERRORTYPE WmvCodecSrcSetup(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
1088 OMX_ERRORTYPE ret = OMX_ErrorNone;
1089 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1090 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1091 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
1092 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1093 OMX_U32 oneFrameSize = pSrcInputData->dataLen;
1094 OMX_BOOL bMetaData = OMX_FALSE;
1096 ExynosVideoDecOps *pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
1097 ExynosVideoDecBufferOps *pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
1098 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
1099 ExynosVideoGeometry bufferConf;
1103 if ((oneFrameSize <= 0) && (pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
1104 OMX_BUFFERHEADERTYPE *OMXBuffer = NULL;
1105 OMXBuffer = Exynos_OutputBufferGetQueue_Direct(pExynosComponent);
1106 if (OMXBuffer == NULL) {
1107 ret = OMX_ErrorUndefined;
1111 OMXBuffer->nTimeStamp = pSrcInputData->timeStamp;
1112 OMXBuffer->nFlags = pSrcInputData->nFlags;
1113 Exynos_OMX_OutputBufferReturn(pOMXComponent, OMXBuffer);
1115 ret = OMX_ErrorNone;
1119 if (!((pExynosInputPort->bufferProcessType & BUFFER_COPY) &&
1120 pWmvDec->hMFCWmvHandle.bShareableBuf == OMX_FALSE)) {
1121 if (pSrcInputData->nFlags & OMX_BUFFERFLAG_CODECCONFIG) {
1122 BitmapInfoHhr *pBitmapInfoHeader;
1123 pBitmapInfoHeader = (BitmapInfoHhr *)pSrcInputData->buffer.singlePlaneBuffer.dataBuffer;
1124 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "OMX_BUFFERFLAG_CODECCONFIG");
1125 if (pBitmapInfoHeader->BiCompression == wmv3) {
1126 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "WMV_FORMAT_WMV3");
1127 pWmvDec->hMFCWmvHandle.wmvFormat = WMV_FORMAT_WMV3;
1128 } else if ((pBitmapInfoHeader->BiCompression == wvc1) || (pBitmapInfoHeader->BiCompression == wmva)) {
1129 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "WMV_FORMAT_VC1");
1130 pWmvDec->hMFCWmvHandle.wmvFormat = WMV_FORMAT_VC1;
1134 ret = WmvCodecSrcInit(pOMXComponent);
1135 if (ret != OMX_ErrorNone)
1139 /* set output geometry */
1140 Exynos_OSAL_Memset(&bufferConf, 0, sizeof(bufferConf));
1141 pWmvDec->hMFCWmvHandle.MFCOutputColorType = bufferConf.eColorFormat = VIDEO_COLORFORMAT_NV12_TILED;
1142 if (pOutbufOps->Set_Geometry(hMFCHandle, &bufferConf) != VIDEO_ERROR_NONE) {
1143 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to set geometry for output buffer");
1144 ret = OMX_ErrorInsufficientResources;
1148 bMetaData = Make_Stream_MetaData(pSrcInputData->buffer.singlePlaneBuffer.dataBuffer, &oneFrameSize, pWmvDec->hMFCWmvHandle.wmvFormat
1149 #ifdef TIZEN_FEATURE_E3250
1150 , pExynosComponent->pExynosPort[INPUT_PORT_INDEX].portDefinition.format.video.nFrameWidth
1151 , pExynosComponent->pExynosPort[INPUT_PORT_INDEX].portDefinition.format.video.nFrameHeight
1154 if (bMetaData == OMX_FALSE) {
1155 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Fail to Make Stream MetaData");
1156 ret = OMX_ErrorInsufficientResources;
1160 /* input buffer enqueue for header parsing */
1161 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "oneFrameSize: %d", oneFrameSize);
1162 if (pInbufOps->Enqueue(hMFCHandle, (unsigned char **)&pSrcInputData->buffer.singlePlaneBuffer.dataBuffer,
1163 (unsigned int *)&oneFrameSize, MFC_INPUT_BUFFER_PLANE, pSrcInputData->bufferHeader) != VIDEO_ERROR_NONE) {
1164 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to enqueue input buffer for header parsing");
1165 // ret = OMX_ErrorInsufficientResources;
1166 ret = (OMX_ERRORTYPE)OMX_ErrorCodecInit;
1170 /* start header parsing */
1171 if (pInbufOps->Run(hMFCHandle) != VIDEO_ERROR_NONE) {
1172 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to run input buffer for header parsing");
1173 ret = OMX_ErrorCodecInit;
1177 ret = WmvCodecCheckResolutionChange(pOMXComponent);
1178 if (ret != OMX_ErrorNone) {
1179 ret = OMX_ErrorCodecInit;
1183 Exynos_OSAL_SleepMillisec(0);
1184 ret = OMX_ErrorInputDataDecodeYet;
1186 #ifdef USE_IMMEDIATE_DISPLAY
1187 /* Set Immediately display for I Frame*/
1188 pDecOps->Set_ImmediateDisplay(hMFCHandle);
1191 WmvCodecStop(pOMXComponent, INPUT_PORT_INDEX);
1197 OMX_ERRORTYPE WmvCodecDstSetup(OMX_COMPONENTTYPE *pOMXComponent)
1199 OMX_ERRORTYPE ret = OMX_ErrorNone;
1200 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1201 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1202 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1203 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
1204 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1206 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
1213 nOutbufs = pWmvDec->hMFCWmvHandle.maxDPBNum;
1215 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1216 /* should be done before prepare output buffer */
1217 if (pOutbufOps->Enable_Cacheable(hMFCHandle) != VIDEO_ERROR_NONE) {
1218 ret = OMX_ErrorInsufficientResources;
1223 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE
1224 ||pWmvDec->hMFCWmvHandle.bShareableBuf == OMX_TRUE)
1225 pOutbufOps->Set_Shareable(hMFCHandle);
1227 if (pOutbufOps->Setup(hMFCHandle, nOutbufs) != VIDEO_ERROR_NONE) {
1228 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to setup output buffer");
1229 ret = OMX_ErrorInsufficientResources;
1233 ExynosVideoPlane planes[MFC_OUTPUT_BUFFER_PLANE];
1234 OMX_U32 nAllocLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
1235 OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
1238 nAllocLen[0] = calc_yplane(pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth,
1239 pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight);
1240 nAllocLen[1] = calc_uvplane(pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth,
1241 pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight >> 1);
1243 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY &&
1244 pWmvDec->hMFCWmvHandle.bShareableBuf == OMX_TRUE) {
1245 WmvCodecDstAllocCodecBuffers(pOMXComponent, nOutbufs);
1246 WmvCodecDstRegistCodecBuffers(pOMXComponent, nOutbufs);
1247 } else if (pExynosOutputPort->bufferProcessType & BUFFER_COPY &&
1248 pWmvDec->hMFCWmvHandle.bShareableBuf == OMX_FALSE) {
1249 /* Register output buffer */
1250 for (i = 0; i < nOutbufs; i++) {
1252 OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
1253 ExynosVideoBuffer *pBuffer = NULL;
1254 pVideoDec->pMFCDecOutputBuffer[i] = (CODEC_DEC_BUFFER *)Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
1255 Exynos_OSAL_Memset(pVideoDec->pMFCDecOutputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
1257 if (pOutbufOps->Get_Buffer) {
1258 if (pOutbufOps->Get_Buffer(pWmvDec->hMFCWmvHandle.hMFCHandle, i, &pBuffer) != VIDEO_ERROR_NONE) {
1259 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get Output buffer info");
1260 ret = OMX_ErrorInsufficientResources;
1265 for (plane = 0; plane < MFC_OUTPUT_BUFFER_PLANE; plane++) {
1266 pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[plane] = (void *)pBuffer->planes[plane].addr;
1267 pVideoDec->pMFCDecOutputBuffer[i]->fd[plane] = pBuffer->planes[plane].fd;
1268 pVideoDec->pMFCDecOutputBuffer[i]->bufferSize[plane] = pBuffer->planes[plane].allocSize;
1271 pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr,
1272 (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
1275 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1277 if (pExynosOutputPort->bIsPBEnabled == OMX_TRUE) {
1278 for (i = 0; i < pExynosOutputPort->assignedBufferNum; i++) {
1279 for (plane = 0; plane < MFC_OUTPUT_BUFFER_PLANE; plane++) {
1280 planes[plane].fd = pExynosOutputPort->extendBufferHeader[i].buf_fd[plane];
1281 planes[plane].addr = pExynosOutputPort->extendBufferHeader[i].pYUVBuf[plane];
1282 planes[plane].allocSize = nAllocLen[plane];
1285 if (pOutbufOps->Register(hMFCHandle, planes, MFC_OUTPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
1286 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register output buffer");
1287 ret = OMX_ErrorInsufficientResources;
1290 pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pExynosOutputPort->extendBufferHeader[i].pYUVBuf,
1291 (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
1294 ret = OMX_ErrorNotImplemented;
1298 ret = OMX_ErrorNotImplemented;
1303 if (pOutbufOps->Run(hMFCHandle) != VIDEO_ERROR_NONE) {
1304 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to run output buffer");
1305 ret = OMX_ErrorInsufficientResources;
1309 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1310 WmvCodecStop (pOMXComponent, OUTPUT_PORT_INDEX);
1312 pWmvDec->hMFCWmvHandle.bConfiguredMFCDst = OMX_TRUE;
1314 ret = OMX_ErrorNone;
1322 OMX_ERRORTYPE WmvCodecCheckResolutionChange(OMX_COMPONENTTYPE *pOMXComponent)
1324 OMX_ERRORTYPE ret = OMX_ErrorNone;
1325 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1326 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1327 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1328 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
1329 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1330 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1332 ExynosVideoDecOps *pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
1333 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
1337 /* get geometry for output */
1338 Exynos_OSAL_Memset(&pWmvDec->hMFCWmvHandle.codecOutbufConf, 0, sizeof(ExynosVideoGeometry));
1339 if (pOutbufOps->Get_Geometry(hMFCHandle, &pWmvDec->hMFCWmvHandle.codecOutbufConf) != VIDEO_ERROR_NONE) {
1340 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get geometry for parsed header info");
1341 ret = OMX_ErrorInsufficientResources;
1346 pWmvDec->hMFCWmvHandle.maxDPBNum = pDecOps->Get_ActualBufferCount(hMFCHandle);
1347 if (pVideoDec->bThumbnailMode == OMX_FALSE)
1348 pWmvDec->hMFCWmvHandle.maxDPBNum += EXTRA_DPB_NUM;
1349 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "WmvCodecCheckResolutionChange WmvCodecSetup nOutbufs: %d", pWmvDec->hMFCWmvHandle.maxDPBNum);
1351 pWmvDec->hMFCWmvHandle.bConfiguredMFCSrc = OMX_TRUE;
1353 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1354 if ((pVideoDec->bDRCProcessing) ||
1355 (pExynosInputPort->portDefinition.format.video.nFrameWidth != pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth) ||
1356 (pExynosInputPort->portDefinition.format.video.nFrameHeight != pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight)) {
1357 pExynosInputPort->portDefinition.format.video.nFrameWidth = pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth;
1358 pExynosInputPort->portDefinition.format.video.nFrameHeight = pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight;
1359 pExynosInputPort->portDefinition.format.video.nStride = ((pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth + 15) & (~15));
1360 pExynosInputPort->portDefinition.format.video.nSliceHeight = ((pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight + 15) & (~15));
1362 if (pVideoDec->bDRCProcessing == OMX_TRUE) {
1363 pVideoDec->nDRCSavedBufferCount = pExynosOutputPort->portDefinition.nBufferCountActual;
1365 Exynos_UpdateFrameSize(pOMXComponent);
1366 pExynosOutputPort->exceptionFlag = NEED_PORT_DISABLE;
1368 /** Send Port Settings changed call back **/
1369 (*(pExynosComponent->pCallbacks->EventHandler))
1371 pExynosComponent->callbackData,
1372 OMX_EventPortSettingsChanged, /* The command was completed */
1373 OMX_DirOutput, /* This is the port index */
1377 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1378 if ((pExynosInputPort->portDefinition.format.video.nFrameWidth != pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth) ||
1379 (pExynosInputPort->portDefinition.format.video.nFrameHeight != pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight) ||
1380 (pExynosOutputPort->portDefinition.nBufferCountActual != pWmvDec->hMFCWmvHandle.maxDPBNum)) {
1381 pExynosInputPort->portDefinition.format.video.nFrameWidth = pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth;
1382 pExynosInputPort->portDefinition.format.video.nFrameHeight = pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight;
1383 pExynosInputPort->portDefinition.format.video.nStride = ((pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth + 15) & (~15));
1384 pExynosInputPort->portDefinition.format.video.nSliceHeight = ((pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight + 15) & (~15));
1386 if (pVideoDec->bDRCProcessing == OMX_TRUE) {
1387 pVideoDec->nDRCSavedBufferCount = pExynosOutputPort->portDefinition.nBufferCountActual;
1389 #ifdef TIZEN_FEATURE_E3250
1390 pExynosOutputPort->portDefinition.nBufferCountActual = pWmvDec->hMFCWmvHandle.maxDPBNum;
1391 pExynosOutputPort->portDefinition.nBufferCountMin = pWmvDec->hMFCWmvHandle.maxDPBNum;
1393 pExynosOutputPort->portDefinition.nBufferCountActual = pWmvDec->hMFCWmvHandle.maxDPBNum - 4;
1394 pExynosOutputPort->portDefinition.nBufferCountMin = pWmvDec->hMFCWmvHandle.maxDPBNum - 4;
1396 Exynos_UpdateFrameSize(pOMXComponent);
1397 pExynosOutputPort->exceptionFlag = NEED_PORT_DISABLE;
1399 /** Send Port Settings changed call back **/
1400 (*(pExynosComponent->pCallbacks->EventHandler))
1402 pExynosComponent->callbackData,
1403 OMX_EventPortSettingsChanged, /* The command was completed */
1404 OMX_DirOutput, /* This is the port index */
1410 ret = OMX_ErrorNone;
1418 OMX_ERRORTYPE Exynos_WmvDec_GetParameter(
1419 OMX_IN OMX_HANDLETYPE hComponent,
1420 OMX_IN OMX_INDEXTYPE nParamIndex,
1421 OMX_INOUT OMX_PTR pComponentParameterStructure)
1423 OMX_ERRORTYPE ret = OMX_ErrorNone;
1424 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1425 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1429 if (hComponent == NULL || pComponentParameterStructure == NULL) {
1430 ret = OMX_ErrorBadParameter;
1433 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1434 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1435 if (ret != OMX_ErrorNone) {
1438 if (pOMXComponent->pComponentPrivate == NULL) {
1439 ret = OMX_ErrorBadParameter;
1443 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1444 if (pExynosComponent->currentState == OMX_StateInvalid ) {
1445 ret = OMX_ErrorInvalidState;
1449 switch (nParamIndex) {
1450 case OMX_IndexParamVideoWmv:
1452 OMX_VIDEO_PARAM_WMVTYPE *pDstWmvParam = (OMX_VIDEO_PARAM_WMVTYPE *)pComponentParameterStructure;
1453 OMX_VIDEO_PARAM_WMVTYPE *pSrcWmvParam = NULL;
1454 EXYNOS_WMVDEC_HANDLE *pWmvDec = NULL;
1455 ret = Exynos_OMX_Check_SizeVersion(pDstWmvParam, sizeof(OMX_VIDEO_PARAM_WMVTYPE));
1456 if (ret != OMX_ErrorNone) {
1460 if (pDstWmvParam->nPortIndex > OUTPUT_PORT_INDEX) {
1461 ret = OMX_ErrorBadPortIndex;
1464 pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1465 pSrcWmvParam = &pWmvDec->WmvComponent[pDstWmvParam->nPortIndex];
1467 Exynos_OSAL_Memcpy(pDstWmvParam, pSrcWmvParam, sizeof(OMX_VIDEO_PARAM_WMVTYPE));
1471 case OMX_IndexParamStandardComponentRole:
1473 OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE *)pComponentParameterStructure;
1474 ret = Exynos_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1475 if (ret != OMX_ErrorNone) {
1479 Exynos_OSAL_Strcpy((char *)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_WMV_DEC_ROLE);
1482 case OMX_IndexParamVideoErrorCorrection:
1484 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
1485 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = NULL;
1486 EXYNOS_WMVDEC_HANDLE *pWmvDec = NULL;
1488 ret = Exynos_OMX_Check_SizeVersion(pDstErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
1489 if (ret != OMX_ErrorNone) {
1493 if (pDstErrorCorrectionType->nPortIndex != INPUT_PORT_INDEX) {
1494 ret = OMX_ErrorBadPortIndex;
1498 pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1499 pSrcErrorCorrectionType = &pWmvDec->errorCorrectionType[INPUT_PORT_INDEX];
1501 pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
1502 pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
1503 pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
1504 pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
1505 pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
1509 ret = Exynos_OMX_VideoDecodeGetParameter(hComponent, nParamIndex, pComponentParameterStructure);
1518 OMX_ERRORTYPE Exynos_WmvDec_SetParameter(
1519 OMX_IN OMX_HANDLETYPE hComponent,
1520 OMX_IN OMX_INDEXTYPE nIndex,
1521 OMX_IN OMX_PTR pComponentParameterStructure)
1523 OMX_ERRORTYPE ret = OMX_ErrorNone;
1524 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1525 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1529 if (hComponent == NULL || pComponentParameterStructure == NULL) {
1530 ret = OMX_ErrorBadParameter;
1533 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1534 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1535 if (ret != OMX_ErrorNone) {
1538 if (pOMXComponent->pComponentPrivate == NULL) {
1539 ret = OMX_ErrorBadParameter;
1543 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1544 if (pExynosComponent->currentState == OMX_StateInvalid ) {
1545 ret = OMX_ErrorInvalidState;
1550 case OMX_IndexParamVideoWmv:
1552 OMX_VIDEO_PARAM_WMVTYPE *pDstWmvParam = NULL;
1553 OMX_VIDEO_PARAM_WMVTYPE *pSrcWmvParam = (OMX_VIDEO_PARAM_WMVTYPE *)pComponentParameterStructure;
1554 EXYNOS_WMVDEC_HANDLE *pWmvDec = NULL;
1555 ret = Exynos_OMX_Check_SizeVersion(pSrcWmvParam, sizeof(OMX_VIDEO_PARAM_WMVTYPE));
1556 if (ret != OMX_ErrorNone) {
1560 if (pSrcWmvParam->nPortIndex > OUTPUT_PORT_INDEX) {
1561 ret = OMX_ErrorBadPortIndex;
1565 pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1566 pDstWmvParam = &pWmvDec->WmvComponent[pSrcWmvParam->nPortIndex];
1568 Exynos_OSAL_Memcpy(pDstWmvParam, pSrcWmvParam, sizeof(OMX_VIDEO_PARAM_WMVTYPE));
1571 case OMX_IndexParamStandardComponentRole:
1573 OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE*)pComponentParameterStructure;
1575 ret = Exynos_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1576 if (ret != OMX_ErrorNone) {
1580 if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1581 ret = OMX_ErrorIncorrectStateOperation;
1585 if (!Exynos_OSAL_Strcmp((char*)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_WMV_DEC_ROLE)) {
1586 pExynosComponent->pExynosPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingWMV;
1588 ret = OMX_ErrorBadParameter;
1593 case OMX_IndexParamPortDefinition:
1595 OMX_PARAM_PORTDEFINITIONTYPE *pPortDefinition = (OMX_PARAM_PORTDEFINITIONTYPE *)pComponentParameterStructure;
1596 OMX_U32 portIndex = pPortDefinition->nPortIndex;
1597 EXYNOS_OMX_BASEPORT *pExynosPort;
1598 OMX_U32 width, height, size;
1599 OMX_U32 realWidth, realHeight;
1600 OMX_PARAM_PORTDEFINITIONTYPE portDefinition_backup;
1602 if (portIndex >= pExynosComponent->portParam.nPorts) {
1603 ret = OMX_ErrorBadPortIndex;
1606 ret = Exynos_OMX_Check_SizeVersion(pPortDefinition, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1607 if (ret != OMX_ErrorNone) {
1611 pExynosPort = &pExynosComponent->pExynosPort[portIndex];
1613 if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1614 if (pExynosPort->portDefinition.bEnabled == OMX_TRUE) {
1615 ret = OMX_ErrorIncorrectStateOperation;
1619 if (pPortDefinition->nBufferCountActual < pExynosPort->portDefinition.nBufferCountMin) {
1620 ret = OMX_ErrorBadParameter;
1624 Exynos_OSAL_Memcpy(&portDefinition_backup, &pExynosPort->portDefinition, pPortDefinition->nSize);
1625 Exynos_OSAL_Memcpy(&pExynosPort->portDefinition, pPortDefinition, pPortDefinition->nSize);
1626 RESTORE_READONLYPARAMETERS_OMX_PARAM_PORTDEFINITIONTYPE(&pExynosPort->portDefinition,&portDefinition_backup);
1628 realWidth = pExynosPort->portDefinition.format.video.nFrameWidth;
1629 realHeight = pExynosPort->portDefinition.format.video.nFrameHeight;
1630 width = ((realWidth + 15) & (~15));
1631 height = ((realHeight + 15) & (~15));
1632 size = (width * height * 3) / 2;
1633 pExynosPort->portDefinition.format.video.nStride = width;
1634 pExynosPort->portDefinition.format.video.nSliceHeight = height;
1635 pExynosPort->portDefinition.nBufferSize = (size > pExynosPort->portDefinition.nBufferSize) ? size : pExynosPort->portDefinition.nBufferSize;
1637 if (portIndex == INPUT_PORT_INDEX) {
1638 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1639 pExynosOutputPort->portDefinition.format.video.nFrameWidth = pExynosPort->portDefinition.format.video.nFrameWidth;
1640 pExynosOutputPort->portDefinition.format.video.nFrameHeight = pExynosPort->portDefinition.format.video.nFrameHeight;
1641 pExynosOutputPort->portDefinition.format.video.nStride = width;
1642 pExynosOutputPort->portDefinition.format.video.nSliceHeight = height;
1644 switch (pExynosOutputPort->portDefinition.format.video.eColorFormat) {
1645 case OMX_COLOR_FormatYUV420Planar:
1646 case OMX_COLOR_FormatYUV420SemiPlanar:
1647 pExynosOutputPort->portDefinition.nBufferSize = (width * height * 3) / 2;
1649 #ifdef TIZEN_FEATURE_E3250 /* NV12T fd */
1650 case OMX_SEC_COLOR_FormatNV12T_DmaBuf_Fd:
1651 pExynosOutputPort->portDefinition.nBufferSize = sizeof(MMVideoBuffer);
1654 case OMX_SEC_COLOR_FormatNV12Tiled:
1655 pExynosOutputPort->portDefinition.nBufferSize =
1656 calc_yplane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight) +
1657 calc_uvplane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight >> 1);
1660 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Color format is not support!! use default YUV size!!");
1661 ret = OMX_ErrorUnsupportedSetting;
1665 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1666 pExynosOutputPort->portDefinition.nBufferSize =
1667 calc_yplane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight) +
1668 calc_uvplane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight >> 1);
1673 case OMX_IndexParamVideoErrorCorrection:
1675 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
1676 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = NULL;
1677 EXYNOS_WMVDEC_HANDLE *pWmvDec = NULL;
1679 ret = Exynos_OMX_Check_SizeVersion(pSrcErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
1680 if (ret != OMX_ErrorNone) {
1684 if (pSrcErrorCorrectionType->nPortIndex != INPUT_PORT_INDEX) {
1685 ret = OMX_ErrorBadPortIndex;
1689 pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1690 pDstErrorCorrectionType = &pWmvDec->errorCorrectionType[INPUT_PORT_INDEX];
1692 pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
1693 pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
1694 pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
1695 pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
1696 pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
1700 ret = Exynos_OMX_VideoDecodeSetParameter(hComponent, nIndex, pComponentParameterStructure);
1709 OMX_ERRORTYPE Exynos_WmvDec_GetConfig(
1710 OMX_HANDLETYPE hComponent,
1711 OMX_INDEXTYPE nIndex,
1712 OMX_PTR pComponentConfigStructure)
1714 OMX_ERRORTYPE ret = OMX_ErrorNone;
1715 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1716 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1720 if (hComponent == NULL || pComponentConfigStructure == NULL) {
1721 ret = OMX_ErrorBadParameter;
1724 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1725 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1726 if (ret != OMX_ErrorNone) {
1729 if (pOMXComponent->pComponentPrivate == NULL) {
1730 ret = OMX_ErrorBadParameter;
1733 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1734 if (pExynosComponent->currentState == OMX_StateInvalid) {
1735 ret = OMX_ErrorInvalidState;
1741 ret = Exynos_OMX_VideoDecodeGetConfig(hComponent, nIndex, pComponentConfigStructure);
1751 OMX_ERRORTYPE Exynos_WmvDec_SetConfig(
1752 OMX_HANDLETYPE hComponent,
1753 OMX_INDEXTYPE nIndex,
1754 OMX_PTR pComponentConfigStructure)
1756 OMX_ERRORTYPE ret = OMX_ErrorNone;
1757 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1758 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1762 if (hComponent == NULL || pComponentConfigStructure == NULL) {
1763 ret = OMX_ErrorBadParameter;
1766 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1767 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1768 if (ret != OMX_ErrorNone) {
1771 if (pOMXComponent->pComponentPrivate == NULL) {
1772 ret = OMX_ErrorBadParameter;
1775 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1776 if (pExynosComponent->currentState == OMX_StateInvalid) {
1777 ret = OMX_ErrorInvalidState;
1783 ret = Exynos_OMX_VideoDecodeSetConfig(hComponent, nIndex, pComponentConfigStructure);
1793 OMX_ERRORTYPE Exynos_WmvDec_GetExtensionIndex(
1794 OMX_IN OMX_HANDLETYPE hComponent,
1795 OMX_IN OMX_STRING cParameterName,
1796 OMX_OUT OMX_INDEXTYPE *pIndexType)
1798 OMX_ERRORTYPE ret = OMX_ErrorNone;
1799 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1800 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1804 if (hComponent == NULL) {
1805 ret = OMX_ErrorBadParameter;
1808 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1809 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1810 if (ret != OMX_ErrorNone) {
1813 if (pOMXComponent->pComponentPrivate == NULL) {
1814 ret = OMX_ErrorBadParameter;
1817 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1818 if ((cParameterName == NULL) || (pIndexType == NULL)) {
1819 ret = OMX_ErrorBadParameter;
1822 if (pExynosComponent->currentState == OMX_StateInvalid) {
1823 ret = OMX_ErrorInvalidState;
1827 if (Exynos_OSAL_Strcmp(cParameterName, EXYNOS_INDEX_PARAM_ENABLE_THUMBNAIL) == 0) {
1828 *pIndexType = OMX_IndexVendorThumbnailMode;
1829 ret = OMX_ErrorNone;
1831 ret = Exynos_OMX_VideoDecodeGetExtensionIndex(hComponent, cParameterName, pIndexType);
1840 OMX_ERRORTYPE Exynos_WmvDec_ComponentRoleEnum(
1841 OMX_HANDLETYPE hComponent,
1845 OMX_ERRORTYPE ret = OMX_ErrorNone;
1849 if ((hComponent == NULL) || (cRole == NULL)) {
1850 ret = OMX_ErrorBadParameter;
1853 if (nIndex == (MAX_COMPONENT_ROLE_NUM-1)) {
1854 Exynos_OSAL_Strcpy((char *)cRole, EXYNOS_OMX_COMPONENT_WMV_DEC_ROLE);
1855 ret = OMX_ErrorNone;
1857 ret = OMX_ErrorNoMore;
1867 OMX_ERRORTYPE Exynos_WmvDec_Init(OMX_COMPONENTTYPE *pOMXComponent)
1869 OMX_ERRORTYPE ret = OMX_ErrorNone;
1870 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1871 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1872 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1873 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1874 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
1876 CSC_METHOD csc_method = CSC_METHOD_SW;
1881 pWmvDec->hMFCWmvHandle.bConfiguredMFCSrc = OMX_FALSE;
1882 pWmvDec->hMFCWmvHandle.bConfiguredMFCDst = OMX_FALSE;
1883 pExynosComponent->bUseFlagEOF = OMX_TRUE;
1884 pExynosComponent->bSaveFlagEOS = OMX_FALSE;
1886 /* WMV Codec Open */
1887 ret = WmvCodecOpen(pWmvDec);
1888 if (ret != OMX_ErrorNone) {
1892 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
1893 Exynos_OSAL_SemaphoreCreate(&pExynosInputPort->codecSemID);
1894 Exynos_OSAL_QueueCreate(&pExynosInputPort->codecBufferQ, MAX_QUEUE_ELEMENTS);
1896 if (pWmvDec->hMFCWmvHandle.bShareableBuf == OMX_TRUE) {
1897 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
1898 pVideoDec->pMFCDecInputBuffer[i] = Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
1899 Exynos_OSAL_Memset(pVideoDec->pMFCDecInputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
1900 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]);
1902 for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
1903 /* Use ION Allocator */
1904 pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] = (void *)Exynos_OSAL_SharedMemory_Alloc(pVideoDec->hSharedMemory, DEFAULT_MFC_INPUT_BUFFER_SIZE, NORMAL_MEMORY);
1905 pVideoDec->pMFCDecInputBuffer[i]->fd[plane] = Exynos_OSAL_SharedMemory_VirtToION(pVideoDec->hSharedMemory, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
1906 pVideoDec->pMFCDecInputBuffer[i]->bufferSize[plane] = DEFAULT_MFC_INPUT_BUFFER_SIZE;
1907 pVideoDec->pMFCDecInputBuffer[i]->dataSize = 0;
1908 if (pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] == NULL) {
1909 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Fail input buffer");
1910 ret = OMX_ErrorInsufficientResources;
1913 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]->pVirAddr[%d]: 0x%x", i, plane, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
1915 Exynos_CodecBufferEnQueue(pExynosComponent, INPUT_PORT_INDEX, pVideoDec->pMFCDecInputBuffer[i]);
1921 /* Does not require any actions. */
1923 } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
1927 /* Does not require any actions. */
1930 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1931 Exynos_OSAL_SemaphoreCreate(&pExynosOutputPort->codecSemID);
1932 Exynos_OSAL_QueueCreate(&pExynosOutputPort->codecBufferQ, MAX_QUEUE_ELEMENTS);
1933 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1937 /* Does not require any actions. */
1940 pWmvDec->bSourceStart = OMX_FALSE;
1941 Exynos_OSAL_SignalCreate(&pWmvDec->hSourceStartEvent);
1942 pWmvDec->bDestinationStart = OMX_FALSE;
1943 Exynos_OSAL_SignalCreate(&pWmvDec->hDestinationStartEvent);
1945 Exynos_OSAL_Memset(pExynosComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
1946 Exynos_OSAL_Memset(pExynosComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
1947 pWmvDec->hMFCWmvHandle.indexTimestamp = 0;
1948 pWmvDec->hMFCWmvHandle.outputIndexTimestamp = 0;
1949 /* Default WMV codec format is set as VC1*/
1950 pWmvDec->hMFCWmvHandle.wmvFormat = WMV_FORMAT_WMV3;//WMV_FORMAT_VC1;
1952 pExynosComponent->getAllDelayBuffer = OMX_FALSE;
1954 #if 0//defined(USE_CSC_GSCALER)
1955 csc_method = CSC_METHOD_HW; //in case of Use ION buffer.
1957 pVideoDec->csc_handle = csc_init(csc_method);
1958 if (pVideoDec->csc_handle == NULL) {
1959 ret = OMX_ErrorInsufficientResources;
1962 pVideoDec->csc_set_format = OMX_FALSE;
1971 OMX_ERRORTYPE Exynos_WmvDec_Terminate(OMX_COMPONENTTYPE *pOMXComponent)
1973 OMX_ERRORTYPE ret = OMX_ErrorNone;
1974 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1975 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1976 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1977 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1978 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1984 if (pVideoDec->csc_handle != NULL) {
1985 csc_deinit(pVideoDec->csc_handle);
1986 pVideoDec->csc_handle = NULL;
1989 Exynos_OSAL_SignalTerminate(pWmvDec->hDestinationStartEvent);
1990 pWmvDec->hDestinationStartEvent = NULL;
1991 pWmvDec->bDestinationStart = OMX_FALSE;
1992 Exynos_OSAL_SignalTerminate(pWmvDec->hSourceStartEvent);
1993 pWmvDec->hSourceStartEvent = NULL;
1994 pWmvDec->bSourceStart = OMX_FALSE;
1996 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1997 WmvCodecDstFreeCodecBuffers(pOMXComponent);
1999 Exynos_OSAL_QueueTerminate(&pExynosOutputPort->codecBufferQ);
2000 Exynos_OSAL_SemaphoreTerminate(pExynosOutputPort->codecSemID);
2001 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
2005 /* Does not require any actions. */
2008 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2009 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
2010 if (pVideoDec->pMFCDecInputBuffer[i] != NULL) {
2011 for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
2012 if (pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] != NULL)
2013 Exynos_OSAL_SharedMemory_Free(pVideoDec->hSharedMemory, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
2016 Exynos_OSAL_Free(pVideoDec->pMFCDecInputBuffer[i]);
2017 pVideoDec->pMFCDecInputBuffer[i] = NULL;
2021 Exynos_OSAL_QueueTerminate(&pExynosInputPort->codecBufferQ);
2022 Exynos_OSAL_SemaphoreTerminate(pExynosInputPort->codecSemID);
2023 } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
2027 /* Does not require any actions. */
2029 WmvCodecClose(pWmvDec);
2036 OMX_ERRORTYPE Exynos_WmvDec_SrcIn(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
2038 OMX_ERRORTYPE ret = OMX_ErrorNone;
2039 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2040 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2041 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
2042 OMX_U32 oneFrameSize = pSrcInputData->dataLen;
2043 OMX_BOOL bStartCode = OMX_FALSE;
2044 ExynosVideoDecOps *pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
2045 ExynosVideoDecBufferOps *pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
2046 ExynosVideoErrorType codecReturn = VIDEO_ERROR_NONE;
2050 if (pWmvDec->hMFCWmvHandle.bConfiguredMFCSrc == OMX_FALSE) {
2051 ret = WmvCodecSrcSetup(pOMXComponent, pSrcInputData);
2054 if (pWmvDec->hMFCWmvHandle.bConfiguredMFCDst == OMX_FALSE) {
2055 ret = WmvCodecDstSetup(pOMXComponent);
2058 bStartCode = Check_Stream_PrefixCode(pSrcInputData->buffer.singlePlaneBuffer.dataBuffer, oneFrameSize, pWmvDec->hMFCWmvHandle.wmvFormat);
2059 if (bStartCode == OMX_FALSE && ((pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS)) {
2060 if (pSrcInputData->allocSize < oneFrameSize+4) {
2061 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Can't attach startcode due to lack of buffer space");
2062 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2066 bStartCode = Make_Stream_StartCode(pSrcInputData->buffer.singlePlaneBuffer.dataBuffer, &oneFrameSize, pWmvDec->hMFCWmvHandle.wmvFormat);
2067 if (bStartCode == OMX_FALSE) {
2068 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Fail to Make Stream Start Code");
2069 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2074 if ((bStartCode == OMX_TRUE) || ((pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)){
2075 pExynosComponent->timeStamp[pWmvDec->hMFCWmvHandle.indexTimestamp] = pSrcInputData->timeStamp;
2076 pExynosComponent->nFlags[pWmvDec->hMFCWmvHandle.indexTimestamp] = pSrcInputData->nFlags;
2077 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);
2078 pDecOps->Set_FrameTag(hMFCHandle, pWmvDec->hMFCWmvHandle.indexTimestamp);
2079 pWmvDec->hMFCWmvHandle.indexTimestamp++;
2080 pWmvDec->hMFCWmvHandle.indexTimestamp %= MAX_TIMESTAMP;
2082 #ifdef USE_IMMEDIATE_DISPLAY
2083 /* Set Immediately display for I Frame*/
2084 if (pExynosComponent->checkTimeStamp.needCheckStartTimeStamp == OMX_TRUE) {
2085 if ( pExynosComponent->checkTimeStamp.bImmediateDisplay == OMX_FALSE) {
2086 /* Enable Immediately display After seek*/
2087 pDecOps->Set_ImmediateDisplay(hMFCHandle);
2088 pExynosComponent->checkTimeStamp.bImmediateDisplay = OMX_TRUE;
2093 /* queue work for input buffer */
2094 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "oneFrameSize: %d, bufferHeader: 0x%x, dataBuffer: 0x%x", oneFrameSize, pSrcInputData->bufferHeader, pSrcInputData->buffer.singlePlaneBuffer.dataBuffer);
2095 codecReturn = pInbufOps->Enqueue(hMFCHandle, (unsigned char **)&pSrcInputData->buffer.singlePlaneBuffer.dataBuffer,
2096 (unsigned int *)&oneFrameSize, MFC_INPUT_BUFFER_PLANE, pSrcInputData->bufferHeader);
2097 if (codecReturn != VIDEO_ERROR_NONE) {
2098 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2099 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s : %d", __FUNCTION__, __LINE__);
2102 WmvCodecStart(pOMXComponent, INPUT_PORT_INDEX);
2103 if (pWmvDec->bSourceStart == OMX_FALSE) {
2104 pWmvDec->bSourceStart = OMX_TRUE;
2105 Exynos_OSAL_SignalSet(pWmvDec->hSourceStartEvent);
2106 Exynos_OSAL_SleepMillisec(0);
2108 if (pWmvDec->bDestinationStart == OMX_FALSE) {
2109 pWmvDec->bDestinationStart = OMX_TRUE;
2110 Exynos_OSAL_SignalSet(pWmvDec->hDestinationStartEvent);
2111 Exynos_OSAL_SleepMillisec(0);
2115 ret = OMX_ErrorNone;
2123 OMX_ERRORTYPE Exynos_WmvDec_SrcOut(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcOutputData)
2125 OMX_ERRORTYPE ret = OMX_ErrorNone;
2126 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2127 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2128 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2129 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
2130 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2131 ExynosVideoDecBufferOps *pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
2132 ExynosVideoBuffer *pVideoBuffer;
2136 pVideoBuffer = pInbufOps->Dequeue(hMFCHandle);
2138 pSrcOutputData->dataLen = 0;
2139 pSrcOutputData->usedDataLen = 0;
2140 pSrcOutputData->remainDataLen = 0;
2141 pSrcOutputData->nFlags = 0;
2142 pSrcOutputData->timeStamp = 0;
2144 if (pVideoBuffer == NULL) {
2145 pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer = NULL;
2146 pSrcOutputData->allocSize = 0;
2147 pSrcOutputData->pPrivate = NULL;
2148 pSrcOutputData->bufferHeader = NULL;
2150 pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer = pVideoBuffer->planes[0].addr;
2151 pSrcOutputData->buffer.singlePlaneBuffer.fd = pVideoBuffer->planes[0].fd;
2152 pSrcOutputData->allocSize = pVideoBuffer->planes[0].allocSize;
2154 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2156 while (pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer != pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[0]) {
2158 if (i >= MFC_INPUT_BUFFER_NUM_MAX) {
2159 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Can not find buffer");
2160 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2164 pVideoDec->pMFCDecInputBuffer[i]->dataSize = 0;
2165 pSrcOutputData->pPrivate = pVideoDec->pMFCDecInputBuffer[i];
2168 /* For Share Buffer */
2169 pSrcOutputData->bufferHeader = (OMX_BUFFERHEADERTYPE*)pVideoBuffer->pPrivate;
2172 ret = OMX_ErrorNone;
2180 OMX_ERRORTYPE Exynos_WmvDec_DstIn(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstInputData)
2182 OMX_ERRORTYPE ret = OMX_ErrorNone;
2183 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2184 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2185 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2186 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
2187 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2188 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
2189 OMX_U32 dataLen[2] = {0,};
2190 ExynosVideoErrorType codecReturn = VIDEO_ERROR_NONE;
2194 if (pDstInputData->buffer.multiPlaneBuffer.dataBuffer[0] == NULL) {
2195 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to find input buffer");
2196 ret = OMX_ErrorBadParameter;
2200 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "%s : %d => ADDR[0]: 0x%x, ADDR[1]: 0x%x", __FUNCTION__, __LINE__,
2201 pDstInputData->buffer.multiPlaneBuffer.dataBuffer[0],
2202 pDstInputData->buffer.multiPlaneBuffer.dataBuffer[1]);
2204 if ((pVideoDec->bDRCProcessing == OMX_TRUE) &&
2205 (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) &&
2206 (pExynosOutputPort->exceptionFlag == GENERAL_STATE)) {
2207 ret = WmvCodecDstSetup(pOMXComponent);
2208 if (ret != OMX_ErrorNone) {
2209 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "DRC Reconfig CodecDstSetup Failed");
2212 pVideoDec->bDRCProcessing = OMX_FALSE;
2215 codecReturn = pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pDstInputData->buffer.multiPlaneBuffer.dataBuffer,
2216 (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, pDstInputData->bufferHeader);
2219 if (codecReturn != VIDEO_ERROR_NONE) {
2220 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s : %d", __FUNCTION__, __LINE__);
2221 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2224 WmvCodecStart(pOMXComponent, OUTPUT_PORT_INDEX);
2226 ret = OMX_ErrorNone;
2234 OMX_ERRORTYPE Exynos_WmvDec_DstOut(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstOutputData)
2236 OMX_ERRORTYPE ret = OMX_ErrorNone;
2237 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2238 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2239 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2240 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
2241 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2242 ExynosVideoDecOps *pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
2243 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
2244 ExynosVideoBuffer *pVideoBuffer;
2245 ExynosVideoFrameStatusType displayStatus = VIDEO_FRAME_STATUS_UNKNOWN;
2246 ExynosVideoGeometry *bufferGeometry;
2247 DECODE_CODEC_EXTRA_BUFFERINFO *pBufferInfo = NULL;
2248 OMX_S32 indexTimestamp = 0;
2253 if (pWmvDec->bDestinationStart == OMX_FALSE) {
2254 ret = OMX_ErrorNone;
2259 pVideoBuffer = pOutbufOps->Dequeue(hMFCHandle);
2260 if (pVideoBuffer == (ExynosVideoBuffer *)VIDEO_ERROR_DQBUF_EIO) {
2261 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "HW is not available");
2262 ret = OMX_ErrorHardware;
2266 if (pVideoBuffer == NULL) {
2267 ret = OMX_ErrorNone;
2270 displayStatus = pVideoBuffer->displayStatus;
2271 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "displayStatus: 0x%x", displayStatus);
2273 if ((displayStatus == VIDEO_FRAME_STATUS_DISPLAY_DECODING) ||
2274 (displayStatus == VIDEO_FRAME_STATUS_DISPLAY_ONLY) ||
2275 (displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) ||
2276 (displayStatus == VIDEO_FRAME_STATUS_DECODING_FINISHED) ||
2277 (CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2278 if (pVideoBuffer != NULL) {
2279 ret = OMX_ErrorNone;
2282 ret = OMX_ErrorUndefined;
2288 if (displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) {
2289 if (pVideoDec->bDRCProcessing != OMX_TRUE) {
2290 pExynosOutputPort->exceptionFlag = NEED_PORT_FLUSH;
2291 pVideoDec->bDRCProcessing = OMX_TRUE;
2292 WmvCodecCheckResolutionChange(pOMXComponent);
2293 pVideoDec->csc_set_format = OMX_FALSE;
2295 ret = OMX_ErrorNone;
2299 pWmvDec->hMFCWmvHandle.outputIndexTimestamp++;
2300 pWmvDec->hMFCWmvHandle.outputIndexTimestamp %= MAX_TIMESTAMP;
2302 pDstOutputData->allocSize = pDstOutputData->dataLen = 0;
2303 for (plane = 0; plane < MFC_OUTPUT_BUFFER_PLANE; plane++) {
2304 pDstOutputData->buffer.multiPlaneBuffer.dataBuffer[plane] = pVideoBuffer->planes[plane].addr;
2305 pDstOutputData->buffer.multiPlaneBuffer.fd[plane] = pVideoBuffer->planes[plane].fd;
2306 pDstOutputData->allocSize += pVideoBuffer->planes[plane].allocSize;
2307 pDstOutputData->dataLen += pVideoBuffer->planes[plane].dataSize;
2309 pDstOutputData->usedDataLen = 0;
2310 pDstOutputData->pPrivate = pVideoBuffer;
2311 /* For Share Buffer */
2312 pDstOutputData->bufferHeader = (OMX_BUFFERHEADERTYPE *)pVideoBuffer->pPrivate;
2314 pBufferInfo = (DECODE_CODEC_EXTRA_BUFFERINFO *)pDstOutputData->extInfo;
2315 bufferGeometry = &pWmvDec->hMFCWmvHandle.codecOutbufConf;
2316 pBufferInfo->imageWidth = bufferGeometry->nFrameWidth;
2317 pBufferInfo->imageHeight = bufferGeometry->nFrameHeight;
2318 switch (bufferGeometry->eColorFormat) {
2319 case VIDEO_COLORFORMAT_NV12:
2320 #ifdef TIZEN_FEATURE_E3250 /* NV12T fd */
2321 pBufferInfo->ColorFormat = OMX_SEC_COLOR_FormatNV12T_DmaBuf_Fd;
2323 pBufferInfo->ColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
2326 case VIDEO_COLORFORMAT_NV12_TILED:
2328 pBufferInfo->ColorFormat = OMX_SEC_COLOR_FormatNV12Tiled;
2332 indexTimestamp = pDecOps->Get_FrameTag(hMFCHandle);
2333 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "out indexTimestamp: %d", indexTimestamp);
2334 if ((indexTimestamp < 0) || (indexTimestamp >= MAX_TIMESTAMP)) {
2335 if ((pExynosComponent->checkTimeStamp.needSetStartTimeStamp != OMX_TRUE) &&
2336 (pExynosComponent->checkTimeStamp.needCheckStartTimeStamp != OMX_TRUE)) {
2337 pDstOutputData->timeStamp = pExynosComponent->timeStamp[pWmvDec->hMFCWmvHandle.outputIndexTimestamp];
2338 pDstOutputData->nFlags = pExynosComponent->nFlags[pWmvDec->hMFCWmvHandle.outputIndexTimestamp];
2339 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "missing out indexTimestamp: %d", indexTimestamp);
2341 pDstOutputData->timeStamp = 0x00;
2342 pDstOutputData->nFlags = 0x00;
2345 /* For timestamp correction. if mfc support frametype detect */
2346 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "disp_pic_frame_type: %d", pVideoBuffer->frameType);
2348 //#ifdef NEED_TIMESTAMP_REORDER
2349 if (pVideoDec->bNeedTimestampReorder == OMX_TRUE) { /* TIZEN_FEATURE_E3250 */
2350 if ((pVideoBuffer->frameType == VIDEO_FRAME_I)) {
2351 pDstOutputData->timeStamp = pExynosComponent->timeStamp[indexTimestamp];
2352 pDstOutputData->nFlags = pExynosComponent->nFlags[indexTimestamp];
2353 pWmvDec->hMFCWmvHandle.outputIndexTimestamp = indexTimestamp;
2355 pDstOutputData->timeStamp = pExynosComponent->timeStamp[pWmvDec->hMFCWmvHandle.outputIndexTimestamp];
2356 pDstOutputData->nFlags = pExynosComponent->nFlags[pWmvDec->hMFCWmvHandle.outputIndexTimestamp];
2360 pDstOutputData->timeStamp = pExynosComponent->timeStamp[indexTimestamp];
2361 pDstOutputData->nFlags = pExynosComponent->nFlags[indexTimestamp];
2364 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "timestamp %lld us (%.2f secs), indexTimestamp: %d, nFlags: 0x%x", pDstOutputData->timeStamp, pDstOutputData->timeStamp / 1E6, indexTimestamp, pDstOutputData->nFlags);
2367 if ((displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) ||
2368 (displayStatus == VIDEO_FRAME_STATUS_DECODING_FINISHED) ||
2369 ((pDstOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)) {
2370 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "displayStatus:%d, nFlags0x%x", displayStatus, pDstOutputData->nFlags);
2371 pDstOutputData->remainDataLen = 0;
2373 pDstOutputData->remainDataLen = bufferGeometry->nFrameWidth * bufferGeometry->nFrameHeight * 3 / 2;
2376 ret = OMX_ErrorNone;
2384 OMX_ERRORTYPE Exynos_WmvDec_srcInputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
2386 OMX_ERRORTYPE ret = OMX_ErrorNone;
2387 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2388 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2392 if ((!CHECK_PORT_ENABLED(pExynosInputPort)) || (!CHECK_PORT_POPULATED(pExynosInputPort))) {
2393 ret = OMX_ErrorNone;
2396 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, INPUT_PORT_INDEX)) {
2397 ret = OMX_ErrorNone;
2401 ret = Exynos_WmvDec_SrcIn(pOMXComponent, pSrcInputData);
2402 if ((ret != OMX_ErrorNone) && (ret != (OMX_ERRORTYPE)OMX_ErrorInputDataDecodeYet)) {
2403 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2404 pExynosComponent->callbackData,
2405 OMX_EventError, ret, 0, NULL);
2414 OMX_ERRORTYPE Exynos_WmvDec_srcOutputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcOutputData)
2416 OMX_ERRORTYPE ret = OMX_ErrorNone;
2417 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2418 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2419 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2423 if ((!CHECK_PORT_ENABLED(pExynosInputPort)) || (!CHECK_PORT_POPULATED(pExynosInputPort))) {
2424 ret = OMX_ErrorNone;
2428 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2429 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, INPUT_PORT_INDEX)) {
2430 ret = OMX_ErrorNone;
2434 if ((pWmvDec->bSourceStart == OMX_FALSE) &&
2435 (!CHECK_PORT_BEING_FLUSHED(pExynosInputPort))) {
2436 Exynos_OSAL_SignalWait(pWmvDec->hSourceStartEvent, DEF_MAX_WAIT_TIME);
2437 Exynos_OSAL_SignalReset(pWmvDec->hSourceStartEvent);
2440 ret = Exynos_WmvDec_SrcOut(pOMXComponent, pSrcOutputData);
2441 if ((ret != OMX_ErrorNone) &&
2442 (pExynosComponent->currentState == OMX_StateExecuting)) {
2443 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2444 pExynosComponent->callbackData,
2445 OMX_EventError, ret, 0, NULL);
2454 OMX_ERRORTYPE Exynos_WmvDec_dstInputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstInputData)
2456 OMX_ERRORTYPE ret = OMX_ErrorNone;
2457 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2458 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2459 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2463 if ((!CHECK_PORT_ENABLED(pExynosOutputPort)) || (!CHECK_PORT_POPULATED(pExynosOutputPort))) {
2464 ret = OMX_ErrorNone;
2467 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, OUTPUT_PORT_INDEX)) {
2468 ret = OMX_ErrorNone;
2471 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
2472 if ((pWmvDec->bDestinationStart == OMX_FALSE) &&
2473 (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2474 Exynos_OSAL_SignalWait(pWmvDec->hDestinationStartEvent, DEF_MAX_WAIT_TIME);
2475 Exynos_OSAL_SignalReset(pWmvDec->hDestinationStartEvent);
2478 if (pWmvDec->hMFCWmvHandle.bConfiguredMFCDst == OMX_TRUE) {
2479 ret = Exynos_WmvDec_DstIn(pOMXComponent, pDstInputData);
2480 if (ret != OMX_ErrorNone) {
2481 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2482 pExynosComponent->callbackData,
2483 OMX_EventError, ret, 0, NULL);
2493 OMX_ERRORTYPE Exynos_WmvDec_dstOutputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstOutputData)
2495 OMX_ERRORTYPE ret = OMX_ErrorNone;
2496 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2497 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2498 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2502 if ((!CHECK_PORT_ENABLED(pExynosOutputPort)) || (!CHECK_PORT_POPULATED(pExynosOutputPort))) {
2503 ret = OMX_ErrorNone;
2506 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, OUTPUT_PORT_INDEX)) {
2507 ret = OMX_ErrorNone;
2511 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
2512 if ((pWmvDec->bDestinationStart == OMX_FALSE) &&
2513 (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2514 Exynos_OSAL_SignalWait(pWmvDec->hDestinationStartEvent, DEF_MAX_WAIT_TIME);
2515 Exynos_OSAL_SignalReset(pWmvDec->hDestinationStartEvent);
2518 ret = Exynos_WmvDec_DstOut(pOMXComponent, pDstOutputData);
2519 if ((ret != OMX_ErrorNone) &&
2520 (pExynosComponent->currentState == OMX_StateExecuting)) {
2521 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2522 pExynosComponent->callbackData,
2523 OMX_EventError, ret, 0, NULL);
2532 OSCL_EXPORT_REF OMX_ERRORTYPE Exynos_OMX_ComponentInit(
2533 OMX_HANDLETYPE hComponent,
2534 OMX_STRING componentName)
2536 OMX_ERRORTYPE ret = OMX_ErrorNone;
2537 OMX_COMPONENTTYPE *pOMXComponent = NULL;
2538 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
2539 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
2540 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
2541 EXYNOS_WMVDEC_HANDLE *pWmvDec = NULL;
2542 OMX_S32 wmvFormat = WMV_FORMAT_UNKNOWN;
2547 if ((hComponent == NULL) || (componentName == NULL)) {
2548 ret = OMX_ErrorBadParameter;
2549 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
2552 if (Exynos_OSAL_Strcmp(EXYNOS_OMX_COMPONENT_WMV_DEC, componentName) != 0) {
2553 ret = OMX_ErrorBadParameter;
2554 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, componentName:%s, Line:%d", componentName, __LINE__);
2558 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2559 ret = Exynos_OMX_VideoDecodeComponentInit(pOMXComponent);
2560 if (ret != OMX_ErrorNone) {
2561 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_Error, Line:%d", __LINE__);
2564 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2565 pExynosComponent->codecType = HW_VIDEO_DEC_CODEC;
2567 pExynosComponent->componentName = (OMX_STRING)Exynos_OSAL_Malloc(MAX_OMX_COMPONENT_NAME_SIZE);
2568 if (pExynosComponent->componentName == NULL) {
2569 Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2570 ret = OMX_ErrorInsufficientResources;
2571 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2574 Exynos_OSAL_Memset(pExynosComponent->componentName, 0, MAX_OMX_COMPONENT_NAME_SIZE);
2576 pWmvDec = Exynos_OSAL_Malloc(sizeof(EXYNOS_WMVDEC_HANDLE));
2577 if (pWmvDec == NULL) {
2578 Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2579 ret = OMX_ErrorInsufficientResources;
2580 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2583 Exynos_OSAL_Memset(pWmvDec, 0, sizeof(EXYNOS_WMVDEC_HANDLE));
2584 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2585 pVideoDec->hCodecHandle = (OMX_HANDLETYPE)pWmvDec;
2586 pWmvDec->hMFCWmvHandle.wmvFormat = wmvFormat;
2588 Exynos_OSAL_Strcpy(pExynosComponent->componentName, EXYNOS_OMX_COMPONENT_WMV_DEC);
2590 /* In case of BUFFER_COPY mode
2591 bShareableBuf = TRUE means MemoryType is V4L2_MEMORY_USERPTR
2592 bShareableBuf = FALSE means MemoryType is V4L2_MEMORY_MMAP
2593 In case of BUFFER_SHARE
2594 bShareableBuf should be TRUE, FALSE is ignored
2596 pWmvDec->hMFCWmvHandle.bShareableBuf = OMX_FALSE;
2598 /* Set componentVersion */
2599 pExynosComponent->componentVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
2600 pExynosComponent->componentVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
2601 pExynosComponent->componentVersion.s.nRevision = REVISION_NUMBER;
2602 pExynosComponent->componentVersion.s.nStep = STEP_NUMBER;
2603 /* Set specVersion */
2604 pExynosComponent->specVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
2605 pExynosComponent->specVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
2606 pExynosComponent->specVersion.s.nRevision = REVISION_NUMBER;
2607 pExynosComponent->specVersion.s.nStep = STEP_NUMBER;
2610 pExynosPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2611 pExynosPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
2612 pExynosPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
2613 pExynosPort->portDefinition.format.video.nStride = 0; /*DEFAULT_FRAME_WIDTH;*/
2614 pExynosPort->portDefinition.format.video.nSliceHeight = 0;
2615 pExynosPort->portDefinition.nBufferSize = DEFAULT_VIDEO_INPUT_BUFFER_SIZE;
2616 pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingWMV;
2617 Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2618 Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "video/wmv");
2619 pExynosPort->portDefinition.format.video.pNativeRender = 0;
2620 pExynosPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
2621 pExynosPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatUnused;
2622 pExynosPort->portDefinition.bEnabled = OMX_TRUE;
2623 pExynosPort->bufferProcessType = BUFFER_COPY;
2624 pExynosPort->portWayType = WAY2_PORT;
2627 pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2628 pExynosPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
2629 pExynosPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
2630 pExynosPort->portDefinition.format.video.nStride = 0; /*DEFAULT_FRAME_WIDTH;*/
2631 pExynosPort->portDefinition.format.video.nSliceHeight = 0;
2632 pExynosPort->portDefinition.nBufferSize = DEFAULT_VIDEO_OUTPUT_BUFFER_SIZE;
2633 pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused;
2634 Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2635 Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "raw/video");
2636 pExynosPort->portDefinition.format.video.pNativeRender = 0;
2637 pExynosPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
2638 #ifdef TIZEN_FEATURE_E3250
2639 pExynosPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatNV12T_DmaBuf_Fd;
2641 pExynosPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
2643 pExynosPort->portDefinition.bEnabled = OMX_TRUE;
2644 #ifdef TIZEN_FEATURE_E3250
2645 pExynosPort->bufferProcessType = BUFFER_SHARE;
2647 pExynosPort->bufferProcessType = BUFFER_COPY;
2649 pExynosPort->portWayType = WAY2_PORT;
2651 for(i = 0; i < ALL_PORT_NUM; i++) {
2652 INIT_SET_SIZE_VERSION(&pWmvDec->WmvComponent[i], OMX_VIDEO_PARAM_WMVTYPE);
2653 pWmvDec->WmvComponent[i].nPortIndex = i;
2654 pWmvDec->WmvComponent[i].eFormat = OMX_VIDEO_WMVFormat9;
2657 #ifdef TIZEN_FEATURE_E3250
2658 pWmvDec->wmvFormat = WMV_FORMAT_UNKNOWN;
2661 pOMXComponent->GetParameter = &Exynos_WmvDec_GetParameter;
2662 pOMXComponent->SetParameter = &Exynos_WmvDec_SetParameter;
2663 pOMXComponent->GetConfig = &Exynos_WmvDec_GetConfig;
2664 pOMXComponent->SetConfig = &Exynos_WmvDec_SetConfig;
2665 pOMXComponent->GetExtensionIndex = &Exynos_WmvDec_GetExtensionIndex;
2666 pOMXComponent->ComponentRoleEnum = &Exynos_WmvDec_ComponentRoleEnum;
2667 pOMXComponent->ComponentDeInit = &Exynos_OMX_ComponentDeinit;
2669 pExynosComponent->exynos_codec_componentInit = &Exynos_WmvDec_Init;
2670 pExynosComponent->exynos_codec_componentTerminate = &Exynos_WmvDec_Terminate;
2672 pVideoDec->exynos_codec_srcInputProcess = &Exynos_WmvDec_srcInputBufferProcess;
2673 pVideoDec->exynos_codec_srcOutputProcess = &Exynos_WmvDec_srcOutputBufferProcess;
2674 pVideoDec->exynos_codec_dstInputProcess = &Exynos_WmvDec_dstInputBufferProcess;
2675 pVideoDec->exynos_codec_dstOutputProcess = &Exynos_WmvDec_dstOutputBufferProcess;
2677 pVideoDec->exynos_codec_start = &WmvCodecStart;
2678 pVideoDec->exynos_codec_stop = &WmvCodecStop;
2679 pVideoDec->exynos_codec_bufferProcessRun = &WmvCodecOutputBufferProcessRun;
2680 pVideoDec->exynos_codec_enqueueAllBuffer = &WmvCodecEnQueueAllBuffer;
2681 pVideoDec->exynos_codec_resetupAllElement = &WmvCodecResetupAllElement;
2683 pVideoDec->exynos_checkInputFrame = NULL;
2684 pVideoDec->exynos_codec_getCodecInputPrivateData = &GetCodecInputPrivateData;
2685 pVideoDec->exynos_codec_getCodecOutputPrivateData = &GetCodecOutputPrivateData;
2687 pVideoDec->exynos_process_codecConfigData = &Process_Wmv_CodecConfigData;
2689 #ifndef TIZEN_FEATURE_E3250 /* do not use ion */
2690 pVideoDec->hSharedMemory = Exynos_OSAL_SharedMemory_Open();
2691 if (pVideoDec->hSharedMemory == NULL) {
2692 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2693 Exynos_OSAL_Free(pWmvDec);
2694 pWmvDec = ((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle = NULL;
2695 Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2696 ret = OMX_ErrorInsufficientResources;
2700 pExynosComponent->currentState = OMX_StateLoaded;
2702 ret = OMX_ErrorNone;
2710 OMX_ERRORTYPE Exynos_OMX_ComponentDeinit(
2711 OMX_HANDLETYPE hComponent)
2713 OMX_ERRORTYPE ret = OMX_ErrorNone;
2714 OMX_COMPONENTTYPE *pOMXComponent = NULL;
2715 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
2716 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
2717 EXYNOS_WMVDEC_HANDLE *pWmvDec = NULL;
2721 if (hComponent == NULL) {
2722 ret = OMX_ErrorBadParameter;
2725 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2726 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2727 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2728 #ifndef TIZEN_FEATURE_E3250 /* do not use ion */
2729 Exynos_OSAL_SharedMemory_Close(pVideoDec->hSharedMemory);
2731 Exynos_OSAL_Free(pExynosComponent->componentName);
2732 pExynosComponent->componentName = NULL;
2734 pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
2735 if (pWmvDec != NULL) {
2736 Exynos_OSAL_Free(pWmvDec);
2737 pWmvDec = pVideoDec->hCodecHandle = NULL;
2740 ret = Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2741 if (ret != OMX_ErrorNone) {
2745 ret = OMX_ErrorNone;