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)
34 #include "Exynos_OMX_Macros.h"
35 #include "Exynos_OMX_Basecomponent.h"
36 #include "Exynos_OMX_Baseport.h"
37 #include "Exynos_OMX_Vdec.h"
38 #include "Exynos_OSAL_ETC.h"
39 #include "Exynos_OSAL_Semaphore.h"
40 #include "Exynos_OSAL_Thread.h"
41 #include "library_register.h"
42 #include "Exynos_OMX_Wmvdec.h"
43 #include "ExynosVideoApi.h"
44 #include "Exynos_OSAL_SharedMemory.h"
45 #include "Exynos_OSAL_Event.h"
48 #include "Exynos_OSAL_Platform_Specific.h"
51 /* To use CSC_METHOD_HW in EXYNOS OMX, gralloc should allocate physical memory using FIMC */
52 /* It means GRALLOC_USAGE_HW_FIMC1 should be set on Native Window usage */
56 #define EXYNOS_LOG_TAG "EXYNOS_WMV_DEC"
57 #define EXYNOS_LOG_OFF
58 //#define EXYNOS_TRACE_ON
59 #include "Exynos_OSAL_Log.h"
61 #define WMV_DEC_NUM_OF_EXTRA_BUFFERS 7
63 //#define FULL_FRAME_SEARCH
65 /* ASF parser does not send start code on Stagefright */
67 /* Enable or disable "WMV3_ADDITIONAL_START_CODE" based on MFC F/W's need */
68 //#define WMV3_ADDITIONAL_START_CODE
70 const OMX_U32 wmv3 = 0x33564d57;
71 const OMX_U32 wvc1 = 0x31435657;
72 const OMX_U32 wmva = 0x41564d57;
75 static OMX_ERRORTYPE GetCodecInputPrivateData(OMX_PTR codecBuffer, void *pVirtAddr, OMX_U32 *dataSize)
77 OMX_ERRORTYPE ret = OMX_ErrorNone;
83 static OMX_ERRORTYPE GetCodecOutputPrivateData(OMX_PTR codecBuffer, void *addr[], int size[])
85 OMX_ERRORTYPE ret = OMX_ErrorNone;
86 ExynosVideoBuffer *pCodecBuffer;
88 if (codecBuffer == NULL) {
89 ret = OMX_ErrorBadParameter;
93 pCodecBuffer = (ExynosVideoBuffer *)codecBuffer;
96 addr[0] = pCodecBuffer->planes[0].addr;
97 addr[1] = pCodecBuffer->planes[1].addr;
98 addr[2] = pCodecBuffer->planes[2].addr;
102 size[0] = pCodecBuffer->planes[0].allocSize;
103 size[1] = pCodecBuffer->planes[1].allocSize;
104 size[2] = pCodecBuffer->planes[2].allocSize;
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);
207 static OMX_BOOL Check_Stream_PrefixCode(
208 OMX_U8 *pInputStream,
210 WMV_FORMAT wmvFormat)
213 case WMV_FORMAT_WMV3:
214 #ifdef WMV3_ADDITIONAL_START_CODE
223 /* TODO : for comformanc test based on common buffer scheme w/o parser */
224 if (streamSize < 3) {
225 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: streamSize is too small (%d)", __FUNCTION__, streamSize);
227 } else if ((pInputStream[0] == 0x00) &&
228 (pInputStream[1] == 0x00) &&
229 (pInputStream[2] == 0x01)) {
232 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: Cannot find prefix", __FUNCTION__);
238 Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "%s: undefined wmvFormat (%d)", __FUNCTION__, wmvFormat);
244 static OMX_BOOL Make_Stream_MetaData(
245 OMX_U8 *pInputStream,
246 OMX_U32 *pStreamSize,
249 , OMX_U32 width, OMX_U32 height
253 OMX_U8 *pCurrBuf = pInputStream;
256 OMX_U32 width, height;
260 /* Sequence Layer Data Structure */
261 OMX_U8 const_C5[4] = {0x00, 0x00, 0x00, 0xc5};
262 OMX_U8 const_04[4] = {0x04, 0x00, 0x00, 0x00};
263 OMX_U8 const_0C[4] = {0x0C, 0x00, 0x00, 0x00};
264 OMX_U8 struct_B_1[4] = {0xB3, 0x19, 0x00, 0x00};
265 OMX_U8 struct_B_2[4] = {0x44, 0x62, 0x05, 0x00};
266 OMX_U8 struct_B_3[4] = {0x0F, 0x00, 0x00, 0x00};
267 OMX_U8 struct_C[4] = {0x30, 0x00, 0x00, 0x00};
270 case WMV_FORMAT_WMV3:
271 if (*pStreamSize >= BITMAPINFOHEADER_SIZE) {
273 BitmapInfoHhr *pBitmapInfoHeader;
274 pBitmapInfoHeader = (BitmapInfoHhr *)pInputStream;
276 width = pBitmapInfoHeader->BiWidth;
277 height = pBitmapInfoHeader->BiHeight;
279 if (*pStreamSize > BITMAPINFOHEADER_SIZE)
280 Exynos_OSAL_Memcpy(struct_C, pInputStream+BITMAPINFOHEADER_SIZE, 4);
282 Exynos_OSAL_Memcpy(pCurrBuf + currPos, const_C5, 4);
285 Exynos_OSAL_Memcpy(pCurrBuf + currPos, const_04, 4);
288 Exynos_OSAL_Memcpy(pCurrBuf + currPos, struct_C, 4);
291 /* struct_A : VERT_SIZE */
292 pCurrBuf[currPos] = height & 0xFF;
293 pCurrBuf[currPos+1] = (height>>8) & 0xFF;
294 pCurrBuf[currPos+2] = (height>>16) & 0xFF;
295 pCurrBuf[currPos+3] = (height>>24) & 0xFF;
298 /* struct_A : HORIZ_SIZE */
299 pCurrBuf[currPos] = width & 0xFF;
300 pCurrBuf[currPos+1] = (width>>8) & 0xFF;
301 pCurrBuf[currPos+2] = (width>>16) & 0xFF;
302 pCurrBuf[currPos+3] = (width>>24) & 0xFF;
305 Exynos_OSAL_Memcpy(pCurrBuf + currPos,const_0C, 4);
308 Exynos_OSAL_Memcpy(pCurrBuf + currPos, struct_B_1, 4);
311 Exynos_OSAL_Memcpy(pCurrBuf + currPos, struct_B_2, 4);
314 Exynos_OSAL_Memcpy(pCurrBuf + currPos, struct_B_3, 4);
317 *pStreamSize = currPos;
320 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: *pStreamSize is too small to contain metadata(%d)", __FUNCTION__, *pStreamSize);
325 if (*pStreamSize >= BITMAPINFOHEADER_ASFBINDING_SIZE) {
326 Exynos_OSAL_Memcpy(pCurrBuf, pInputStream + BITMAPINFOHEADER_ASFBINDING_SIZE, *pStreamSize - BITMAPINFOHEADER_ASFBINDING_SIZE);
327 *pStreamSize -= BITMAPINFOHEADER_ASFBINDING_SIZE;
330 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: *pStreamSize is too small to contain metadata(%d)", __FUNCTION__, *pStreamSize);
335 Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "%s: It is not necessary to make bitstream metadata for wmvFormat (%d)", __FUNCTION__, wmvFormat);
341 static OMX_BOOL Make_Stream_StartCode(
342 OMX_U8 *pInputStream,
343 OMX_U32 *pStreamSize,
344 WMV_FORMAT wmvFormat)
346 OMX_U8 frameStartCode[4] = {0x00, 0x00, 0x01, 0x0d};
347 #ifdef WMV3_ADDITIONAL_START_CODE
348 /* first 4 bytes : size of Frame, second 4 bytes : present Time stamp */
349 OMX_U8 frameStartCode2[8] = {0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00};
354 case WMV_FORMAT_WMV3:
355 #ifdef WMV3_ADDITIONAL_START_CODE
356 Exynos_OSAL_Memmove(pInputStream+8, pInputStream, *pStreamSize);
357 Exynos_OSAL_Memcpy(pInputStream, frameStartCode2, 8);
364 /* Should find better way to shift data */
365 Exynos_OSAL_Memmove(pInputStream+4, pInputStream, *pStreamSize);
366 Exynos_OSAL_Memcpy(pInputStream, frameStartCode, 4);
372 Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "%s: undefined wmvFormat (%d)", __FUNCTION__, wmvFormat);
378 OMX_ERRORTYPE Process_Wmv_CodecConfigData(OMX_COMPONENTTYPE *pOMXComponent, void *pConfig)
380 OMX_ERRORTYPE ret = OMX_ErrorNone;
381 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
382 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
383 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
384 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
385 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
386 OMX_PTR hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
388 EXYNOS_OMX_DATABUFFER *pSrcInputData = (EXYNOS_OMX_DATA *)pConfig;
389 OMX_U8 *pInputStream = pSrcInputData->bufferHeader->pBuffer;
395 if (pWmvDec->wmvFormat == WMV_FORMAT_UNKNOWN) {
396 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Process_Wmv_CodecConfigData. dataLen = %d", pSrcInputData->dataLen);
397 if (pSrcInputData->dataLen < 4) {
398 pWmvDec->wmvFormat = WMV_FORMAT_UNKNOWN;
399 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "WMV_FORMAT_UNKNOWN");
400 } else if ((pInputStream[1] == 0x00) &&
401 (pInputStream[2] == 0x00) &&
402 (pInputStream[3] == 0x01)) {
403 pWmvDec->wmvFormat = WMV_FORMAT_VC1;
404 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "WMV_FORMAT_VC1");
406 pWmvDec->wmvFormat = WMV_FORMAT_WMV3;
407 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "WMV_FORMAT_WMV3");
411 pWmvDec->hMFCWmvHandle.wmvFormat = pWmvDec->wmvFormat;
413 BitmapInfoHhr *pBitmapInfoHeader;
414 pBitmapInfoHeader = (BitmapInfoHhr *)pConfig;
415 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "OMX_BUFFERFLAG_CODECCONFIG");
416 if (pBitmapInfoHeader->BiCompression == wmv3) {
417 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "WMV_FORMAT_WMV3");
418 pWmvDec->hMFCWmvHandle.wmvFormat = WMV_FORMAT_WMV3;
419 } else if ((pBitmapInfoHeader->BiCompression == wvc1) || (pBitmapInfoHeader->BiCompression == wmva)) {
420 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "WMV_FORMAT_VC1");
421 pWmvDec->hMFCWmvHandle.wmvFormat = WMV_FORMAT_VC1;
423 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "WMV_FORMAT_UNKNOWN (0x%x), default value will be used", pBitmapInfoHeader->BiCompression);
426 ret = WmvCodecSrcInit(pOMXComponent);
427 if (ret != OMX_ErrorNone) {
428 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to WmvCodecSrcInit");
440 OMX_ERRORTYPE WmvCodecOpen(EXYNOS_WMVDEC_HANDLE *pWmvDec)
442 OMX_ERRORTYPE ret = OMX_ErrorNone;
443 ExynosVideoDecOps *pDecOps = NULL;
444 ExynosVideoDecBufferOps *pInbufOps = NULL;
445 ExynosVideoDecBufferOps *pOutbufOps = NULL;
446 enum v4l2_memory v4l2MemoryType = V4L2_MEMORY_USERPTR;
450 if (pWmvDec == NULL) {
451 ret = OMX_ErrorBadParameter;
452 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
456 /* alloc ops structure */
457 pDecOps = (ExynosVideoDecOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoDecOps));
458 pInbufOps = (ExynosVideoDecBufferOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoDecBufferOps));
459 pOutbufOps = (ExynosVideoDecBufferOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoDecBufferOps));
461 if ((pDecOps == NULL) || (pInbufOps == NULL) || (pOutbufOps == NULL)) {
462 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to allocate decoder ops buffer");
463 ret = OMX_ErrorInsufficientResources;
467 pWmvDec->hMFCWmvHandle.pDecOps = pDecOps;
468 pWmvDec->hMFCWmvHandle.pInbufOps = pInbufOps;
469 pWmvDec->hMFCWmvHandle.pOutbufOps = pOutbufOps;
471 /* function pointer mapping */
472 pDecOps->nSize = sizeof(ExynosVideoDecOps);
473 pInbufOps->nSize = sizeof(ExynosVideoDecBufferOps);
474 pOutbufOps->nSize = sizeof(ExynosVideoDecBufferOps);
476 Exynos_Video_Register_Decoder(pDecOps, pInbufOps, pOutbufOps);
478 /* check mandatory functions for decoder ops */
479 if ((pDecOps->Init == NULL) || (pDecOps->Finalize == NULL) ||
480 (pDecOps->Get_ActualBufferCount == NULL) || (pDecOps->Set_FrameTag == NULL) ||
481 (pDecOps->Get_FrameTag == NULL)) {
482 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Mandatory functions must be supplied");
483 ret = OMX_ErrorInsufficientResources;
487 /* check mandatory functions for buffer ops */
488 if ((pInbufOps->Setup == NULL) || (pOutbufOps->Setup == NULL) ||
489 (pInbufOps->Run == NULL) || (pOutbufOps->Run == NULL) ||
490 (pInbufOps->Stop == NULL) || (pOutbufOps->Stop == NULL) ||
491 (pInbufOps->Enqueue == NULL) || (pOutbufOps->Enqueue == NULL) ||
492 (pInbufOps->Dequeue == NULL) || (pOutbufOps->Dequeue == NULL)) {
493 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Mandatory functions must be supplied");
494 ret = OMX_ErrorInsufficientResources;
499 if (pWmvDec->hMFCWmvHandle.bShareableBuf == OMX_TRUE) {
501 v4l2MemoryType = V4L2_MEMORY_DMABUF;
502 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "using Dec V4L2_MEMORY_DMABUF");
504 v4l2MemoryType = V4L2_MEMORY_USERPTR;
505 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "using Dec V4L2_MEMORY_USEPTR");
508 v4l2MemoryType = V4L2_MEMORY_DMABUF;
509 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "using Dec V4L2_MEMORY_DMABUF");
512 /* alloc context, open, querycap */
513 pWmvDec->hMFCWmvHandle.hMFCHandle = pWmvDec->hMFCWmvHandle.pDecOps->Init(v4l2MemoryType);
514 if (pWmvDec->hMFCWmvHandle.hMFCHandle == NULL) {
515 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to allocate context buffer");
516 ret = OMX_ErrorInsufficientResources;
523 if (ret != OMX_ErrorNone) {
524 if (pDecOps != NULL) {
525 Exynos_OSAL_Free(pDecOps);
526 pWmvDec->hMFCWmvHandle.pDecOps = NULL;
528 if (pInbufOps != NULL) {
529 Exynos_OSAL_Free(pInbufOps);
530 pWmvDec->hMFCWmvHandle.pInbufOps = NULL;
532 if (pOutbufOps != NULL) {
533 Exynos_OSAL_Free(pOutbufOps);
534 pWmvDec->hMFCWmvHandle.pOutbufOps = NULL;
543 OMX_ERRORTYPE WmvCodecClose(EXYNOS_WMVDEC_HANDLE *pWmvDec)
545 OMX_ERRORTYPE ret = OMX_ErrorNone;
546 void *hMFCHandle = NULL;
547 ExynosVideoDecOps *pDecOps = NULL;
548 ExynosVideoDecBufferOps *pInbufOps = NULL;
549 ExynosVideoDecBufferOps *pOutbufOps = NULL;
553 if (pWmvDec == NULL) {
554 ret = OMX_ErrorBadParameter;
558 hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
559 pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
560 pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
561 pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
563 if (hMFCHandle != NULL) {
564 pDecOps->Finalize(hMFCHandle);
565 pWmvDec->hMFCWmvHandle.hMFCHandle = NULL;
567 if (pOutbufOps != NULL) {
568 Exynos_OSAL_Free(pOutbufOps);
569 pWmvDec->hMFCWmvHandle.pOutbufOps = NULL;
571 if (pInbufOps != NULL) {
572 Exynos_OSAL_Free(pInbufOps);
573 pWmvDec->hMFCWmvHandle.pInbufOps = NULL;
575 if (pDecOps != NULL) {
576 Exynos_OSAL_Free(pDecOps);
577 pWmvDec->hMFCWmvHandle.pDecOps = NULL;
588 OMX_ERRORTYPE WmvCodecStart(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
590 OMX_ERRORTYPE ret = OMX_ErrorNone;
591 void *hMFCHandle = NULL;
592 ExynosVideoDecOps *pDecOps = NULL;
593 ExynosVideoDecBufferOps *pInbufOps = NULL;
594 ExynosVideoDecBufferOps *pOutbufOps = NULL;
595 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
596 EXYNOS_WMVDEC_HANDLE *pWmvDec = NULL;
600 if (pOMXComponent == NULL) {
601 ret = OMX_ErrorBadParameter;
605 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
606 if (pVideoDec == NULL) {
607 ret = OMX_ErrorBadParameter;
611 pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
612 if (pWmvDec == NULL) {
613 ret = OMX_ErrorBadParameter;
617 hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
618 pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
619 pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
620 pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
622 if (nPortIndex == INPUT_PORT_INDEX)
623 pInbufOps->Run(hMFCHandle);
624 else if (nPortIndex == OUTPUT_PORT_INDEX)
625 pOutbufOps->Run(hMFCHandle);
635 OMX_ERRORTYPE WmvCodecStop(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
637 OMX_ERRORTYPE ret = OMX_ErrorNone;
638 void *hMFCHandle = NULL;
639 ExynosVideoDecOps *pDecOps = NULL;
640 ExynosVideoDecBufferOps *pInbufOps = NULL;
641 ExynosVideoDecBufferOps *pOutbufOps = NULL;
642 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
643 EXYNOS_WMVDEC_HANDLE *pWmvDec = NULL;
647 if (pOMXComponent == NULL) {
648 ret = OMX_ErrorBadParameter;
652 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
653 if (pVideoDec == NULL) {
654 ret = OMX_ErrorBadParameter;
657 pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
658 if (pWmvDec == NULL) {
659 ret = OMX_ErrorBadParameter;
663 hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
664 pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
665 pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
666 pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
668 if ((nPortIndex == INPUT_PORT_INDEX) && (pInbufOps != NULL))
669 pInbufOps->Stop(hMFCHandle);
670 else if ((nPortIndex == OUTPUT_PORT_INDEX) && (pOutbufOps != NULL))
671 pOutbufOps->Stop(hMFCHandle);
682 OMX_ERRORTYPE WmvCodecSrcInit(OMX_COMPONENTTYPE *pOMXComponent)
684 OMX_ERRORTYPE ret = OMX_ErrorNone;
685 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
686 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
687 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
688 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
689 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
690 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
692 ExynosVideoDecOps *pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
693 ExynosVideoDecBufferOps *pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
694 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
695 ExynosVideoGeometry bufferConf;
696 OMX_U32 inputBufferNumber = 0;
701 if (pVideoDec->bThumbnailMode == OMX_TRUE)
702 pDecOps->Set_DisplayDelay(hMFCHandle, 0);
704 /* input buffer info */
705 Exynos_OSAL_Memset(&bufferConf, 0, sizeof(bufferConf));
706 if (pWmvDec->hMFCWmvHandle.wmvFormat == WMV_FORMAT_WMV3) {
707 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "VIDEO_CODING_VC1_RCV");
708 bufferConf.eCompressionFormat = VIDEO_CODING_VC1_RCV;
709 } else if (pWmvDec->hMFCWmvHandle.wmvFormat == WMV_FORMAT_VC1) {
710 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "VIDEO_CODING_VC1");
711 bufferConf.eCompressionFormat = VIDEO_CODING_VC1;
713 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Unsupported WMV Codec Format Type");
714 ret = OMX_ErrorUndefined;
718 if (pExynosInputPort->bufferProcessType & BUFFER_SHARE
719 ||pWmvDec->hMFCWmvHandle.bShareableBuf == OMX_TRUE)
720 pInbufOps->Set_Shareable(hMFCHandle);
722 if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
723 bufferConf.nSizeImage = pExynosInputPort->portDefinition.format.video.nFrameWidth
724 * pExynosInputPort->portDefinition.format.video.nFrameHeight * 3 / 2;
725 inputBufferNumber = MAX_VIDEO_INPUTBUFFER_NUM;
726 } else if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
727 bufferConf.nSizeImage = DEFAULT_MFC_INPUT_BUFFER_SIZE;
728 inputBufferNumber = MFC_INPUT_BUFFER_NUM_MAX;
731 /* should be done before prepare input buffer */
732 if (pInbufOps->Enable_Cacheable(hMFCHandle) != VIDEO_ERROR_NONE) {
733 ret = OMX_ErrorInsufficientResources;
737 /* set input buffer geometry */
738 if (pInbufOps->Set_Geometry(hMFCHandle, &bufferConf) != VIDEO_ERROR_NONE) {
739 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to set geometry for input buffer");
740 ret = OMX_ErrorInsufficientResources;
744 /* setup input buffer */
745 if (pInbufOps->Setup(hMFCHandle, inputBufferNumber) != VIDEO_ERROR_NONE) {
746 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to setup input buffer");
747 ret = OMX_ErrorInsufficientResources;
751 if ((pExynosInputPort->bufferProcessType & BUFFER_COPY) &&
752 pWmvDec->hMFCWmvHandle.bShareableBuf == OMX_TRUE) {
753 /* Register input buffer */
754 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
755 ExynosVideoPlane plane;
756 plane.addr = pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[0];
757 plane.allocSize = pVideoDec->pMFCDecInputBuffer[i]->bufferSize[0];
758 plane.fd = pVideoDec->pMFCDecInputBuffer[i]->fd[0];
759 if (pInbufOps->Register(hMFCHandle, &plane, MFC_INPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
760 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register input buffer");
761 ret = OMX_ErrorInsufficientResources;
765 } else if ((pExynosInputPort->bufferProcessType & BUFFER_COPY) &&
766 pWmvDec->hMFCWmvHandle.bShareableBuf == OMX_FALSE) {
767 ExynosVideoBuffer *pBuffer = NULL;
769 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
770 pVideoDec->pMFCDecInputBuffer[i] = Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
771 Exynos_OSAL_Memset(pVideoDec->pMFCDecInputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
772 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "@pVideoDec->pMFCDecInputBuffer[%d]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]);
773 /* get input buffer info */
774 if (pInbufOps->Get_Buffer) {
775 if (pInbufOps->Get_Buffer(pWmvDec->hMFCWmvHandle.hMFCHandle, i, &pBuffer) != VIDEO_ERROR_NONE) {
776 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get input buffer info");
777 ret = OMX_ErrorInsufficientResources;
782 for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
783 /* Use ION Allocator */
784 pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] = (void *)pBuffer->planes[plane].addr;
785 pVideoDec->pMFCDecInputBuffer[i]->fd[plane] = pBuffer->planes[plane].fd;
786 pVideoDec->pMFCDecInputBuffer[i]->bufferSize[plane] = pBuffer->planes[plane].allocSize;
787 pVideoDec->pMFCDecInputBuffer[i]->dataSize = 0;
788 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "@pVideoDec->pMFCDecInputBuffer[%d]->pVirAddr[%d]: 0x%x", i, plane, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
791 Exynos_CodecBufferEnQueue(pExynosComponent, INPUT_PORT_INDEX, pVideoDec->pMFCDecInputBuffer[i]);
793 } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
794 /* Register input buffer */
795 for (i = 0; i < pExynosInputPort->portDefinition.nBufferCountActual; i++) {
796 ExynosVideoPlane plane;
797 plane.addr = pExynosInputPort->extendBufferHeader[i].OMXBufferHeader->pBuffer;
798 plane.allocSize = pExynosInputPort->extendBufferHeader[i].OMXBufferHeader->nAllocLen;
799 plane.fd = pExynosInputPort->extendBufferHeader[i].buf_fd[0];
800 if (pInbufOps->Register(hMFCHandle, &plane, MFC_INPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
801 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register input buffer");
802 ret = OMX_ErrorInsufficientResources;
814 OMX_ERRORTYPE WmvCodecOutputBufferProcessRun(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
816 OMX_ERRORTYPE ret = OMX_ErrorNone;
817 void *hMFCHandle = NULL;
818 ExynosVideoDecOps *pDecOps = NULL;
819 ExynosVideoDecBufferOps *pInbufOps = NULL;
820 ExynosVideoDecBufferOps *pOutbufOps = NULL;
821 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
822 EXYNOS_WMVDEC_HANDLE *pWmvDec = NULL;
826 if (pOMXComponent == NULL) {
827 ret = OMX_ErrorBadParameter;
831 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
832 if (pVideoDec == NULL) {
833 ret = OMX_ErrorBadParameter;
836 pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
837 if (pWmvDec == NULL) {
838 ret = OMX_ErrorBadParameter;
842 hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
843 pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
844 pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
845 pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
847 if (nPortIndex == INPUT_PORT_INDEX) {
848 if (pWmvDec->bSourceStart == OMX_FALSE) {
849 Exynos_OSAL_SignalSet(pWmvDec->hSourceStartEvent);
850 Exynos_OSAL_SleepMillisec(0);
854 if (nPortIndex == OUTPUT_PORT_INDEX) {
855 if (pWmvDec->bDestinationStart == OMX_FALSE) {
856 Exynos_OSAL_SignalSet(pWmvDec->hDestinationStartEvent);
857 Exynos_OSAL_SleepMillisec(0);
869 OMX_ERRORTYPE WmvCodecEnQueueAllBuffer(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
871 OMX_ERRORTYPE ret = OMX_ErrorNone;
872 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
873 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
874 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
875 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
876 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
877 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
880 ExynosVideoDecOps *pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
881 ExynosVideoDecBufferOps *pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
882 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
886 if ((nPortIndex != INPUT_PORT_INDEX) && (nPortIndex != OUTPUT_PORT_INDEX)) {
887 ret = OMX_ErrorBadPortIndex;
891 if ((nPortIndex == INPUT_PORT_INDEX) &&
892 (pWmvDec->bSourceStart == OMX_TRUE)) {
893 Exynos_CodecBufferReset(pExynosComponent, INPUT_PORT_INDEX);
895 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
896 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]);
897 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]->pVirAddr[0]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[0]);
899 Exynos_CodecBufferEnQueue(pExynosComponent, INPUT_PORT_INDEX, pVideoDec->pMFCDecInputBuffer[i]);
902 pInbufOps->Clear_Queue(hMFCHandle);
903 } else if ((nPortIndex == OUTPUT_PORT_INDEX) &&
904 (pWmvDec->bDestinationStart == OMX_TRUE)) {
905 OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
906 ExynosVideoBuffer *pBuffer = NULL;
908 Exynos_CodecBufferReset(pExynosComponent, OUTPUT_PORT_INDEX);
910 nOutbufs = pDecOps->Get_ActualBufferCount(hMFCHandle);
911 nOutbufs += EXTRA_DPB_NUM;
912 for (i = 0; i < nOutbufs; i++) {
913 pOutbufOps->Get_Buffer(hMFCHandle, i, &pBuffer);
914 Exynos_CodecBufferEnQueue(pExynosComponent, OUTPUT_PORT_INDEX, (OMX_PTR)pBuffer);
916 pOutbufOps->Clear_Queue(hMFCHandle);
925 OMX_ERRORTYPE WmvCodecDstFreeCodecBuffers(
926 OMX_COMPONENTTYPE *pOMXComponent)
928 OMX_ERRORTYPE ret = OMX_ErrorNone;
929 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
930 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
931 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
937 for (i = 0; i < MFC_OUTPUT_BUFFER_NUM_MAX; i++) {
938 if (pVideoDec->pMFCDecOutputBuffer[i] != NULL) {
939 for (j = 0; j < MFC_OUTPUT_BUFFER_PLANE; j++) {
940 if (pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j] != NULL &&
941 pWmvDec->hMFCWmvHandle.bShareableBuf == OMX_TRUE)
942 Exynos_OSAL_SharedMemory_Free(pVideoDec->hSharedMemory, pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j]);
945 Exynos_OSAL_Free(pVideoDec->pMFCDecOutputBuffer[i]);
949 Exynos_OSAL_Memset(pVideoDec->pMFCDecOutputBuffer, 0, sizeof(pVideoDec->pMFCDecOutputBuffer));
953 return OMX_ErrorNone;
956 OMX_ERRORTYPE WmvCodecDstAllocCodecBuffers(
957 OMX_COMPONENTTYPE *pOMXComponent,
960 OMX_ERRORTYPE ret = OMX_ErrorNone;
961 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
962 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
963 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
965 MEMORY_TYPE eMemoryType = NORMAL_MEMORY;
966 OMX_U32 nAllocLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
971 nAllocLen[0] = calc_yplane(pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth,
972 pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight);
973 nAllocLen[1] = calc_uvplane(pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth,
974 pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight >> 1);
976 for (i = 0; i < nOutbufs; i++) {
977 pVideoDec->pMFCDecOutputBuffer[i] = (CODEC_DEC_BUFFER *)Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
978 if (pVideoDec->pMFCDecOutputBuffer[i] == NULL) {
979 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Alloc codec buffer");
980 ret = OMX_ErrorInsufficientResources;
983 Exynos_OSAL_Memset(pVideoDec->pMFCDecOutputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
985 for (j = 0; j < MFC_OUTPUT_BUFFER_PLANE; j++) {
986 pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j] =
987 (void *)Exynos_OSAL_SharedMemory_Alloc(pVideoDec->hSharedMemory, nAllocLen[j], eMemoryType);
988 if (pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j] == NULL) {
989 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Alloc output buffer");
990 ret = OMX_ErrorInsufficientResources;
994 pVideoDec->pMFCDecOutputBuffer[i]->fd[j] =
995 Exynos_OSAL_SharedMemory_VirtToION(pVideoDec->hSharedMemory,
996 pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j]);
997 pVideoDec->pMFCDecOutputBuffer[i]->bufferSize[j] = nAllocLen[j];
1001 return OMX_ErrorNone;
1004 WmvCodecDstFreeCodecBuffers(pOMXComponent);
1011 OMX_ERRORTYPE WmvCodecDstRegistCodecBuffers(
1012 OMX_COMPONENTTYPE *pOMXComponent,
1015 OMX_ERRORTYPE ret = OMX_ErrorNone;
1016 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1017 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1018 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
1019 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
1020 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
1022 ExynosVideoPlane planes[MFC_OUTPUT_BUFFER_PLANE];
1023 OMX_U32 nDataLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
1028 /* Register output buffer */
1029 for (i = 0; i < nOutbufs; i++) {
1030 for (j = 0; j < MFC_OUTPUT_BUFFER_PLANE; j++) {
1031 planes[j].addr = pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j];
1032 planes[j].fd = pVideoDec->pMFCDecOutputBuffer[i]->fd[j];
1033 planes[j].allocSize = pVideoDec->pMFCDecOutputBuffer[i]->bufferSize[j];
1036 if (pOutbufOps->Register(hMFCHandle, planes, MFC_OUTPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
1037 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register output buffer");
1038 ret = OMX_ErrorInsufficientResources;
1042 pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr,
1043 (unsigned int *)nDataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
1046 ret = OMX_ErrorNone;
1054 OMX_ERRORTYPE WmvCodecResetupAllElement(
1055 OMX_COMPONENTTYPE *pOMXComponent,
1058 OMX_ERRORTYPE ret = OMX_ErrorNone;
1059 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1060 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1061 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
1062 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
1063 EXYNOS_OMX_BASEPORT *pOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1064 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
1070 if ((nPortIndex == INPUT_PORT_INDEX) &&
1071 (pWmvDec->bSourceStart == OMX_TRUE)) {
1072 ret = OMX_ErrorNotImplemented;
1074 } else if ((nPortIndex == OUTPUT_PORT_INDEX) &&
1075 (pWmvDec->bDestinationStart == OMX_TRUE)) {
1076 if (pOutputPort->bufferProcessType & BUFFER_COPY) {
1078 /**********************************/
1079 /* Codec Buffer Free & Unregister */
1080 /**********************************/
1081 WmvCodecDstFreeCodecBuffers(pOMXComponent);
1082 Exynos_CodecBufferReset(pExynosComponent, OUTPUT_PORT_INDEX);
1084 if (pWmvDec->hMFCWmvHandle.bShareableBuf == OMX_TRUE)
1085 pOutbufOps->Clear_RegisteredBuffer(hMFCHandle);
1087 pOutbufOps->Cleanup(hMFCHandle);
1088 /******************************************************/
1089 /* V4L2 Destnation Setup for DPB Buffer Number Change */
1090 /******************************************************/
1091 WmvCodecDstSetup(pOMXComponent);
1093 pVideoDec->bDRCProcessing = OMX_FALSE;
1094 } else if (pOutputPort->bufferProcessType & BUFFER_SHARE) {
1096 /**********************************/
1097 /* Codec Buffer Unregister */
1098 /**********************************/
1099 pOutbufOps->Clear_RegisteredBuffer(hMFCHandle);
1100 pOutbufOps->Cleanup(hMFCHandle);
1103 ret = OMX_ErrorBadParameter;
1113 OMX_ERRORTYPE WmvCodecSrcSetup(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
1115 OMX_ERRORTYPE ret = OMX_ErrorNone;
1116 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1117 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1118 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1119 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
1120 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1121 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1122 OMX_U32 oneFrameSize = pSrcInputData->dataLen;
1123 OMX_BOOL bMetaData = OMX_FALSE;
1125 ExynosVideoDecOps *pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
1126 ExynosVideoDecBufferOps *pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
1127 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
1128 ExynosVideoGeometry bufferConf;
1129 OMX_U32 inputBufferNumber = 0;
1134 if ((oneFrameSize <= 0) && (pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
1135 OMX_BUFFERHEADERTYPE *OMXBuffer = NULL;
1136 OMXBuffer = Exynos_OutputBufferGetQueue_Direct(pExynosComponent);
1137 if (OMXBuffer == NULL) {
1138 ret = OMX_ErrorUndefined;
1142 OMXBuffer->nTimeStamp = pSrcInputData->timeStamp;
1143 OMXBuffer->nFlags = pSrcInputData->nFlags;
1144 Exynos_OMX_OutputBufferReturn(pOMXComponent, OMXBuffer);
1146 ret = OMX_ErrorNone;
1150 if (!((pExynosInputPort->bufferProcessType & BUFFER_COPY) &&
1151 pWmvDec->hMFCWmvHandle.bShareableBuf == OMX_FALSE)) {
1152 if (pSrcInputData->nFlags & OMX_BUFFERFLAG_CODECCONFIG) {
1153 BitmapInfoHhr *pBitmapInfoHeader;
1154 pBitmapInfoHeader = (BitmapInfoHhr *)pSrcInputData->buffer.singlePlaneBuffer.dataBuffer;
1155 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "OMX_BUFFERFLAG_CODECCONFIG");
1156 if (pBitmapInfoHeader->BiCompression == wmv3) {
1157 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "WMV_FORMAT_WMV3");
1158 pWmvDec->hMFCWmvHandle.wmvFormat = WMV_FORMAT_WMV3;
1159 } else if ((pBitmapInfoHeader->BiCompression == wvc1) || (pBitmapInfoHeader->BiCompression == wmva)) {
1160 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "WMV_FORMAT_VC1");
1161 pWmvDec->hMFCWmvHandle.wmvFormat = WMV_FORMAT_VC1;
1165 ret = WmvCodecSrcInit(pOMXComponent);
1166 if (ret != OMX_ErrorNone)
1170 /* set output geometry */
1171 Exynos_OSAL_Memset(&bufferConf, 0, sizeof(bufferConf));
1172 pWmvDec->hMFCWmvHandle.MFCOutputColorType = bufferConf.eColorFormat = VIDEO_COLORFORMAT_NV12_TILED;
1173 if (pOutbufOps->Set_Geometry(hMFCHandle, &bufferConf) != VIDEO_ERROR_NONE) {
1174 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to set geometry for output buffer");
1175 ret = OMX_ErrorInsufficientResources;
1179 bMetaData = Make_Stream_MetaData(pSrcInputData->buffer.singlePlaneBuffer.dataBuffer, &oneFrameSize, pWmvDec->hMFCWmvHandle.wmvFormat
1181 , pExynosComponent->pExynosPort[INPUT_PORT_INDEX].portDefinition.format.video.nFrameWidth
1182 , pExynosComponent->pExynosPort[INPUT_PORT_INDEX].portDefinition.format.video.nFrameHeight
1185 if (bMetaData == OMX_FALSE) {
1186 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Fail to Make Stream MetaData");
1187 ret = OMX_ErrorInsufficientResources;
1191 /* input buffer enqueue for header parsing */
1192 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "oneFrameSize: %d", oneFrameSize);
1193 if (pInbufOps->Enqueue(hMFCHandle, (unsigned char **)&pSrcInputData->buffer.singlePlaneBuffer.dataBuffer,
1194 (unsigned int *)&oneFrameSize, MFC_INPUT_BUFFER_PLANE, pSrcInputData->bufferHeader) != VIDEO_ERROR_NONE) {
1195 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to enqueue input buffer for header parsing");
1196 // ret = OMX_ErrorInsufficientResources;
1197 ret = (OMX_ERRORTYPE)OMX_ErrorCodecInit;
1201 /* start header parsing */
1202 if (pInbufOps->Run(hMFCHandle) != VIDEO_ERROR_NONE) {
1203 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to run input buffer for header parsing");
1204 ret = OMX_ErrorCodecInit;
1208 ret = WmvCodecCheckResolutionChange(pOMXComponent);
1209 if (ret != OMX_ErrorNone) {
1210 ret = OMX_ErrorCodecInit;
1214 Exynos_OSAL_SleepMillisec(0);
1215 ret = OMX_ErrorInputDataDecodeYet;
1217 #ifdef USE_IMMEDIATE_DISPLAY
1218 /* Set Immediately display for I Frame*/
1219 pDecOps->Set_ImmediateDisplay(hMFCHandle);
1222 WmvCodecStop(pOMXComponent, INPUT_PORT_INDEX);
1228 OMX_ERRORTYPE WmvCodecDstSetup(OMX_COMPONENTTYPE *pOMXComponent)
1230 OMX_ERRORTYPE ret = OMX_ErrorNone;
1231 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1232 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1233 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1234 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
1235 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1236 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1238 ExynosVideoDecOps *pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
1239 ExynosVideoDecBufferOps *pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
1240 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
1247 nOutbufs = pWmvDec->hMFCWmvHandle.maxDPBNum;
1249 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1250 /* should be done before prepare output buffer */
1251 if (pOutbufOps->Enable_Cacheable(hMFCHandle) != VIDEO_ERROR_NONE) {
1252 ret = OMX_ErrorInsufficientResources;
1257 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE
1258 ||pWmvDec->hMFCWmvHandle.bShareableBuf == OMX_TRUE)
1259 pOutbufOps->Set_Shareable(hMFCHandle);
1261 if (pOutbufOps->Setup(hMFCHandle, nOutbufs) != VIDEO_ERROR_NONE) {
1262 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to setup output buffer");
1263 ret = OMX_ErrorInsufficientResources;
1267 ExynosVideoPlane planes[MFC_OUTPUT_BUFFER_PLANE];
1268 OMX_U32 nAllocLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
1269 OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
1272 nAllocLen[0] = calc_yplane(pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth,
1273 pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight);
1274 nAllocLen[1] = calc_uvplane(pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth,
1275 pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight >> 1);
1277 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY &&
1278 pWmvDec->hMFCWmvHandle.bShareableBuf == OMX_TRUE) {
1279 WmvCodecDstAllocCodecBuffers(pOMXComponent, nOutbufs);
1280 WmvCodecDstRegistCodecBuffers(pOMXComponent, nOutbufs);
1281 } else if (pExynosOutputPort->bufferProcessType & BUFFER_COPY &&
1282 pWmvDec->hMFCWmvHandle.bShareableBuf == OMX_FALSE) {
1283 /* Register output buffer */
1284 for (i = 0; i < nOutbufs; i++) {
1286 OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
1287 ExynosVideoBuffer *pBuffer = NULL;
1288 pVideoDec->pMFCDecOutputBuffer[i] = (CODEC_DEC_BUFFER *)Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
1289 Exynos_OSAL_Memset(pVideoDec->pMFCDecOutputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
1291 if (pOutbufOps->Get_Buffer) {
1292 if (pOutbufOps->Get_Buffer(pWmvDec->hMFCWmvHandle.hMFCHandle, i, &pBuffer) != VIDEO_ERROR_NONE) {
1293 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get Output buffer info");
1294 ret = OMX_ErrorInsufficientResources;
1299 for (plane = 0; plane < MFC_OUTPUT_BUFFER_PLANE; plane++) {
1300 pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[plane] = (void *)pBuffer->planes[plane].addr;
1301 pVideoDec->pMFCDecOutputBuffer[i]->fd[plane] = pBuffer->planes[plane].fd;
1302 pVideoDec->pMFCDecOutputBuffer[i]->bufferSize[plane] = pBuffer->planes[plane].allocSize;
1305 pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr,
1306 (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
1309 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1311 if (pExynosOutputPort->bIsPBEnabled == OMX_TRUE) {
1312 for (i = 0; i < pExynosOutputPort->assignedBufferNum; i++) {
1313 for (plane = 0; plane < MFC_OUTPUT_BUFFER_PLANE; plane++) {
1314 planes[plane].fd = pExynosOutputPort->extendBufferHeader[i].buf_fd[plane];
1315 planes[plane].addr = pExynosOutputPort->extendBufferHeader[i].pYUVBuf[plane];
1316 planes[plane].allocSize = nAllocLen[plane];
1319 if (pOutbufOps->Register(hMFCHandle, planes, MFC_OUTPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
1320 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register output buffer");
1321 ret = OMX_ErrorInsufficientResources;
1324 pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pExynosOutputPort->extendBufferHeader[i].pYUVBuf,
1325 (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
1328 ret = OMX_ErrorNotImplemented;
1332 ret = OMX_ErrorNotImplemented;
1337 if (pOutbufOps->Run(hMFCHandle) != VIDEO_ERROR_NONE) {
1338 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to run output buffer");
1339 ret = OMX_ErrorInsufficientResources;
1343 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1344 WmvCodecStop (pOMXComponent, OUTPUT_PORT_INDEX);
1346 pWmvDec->hMFCWmvHandle.bConfiguredMFCDst = OMX_TRUE;
1348 ret = OMX_ErrorNone;
1356 OMX_ERRORTYPE WmvCodecCheckResolutionChange(OMX_COMPONENTTYPE *pOMXComponent)
1358 OMX_ERRORTYPE ret = OMX_ErrorNone;
1359 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1360 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1361 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1362 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
1363 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1364 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1366 ExynosVideoDecOps *pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
1367 ExynosVideoDecBufferOps *pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
1368 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
1369 ExynosVideoGeometry bufferConf;
1374 /* get geometry for output */
1375 Exynos_OSAL_Memset(&pWmvDec->hMFCWmvHandle.codecOutbufConf, 0, sizeof(ExynosVideoGeometry));
1376 if (pOutbufOps->Get_Geometry(hMFCHandle, &pWmvDec->hMFCWmvHandle.codecOutbufConf) != VIDEO_ERROR_NONE) {
1377 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get geometry for parsed header info");
1378 ret = OMX_ErrorInsufficientResources;
1383 pWmvDec->hMFCWmvHandle.maxDPBNum = pDecOps->Get_ActualBufferCount(hMFCHandle);
1384 if (pVideoDec->bThumbnailMode == OMX_FALSE)
1385 pWmvDec->hMFCWmvHandle.maxDPBNum += EXTRA_DPB_NUM;
1386 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "WmvCodecCheckResolutionChange WmvCodecSetup nOutbufs: %d", pWmvDec->hMFCWmvHandle.maxDPBNum);
1388 pWmvDec->hMFCWmvHandle.bConfiguredMFCSrc = OMX_TRUE;
1390 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1391 if ((pVideoDec->bDRCProcessing) ||
1392 (pExynosInputPort->portDefinition.format.video.nFrameWidth != pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth) ||
1393 (pExynosInputPort->portDefinition.format.video.nFrameHeight != pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight)) {
1394 pExynosInputPort->portDefinition.format.video.nFrameWidth = pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth;
1395 pExynosInputPort->portDefinition.format.video.nFrameHeight = pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight;
1396 pExynosInputPort->portDefinition.format.video.nStride = ((pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth + 15) & (~15));
1397 pExynosInputPort->portDefinition.format.video.nSliceHeight = ((pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight + 15) & (~15));
1399 if (pVideoDec->bDRCProcessing == OMX_TRUE) {
1400 pVideoDec->nDRCSavedBufferCount = pExynosOutputPort->portDefinition.nBufferCountActual;
1402 Exynos_UpdateFrameSize(pOMXComponent);
1403 pExynosOutputPort->exceptionFlag = NEED_PORT_DISABLE;
1405 /** Send Port Settings changed call back **/
1406 (*(pExynosComponent->pCallbacks->EventHandler))
1408 pExynosComponent->callbackData,
1409 OMX_EventPortSettingsChanged, /* The command was completed */
1410 OMX_DirOutput, /* This is the port index */
1414 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1415 if ((pExynosInputPort->portDefinition.format.video.nFrameWidth != pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth) ||
1416 (pExynosInputPort->portDefinition.format.video.nFrameHeight != pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight) ||
1417 (pExynosOutputPort->portDefinition.nBufferCountActual != pWmvDec->hMFCWmvHandle.maxDPBNum)) {
1418 pExynosInputPort->portDefinition.format.video.nFrameWidth = pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth;
1419 pExynosInputPort->portDefinition.format.video.nFrameHeight = pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight;
1420 pExynosInputPort->portDefinition.format.video.nStride = ((pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth + 15) & (~15));
1421 pExynosInputPort->portDefinition.format.video.nSliceHeight = ((pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight + 15) & (~15));
1423 if (pVideoDec->bDRCProcessing == OMX_TRUE) {
1424 pVideoDec->nDRCSavedBufferCount = pExynosOutputPort->portDefinition.nBufferCountActual;
1427 pExynosOutputPort->portDefinition.nBufferCountActual = pWmvDec->hMFCWmvHandle.maxDPBNum;
1428 pExynosOutputPort->portDefinition.nBufferCountMin = pWmvDec->hMFCWmvHandle.maxDPBNum;
1430 pExynosOutputPort->portDefinition.nBufferCountActual = pWmvDec->hMFCWmvHandle.maxDPBNum - 4;
1431 pExynosOutputPort->portDefinition.nBufferCountMin = pWmvDec->hMFCWmvHandle.maxDPBNum - 4;
1433 Exynos_UpdateFrameSize(pOMXComponent);
1434 pExynosOutputPort->exceptionFlag = NEED_PORT_DISABLE;
1436 /** Send Port Settings changed call back **/
1437 (*(pExynosComponent->pCallbacks->EventHandler))
1439 pExynosComponent->callbackData,
1440 OMX_EventPortSettingsChanged, /* The command was completed */
1441 OMX_DirOutput, /* This is the port index */
1447 ret = OMX_ErrorNone;
1455 OMX_ERRORTYPE Exynos_WmvDec_GetParameter(
1456 OMX_IN OMX_HANDLETYPE hComponent,
1457 OMX_IN OMX_INDEXTYPE nParamIndex,
1458 OMX_INOUT OMX_PTR pComponentParameterStructure)
1460 OMX_ERRORTYPE ret = OMX_ErrorNone;
1461 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1462 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1466 if (hComponent == NULL || pComponentParameterStructure == NULL) {
1467 ret = OMX_ErrorBadParameter;
1470 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1471 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1472 if (ret != OMX_ErrorNone) {
1475 if (pOMXComponent->pComponentPrivate == NULL) {
1476 ret = OMX_ErrorBadParameter;
1480 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1481 if (pExynosComponent->currentState == OMX_StateInvalid ) {
1482 ret = OMX_ErrorInvalidState;
1486 switch (nParamIndex) {
1487 case OMX_IndexParamVideoWmv:
1489 OMX_VIDEO_PARAM_WMVTYPE *pDstWmvParam = (OMX_VIDEO_PARAM_WMVTYPE *)pComponentParameterStructure;
1490 OMX_VIDEO_PARAM_WMVTYPE *pSrcWmvParam = NULL;
1491 EXYNOS_WMVDEC_HANDLE *pWmvDec = NULL;
1492 ret = Exynos_OMX_Check_SizeVersion(pDstWmvParam, sizeof(OMX_VIDEO_PARAM_WMVTYPE));
1493 if (ret != OMX_ErrorNone) {
1497 if (pDstWmvParam->nPortIndex > OUTPUT_PORT_INDEX) {
1498 ret = OMX_ErrorBadPortIndex;
1501 pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1502 pSrcWmvParam = &pWmvDec->WmvComponent[pDstWmvParam->nPortIndex];
1504 Exynos_OSAL_Memcpy(pDstWmvParam, pSrcWmvParam, sizeof(OMX_VIDEO_PARAM_WMVTYPE));
1508 case OMX_IndexParamStandardComponentRole:
1510 OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE *)pComponentParameterStructure;
1511 ret = Exynos_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1512 if (ret != OMX_ErrorNone) {
1516 Exynos_OSAL_Strcpy((char *)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_WMV_DEC_ROLE);
1519 case OMX_IndexParamVideoErrorCorrection:
1521 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
1522 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = NULL;
1523 EXYNOS_WMVDEC_HANDLE *pWmvDec = NULL;
1525 ret = Exynos_OMX_Check_SizeVersion(pDstErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
1526 if (ret != OMX_ErrorNone) {
1530 if (pDstErrorCorrectionType->nPortIndex != INPUT_PORT_INDEX) {
1531 ret = OMX_ErrorBadPortIndex;
1535 pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1536 pSrcErrorCorrectionType = &pWmvDec->errorCorrectionType[INPUT_PORT_INDEX];
1538 pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
1539 pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
1540 pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
1541 pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
1542 pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
1546 ret = Exynos_OMX_VideoDecodeGetParameter(hComponent, nParamIndex, pComponentParameterStructure);
1555 OMX_ERRORTYPE Exynos_WmvDec_SetParameter(
1556 OMX_IN OMX_HANDLETYPE hComponent,
1557 OMX_IN OMX_INDEXTYPE nIndex,
1558 OMX_IN OMX_PTR pComponentParameterStructure)
1560 OMX_ERRORTYPE ret = OMX_ErrorNone;
1561 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1562 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1566 if (hComponent == NULL || pComponentParameterStructure == NULL) {
1567 ret = OMX_ErrorBadParameter;
1570 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1571 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1572 if (ret != OMX_ErrorNone) {
1575 if (pOMXComponent->pComponentPrivate == NULL) {
1576 ret = OMX_ErrorBadParameter;
1580 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1581 if (pExynosComponent->currentState == OMX_StateInvalid ) {
1582 ret = OMX_ErrorInvalidState;
1587 case OMX_IndexParamVideoWmv:
1589 OMX_VIDEO_PARAM_WMVTYPE *pDstWmvParam = NULL;
1590 OMX_VIDEO_PARAM_WMVTYPE *pSrcWmvParam = (OMX_VIDEO_PARAM_WMVTYPE *)pComponentParameterStructure;
1591 EXYNOS_WMVDEC_HANDLE *pWmvDec = NULL;
1592 ret = Exynos_OMX_Check_SizeVersion(pSrcWmvParam, sizeof(OMX_VIDEO_PARAM_WMVTYPE));
1593 if (ret != OMX_ErrorNone) {
1597 if (pSrcWmvParam->nPortIndex > OUTPUT_PORT_INDEX) {
1598 ret = OMX_ErrorBadPortIndex;
1602 pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1603 pDstWmvParam = &pWmvDec->WmvComponent[pSrcWmvParam->nPortIndex];
1605 Exynos_OSAL_Memcpy(pDstWmvParam, pSrcWmvParam, sizeof(OMX_VIDEO_PARAM_WMVTYPE));
1608 case OMX_IndexParamStandardComponentRole:
1610 OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE*)pComponentParameterStructure;
1612 ret = Exynos_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1613 if (ret != OMX_ErrorNone) {
1617 if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1618 ret = OMX_ErrorIncorrectStateOperation;
1622 if (!Exynos_OSAL_Strcmp((char*)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_WMV_DEC_ROLE)) {
1623 pExynosComponent->pExynosPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingWMV;
1625 ret = OMX_ErrorBadParameter;
1630 case OMX_IndexParamPortDefinition:
1632 OMX_PARAM_PORTDEFINITIONTYPE *pPortDefinition = (OMX_PARAM_PORTDEFINITIONTYPE *)pComponentParameterStructure;
1633 OMX_U32 portIndex = pPortDefinition->nPortIndex;
1634 EXYNOS_OMX_BASEPORT *pExynosPort;
1635 OMX_U32 width, height, size;
1636 OMX_U32 realWidth, realHeight;
1637 OMX_PARAM_PORTDEFINITIONTYPE portDefinition_backup;
1639 if (portIndex >= pExynosComponent->portParam.nPorts) {
1640 ret = OMX_ErrorBadPortIndex;
1643 ret = Exynos_OMX_Check_SizeVersion(pPortDefinition, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1644 if (ret != OMX_ErrorNone) {
1648 pExynosPort = &pExynosComponent->pExynosPort[portIndex];
1650 if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1651 if (pExynosPort->portDefinition.bEnabled == OMX_TRUE) {
1652 ret = OMX_ErrorIncorrectStateOperation;
1656 if (pPortDefinition->nBufferCountActual < pExynosPort->portDefinition.nBufferCountMin) {
1657 ret = OMX_ErrorBadParameter;
1661 Exynos_OSAL_Memcpy(&portDefinition_backup, &pExynosPort->portDefinition, pPortDefinition->nSize);
1662 Exynos_OSAL_Memcpy(&pExynosPort->portDefinition, pPortDefinition, pPortDefinition->nSize);
1663 RESTORE_READONLYPARAMETERS_OMX_PARAM_PORTDEFINITIONTYPE(&pExynosPort->portDefinition,&portDefinition_backup);
1665 realWidth = pExynosPort->portDefinition.format.video.nFrameWidth;
1666 realHeight = pExynosPort->portDefinition.format.video.nFrameHeight;
1667 width = ((realWidth + 15) & (~15));
1668 height = ((realHeight + 15) & (~15));
1669 size = (width * height * 3) / 2;
1670 pExynosPort->portDefinition.format.video.nStride = width;
1671 pExynosPort->portDefinition.format.video.nSliceHeight = height;
1672 pExynosPort->portDefinition.nBufferSize = (size > pExynosPort->portDefinition.nBufferSize) ? size : pExynosPort->portDefinition.nBufferSize;
1674 if (portIndex == INPUT_PORT_INDEX) {
1675 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1676 pExynosOutputPort->portDefinition.format.video.nFrameWidth = pExynosPort->portDefinition.format.video.nFrameWidth;
1677 pExynosOutputPort->portDefinition.format.video.nFrameHeight = pExynosPort->portDefinition.format.video.nFrameHeight;
1678 pExynosOutputPort->portDefinition.format.video.nStride = width;
1679 pExynosOutputPort->portDefinition.format.video.nSliceHeight = height;
1681 switch (pExynosOutputPort->portDefinition.format.video.eColorFormat) {
1682 case OMX_COLOR_FormatYUV420Planar:
1683 case OMX_COLOR_FormatYUV420SemiPlanar:
1684 pExynosOutputPort->portDefinition.nBufferSize = (width * height * 3) / 2;
1686 #ifdef SLP_PLATFORM /* NV12T fd */
1687 case OMX_SEC_COLOR_FormatNV12T_DmaBuf_Fd:
1688 pExynosOutputPort->portDefinition.nBufferSize = sizeof(SCMN_IMGB);
1691 case OMX_SEC_COLOR_FormatNV12Tiled:
1692 pExynosOutputPort->portDefinition.nBufferSize =
1693 calc_yplane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight) +
1694 calc_uvplane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight >> 1);
1697 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Color format is not support!! use default YUV size!!");
1698 ret = OMX_ErrorUnsupportedSetting;
1702 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1703 pExynosOutputPort->portDefinition.nBufferSize =
1704 calc_yplane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight) +
1705 calc_uvplane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight >> 1);
1710 case OMX_IndexParamVideoErrorCorrection:
1712 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
1713 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = NULL;
1714 EXYNOS_WMVDEC_HANDLE *pWmvDec = NULL;
1716 ret = Exynos_OMX_Check_SizeVersion(pSrcErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
1717 if (ret != OMX_ErrorNone) {
1721 if (pSrcErrorCorrectionType->nPortIndex != INPUT_PORT_INDEX) {
1722 ret = OMX_ErrorBadPortIndex;
1726 pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1727 pDstErrorCorrectionType = &pWmvDec->errorCorrectionType[INPUT_PORT_INDEX];
1729 pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
1730 pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
1731 pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
1732 pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
1733 pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
1737 ret = Exynos_OMX_VideoDecodeSetParameter(hComponent, nIndex, pComponentParameterStructure);
1746 OMX_ERRORTYPE Exynos_WmvDec_GetConfig(
1747 OMX_HANDLETYPE hComponent,
1748 OMX_INDEXTYPE nIndex,
1749 OMX_PTR pComponentConfigStructure)
1751 OMX_ERRORTYPE ret = OMX_ErrorNone;
1752 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1753 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1757 if (hComponent == NULL || pComponentConfigStructure == NULL) {
1758 ret = OMX_ErrorBadParameter;
1761 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1762 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1763 if (ret != OMX_ErrorNone) {
1766 if (pOMXComponent->pComponentPrivate == NULL) {
1767 ret = OMX_ErrorBadParameter;
1770 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1771 if (pExynosComponent->currentState == OMX_StateInvalid) {
1772 ret = OMX_ErrorInvalidState;
1778 ret = Exynos_OMX_VideoDecodeGetConfig(hComponent, nIndex, pComponentConfigStructure);
1788 OMX_ERRORTYPE Exynos_WmvDec_SetConfig(
1789 OMX_HANDLETYPE hComponent,
1790 OMX_INDEXTYPE nIndex,
1791 OMX_PTR pComponentConfigStructure)
1793 OMX_ERRORTYPE ret = OMX_ErrorNone;
1794 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1795 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1799 if (hComponent == NULL || pComponentConfigStructure == NULL) {
1800 ret = OMX_ErrorBadParameter;
1803 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1804 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1805 if (ret != OMX_ErrorNone) {
1808 if (pOMXComponent->pComponentPrivate == NULL) {
1809 ret = OMX_ErrorBadParameter;
1812 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1813 if (pExynosComponent->currentState == OMX_StateInvalid) {
1814 ret = OMX_ErrorInvalidState;
1820 ret = Exynos_OMX_VideoDecodeSetConfig(hComponent, nIndex, pComponentConfigStructure);
1830 OMX_ERRORTYPE Exynos_WmvDec_GetExtensionIndex(
1831 OMX_IN OMX_HANDLETYPE hComponent,
1832 OMX_IN OMX_STRING cParameterName,
1833 OMX_OUT OMX_INDEXTYPE *pIndexType)
1835 OMX_ERRORTYPE ret = OMX_ErrorNone;
1836 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1837 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1841 if (hComponent == NULL) {
1842 ret = OMX_ErrorBadParameter;
1845 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1846 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1847 if (ret != OMX_ErrorNone) {
1850 if (pOMXComponent->pComponentPrivate == NULL) {
1851 ret = OMX_ErrorBadParameter;
1854 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1855 if ((cParameterName == NULL) || (pIndexType == NULL)) {
1856 ret = OMX_ErrorBadParameter;
1859 if (pExynosComponent->currentState == OMX_StateInvalid) {
1860 ret = OMX_ErrorInvalidState;
1864 if (Exynos_OSAL_Strcmp(cParameterName, EXYNOS_INDEX_PARAM_ENABLE_THUMBNAIL) == 0) {
1865 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1866 *pIndexType = OMX_IndexVendorThumbnailMode;
1867 ret = OMX_ErrorNone;
1869 ret = Exynos_OMX_VideoDecodeGetExtensionIndex(hComponent, cParameterName, pIndexType);
1878 OMX_ERRORTYPE Exynos_WmvDec_ComponentRoleEnum(
1879 OMX_HANDLETYPE hComponent,
1883 OMX_ERRORTYPE ret = OMX_ErrorNone;
1884 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1885 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1889 if ((hComponent == NULL) || (cRole == NULL)) {
1890 ret = OMX_ErrorBadParameter;
1893 if (nIndex == (MAX_COMPONENT_ROLE_NUM-1)) {
1894 Exynos_OSAL_Strcpy((char *)cRole, EXYNOS_OMX_COMPONENT_WMV_DEC_ROLE);
1895 ret = OMX_ErrorNone;
1897 ret = OMX_ErrorNoMore;
1907 OMX_ERRORTYPE Exynos_WmvDec_Init(OMX_COMPONENTTYPE *pOMXComponent)
1909 OMX_ERRORTYPE ret = OMX_ErrorNone;
1910 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1911 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1912 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1913 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1914 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
1915 OMX_PTR hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
1917 ExynosVideoDecOps *pDecOps = NULL;
1918 ExynosVideoDecBufferOps *pInbufOps = NULL;
1919 ExynosVideoDecBufferOps *pOutbufOps = NULL;
1921 CSC_METHOD csc_method = CSC_METHOD_SW;
1926 pWmvDec->hMFCWmvHandle.bConfiguredMFCSrc = OMX_FALSE;
1927 pWmvDec->hMFCWmvHandle.bConfiguredMFCDst = OMX_FALSE;
1928 pExynosComponent->bUseFlagEOF = OMX_TRUE;
1929 pExynosComponent->bSaveFlagEOS = OMX_FALSE;
1931 /* WMV Codec Open */
1932 ret = WmvCodecOpen(pWmvDec);
1933 if (ret != OMX_ErrorNone) {
1937 pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
1938 pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
1939 pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
1941 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
1942 Exynos_OSAL_SemaphoreCreate(&pExynosInputPort->codecSemID);
1943 Exynos_OSAL_QueueCreate(&pExynosInputPort->codecBufferQ, MAX_QUEUE_ELEMENTS);
1945 if (pWmvDec->hMFCWmvHandle.bShareableBuf == OMX_TRUE) {
1946 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
1947 pVideoDec->pMFCDecInputBuffer[i] = Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
1948 Exynos_OSAL_Memset(pVideoDec->pMFCDecInputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
1949 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]);
1951 for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
1952 /* Use ION Allocator */
1953 pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] = (void *)Exynos_OSAL_SharedMemory_Alloc(pVideoDec->hSharedMemory, DEFAULT_MFC_INPUT_BUFFER_SIZE, NORMAL_MEMORY);
1954 pVideoDec->pMFCDecInputBuffer[i]->fd[plane] = Exynos_OSAL_SharedMemory_VirtToION(pVideoDec->hSharedMemory, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
1955 pVideoDec->pMFCDecInputBuffer[i]->bufferSize[plane] = DEFAULT_MFC_INPUT_BUFFER_SIZE;
1956 pVideoDec->pMFCDecInputBuffer[i]->dataSize = 0;
1957 if (pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] == NULL) {
1958 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Fail input buffer");
1959 ret = OMX_ErrorInsufficientResources;
1962 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]->pVirAddr[%d]: 0x%x", i, plane, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
1964 Exynos_CodecBufferEnQueue(pExynosComponent, INPUT_PORT_INDEX, pVideoDec->pMFCDecInputBuffer[i]);
1970 /* Does not require any actions. */
1972 } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
1976 /* Does not require any actions. */
1979 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1980 Exynos_OSAL_SemaphoreCreate(&pExynosOutputPort->codecSemID);
1981 Exynos_OSAL_QueueCreate(&pExynosOutputPort->codecBufferQ, MAX_QUEUE_ELEMENTS);
1982 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1986 /* Does not require any actions. */
1989 pWmvDec->bSourceStart = OMX_FALSE;
1990 Exynos_OSAL_SignalCreate(&pWmvDec->hSourceStartEvent);
1991 pWmvDec->bDestinationStart = OMX_FALSE;
1992 Exynos_OSAL_SignalCreate(&pWmvDec->hDestinationStartEvent);
1994 Exynos_OSAL_Memset(pExynosComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
1995 Exynos_OSAL_Memset(pExynosComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
1996 pWmvDec->hMFCWmvHandle.indexTimestamp = 0;
1997 pWmvDec->hMFCWmvHandle.outputIndexTimestamp = 0;
1998 /* Default WMV codec format is set as VC1*/
1999 pWmvDec->hMFCWmvHandle.wmvFormat = WMV_FORMAT_WMV3;//WMV_FORMAT_VC1;
2001 pExynosComponent->getAllDelayBuffer = OMX_FALSE;
2003 #if 0//defined(USE_CSC_GSCALER)
2004 csc_method = CSC_METHOD_HW; //in case of Use ION buffer.
2006 pVideoDec->csc_handle = csc_init(csc_method);
2007 if (pVideoDec->csc_handle == NULL) {
2008 ret = OMX_ErrorInsufficientResources;
2011 pVideoDec->csc_set_format = OMX_FALSE;
2020 OMX_ERRORTYPE Exynos_WmvDec_Terminate(OMX_COMPONENTTYPE *pOMXComponent)
2022 OMX_ERRORTYPE ret = OMX_ErrorNone;
2023 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2024 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2025 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2026 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2027 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2028 OMX_PTR hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
2030 ExynosVideoDecOps *pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
2031 ExynosVideoDecBufferOps *pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
2032 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
2038 if (pVideoDec->csc_handle != NULL) {
2039 csc_deinit(pVideoDec->csc_handle);
2040 pVideoDec->csc_handle = NULL;
2043 Exynos_OSAL_SignalTerminate(pWmvDec->hDestinationStartEvent);
2044 pWmvDec->hDestinationStartEvent = NULL;
2045 pWmvDec->bDestinationStart = OMX_FALSE;
2046 Exynos_OSAL_SignalTerminate(pWmvDec->hSourceStartEvent);
2047 pWmvDec->hSourceStartEvent = NULL;
2048 pWmvDec->bSourceStart = OMX_FALSE;
2050 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
2051 WmvCodecDstFreeCodecBuffers(pOMXComponent);
2053 Exynos_OSAL_QueueTerminate(&pExynosOutputPort->codecBufferQ);
2054 Exynos_OSAL_SemaphoreTerminate(pExynosOutputPort->codecSemID);
2055 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
2059 /* Does not require any actions. */
2062 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2063 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
2064 if (pVideoDec->pMFCDecInputBuffer[i] != NULL) {
2065 for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
2066 if (pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] != NULL)
2067 Exynos_OSAL_SharedMemory_Free(pVideoDec->hSharedMemory, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
2070 Exynos_OSAL_Free(pVideoDec->pMFCDecInputBuffer[i]);
2071 pVideoDec->pMFCDecInputBuffer[i] = NULL;
2075 Exynos_OSAL_QueueTerminate(&pExynosInputPort->codecBufferQ);
2076 Exynos_OSAL_SemaphoreTerminate(pExynosInputPort->codecSemID);
2077 } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
2081 /* Does not require any actions. */
2083 WmvCodecClose(pWmvDec);
2091 OMX_ERRORTYPE Exynos_WmvDec_SrcIn(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
2093 OMX_ERRORTYPE ret = OMX_ErrorNone;
2094 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2095 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2096 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2097 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
2098 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2099 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2100 OMX_U32 oneFrameSize = pSrcInputData->dataLen;
2101 OMX_BOOL bStartCode = OMX_FALSE;
2102 ExynosVideoDecOps *pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
2103 ExynosVideoDecBufferOps *pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
2104 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
2105 ExynosVideoErrorType codecReturn = VIDEO_ERROR_NONE;
2110 if (pWmvDec->hMFCWmvHandle.bConfiguredMFCSrc == OMX_FALSE) {
2111 ret = WmvCodecSrcSetup(pOMXComponent, pSrcInputData);
2114 if (pWmvDec->hMFCWmvHandle.bConfiguredMFCDst == OMX_FALSE) {
2115 ret = WmvCodecDstSetup(pOMXComponent);
2118 bStartCode = Check_Stream_PrefixCode(pSrcInputData->buffer.singlePlaneBuffer.dataBuffer, oneFrameSize, pWmvDec->hMFCWmvHandle.wmvFormat);
2119 if (bStartCode == OMX_FALSE && ((pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS)) {
2120 if (pSrcInputData->allocSize < oneFrameSize+4) {
2121 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Can't attach startcode due to lack of buffer space");
2122 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2126 bStartCode = Make_Stream_StartCode(pSrcInputData->buffer.singlePlaneBuffer.dataBuffer, &oneFrameSize, pWmvDec->hMFCWmvHandle.wmvFormat);
2127 if (bStartCode == OMX_FALSE) {
2128 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Fail to Make Stream Start Code");
2129 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2134 if ((bStartCode == OMX_TRUE) || ((pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)){
2135 pExynosComponent->timeStamp[pWmvDec->hMFCWmvHandle.indexTimestamp] = pSrcInputData->timeStamp;
2136 pExynosComponent->nFlags[pWmvDec->hMFCWmvHandle.indexTimestamp] = pSrcInputData->nFlags;
2137 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);
2138 pDecOps->Set_FrameTag(hMFCHandle, pWmvDec->hMFCWmvHandle.indexTimestamp);
2139 pWmvDec->hMFCWmvHandle.indexTimestamp++;
2140 pWmvDec->hMFCWmvHandle.indexTimestamp %= MAX_TIMESTAMP;
2142 #ifdef USE_IMMEDIATE_DISPLAY
2143 /* Set Immediately display for I Frame*/
2144 if (pExynosComponent->checkTimeStamp.needCheckStartTimeStamp == OMX_TRUE) {
2145 if ( pExynosComponent->checkTimeStamp.bImmediateDisplay == OMX_FALSE) {
2146 /* Enable Immediately display After seek*/
2147 pDecOps->Set_ImmediateDisplay(hMFCHandle);
2148 pExynosComponent->checkTimeStamp.bImmediateDisplay = OMX_TRUE;
2153 /* queue work for input buffer */
2154 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "oneFrameSize: %d, bufferHeader: 0x%x, dataBuffer: 0x%x", oneFrameSize, pSrcInputData->bufferHeader, pSrcInputData->buffer.singlePlaneBuffer.dataBuffer);
2155 codecReturn = pInbufOps->Enqueue(hMFCHandle, (unsigned char **)&pSrcInputData->buffer.singlePlaneBuffer.dataBuffer,
2156 (unsigned int *)&oneFrameSize, MFC_INPUT_BUFFER_PLANE, pSrcInputData->bufferHeader);
2157 if (codecReturn != VIDEO_ERROR_NONE) {
2158 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2159 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s : %d", __FUNCTION__, __LINE__);
2162 WmvCodecStart(pOMXComponent, INPUT_PORT_INDEX);
2163 if (pWmvDec->bSourceStart == OMX_FALSE) {
2164 pWmvDec->bSourceStart = OMX_TRUE;
2165 Exynos_OSAL_SignalSet(pWmvDec->hSourceStartEvent);
2166 Exynos_OSAL_SleepMillisec(0);
2168 if (pWmvDec->bDestinationStart == OMX_FALSE) {
2169 pWmvDec->bDestinationStart = OMX_TRUE;
2170 Exynos_OSAL_SignalSet(pWmvDec->hDestinationStartEvent);
2171 Exynos_OSAL_SleepMillisec(0);
2175 ret = OMX_ErrorNone;
2183 OMX_ERRORTYPE Exynos_WmvDec_SrcOut(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcOutputData)
2185 OMX_ERRORTYPE ret = OMX_ErrorNone;
2186 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2187 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2188 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2189 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
2190 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2191 ExynosVideoDecOps *pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
2192 ExynosVideoDecBufferOps *pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
2193 ExynosVideoBuffer *pVideoBuffer;
2197 pVideoBuffer = pInbufOps->Dequeue(hMFCHandle);
2199 pSrcOutputData->dataLen = 0;
2200 pSrcOutputData->usedDataLen = 0;
2201 pSrcOutputData->remainDataLen = 0;
2202 pSrcOutputData->nFlags = 0;
2203 pSrcOutputData->timeStamp = 0;
2205 if (pVideoBuffer == NULL) {
2206 pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer = NULL;
2207 pSrcOutputData->allocSize = 0;
2208 pSrcOutputData->pPrivate = NULL;
2209 pSrcOutputData->bufferHeader = NULL;
2211 pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer = pVideoBuffer->planes[0].addr;
2212 pSrcOutputData->buffer.singlePlaneBuffer.fd = pVideoBuffer->planes[0].fd;
2213 pSrcOutputData->allocSize = pVideoBuffer->planes[0].allocSize;
2215 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2217 while (pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer != pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[0]) {
2218 if (i >= MFC_INPUT_BUFFER_NUM_MAX) {
2219 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Can not find buffer");
2220 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2225 pVideoDec->pMFCDecInputBuffer[i]->dataSize = 0;
2226 pSrcOutputData->pPrivate = pVideoDec->pMFCDecInputBuffer[i];
2229 /* For Share Buffer */
2230 pSrcOutputData->bufferHeader = (OMX_BUFFERHEADERTYPE*)pVideoBuffer->pPrivate;
2233 ret = OMX_ErrorNone;
2241 OMX_ERRORTYPE Exynos_WmvDec_DstIn(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstInputData)
2243 OMX_ERRORTYPE ret = OMX_ErrorNone;
2244 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2245 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2246 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2247 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
2248 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2249 ExynosVideoDecOps *pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
2250 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
2251 OMX_U32 dataLen[2] = {0,};
2252 ExynosVideoErrorType codecReturn = VIDEO_ERROR_NONE;
2256 if (pDstInputData->buffer.multiPlaneBuffer.dataBuffer[0] == NULL) {
2257 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to find input buffer");
2258 ret = OMX_ErrorBadParameter;
2262 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "%s : %d => ADDR[0]: 0x%x, ADDR[1]: 0x%x", __FUNCTION__, __LINE__,
2263 pDstInputData->buffer.multiPlaneBuffer.dataBuffer[0],
2264 pDstInputData->buffer.multiPlaneBuffer.dataBuffer[1]);
2266 if ((pVideoDec->bDRCProcessing == OMX_TRUE) &&
2267 (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) &&
2268 (pExynosOutputPort->exceptionFlag == GENERAL_STATE)) {
2269 ret = WmvCodecDstSetup(pOMXComponent);
2270 if (ret != OMX_ErrorNone) {
2271 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "DRC Reconfig CodecDstSetup Failed");
2274 pVideoDec->bDRCProcessing = OMX_FALSE;
2277 codecReturn = pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pDstInputData->buffer.multiPlaneBuffer.dataBuffer,
2278 (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, pDstInputData->bufferHeader);
2281 if (codecReturn != VIDEO_ERROR_NONE) {
2282 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s : %d", __FUNCTION__, __LINE__);
2283 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2286 WmvCodecStart(pOMXComponent, OUTPUT_PORT_INDEX);
2288 ret = OMX_ErrorNone;
2296 OMX_ERRORTYPE Exynos_WmvDec_DstOut(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstOutputData)
2298 OMX_ERRORTYPE ret = OMX_ErrorNone;
2299 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2300 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2301 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2302 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
2303 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2304 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2305 ExynosVideoDecOps *pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
2306 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
2307 ExynosVideoBuffer *pVideoBuffer;
2308 ExynosVideoFrameStatusType displayStatus = VIDEO_FRAME_STATUS_UNKNOWN;
2309 ExynosVideoGeometry *bufferGeometry;
2310 DECODE_CODEC_EXTRA_BUFFERINFO *pBufferInfo = NULL;
2311 OMX_S32 indexTimestamp = 0;
2316 if (pWmvDec->bDestinationStart == OMX_FALSE) {
2317 ret = OMX_ErrorNone;
2322 pVideoBuffer = pOutbufOps->Dequeue(hMFCHandle);
2323 if (pVideoBuffer == (ExynosVideoBuffer *)VIDEO_ERROR_DQBUF_EIO) {
2324 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "HW is not available");
2325 ret = OMX_ErrorHardware;
2329 if (pVideoBuffer == NULL) {
2330 ret = OMX_ErrorNone;
2333 displayStatus = pVideoBuffer->displayStatus;
2334 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "displayStatus: 0x%x", displayStatus);
2336 if ((displayStatus == VIDEO_FRAME_STATUS_DISPLAY_DECODING) ||
2337 (displayStatus == VIDEO_FRAME_STATUS_DISPLAY_ONLY) ||
2338 (displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) ||
2339 (displayStatus == VIDEO_FRAME_STATUS_DECODING_FINISHED) ||
2340 (CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2341 if (pVideoBuffer != NULL) {
2342 ret = OMX_ErrorNone;
2345 ret = OMX_ErrorUndefined;
2351 if (displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) {
2352 if (pVideoDec->bDRCProcessing != OMX_TRUE) {
2353 pExynosOutputPort->exceptionFlag = NEED_PORT_FLUSH;
2354 pVideoDec->bDRCProcessing = OMX_TRUE;
2355 WmvCodecCheckResolutionChange(pOMXComponent);
2356 pVideoDec->csc_set_format = OMX_FALSE;
2358 ret = OMX_ErrorNone;
2362 pWmvDec->hMFCWmvHandle.outputIndexTimestamp++;
2363 pWmvDec->hMFCWmvHandle.outputIndexTimestamp %= MAX_TIMESTAMP;
2365 pDstOutputData->allocSize = pDstOutputData->dataLen = 0;
2366 for (plane = 0; plane < MFC_OUTPUT_BUFFER_PLANE; plane++) {
2367 pDstOutputData->buffer.multiPlaneBuffer.dataBuffer[plane] = pVideoBuffer->planes[plane].addr;
2368 pDstOutputData->buffer.multiPlaneBuffer.fd[plane] = pVideoBuffer->planes[plane].fd;
2369 pDstOutputData->allocSize += pVideoBuffer->planes[plane].allocSize;
2370 pDstOutputData->dataLen += pVideoBuffer->planes[plane].dataSize;
2372 pDstOutputData->usedDataLen = 0;
2373 pDstOutputData->pPrivate = pVideoBuffer;
2374 /* For Share Buffer */
2375 pDstOutputData->bufferHeader = (OMX_BUFFERHEADERTYPE *)pVideoBuffer->pPrivate;
2377 pBufferInfo = (DECODE_CODEC_EXTRA_BUFFERINFO *)pDstOutputData->extInfo;
2378 bufferGeometry = &pWmvDec->hMFCWmvHandle.codecOutbufConf;
2379 pBufferInfo->imageWidth = bufferGeometry->nFrameWidth;
2380 pBufferInfo->imageHeight = bufferGeometry->nFrameHeight;
2381 switch (bufferGeometry->eColorFormat) {
2382 case VIDEO_COLORFORMAT_NV12:
2383 #ifdef SLP_PLATFORM /* NV12T fd */
2384 pBufferInfo->ColorFormat = OMX_SEC_COLOR_FormatNV12T_DmaBuf_Fd;
2386 pBufferInfo->ColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
2389 case VIDEO_COLORFORMAT_NV12_TILED:
2391 pBufferInfo->ColorFormat = OMX_SEC_COLOR_FormatNV12Tiled;
2395 indexTimestamp = pDecOps->Get_FrameTag(hMFCHandle);
2396 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "out indexTimestamp: %d", indexTimestamp);
2397 if ((indexTimestamp < 0) || (indexTimestamp >= MAX_TIMESTAMP)) {
2398 if ((pExynosComponent->checkTimeStamp.needSetStartTimeStamp != OMX_TRUE) &&
2399 (pExynosComponent->checkTimeStamp.needCheckStartTimeStamp != OMX_TRUE)) {
2400 pDstOutputData->timeStamp = pExynosComponent->timeStamp[pWmvDec->hMFCWmvHandle.outputIndexTimestamp];
2401 pDstOutputData->nFlags = pExynosComponent->nFlags[pWmvDec->hMFCWmvHandle.outputIndexTimestamp];
2402 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "missing out indexTimestamp: %d", indexTimestamp);
2404 pDstOutputData->timeStamp = 0x00;
2405 pDstOutputData->nFlags = 0x00;
2408 /* For timestamp correction. if mfc support frametype detect */
2409 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "disp_pic_frame_type: %d", pVideoBuffer->frameType);
2411 //#ifdef NEED_TIMESTAMP_REORDER
2412 if (pVideoDec->bNeedTimestampReorder == OMX_TRUE) { /* SLP_PLATFORM */
2413 if ((pVideoBuffer->frameType == VIDEO_FRAME_I)) {
2414 pDstOutputData->timeStamp = pExynosComponent->timeStamp[indexTimestamp];
2415 pDstOutputData->nFlags = pExynosComponent->nFlags[indexTimestamp];
2416 pWmvDec->hMFCWmvHandle.outputIndexTimestamp = indexTimestamp;
2418 pDstOutputData->timeStamp = pExynosComponent->timeStamp[pWmvDec->hMFCWmvHandle.outputIndexTimestamp];
2419 pDstOutputData->nFlags = pExynosComponent->nFlags[pWmvDec->hMFCWmvHandle.outputIndexTimestamp];
2423 pDstOutputData->timeStamp = pExynosComponent->timeStamp[indexTimestamp];
2424 pDstOutputData->nFlags = pExynosComponent->nFlags[indexTimestamp];
2427 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "timestamp %lld us (%.2f secs), indexTimestamp: %d, nFlags: 0x%x", pDstOutputData->timeStamp, pDstOutputData->timeStamp / 1E6, indexTimestamp, pDstOutputData->nFlags);
2430 if ((displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) ||
2431 (displayStatus == VIDEO_FRAME_STATUS_DECODING_FINISHED) ||
2432 ((pDstOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)) {
2433 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "displayStatus:%d, nFlags0x%x", displayStatus, pDstOutputData->nFlags);
2434 pDstOutputData->remainDataLen = 0;
2436 pDstOutputData->remainDataLen = bufferGeometry->nFrameWidth * bufferGeometry->nFrameHeight * 3 / 2;
2439 ret = OMX_ErrorNone;
2447 OMX_ERRORTYPE Exynos_WmvDec_srcInputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
2449 OMX_ERRORTYPE ret = OMX_ErrorNone;
2450 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2451 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2452 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2456 if ((!CHECK_PORT_ENABLED(pExynosInputPort)) || (!CHECK_PORT_POPULATED(pExynosInputPort))) {
2457 ret = OMX_ErrorNone;
2460 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, INPUT_PORT_INDEX)) {
2461 ret = OMX_ErrorNone;
2465 ret = Exynos_WmvDec_SrcIn(pOMXComponent, pSrcInputData);
2466 if ((ret != OMX_ErrorNone) && (ret != OMX_ErrorInputDataDecodeYet)) {
2467 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2468 pExynosComponent->callbackData,
2469 OMX_EventError, ret, 0, NULL);
2478 OMX_ERRORTYPE Exynos_WmvDec_srcOutputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcOutputData)
2480 OMX_ERRORTYPE ret = OMX_ErrorNone;
2481 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2482 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2483 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2487 if ((!CHECK_PORT_ENABLED(pExynosInputPort)) || (!CHECK_PORT_POPULATED(pExynosInputPort))) {
2488 ret = OMX_ErrorNone;
2492 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2493 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, INPUT_PORT_INDEX)) {
2494 ret = OMX_ErrorNone;
2498 if ((pWmvDec->bSourceStart == OMX_FALSE) &&
2499 (!CHECK_PORT_BEING_FLUSHED(pExynosInputPort))) {
2500 Exynos_OSAL_SignalWait(pWmvDec->hSourceStartEvent, DEF_MAX_WAIT_TIME);
2501 Exynos_OSAL_SignalReset(pWmvDec->hSourceStartEvent);
2504 ret = Exynos_WmvDec_SrcOut(pOMXComponent, pSrcOutputData);
2505 if ((ret != OMX_ErrorNone) &&
2506 (pExynosComponent->currentState == OMX_StateExecuting)) {
2507 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2508 pExynosComponent->callbackData,
2509 OMX_EventError, ret, 0, NULL);
2518 OMX_ERRORTYPE Exynos_WmvDec_dstInputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstInputData)
2520 OMX_ERRORTYPE ret = OMX_ErrorNone;
2521 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2522 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2523 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2527 if ((!CHECK_PORT_ENABLED(pExynosOutputPort)) || (!CHECK_PORT_POPULATED(pExynosOutputPort))) {
2528 ret = OMX_ErrorNone;
2531 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, OUTPUT_PORT_INDEX)) {
2532 ret = OMX_ErrorNone;
2535 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
2536 if ((pWmvDec->bDestinationStart == OMX_FALSE) &&
2537 (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2538 Exynos_OSAL_SignalWait(pWmvDec->hDestinationStartEvent, DEF_MAX_WAIT_TIME);
2539 Exynos_OSAL_SignalReset(pWmvDec->hDestinationStartEvent);
2542 if (pWmvDec->hMFCWmvHandle.bConfiguredMFCDst == OMX_TRUE) {
2543 ret = Exynos_WmvDec_DstIn(pOMXComponent, pDstInputData);
2544 if (ret != OMX_ErrorNone) {
2545 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2546 pExynosComponent->callbackData,
2547 OMX_EventError, ret, 0, NULL);
2557 OMX_ERRORTYPE Exynos_WmvDec_dstOutputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstOutputData)
2559 OMX_ERRORTYPE ret = OMX_ErrorNone;
2560 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2561 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2562 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2566 if ((!CHECK_PORT_ENABLED(pExynosOutputPort)) || (!CHECK_PORT_POPULATED(pExynosOutputPort))) {
2567 ret = OMX_ErrorNone;
2570 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, OUTPUT_PORT_INDEX)) {
2571 ret = OMX_ErrorNone;
2575 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
2576 if ((pWmvDec->bDestinationStart == OMX_FALSE) &&
2577 (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2578 Exynos_OSAL_SignalWait(pWmvDec->hDestinationStartEvent, DEF_MAX_WAIT_TIME);
2579 Exynos_OSAL_SignalReset(pWmvDec->hDestinationStartEvent);
2582 ret = Exynos_WmvDec_DstOut(pOMXComponent, pDstOutputData);
2583 if ((ret != OMX_ErrorNone) &&
2584 (pExynosComponent->currentState == OMX_StateExecuting)) {
2585 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2586 pExynosComponent->callbackData,
2587 OMX_EventError, ret, 0, NULL);
2596 OSCL_EXPORT_REF OMX_ERRORTYPE Exynos_OMX_ComponentInit(
2597 OMX_HANDLETYPE hComponent,
2598 OMX_STRING componentName)
2600 OMX_ERRORTYPE ret = OMX_ErrorNone;
2601 OMX_COMPONENTTYPE *pOMXComponent = NULL;
2602 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
2603 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
2604 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
2605 EXYNOS_WMVDEC_HANDLE *pWmvDec = NULL;
2606 OMX_S32 wmvFormat = WMV_FORMAT_UNKNOWN;
2611 if ((hComponent == NULL) || (componentName == NULL)) {
2612 ret = OMX_ErrorBadParameter;
2613 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
2616 if (Exynos_OSAL_Strcmp(EXYNOS_OMX_COMPONENT_WMV_DEC, componentName) != 0) {
2617 ret = OMX_ErrorBadParameter;
2618 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, componentName:%s, Line:%d", componentName, __LINE__);
2622 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2623 ret = Exynos_OMX_VideoDecodeComponentInit(pOMXComponent);
2624 if (ret != OMX_ErrorNone) {
2625 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_Error, Line:%d", __LINE__);
2628 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2629 pExynosComponent->codecType = HW_VIDEO_DEC_CODEC;
2631 pExynosComponent->componentName = (OMX_STRING)Exynos_OSAL_Malloc(MAX_OMX_COMPONENT_NAME_SIZE);
2632 if (pExynosComponent->componentName == NULL) {
2633 Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2634 ret = OMX_ErrorInsufficientResources;
2635 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2638 Exynos_OSAL_Memset(pExynosComponent->componentName, 0, MAX_OMX_COMPONENT_NAME_SIZE);
2640 pWmvDec = Exynos_OSAL_Malloc(sizeof(EXYNOS_WMVDEC_HANDLE));
2641 if (pWmvDec == NULL) {
2642 Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2643 ret = OMX_ErrorInsufficientResources;
2644 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2647 Exynos_OSAL_Memset(pWmvDec, 0, sizeof(EXYNOS_WMVDEC_HANDLE));
2648 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2649 pVideoDec->hCodecHandle = (OMX_HANDLETYPE)pWmvDec;
2650 pWmvDec->hMFCWmvHandle.wmvFormat = wmvFormat;
2652 Exynos_OSAL_Strcpy(pExynosComponent->componentName, EXYNOS_OMX_COMPONENT_WMV_DEC);
2654 /* In case of BUFFER_COPY mode
2655 bShareableBuf = TRUE means MemoryType is V4L2_MEMORY_USERPTR
2656 bShareableBuf = FALSE means MemoryType is V4L2_MEMORY_MMAP
2657 In case of BUFFER_SHARE
2658 bShareableBuf should be TRUE, FALSE is ignored
2660 pWmvDec->hMFCWmvHandle.bShareableBuf = OMX_FALSE;
2662 /* Set componentVersion */
2663 pExynosComponent->componentVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
2664 pExynosComponent->componentVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
2665 pExynosComponent->componentVersion.s.nRevision = REVISION_NUMBER;
2666 pExynosComponent->componentVersion.s.nStep = STEP_NUMBER;
2667 /* Set specVersion */
2668 pExynosComponent->specVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
2669 pExynosComponent->specVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
2670 pExynosComponent->specVersion.s.nRevision = REVISION_NUMBER;
2671 pExynosComponent->specVersion.s.nStep = STEP_NUMBER;
2674 pExynosPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2675 pExynosPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
2676 pExynosPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
2677 pExynosPort->portDefinition.format.video.nStride = 0; /*DEFAULT_FRAME_WIDTH;*/
2678 pExynosPort->portDefinition.format.video.nSliceHeight = 0;
2679 pExynosPort->portDefinition.nBufferSize = DEFAULT_VIDEO_INPUT_BUFFER_SIZE;
2680 pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingWMV;
2681 Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2682 Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "video/wmv");
2683 pExynosPort->portDefinition.format.video.pNativeRender = 0;
2684 pExynosPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
2685 pExynosPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatUnused;
2686 pExynosPort->portDefinition.bEnabled = OMX_TRUE;
2687 pExynosPort->bufferProcessType = BUFFER_COPY;
2688 pExynosPort->portWayType = WAY2_PORT;
2691 pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2692 pExynosPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
2693 pExynosPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
2694 pExynosPort->portDefinition.format.video.nStride = 0; /*DEFAULT_FRAME_WIDTH;*/
2695 pExynosPort->portDefinition.format.video.nSliceHeight = 0;
2696 pExynosPort->portDefinition.nBufferSize = DEFAULT_VIDEO_OUTPUT_BUFFER_SIZE;
2697 pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused;
2698 Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2699 Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "raw/video");
2700 pExynosPort->portDefinition.format.video.pNativeRender = 0;
2701 pExynosPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
2703 pExynosPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatNV12T_DmaBuf_Fd;
2705 pExynosPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
2707 pExynosPort->portDefinition.bEnabled = OMX_TRUE;
2709 pExynosPort->bufferProcessType = BUFFER_SHARE;
2711 pExynosPort->bufferProcessType = BUFFER_COPY;
2713 pExynosPort->portWayType = WAY2_PORT;
2715 for(i = 0; i < ALL_PORT_NUM; i++) {
2716 INIT_SET_SIZE_VERSION(&pWmvDec->WmvComponent[i], OMX_VIDEO_PARAM_WMVTYPE);
2717 pWmvDec->WmvComponent[i].nPortIndex = i;
2718 pWmvDec->WmvComponent[i].eFormat = OMX_VIDEO_WMVFormat9;
2722 pWmvDec->wmvFormat = WMV_FORMAT_UNKNOWN;
2725 pOMXComponent->GetParameter = &Exynos_WmvDec_GetParameter;
2726 pOMXComponent->SetParameter = &Exynos_WmvDec_SetParameter;
2727 pOMXComponent->GetConfig = &Exynos_WmvDec_GetConfig;
2728 pOMXComponent->SetConfig = &Exynos_WmvDec_SetConfig;
2729 pOMXComponent->GetExtensionIndex = &Exynos_WmvDec_GetExtensionIndex;
2730 pOMXComponent->ComponentRoleEnum = &Exynos_WmvDec_ComponentRoleEnum;
2731 pOMXComponent->ComponentDeInit = &Exynos_OMX_ComponentDeinit;
2733 pExynosComponent->exynos_codec_componentInit = &Exynos_WmvDec_Init;
2734 pExynosComponent->exynos_codec_componentTerminate = &Exynos_WmvDec_Terminate;
2736 pVideoDec->exynos_codec_srcInputProcess = &Exynos_WmvDec_srcInputBufferProcess;
2737 pVideoDec->exynos_codec_srcOutputProcess = &Exynos_WmvDec_srcOutputBufferProcess;
2738 pVideoDec->exynos_codec_dstInputProcess = &Exynos_WmvDec_dstInputBufferProcess;
2739 pVideoDec->exynos_codec_dstOutputProcess = &Exynos_WmvDec_dstOutputBufferProcess;
2741 pVideoDec->exynos_codec_start = &WmvCodecStart;
2742 pVideoDec->exynos_codec_stop = &WmvCodecStop;
2743 pVideoDec->exynos_codec_bufferProcessRun = &WmvCodecOutputBufferProcessRun;
2744 pVideoDec->exynos_codec_enqueueAllBuffer = &WmvCodecEnQueueAllBuffer;
2745 pVideoDec->exynos_codec_resetupAllElement = &WmvCodecResetupAllElement;
2747 pVideoDec->exynos_checkInputFrame = &Check_Wmv_Frame;
2748 pVideoDec->exynos_codec_getCodecInputPrivateData = &GetCodecInputPrivateData;
2749 pVideoDec->exynos_codec_getCodecOutputPrivateData = &GetCodecOutputPrivateData;
2751 pVideoDec->exynos_process_codecConfigData = &Process_Wmv_CodecConfigData;
2753 #ifndef SLP_PLATFORM /* do not use ion */
2754 pVideoDec->hSharedMemory = Exynos_OSAL_SharedMemory_Open();
2755 if (pVideoDec->hSharedMemory == NULL) {
2756 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2757 Exynos_OSAL_Free(pWmvDec);
2758 pWmvDec = ((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle = NULL;
2759 Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2760 ret = OMX_ErrorInsufficientResources;
2764 pExynosComponent->currentState = OMX_StateLoaded;
2766 ret = OMX_ErrorNone;
2774 OMX_ERRORTYPE Exynos_OMX_ComponentDeinit(
2775 OMX_HANDLETYPE hComponent)
2777 OMX_ERRORTYPE ret = OMX_ErrorNone;
2778 OMX_COMPONENTTYPE *pOMXComponent = NULL;
2779 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
2780 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
2781 EXYNOS_WMVDEC_HANDLE *pWmvDec = NULL;
2785 if (hComponent == NULL) {
2786 ret = OMX_ErrorBadParameter;
2789 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2790 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2791 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2792 #ifndef SLP_PLATFORM /* do not use ion */
2793 Exynos_OSAL_SharedMemory_Close(pVideoDec->hSharedMemory);
2795 Exynos_OSAL_Free(pExynosComponent->componentName);
2796 pExynosComponent->componentName = NULL;
2798 pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
2799 if (pWmvDec != NULL) {
2800 Exynos_OSAL_Free(pWmvDec);
2801 pWmvDec = pVideoDec->hCodecHandle = NULL;
2804 ret = Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2805 if (ret != OMX_ErrorNone) {
2809 ret = OMX_ErrorNone;