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_Android.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 #include "Exynos_OSAL_Log.h"
60 #define WMV_DEC_NUM_OF_EXTRA_BUFFERS 7
62 //#define FULL_FRAME_SEARCH
64 /* ASF parser does not send start code on Stagefright */
66 /* Enable or disable "WMV3_ADDITIONAL_START_CODE" based on MFC F/W's need */
67 #define WMV3_ADDITIONAL_START_CODE
69 WMV_FORMAT gWvmFormat
= WMV_FORMAT_UNKNOWN
;
71 const OMX_U32 wmv3
= 0x33564d57;
72 const OMX_U32 wvc1
= 0x31435657;
73 const OMX_U32 wmva
= 0x41564d57;
76 static OMX_ERRORTYPE
GetCodecInputPrivateData(OMX_PTR codecBuffer
, void *pVirtAddr
, OMX_U32
*dataSize
)
78 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
84 static OMX_ERRORTYPE
GetCodecOutputPrivateData(OMX_PTR codecBuffer
, void *addr
[], int size
[])
86 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
87 ExynosVideoBuffer
*pCodecBuffer
;
89 if (codecBuffer
== NULL
) {
90 ret
= OMX_ErrorBadParameter
;
94 pCodecBuffer
= (ExynosVideoBuffer
*)codecBuffer
;
97 addr
[0] = pCodecBuffer
->planes
[0].addr
;
98 addr
[1] = pCodecBuffer
->planes
[1].addr
;
99 addr
[2] = pCodecBuffer
->planes
[2].addr
;
103 size
[0] = pCodecBuffer
->planes
[0].allocSize
;
104 size
[1] = pCodecBuffer
->planes
[1].allocSize
;
105 size
[2] = pCodecBuffer
->planes
[2].allocSize
;
113 OMX_U8
*pInputStream
,
116 OMX_BOOL bPreviousFrameEOF
,
117 OMX_BOOL
*pbEndOfFrame
)
119 OMX_U32 compressionID
;
120 OMX_BOOL bFrameStart
;
121 OMX_U32 len
, readStream
;
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
224 /* TODO : for comformanc test based on common buffer scheme w/o parser */
225 if (streamSize
< 3) {
226 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "%s: streamSize is too small (%d)", __FUNCTION__
, streamSize
);
228 } else if ((pInputStream
[0] == 0x00) &&
229 (pInputStream
[1] == 0x00) &&
230 (pInputStream
[2] == 0x01)) {
233 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "%s: Cannot find prefix", __FUNCTION__
);
239 Exynos_OSAL_Log(EXYNOS_LOG_WARNING
, "%s: undefined wmvFormat (%d)", __FUNCTION__
, wmvFormat
);
245 static OMX_BOOL
Make_Stream_MetaData(
246 OMX_U8
*pInputStream
,
247 OMX_U32
*pStreamSize
,
248 WMV_FORMAT wmvFormat
)
250 OMX_U8
*pCurrBuf
= pInputStream
;
252 OMX_U32 width
, height
;
256 /* Sequence Layer Data Structure */
257 OMX_U8 const_C5
[4] = {0x00, 0x00, 0x00, 0xc5};
258 OMX_U8 const_04
[4] = {0x04, 0x00, 0x00, 0x00};
259 OMX_U8 const_0C
[4] = {0x0C, 0x00, 0x00, 0x00};
260 OMX_U8 struct_B_1
[4] = {0xB3, 0x19, 0x00, 0x00};
261 OMX_U8 struct_B_2
[4] = {0x44, 0x62, 0x05, 0x00};
262 OMX_U8 struct_B_3
[4] = {0x0F, 0x00, 0x00, 0x00};
263 OMX_U8 struct_C
[4] = {0x30, 0x00, 0x00, 0x00};
266 case WMV_FORMAT_WMV3
:
267 if (*pStreamSize
>= BITMAPINFOHEADER_SIZE
) {
268 BitmapInfoHhr
*pBitmapInfoHeader
;
269 pBitmapInfoHeader
= (BitmapInfoHhr
*)pInputStream
;
271 width
= pBitmapInfoHeader
->BiWidth
;
272 height
= pBitmapInfoHeader
->BiHeight
;
273 if (*pStreamSize
> BITMAPINFOHEADER_SIZE
)
274 Exynos_OSAL_Memcpy(struct_C
, pInputStream
+BITMAPINFOHEADER_SIZE
, 4);
276 Exynos_OSAL_Memcpy(pCurrBuf
+ currPos
, const_C5
, 4);
279 Exynos_OSAL_Memcpy(pCurrBuf
+ currPos
, const_04
, 4);
282 Exynos_OSAL_Memcpy(pCurrBuf
+ currPos
, struct_C
, 4);
285 /* struct_A : VERT_SIZE */
286 pCurrBuf
[currPos
] = height
& 0xFF;
287 pCurrBuf
[currPos
+1] = (height
>>8) & 0xFF;
288 pCurrBuf
[currPos
+2] = (height
>>16) & 0xFF;
289 pCurrBuf
[currPos
+3] = (height
>>24) & 0xFF;
292 /* struct_A : HORIZ_SIZE */
293 pCurrBuf
[currPos
] = width
& 0xFF;
294 pCurrBuf
[currPos
+1] = (width
>>8) & 0xFF;
295 pCurrBuf
[currPos
+2] = (width
>>16) & 0xFF;
296 pCurrBuf
[currPos
+3] = (width
>>24) & 0xFF;
299 Exynos_OSAL_Memcpy(pCurrBuf
+ currPos
,const_0C
, 4);
302 Exynos_OSAL_Memcpy(pCurrBuf
+ currPos
, struct_B_1
, 4);
305 Exynos_OSAL_Memcpy(pCurrBuf
+ currPos
, struct_B_2
, 4);
308 Exynos_OSAL_Memcpy(pCurrBuf
+ currPos
, struct_B_3
, 4);
311 *pStreamSize
= currPos
;
314 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "%s: *pStreamSize is too small to contain metadata(%d)", __FUNCTION__
, *pStreamSize
);
319 if (*pStreamSize
>= BITMAPINFOHEADER_ASFBINDING_SIZE
) {
320 Exynos_OSAL_Memcpy(pCurrBuf
, pInputStream
+ BITMAPINFOHEADER_ASFBINDING_SIZE
, *pStreamSize
- BITMAPINFOHEADER_ASFBINDING_SIZE
);
321 *pStreamSize
-= BITMAPINFOHEADER_ASFBINDING_SIZE
;
324 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "%s: *pStreamSize is too small to contain metadata(%d)", __FUNCTION__
, *pStreamSize
);
329 Exynos_OSAL_Log(EXYNOS_LOG_WARNING
, "%s: It is not necessary to make bitstream metadata for wmvFormat (%d)", __FUNCTION__
, wmvFormat
);
335 static OMX_BOOL
Make_Stream_StartCode(
336 OMX_U8
*pInputStream
,
337 OMX_U32
*pStreamSize
,
338 WMV_FORMAT wmvFormat
)
340 OMX_U8 frameStartCode
[4] = {0x00, 0x00, 0x01, 0x0d};
341 #ifdef WMV3_ADDITIONAL_START_CODE
342 /* first 4 bytes : size of Frame, second 4 bytes : present Time stamp */
343 OMX_U8 frameStartCode2
[8] = {0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00};
348 case WMV_FORMAT_WMV3
:
349 #ifdef WMV3_ADDITIONAL_START_CODE
350 Exynos_OSAL_Memmove(pInputStream
+8, pInputStream
, *pStreamSize
);
351 Exynos_OSAL_Memcpy(pInputStream
, frameStartCode2
, 8);
358 /* Should find better way to shift data */
359 Exynos_OSAL_Memmove(pInputStream
+4, pInputStream
, *pStreamSize
);
360 Exynos_OSAL_Memcpy(pInputStream
, frameStartCode
, 4);
366 Exynos_OSAL_Log(EXYNOS_LOG_WARNING
, "%s: undefined wmvFormat (%d)", __FUNCTION__
, wmvFormat
);
372 OMX_ERRORTYPE
WmvCodecOpen(EXYNOS_WMVDEC_HANDLE
*pWmvDec
)
374 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
375 ExynosVideoDecOps
*pDecOps
= NULL
;
376 ExynosVideoDecBufferOps
*pInbufOps
= NULL
;
377 ExynosVideoDecBufferOps
*pOutbufOps
= NULL
;
381 if (pWmvDec
== NULL
) {
382 ret
= OMX_ErrorBadParameter
;
383 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "OMX_ErrorBadParameter, Line:%d", __LINE__
);
387 /* alloc ops structure */
388 pDecOps
= (ExynosVideoDecOps
*)Exynos_OSAL_Malloc(sizeof(ExynosVideoDecOps
));
389 pInbufOps
= (ExynosVideoDecBufferOps
*)Exynos_OSAL_Malloc(sizeof(ExynosVideoDecBufferOps
));
390 pOutbufOps
= (ExynosVideoDecBufferOps
*)Exynos_OSAL_Malloc(sizeof(ExynosVideoDecBufferOps
));
392 if ((pDecOps
== NULL
) || (pInbufOps
== NULL
) || (pOutbufOps
== NULL
)) {
393 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Failed to allocate decoder ops buffer");
394 ret
= OMX_ErrorInsufficientResources
;
398 pWmvDec
->hMFCWmvHandle
.pDecOps
= pDecOps
;
399 pWmvDec
->hMFCWmvHandle
.pInbufOps
= pInbufOps
;
400 pWmvDec
->hMFCWmvHandle
.pOutbufOps
= pOutbufOps
;
402 /* function pointer mapping */
403 pDecOps
->nSize
= sizeof(ExynosVideoDecOps
);
404 pInbufOps
->nSize
= sizeof(ExynosVideoDecBufferOps
);
405 pOutbufOps
->nSize
= sizeof(ExynosVideoDecBufferOps
);
407 Exynos_Video_Register_Decoder(pDecOps
, pInbufOps
, pOutbufOps
);
409 /* check mandatory functions for decoder ops */
410 if ((pDecOps
->Init
== NULL
) || (pDecOps
->Finalize
== NULL
) ||
411 (pDecOps
->Get_ActualBufferCount
== NULL
) || (pDecOps
->Set_FrameTag
== NULL
) ||
412 (pDecOps
->Get_FrameTag
== NULL
)) {
413 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Mandatory functions must be supplied");
414 ret
= OMX_ErrorInsufficientResources
;
418 /* check mandatory functions for buffer ops */
419 if ((pInbufOps
->Setup
== NULL
) || (pOutbufOps
->Setup
== NULL
) ||
420 (pInbufOps
->Run
== NULL
) || (pOutbufOps
->Run
== NULL
) ||
421 (pInbufOps
->Stop
== NULL
) || (pOutbufOps
->Stop
== NULL
) ||
422 (pInbufOps
->Enqueue
== NULL
) || (pOutbufOps
->Enqueue
== NULL
) ||
423 (pInbufOps
->Dequeue
== NULL
) || (pOutbufOps
->Dequeue
== NULL
)) {
424 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Mandatory functions must be supplied");
425 ret
= OMX_ErrorInsufficientResources
;
429 /* alloc context, open, querycap */
431 pWmvDec
->hMFCWmvHandle
.hMFCHandle
= pWmvDec
->hMFCWmvHandle
.pDecOps
->Init(V4L2_MEMORY_DMABUF
);
433 pWmvDec
->hMFCWmvHandle
.hMFCHandle
= pWmvDec
->hMFCWmvHandle
.pDecOps
->Init(V4L2_MEMORY_USERPTR
);
435 if (pWmvDec
->hMFCWmvHandle
.hMFCHandle
== NULL
) {
436 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Failed to allocate context buffer");
437 ret
= OMX_ErrorInsufficientResources
;
444 if (ret
!= OMX_ErrorNone
) {
445 if (pDecOps
!= NULL
) {
446 Exynos_OSAL_Free(pDecOps
);
447 pWmvDec
->hMFCWmvHandle
.pDecOps
= NULL
;
449 if (pInbufOps
!= NULL
) {
450 Exynos_OSAL_Free(pInbufOps
);
451 pWmvDec
->hMFCWmvHandle
.pInbufOps
= NULL
;
453 if (pOutbufOps
!= NULL
) {
454 Exynos_OSAL_Free(pOutbufOps
);
455 pWmvDec
->hMFCWmvHandle
.pOutbufOps
= NULL
;
464 OMX_ERRORTYPE
WmvCodecClose(EXYNOS_WMVDEC_HANDLE
*pWmvDec
)
466 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
467 void *hMFCHandle
= NULL
;
468 ExynosVideoDecOps
*pDecOps
= NULL
;
469 ExynosVideoDecBufferOps
*pInbufOps
= NULL
;
470 ExynosVideoDecBufferOps
*pOutbufOps
= NULL
;
474 if (pWmvDec
== NULL
) {
475 ret
= OMX_ErrorBadParameter
;
479 hMFCHandle
= pWmvDec
->hMFCWmvHandle
.hMFCHandle
;
480 pDecOps
= pWmvDec
->hMFCWmvHandle
.pDecOps
;
481 pInbufOps
= pWmvDec
->hMFCWmvHandle
.pInbufOps
;
482 pOutbufOps
= pWmvDec
->hMFCWmvHandle
.pOutbufOps
;
484 if (hMFCHandle
!= NULL
) {
485 pDecOps
->Finalize(hMFCHandle
);
486 pWmvDec
->hMFCWmvHandle
.hMFCHandle
= NULL
;
488 if (pOutbufOps
!= NULL
) {
489 Exynos_OSAL_Free(pOutbufOps
);
490 pWmvDec
->hMFCWmvHandle
.pOutbufOps
= NULL
;
492 if (pInbufOps
!= NULL
) {
493 Exynos_OSAL_Free(pInbufOps
);
494 pWmvDec
->hMFCWmvHandle
.pInbufOps
= NULL
;
496 if (pDecOps
!= NULL
) {
497 Exynos_OSAL_Free(pDecOps
);
498 pWmvDec
->hMFCWmvHandle
.pDecOps
= NULL
;
509 OMX_ERRORTYPE
WmvCodecStart(OMX_COMPONENTTYPE
*pOMXComponent
, OMX_U32 nPortIndex
)
511 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
512 void *hMFCHandle
= NULL
;
513 ExynosVideoDecOps
*pDecOps
= NULL
;
514 ExynosVideoDecBufferOps
*pInbufOps
= NULL
;
515 ExynosVideoDecBufferOps
*pOutbufOps
= NULL
;
516 EXYNOS_OMX_VIDEODEC_COMPONENT
*pVideoDec
= NULL
;
517 EXYNOS_WMVDEC_HANDLE
*pWmvDec
= NULL
;
521 if (pOMXComponent
== NULL
) {
522 ret
= OMX_ErrorBadParameter
;
526 pVideoDec
= (EXYNOS_OMX_VIDEODEC_COMPONENT
*)((EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
)->hComponentHandle
;
527 if (pVideoDec
== NULL
) {
528 ret
= OMX_ErrorBadParameter
;
532 pWmvDec
= (EXYNOS_WMVDEC_HANDLE
*)pVideoDec
->hCodecHandle
;
533 if (pWmvDec
== NULL
) {
534 ret
= OMX_ErrorBadParameter
;
538 hMFCHandle
= pWmvDec
->hMFCWmvHandle
.hMFCHandle
;
539 pDecOps
= pWmvDec
->hMFCWmvHandle
.pDecOps
;
540 pInbufOps
= pWmvDec
->hMFCWmvHandle
.pInbufOps
;
541 pOutbufOps
= pWmvDec
->hMFCWmvHandle
.pOutbufOps
;
543 if (nPortIndex
== INPUT_PORT_INDEX
)
544 pInbufOps
->Run(hMFCHandle
);
545 else if (nPortIndex
== OUTPUT_PORT_INDEX
)
546 pOutbufOps
->Run(hMFCHandle
);
556 OMX_ERRORTYPE
WmvCodecStop(OMX_COMPONENTTYPE
*pOMXComponent
, OMX_U32 nPortIndex
)
558 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
559 void *hMFCHandle
= NULL
;
560 ExynosVideoDecOps
*pDecOps
= NULL
;
561 ExynosVideoDecBufferOps
*pInbufOps
= NULL
;
562 ExynosVideoDecBufferOps
*pOutbufOps
= NULL
;
563 EXYNOS_OMX_VIDEODEC_COMPONENT
*pVideoDec
= NULL
;
564 EXYNOS_WMVDEC_HANDLE
*pWmvDec
= NULL
;
568 if (pOMXComponent
== NULL
) {
569 ret
= OMX_ErrorBadParameter
;
573 pVideoDec
= (EXYNOS_OMX_VIDEODEC_COMPONENT
*)((EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
)->hComponentHandle
;
574 if (pVideoDec
== NULL
) {
575 ret
= OMX_ErrorBadParameter
;
578 pWmvDec
= (EXYNOS_WMVDEC_HANDLE
*)pVideoDec
->hCodecHandle
;
579 if (pWmvDec
== NULL
) {
580 ret
= OMX_ErrorBadParameter
;
584 hMFCHandle
= pWmvDec
->hMFCWmvHandle
.hMFCHandle
;
585 pDecOps
= pWmvDec
->hMFCWmvHandle
.pDecOps
;
586 pInbufOps
= pWmvDec
->hMFCWmvHandle
.pInbufOps
;
587 pOutbufOps
= pWmvDec
->hMFCWmvHandle
.pOutbufOps
;
589 if ((nPortIndex
== INPUT_PORT_INDEX
) && (pInbufOps
!= NULL
))
590 pInbufOps
->Stop(hMFCHandle
);
591 else if ((nPortIndex
== OUTPUT_PORT_INDEX
) && (pOutbufOps
!= NULL
))
592 pOutbufOps
->Stop(hMFCHandle
);
602 OMX_ERRORTYPE
WmvCodecOutputBufferProcessRun(OMX_COMPONENTTYPE
*pOMXComponent
, OMX_U32 nPortIndex
)
604 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
605 void *hMFCHandle
= NULL
;
606 ExynosVideoDecOps
*pDecOps
= NULL
;
607 ExynosVideoDecBufferOps
*pInbufOps
= NULL
;
608 ExynosVideoDecBufferOps
*pOutbufOps
= NULL
;
609 EXYNOS_OMX_VIDEODEC_COMPONENT
*pVideoDec
= NULL
;
610 EXYNOS_WMVDEC_HANDLE
*pWmvDec
= NULL
;
614 if (pOMXComponent
== NULL
) {
615 ret
= OMX_ErrorBadParameter
;
619 pVideoDec
= (EXYNOS_OMX_VIDEODEC_COMPONENT
*)((EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
)->hComponentHandle
;
620 if (pVideoDec
== NULL
) {
621 ret
= OMX_ErrorBadParameter
;
624 pWmvDec
= (EXYNOS_WMVDEC_HANDLE
*)pVideoDec
->hCodecHandle
;
625 if (pWmvDec
== NULL
) {
626 ret
= OMX_ErrorBadParameter
;
630 hMFCHandle
= pWmvDec
->hMFCWmvHandle
.hMFCHandle
;
631 pDecOps
= pWmvDec
->hMFCWmvHandle
.pDecOps
;
632 pInbufOps
= pWmvDec
->hMFCWmvHandle
.pInbufOps
;
633 pOutbufOps
= pWmvDec
->hMFCWmvHandle
.pOutbufOps
;
635 if (nPortIndex
== INPUT_PORT_INDEX
) {
636 if (pWmvDec
->bSourceStart
== OMX_FALSE
) {
637 Exynos_OSAL_SignalSet(pWmvDec
->hSourceStartEvent
);
638 Exynos_OSAL_SleepMillisec(0);
642 if (nPortIndex
== OUTPUT_PORT_INDEX
) {
643 if (pWmvDec
->bDestinationStart
== OMX_FALSE
) {
644 Exynos_OSAL_SignalSet(pWmvDec
->hDestinationStartEvent
);
645 Exynos_OSAL_SleepMillisec(0);
657 OMX_ERRORTYPE
WMVCodecRegistCodecBuffers(
658 OMX_COMPONENTTYPE
*pOMXComponent
,
662 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
663 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
664 EXYNOS_OMX_VIDEODEC_COMPONENT
*pVideoDec
= (EXYNOS_OMX_VIDEODEC_COMPONENT
*)pExynosComponent
->hComponentHandle
;
665 EXYNOS_WMVDEC_HANDLE
*pWmvDec
= (EXYNOS_WMVDEC_HANDLE
*)((EXYNOS_OMX_VIDEODEC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
666 void *hMFCHandle
= pWmvDec
->hMFCWmvHandle
.hMFCHandle
;
667 CODEC_DEC_BUFFER
**ppCodecBuffer
= NULL
;
668 ExynosVideoDecBufferOps
*pBufOps
= NULL
;
669 ExynosVideoPlane
*pPlanes
= NULL
;
671 OMX_U32 nPlaneCnt
= 0;
676 if (nPortIndex
== INPUT_PORT_INDEX
) {
677 ppCodecBuffer
= &(pVideoDec
->pMFCDecInputBuffer
[0]);
678 nPlaneCnt
= MFC_INPUT_BUFFER_PLANE
;
679 pBufOps
= pWmvDec
->hMFCWmvHandle
.pInbufOps
;
681 ppCodecBuffer
= &(pVideoDec
->pMFCDecOutputBuffer
[0]);
682 nPlaneCnt
= MFC_OUTPUT_BUFFER_PLANE
;
683 pBufOps
= pWmvDec
->hMFCWmvHandle
.pOutbufOps
;
686 pPlanes
= (ExynosVideoPlane
*)Exynos_OSAL_Malloc(sizeof(ExynosVideoPlane
) * nPlaneCnt
);
687 if (pPlanes
== NULL
) {
688 ret
= OMX_ErrorInsufficientResources
;
692 /* Register buffer */
693 for (i
= 0; i
< nBufferCnt
; i
++) {
694 for (j
= 0; j
< nPlaneCnt
; j
++) {
695 pPlanes
[j
].addr
= ppCodecBuffer
[i
]->pVirAddr
[j
];
696 pPlanes
[j
].fd
= ppCodecBuffer
[i
]->fd
[j
];
697 pPlanes
[j
].allocSize
= ppCodecBuffer
[i
]->bufferSize
[j
];
700 if (pBufOps
->Register(hMFCHandle
, pPlanes
, nPlaneCnt
) != VIDEO_ERROR_NONE
) {
701 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "PORT[%d]: Failed to Register buffer", nPortIndex
);
702 ret
= OMX_ErrorInsufficientResources
;
703 Exynos_OSAL_Free(pPlanes
);
708 Exynos_OSAL_Free(pPlanes
);
718 OMX_ERRORTYPE
WmvCodecEnQueueAllBuffer(OMX_COMPONENTTYPE
*pOMXComponent
, OMX_U32 nPortIndex
)
720 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
721 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
722 EXYNOS_OMX_VIDEODEC_COMPONENT
*pVideoDec
= (EXYNOS_OMX_VIDEODEC_COMPONENT
*)pExynosComponent
->hComponentHandle
;
723 EXYNOS_WMVDEC_HANDLE
*pWmvDec
= (EXYNOS_WMVDEC_HANDLE
*)((EXYNOS_OMX_VIDEODEC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
724 void *hMFCHandle
= pWmvDec
->hMFCWmvHandle
.hMFCHandle
;
725 EXYNOS_OMX_BASEPORT
*pExynosInputPort
= &pExynosComponent
->pExynosPort
[INPUT_PORT_INDEX
];
726 EXYNOS_OMX_BASEPORT
*pExynosOutputPort
= &pExynosComponent
->pExynosPort
[OUTPUT_PORT_INDEX
];
729 ExynosVideoDecOps
*pDecOps
= pWmvDec
->hMFCWmvHandle
.pDecOps
;
730 ExynosVideoDecBufferOps
*pInbufOps
= pWmvDec
->hMFCWmvHandle
.pInbufOps
;
731 ExynosVideoDecBufferOps
*pOutbufOps
= pWmvDec
->hMFCWmvHandle
.pOutbufOps
;
735 if ((nPortIndex
!= INPUT_PORT_INDEX
) && (nPortIndex
!= OUTPUT_PORT_INDEX
)) {
736 ret
= OMX_ErrorBadPortIndex
;
740 if ((nPortIndex
== INPUT_PORT_INDEX
) &&
741 (pWmvDec
->bSourceStart
== OMX_TRUE
)) {
742 Exynos_CodecBufferReset(pExynosComponent
, INPUT_PORT_INDEX
);
744 for (i
= 0; i
< MFC_INPUT_BUFFER_NUM_MAX
; i
++) {
745 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "pVideoDec->pMFCDecInputBuffer[%d]: 0x%x", i
, pVideoDec
->pMFCDecInputBuffer
[i
]);
746 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "pVideoDec->pMFCDecInputBuffer[%d]->pVirAddr[0]: 0x%x", i
, pVideoDec
->pMFCDecInputBuffer
[i
]->pVirAddr
[0]);
748 Exynos_CodecBufferEnQueue(pExynosComponent
, INPUT_PORT_INDEX
, pVideoDec
->pMFCDecInputBuffer
[i
]);
751 pInbufOps
->Clear_Queue(hMFCHandle
);
752 } else if ((nPortIndex
== OUTPUT_PORT_INDEX
) &&
753 (pWmvDec
->bDestinationStart
== OMX_TRUE
)) {
754 Exynos_CodecBufferReset(pExynosComponent
, OUTPUT_PORT_INDEX
);
756 for (i
= 0; i
< pWmvDec
->hMFCWmvHandle
.maxDPBNum
; i
++) {
757 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "pVideoDec->pMFCDecOutputBuffer[%d]: 0x%x", i
, pVideoDec
->pMFCDecOutputBuffer
[i
]);
758 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "pVideoDec->pMFCDecOutputBuffer[%d]->pVirAddr[0]: 0x%x", i
, pVideoDec
->pMFCDecOutputBuffer
[i
]->pVirAddr
[0]);
760 Exynos_CodecBufferEnQueue(pExynosComponent
, OUTPUT_PORT_INDEX
, pVideoDec
->pMFCDecOutputBuffer
[i
]);
762 pOutbufOps
->Clear_Queue(hMFCHandle
);
771 OMX_ERRORTYPE
WmvCodecSrcSetup(OMX_COMPONENTTYPE
*pOMXComponent
, EXYNOS_OMX_DATA
*pSrcInputData
)
773 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
774 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
775 EXYNOS_OMX_VIDEODEC_COMPONENT
*pVideoDec
= (EXYNOS_OMX_VIDEODEC_COMPONENT
*)pExynosComponent
->hComponentHandle
;
776 EXYNOS_WMVDEC_HANDLE
*pWmvDec
= (EXYNOS_WMVDEC_HANDLE
*)((EXYNOS_OMX_VIDEODEC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
777 void *hMFCHandle
= pWmvDec
->hMFCWmvHandle
.hMFCHandle
;
778 EXYNOS_OMX_BASEPORT
*pExynosInputPort
= &pExynosComponent
->pExynosPort
[INPUT_PORT_INDEX
];
779 EXYNOS_OMX_BASEPORT
*pExynosOutputPort
= &pExynosComponent
->pExynosPort
[OUTPUT_PORT_INDEX
];
780 OMX_U32 oneFrameSize
= pSrcInputData
->dataLen
;
781 OMX_BOOL bMetaData
= OMX_FALSE
;
783 ExynosVideoDecOps
*pDecOps
= pWmvDec
->hMFCWmvHandle
.pDecOps
;
784 ExynosVideoDecBufferOps
*pInbufOps
= pWmvDec
->hMFCWmvHandle
.pInbufOps
;
785 ExynosVideoDecBufferOps
*pOutbufOps
= pWmvDec
->hMFCWmvHandle
.pOutbufOps
;
786 ExynosVideoGeometry bufferConf
;
787 OMX_U32 inputBufferNumber
= 0;
792 if ((oneFrameSize
<= 0) && (pSrcInputData
->nFlags
& OMX_BUFFERFLAG_EOS
)) {
793 OMX_BUFFERHEADERTYPE
*OMXBuffer
= NULL
;
794 OMXBuffer
= Exynos_OutputBufferGetQueue_Direct(pExynosComponent
);
795 if (OMXBuffer
== NULL
) {
796 ret
= OMX_ErrorUndefined
;
800 OMXBuffer
->nTimeStamp
= pSrcInputData
->timeStamp
;
801 OMXBuffer
->nFlags
= pSrcInputData
->nFlags
;
802 Exynos_OMX_OutputBufferReturn(pOMXComponent
, OMXBuffer
);
808 if (pVideoDec
->bThumbnailMode
== OMX_TRUE
)
809 pDecOps
->Set_DisplayDelay(hMFCHandle
, 0);
811 if ((pDecOps
->Enable_DTSMode
!= NULL
) &&
812 (pVideoDec
->bDTSMode
== OMX_TRUE
))
813 pDecOps
->Enable_DTSMode(hMFCHandle
);
815 if (pSrcInputData
->nFlags
& OMX_BUFFERFLAG_CODECCONFIG
) {
816 BitmapInfoHhr
*pBitmapInfoHeader
;
817 pBitmapInfoHeader
= (BitmapInfoHhr
*)pSrcInputData
->buffer
.singlePlaneBuffer
.dataBuffer
;
818 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "OMX_BUFFERFLAG_CODECCONFIG");
819 if (pBitmapInfoHeader
->BiCompression
== wmv3
) {
820 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "WMV_FORMAT_WMV3");
821 pWmvDec
->hMFCWmvHandle
.wmvFormat
= WMV_FORMAT_WMV3
;
822 } else if ((pBitmapInfoHeader
->BiCompression
== wvc1
) || (pBitmapInfoHeader
->BiCompression
== wmva
)) {
823 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "WMV_FORMAT_VC1");
824 pWmvDec
->hMFCWmvHandle
.wmvFormat
= WMV_FORMAT_VC1
;
828 /* input buffer info */
829 Exynos_OSAL_Memset(&bufferConf
, 0, sizeof(bufferConf
));
830 if (pWmvDec
->hMFCWmvHandle
.wmvFormat
== WMV_FORMAT_WMV3
) {
831 bufferConf
.eCompressionFormat
= VIDEO_CODING_VC1_RCV
;
832 } else if (pWmvDec
->hMFCWmvHandle
.wmvFormat
== WMV_FORMAT_VC1
) {
833 bufferConf
.eCompressionFormat
= VIDEO_CODING_VC1
;
835 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Unsupported WMV Codec Format Type");
836 ret
= OMX_ErrorUndefined
;
840 pInbufOps
->Set_Shareable(hMFCHandle
);
841 if (pExynosInputPort
->bufferProcessType
& BUFFER_SHARE
) {
842 bufferConf
.nSizeImage
= pExynosInputPort
->portDefinition
.format
.video
.nFrameWidth
843 * pExynosInputPort
->portDefinition
.format
.video
.nFrameHeight
* 3 / 2;
844 inputBufferNumber
= MAX_VIDEO_INPUTBUFFER_NUM
;
845 } else if (pExynosInputPort
->bufferProcessType
& BUFFER_COPY
) {
846 bufferConf
.nSizeImage
= DEFAULT_MFC_INPUT_BUFFER_SIZE
;
847 inputBufferNumber
= MFC_INPUT_BUFFER_NUM_MAX
;
850 /* should be done before prepare input buffer */
851 if (pInbufOps
->Enable_Cacheable(hMFCHandle
) != VIDEO_ERROR_NONE
) {
852 ret
= OMX_ErrorInsufficientResources
;
856 /* set input buffer geometry */
857 if (pInbufOps
->Set_Geometry(hMFCHandle
, &bufferConf
) != VIDEO_ERROR_NONE
) {
858 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Failed to set geometry for input buffer");
859 ret
= OMX_ErrorInsufficientResources
;
863 /* setup input buffer */
864 if (pInbufOps
->Setup(hMFCHandle
, inputBufferNumber
) != VIDEO_ERROR_NONE
) {
865 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Failed to setup input buffer");
866 ret
= OMX_ErrorInsufficientResources
;
870 if (pExynosInputPort
->bufferProcessType
& BUFFER_COPY
) {
871 ret
= WMVCodecRegistCodecBuffers(pOMXComponent
, INPUT_PORT_INDEX
, MFC_INPUT_BUFFER_NUM_MAX
);
872 if (ret
!= OMX_ErrorNone
)
874 } else if (pExynosInputPort
->bufferProcessType
& BUFFER_SHARE
) {
875 /* Register input buffer */
876 for (i
= 0; i
< pExynosInputPort
->portDefinition
.nBufferCountActual
; i
++) {
877 ExynosVideoPlane plane
;
878 plane
.addr
= pExynosInputPort
->extendBufferHeader
[i
].OMXBufferHeader
->pBuffer
;
879 plane
.allocSize
= pExynosInputPort
->extendBufferHeader
[i
].OMXBufferHeader
->nAllocLen
;
880 plane
.fd
= pExynosInputPort
->extendBufferHeader
[i
].buf_fd
[0];
881 if (pInbufOps
->Register(hMFCHandle
, &plane
, MFC_INPUT_BUFFER_PLANE
) != VIDEO_ERROR_NONE
) {
882 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Failed to Register input buffer");
883 ret
= OMX_ErrorInsufficientResources
;
889 /* set output geometry */
890 Exynos_OSAL_Memset(&bufferConf
, 0, sizeof(bufferConf
));
891 pWmvDec
->hMFCWmvHandle
.MFCOutputColorType
= bufferConf
.eColorFormat
= VIDEO_COLORFORMAT_NV12_TILED
;
892 if (pOutbufOps
->Set_Geometry(hMFCHandle
, &bufferConf
) != VIDEO_ERROR_NONE
) {
893 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Failed to set geometry for output buffer");
894 ret
= OMX_ErrorInsufficientResources
;
898 bMetaData
= Make_Stream_MetaData(pSrcInputData
->buffer
.singlePlaneBuffer
.dataBuffer
, &oneFrameSize
, pWmvDec
->hMFCWmvHandle
.wmvFormat
);
899 if (bMetaData
== OMX_FALSE
) {
900 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Fail to Make Stream MetaData");
901 ret
= OMX_ErrorInsufficientResources
;
905 /* input buffer enqueue for header parsing */
906 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "oneFrameSize: %d", oneFrameSize
);
907 if (pInbufOps
->Enqueue(hMFCHandle
, (unsigned char **)&pSrcInputData
->buffer
.singlePlaneBuffer
.dataBuffer
,
908 (unsigned int *)&oneFrameSize
, MFC_INPUT_BUFFER_PLANE
, pSrcInputData
->bufferHeader
) != VIDEO_ERROR_NONE
) {
909 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Failed to enqueue input buffer for header parsing");
910 // ret = OMX_ErrorInsufficientResources;
911 ret
= (OMX_ERRORTYPE
)OMX_ErrorCodecInit
;
915 /* start header parsing */
916 if (pInbufOps
->Run(hMFCHandle
) != VIDEO_ERROR_NONE
) {
917 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Failed to run input buffer for header parsing");
918 ret
= OMX_ErrorCodecInit
;
922 /* get geometry for output */
923 Exynos_OSAL_Memset(&pWmvDec
->hMFCWmvHandle
.codecOutbufConf
, 0, sizeof(ExynosVideoGeometry
));
924 if (pOutbufOps
->Get_Geometry(hMFCHandle
, &pWmvDec
->hMFCWmvHandle
.codecOutbufConf
) != VIDEO_ERROR_NONE
) {
925 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Failed to get geometry for parsed header info");
926 ret
= OMX_ErrorInsufficientResources
;
931 pWmvDec
->hMFCWmvHandle
.maxDPBNum
= pDecOps
->Get_ActualBufferCount(hMFCHandle
);
932 if (pVideoDec
->bThumbnailMode
== OMX_FALSE
)
933 pWmvDec
->hMFCWmvHandle
.maxDPBNum
+= EXTRA_DPB_NUM
;
934 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "WmvCodecSetup nOutbufs: %d", pWmvDec
->hMFCWmvHandle
.maxDPBNum
);
936 pWmvDec
->hMFCWmvHandle
.bConfiguredMFCSrc
= OMX_TRUE
;
938 if (pExynosOutputPort
->bufferProcessType
& BUFFER_COPY
) {
939 if ((pExynosInputPort
->portDefinition
.format
.video
.nFrameWidth
!= pWmvDec
->hMFCWmvHandle
.codecOutbufConf
.nFrameWidth
) ||
940 (pExynosInputPort
->portDefinition
.format
.video
.nFrameHeight
!= pWmvDec
->hMFCWmvHandle
.codecOutbufConf
.nFrameHeight
)) {
941 pExynosOutputPort
->exceptionFlag
= NEED_PORT_DISABLE
;
943 pExynosInputPort
->portDefinition
.format
.video
.nFrameWidth
= pWmvDec
->hMFCWmvHandle
.codecOutbufConf
.nFrameWidth
;
944 pExynosInputPort
->portDefinition
.format
.video
.nFrameHeight
= pWmvDec
->hMFCWmvHandle
.codecOutbufConf
.nFrameHeight
;
945 pExynosInputPort
->portDefinition
.format
.video
.nStride
= ((pWmvDec
->hMFCWmvHandle
.codecOutbufConf
.nFrameWidth
+ 15) & (~15));
946 pExynosInputPort
->portDefinition
.format
.video
.nSliceHeight
= ((pWmvDec
->hMFCWmvHandle
.codecOutbufConf
.nFrameHeight
+ 15) & (~15));
948 Exynos_UpdateFrameSize(pOMXComponent
);
950 /** Send Port Settings changed call back **/
951 (*(pExynosComponent
->pCallbacks
->EventHandler
))
953 pExynosComponent
->callbackData
,
954 OMX_EventPortSettingsChanged
, /* The command was completed */
955 OMX_DirOutput
, /* This is the port index */
959 } else if (pExynosOutputPort
->bufferProcessType
& BUFFER_SHARE
) {
960 if ((pExynosInputPort
->portDefinition
.format
.video
.nFrameWidth
!= pWmvDec
->hMFCWmvHandle
.codecOutbufConf
.nFrameWidth
) ||
961 (pExynosInputPort
->portDefinition
.format
.video
.nFrameHeight
!= pWmvDec
->hMFCWmvHandle
.codecOutbufConf
.nFrameHeight
) ||
962 (pExynosOutputPort
->portDefinition
.nBufferCountActual
!= pWmvDec
->hMFCWmvHandle
.maxDPBNum
)) {
963 pExynosOutputPort
->exceptionFlag
= NEED_PORT_DISABLE
;
965 pExynosInputPort
->portDefinition
.format
.video
.nFrameWidth
= pWmvDec
->hMFCWmvHandle
.codecOutbufConf
.nFrameWidth
;
966 pExynosInputPort
->portDefinition
.format
.video
.nFrameHeight
= pWmvDec
->hMFCWmvHandle
.codecOutbufConf
.nFrameHeight
;
967 pExynosInputPort
->portDefinition
.format
.video
.nStride
= ((pWmvDec
->hMFCWmvHandle
.codecOutbufConf
.nFrameWidth
+ 15) & (~15));
968 pExynosInputPort
->portDefinition
.format
.video
.nSliceHeight
= ((pWmvDec
->hMFCWmvHandle
.codecOutbufConf
.nFrameHeight
+ 15) & (~15));
970 pExynosOutputPort
->portDefinition
.nBufferCountActual
= pWmvDec
->hMFCWmvHandle
.maxDPBNum
- 2;
971 pExynosOutputPort
->portDefinition
.nBufferCountMin
= pWmvDec
->hMFCWmvHandle
.maxDPBNum
- 2;
973 Exynos_UpdateFrameSize(pOMXComponent
);
975 /** Send Port Settings changed call back **/
976 (*(pExynosComponent
->pCallbacks
->EventHandler
))
978 pExynosComponent
->callbackData
,
979 OMX_EventPortSettingsChanged
, /* The command was completed */
980 OMX_DirOutput
, /* This is the port index */
985 Exynos_OSAL_SleepMillisec(0);
986 ret
= OMX_ErrorInputDataDecodeYet
;
987 WmvCodecStop(pOMXComponent
, INPUT_PORT_INDEX
);
995 OMX_ERRORTYPE
WmvCodecDstSetup(OMX_COMPONENTTYPE
*pOMXComponent
)
997 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
998 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
999 EXYNOS_OMX_VIDEODEC_COMPONENT
*pVideoDec
= (EXYNOS_OMX_VIDEODEC_COMPONENT
*)pExynosComponent
->hComponentHandle
;
1000 EXYNOS_WMVDEC_HANDLE
*pWmvDec
= (EXYNOS_WMVDEC_HANDLE
*)((EXYNOS_OMX_VIDEODEC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
1001 void *hMFCHandle
= pWmvDec
->hMFCWmvHandle
.hMFCHandle
;
1002 EXYNOS_OMX_BASEPORT
*pExynosInputPort
= &pExynosComponent
->pExynosPort
[INPUT_PORT_INDEX
];
1003 EXYNOS_OMX_BASEPORT
*pExynosOutputPort
= &pExynosComponent
->pExynosPort
[OUTPUT_PORT_INDEX
];
1005 ExynosVideoDecOps
*pDecOps
= pWmvDec
->hMFCWmvHandle
.pDecOps
;
1006 ExynosVideoDecBufferOps
*pInbufOps
= pWmvDec
->hMFCWmvHandle
.pInbufOps
;
1007 ExynosVideoDecBufferOps
*pOutbufOps
= pWmvDec
->hMFCWmvHandle
.pOutbufOps
;
1011 OMX_U32 nAllocLen
[MFC_OUTPUT_BUFFER_PLANE
] = {0, 0};
1012 OMX_U32 dataLen
[MFC_OUTPUT_BUFFER_PLANE
] = {0, 0};
1016 nAllocLen
[0] = pWmvDec
->hMFCWmvHandle
.codecOutbufConf
.nAlignPlaneSize
[0];
1017 nAllocLen
[1] = pWmvDec
->hMFCWmvHandle
.codecOutbufConf
.nAlignPlaneSize
[1];
1019 pOutbufOps
->Set_Shareable(hMFCHandle
);
1021 if (pExynosOutputPort
->bufferProcessType
& BUFFER_COPY
) {
1022 /* should be done before prepare output buffer */
1023 if (pOutbufOps
->Enable_Cacheable(hMFCHandle
) != VIDEO_ERROR_NONE
) {
1024 ret
= OMX_ErrorInsufficientResources
;
1029 nOutbufs
= pWmvDec
->hMFCWmvHandle
.maxDPBNum
;
1030 if (pOutbufOps
->Setup(hMFCHandle
, nOutbufs
) != VIDEO_ERROR_NONE
) {
1031 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Failed to setup output buffer");
1032 ret
= OMX_ErrorInsufficientResources
;
1036 ret
= Exynos_Allocate_CodecBuffers(pOMXComponent
, OUTPUT_PORT_INDEX
, nOutbufs
, nAllocLen
);
1037 if (ret
!= OMX_ErrorNone
)
1040 ret
= WMVCodecRegistCodecBuffers(pOMXComponent
, OUTPUT_PORT_INDEX
, nOutbufs
);
1041 if (ret
!= OMX_ErrorNone
)
1044 /* Enqueue output buffer */
1045 for (i
= 0; i
< nOutbufs
; i
++) {
1046 pOutbufOps
->Enqueue(hMFCHandle
, (unsigned char **)pVideoDec
->pMFCDecOutputBuffer
[i
]->pVirAddr
,
1047 (unsigned int *)dataLen
, MFC_OUTPUT_BUFFER_PLANE
, NULL
);
1050 if (pOutbufOps
->Run(hMFCHandle
) != VIDEO_ERROR_NONE
) {
1051 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Failed to run output buffer");
1052 ret
= OMX_ErrorInsufficientResources
;
1055 } else if (pExynosOutputPort
->bufferProcessType
& BUFFER_SHARE
) {
1056 ExynosVideoPlane planes
[MFC_OUTPUT_BUFFER_PLANE
];
1060 nOutbufs
= pExynosOutputPort
->portDefinition
.nBufferCountActual
;
1061 if (pOutbufOps
->Setup(hMFCHandle
, nOutbufs
) != VIDEO_ERROR_NONE
) {
1062 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Failed to setup output buffer");
1063 ret
= OMX_ErrorInsufficientResources
;
1067 /* Register output buffer */
1072 if (pExynosOutputPort
->bIsANBEnabled
== OMX_TRUE
) {
1073 for (i
= 0; i
< pExynosOutputPort
->assignedBufferNum
; i
++) {
1074 for (plane
= 0; plane
< MFC_OUTPUT_BUFFER_PLANE
; plane
++) {
1075 planes
[plane
].fd
= pExynosOutputPort
->extendBufferHeader
[i
].buf_fd
[plane
];
1076 planes
[plane
].addr
= pExynosOutputPort
->extendBufferHeader
[i
].pYUVBuf
[plane
];
1077 planes
[plane
].allocSize
= nAllocLen
[plane
];
1080 if (pOutbufOps
->Register(hMFCHandle
, planes
, MFC_OUTPUT_BUFFER_PLANE
) != VIDEO_ERROR_NONE
) {
1081 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Failed to Register output buffer");
1082 ret
= OMX_ErrorInsufficientResources
;
1085 pOutbufOps
->Enqueue(hMFCHandle
, (unsigned char **)pExynosOutputPort
->extendBufferHeader
[i
].pYUVBuf
,
1086 (unsigned int *)dataLen
, MFC_OUTPUT_BUFFER_PLANE
, NULL
);
1089 if (pOutbufOps
->Apply_RegisteredBuffer(hMFCHandle
) != VIDEO_ERROR_NONE
) {
1090 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Failed to Apply output buffer");
1091 ret
= OMX_ErrorHardware
;
1095 ret
= OMX_ErrorNotImplemented
;
1099 ret
= OMX_ErrorNotImplemented
;
1104 pWmvDec
->hMFCWmvHandle
.bConfiguredMFCDst
= OMX_TRUE
;
1106 ret
= OMX_ErrorNone
;
1114 OMX_ERRORTYPE
Exynos_WmvDec_GetParameter(
1115 OMX_IN OMX_HANDLETYPE hComponent
,
1116 OMX_IN OMX_INDEXTYPE nParamIndex
,
1117 OMX_INOUT OMX_PTR pComponentParameterStructure
)
1119 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
1120 OMX_COMPONENTTYPE
*pOMXComponent
= NULL
;
1121 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= NULL
;
1125 if (hComponent
== NULL
|| pComponentParameterStructure
== NULL
) {
1126 ret
= OMX_ErrorBadParameter
;
1129 pOMXComponent
= (OMX_COMPONENTTYPE
*)hComponent
;
1130 ret
= Exynos_OMX_Check_SizeVersion(pOMXComponent
, sizeof(OMX_COMPONENTTYPE
));
1131 if (ret
!= OMX_ErrorNone
) {
1134 if (pOMXComponent
->pComponentPrivate
== NULL
) {
1135 ret
= OMX_ErrorBadParameter
;
1139 pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
1140 if (pExynosComponent
->currentState
== OMX_StateInvalid
) {
1141 ret
= OMX_ErrorInvalidState
;
1145 switch (nParamIndex
) {
1146 case OMX_IndexParamVideoWmv
:
1148 OMX_VIDEO_PARAM_WMVTYPE
*pDstWmvParam
= (OMX_VIDEO_PARAM_WMVTYPE
*)pComponentParameterStructure
;
1149 OMX_VIDEO_PARAM_WMVTYPE
*pSrcWmvParam
= NULL
;
1150 EXYNOS_WMVDEC_HANDLE
*pWmvDec
= NULL
;
1151 ret
= Exynos_OMX_Check_SizeVersion(pDstWmvParam
, sizeof(OMX_VIDEO_PARAM_WMVTYPE
));
1152 if (ret
!= OMX_ErrorNone
) {
1156 if (pDstWmvParam
->nPortIndex
> OUTPUT_PORT_INDEX
) {
1157 ret
= OMX_ErrorBadPortIndex
;
1161 pWmvDec
= (EXYNOS_WMVDEC_HANDLE
*)((EXYNOS_OMX_VIDEODEC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
1162 pSrcWmvParam
= &pWmvDec
->WmvComponent
[pDstWmvParam
->nPortIndex
];
1164 Exynos_OSAL_Memcpy(pDstWmvParam
, pSrcWmvParam
, sizeof(OMX_VIDEO_PARAM_WMVTYPE
));
1168 case OMX_IndexParamStandardComponentRole
:
1170 OMX_PARAM_COMPONENTROLETYPE
*pComponentRole
= (OMX_PARAM_COMPONENTROLETYPE
*)pComponentParameterStructure
;
1171 ret
= Exynos_OMX_Check_SizeVersion(pComponentRole
, sizeof(OMX_PARAM_COMPONENTROLETYPE
));
1172 if (ret
!= OMX_ErrorNone
) {
1176 Exynos_OSAL_Strcpy((char *)pComponentRole
->cRole
, EXYNOS_OMX_COMPONENT_WMV_DEC_ROLE
);
1179 case OMX_IndexParamVideoErrorCorrection
:
1181 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE
*pDstErrorCorrectionType
= (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE
*)pComponentParameterStructure
;
1182 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE
*pSrcErrorCorrectionType
= NULL
;
1183 EXYNOS_WMVDEC_HANDLE
*pWmvDec
= NULL
;
1185 ret
= Exynos_OMX_Check_SizeVersion(pDstErrorCorrectionType
, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE
));
1186 if (ret
!= OMX_ErrorNone
) {
1190 if (pDstErrorCorrectionType
->nPortIndex
!= INPUT_PORT_INDEX
) {
1191 ret
= OMX_ErrorBadPortIndex
;
1195 pWmvDec
= (EXYNOS_WMVDEC_HANDLE
*)((EXYNOS_OMX_VIDEODEC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
1196 pSrcErrorCorrectionType
= &pWmvDec
->errorCorrectionType
[INPUT_PORT_INDEX
];
1198 pDstErrorCorrectionType
->bEnableHEC
= pSrcErrorCorrectionType
->bEnableHEC
;
1199 pDstErrorCorrectionType
->bEnableResync
= pSrcErrorCorrectionType
->bEnableResync
;
1200 pDstErrorCorrectionType
->nResynchMarkerSpacing
= pSrcErrorCorrectionType
->nResynchMarkerSpacing
;
1201 pDstErrorCorrectionType
->bEnableDataPartitioning
= pSrcErrorCorrectionType
->bEnableDataPartitioning
;
1202 pDstErrorCorrectionType
->bEnableRVLC
= pSrcErrorCorrectionType
->bEnableRVLC
;
1206 ret
= Exynos_OMX_VideoDecodeGetParameter(hComponent
, nParamIndex
, pComponentParameterStructure
);
1215 OMX_ERRORTYPE
Exynos_WmvDec_SetParameter(
1216 OMX_IN OMX_HANDLETYPE hComponent
,
1217 OMX_IN OMX_INDEXTYPE nIndex
,
1218 OMX_IN OMX_PTR pComponentParameterStructure
)
1220 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
1221 OMX_COMPONENTTYPE
*pOMXComponent
= NULL
;
1222 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= NULL
;
1226 if (hComponent
== NULL
|| pComponentParameterStructure
== NULL
) {
1227 ret
= OMX_ErrorBadParameter
;
1230 pOMXComponent
= (OMX_COMPONENTTYPE
*)hComponent
;
1231 ret
= Exynos_OMX_Check_SizeVersion(pOMXComponent
, sizeof(OMX_COMPONENTTYPE
));
1232 if (ret
!= OMX_ErrorNone
) {
1235 if (pOMXComponent
->pComponentPrivate
== NULL
) {
1236 ret
= OMX_ErrorBadParameter
;
1240 pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
1241 if (pExynosComponent
->currentState
== OMX_StateInvalid
) {
1242 ret
= OMX_ErrorInvalidState
;
1247 case OMX_IndexParamVideoWmv
:
1249 OMX_VIDEO_PARAM_WMVTYPE
*pDstWmvParam
= NULL
;
1250 OMX_VIDEO_PARAM_WMVTYPE
*pSrcWmvParam
= (OMX_VIDEO_PARAM_WMVTYPE
*)pComponentParameterStructure
;
1251 EXYNOS_WMVDEC_HANDLE
*pWmvDec
= NULL
;
1252 ret
= Exynos_OMX_Check_SizeVersion(pSrcWmvParam
, sizeof(OMX_VIDEO_PARAM_WMVTYPE
));
1253 if (ret
!= OMX_ErrorNone
) {
1257 if (pSrcWmvParam
->nPortIndex
> OUTPUT_PORT_INDEX
) {
1258 ret
= OMX_ErrorBadPortIndex
;
1262 pWmvDec
= (EXYNOS_WMVDEC_HANDLE
*)((EXYNOS_OMX_VIDEODEC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
1263 pDstWmvParam
= &pWmvDec
->WmvComponent
[pSrcWmvParam
->nPortIndex
];
1265 Exynos_OSAL_Memcpy(pDstWmvParam
, pSrcWmvParam
, sizeof(OMX_VIDEO_PARAM_WMVTYPE
));
1268 case OMX_IndexParamStandardComponentRole
:
1270 OMX_PARAM_COMPONENTROLETYPE
*pComponentRole
= (OMX_PARAM_COMPONENTROLETYPE
*)pComponentParameterStructure
;
1272 ret
= Exynos_OMX_Check_SizeVersion(pComponentRole
, sizeof(OMX_PARAM_COMPONENTROLETYPE
));
1273 if (ret
!= OMX_ErrorNone
) {
1277 if ((pExynosComponent
->currentState
!= OMX_StateLoaded
) && (pExynosComponent
->currentState
!= OMX_StateWaitForResources
)) {
1278 ret
= OMX_ErrorIncorrectStateOperation
;
1282 if (!Exynos_OSAL_Strcmp((char*)pComponentRole
->cRole
, EXYNOS_OMX_COMPONENT_WMV_DEC_ROLE
)) {
1283 pExynosComponent
->pExynosPort
[INPUT_PORT_INDEX
].portDefinition
.format
.video
.eCompressionFormat
= OMX_VIDEO_CodingWMV
;
1285 ret
= OMX_ErrorBadParameter
;
1290 case OMX_IndexParamVideoErrorCorrection
:
1292 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE
*pSrcErrorCorrectionType
= (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE
*)pComponentParameterStructure
;
1293 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE
*pDstErrorCorrectionType
= NULL
;
1294 EXYNOS_WMVDEC_HANDLE
*pWmvDec
= NULL
;
1296 ret
= Exynos_OMX_Check_SizeVersion(pSrcErrorCorrectionType
, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE
));
1297 if (ret
!= OMX_ErrorNone
) {
1301 if (pSrcErrorCorrectionType
->nPortIndex
!= INPUT_PORT_INDEX
) {
1302 ret
= OMX_ErrorBadPortIndex
;
1306 pWmvDec
= (EXYNOS_WMVDEC_HANDLE
*)((EXYNOS_OMX_VIDEODEC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
1307 pDstErrorCorrectionType
= &pWmvDec
->errorCorrectionType
[INPUT_PORT_INDEX
];
1309 pDstErrorCorrectionType
->bEnableHEC
= pSrcErrorCorrectionType
->bEnableHEC
;
1310 pDstErrorCorrectionType
->bEnableResync
= pSrcErrorCorrectionType
->bEnableResync
;
1311 pDstErrorCorrectionType
->nResynchMarkerSpacing
= pSrcErrorCorrectionType
->nResynchMarkerSpacing
;
1312 pDstErrorCorrectionType
->bEnableDataPartitioning
= pSrcErrorCorrectionType
->bEnableDataPartitioning
;
1313 pDstErrorCorrectionType
->bEnableRVLC
= pSrcErrorCorrectionType
->bEnableRVLC
;
1317 ret
= Exynos_OMX_VideoDecodeSetParameter(hComponent
, nIndex
, pComponentParameterStructure
);
1326 OMX_ERRORTYPE
Exynos_WmvDec_GetConfig(
1327 OMX_HANDLETYPE hComponent
,
1328 OMX_INDEXTYPE nIndex
,
1329 OMX_PTR pComponentConfigStructure
)
1331 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
1332 OMX_COMPONENTTYPE
*pOMXComponent
= NULL
;
1333 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= NULL
;
1337 if (hComponent
== NULL
|| pComponentConfigStructure
== NULL
) {
1338 ret
= OMX_ErrorBadParameter
;
1341 pOMXComponent
= (OMX_COMPONENTTYPE
*)hComponent
;
1342 ret
= Exynos_OMX_Check_SizeVersion(pOMXComponent
, sizeof(OMX_COMPONENTTYPE
));
1343 if (ret
!= OMX_ErrorNone
) {
1346 if (pOMXComponent
->pComponentPrivate
== NULL
) {
1347 ret
= OMX_ErrorBadParameter
;
1350 pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
1351 if (pExynosComponent
->currentState
== OMX_StateInvalid
) {
1352 ret
= OMX_ErrorInvalidState
;
1358 ret
= Exynos_OMX_VideoDecodeGetConfig(hComponent
, nIndex
, pComponentConfigStructure
);
1368 OMX_ERRORTYPE
Exynos_WmvDec_SetConfig(
1369 OMX_HANDLETYPE hComponent
,
1370 OMX_INDEXTYPE nIndex
,
1371 OMX_PTR pComponentConfigStructure
)
1373 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
1374 OMX_COMPONENTTYPE
*pOMXComponent
= NULL
;
1375 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= NULL
;
1379 if (hComponent
== NULL
|| pComponentConfigStructure
== NULL
) {
1380 ret
= OMX_ErrorBadParameter
;
1383 pOMXComponent
= (OMX_COMPONENTTYPE
*)hComponent
;
1384 ret
= Exynos_OMX_Check_SizeVersion(pOMXComponent
, sizeof(OMX_COMPONENTTYPE
));
1385 if (ret
!= OMX_ErrorNone
) {
1388 if (pOMXComponent
->pComponentPrivate
== NULL
) {
1389 ret
= OMX_ErrorBadParameter
;
1392 pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
1393 if (pExynosComponent
->currentState
== OMX_StateInvalid
) {
1394 ret
= OMX_ErrorInvalidState
;
1400 ret
= Exynos_OMX_VideoDecodeSetConfig(hComponent
, nIndex
, pComponentConfigStructure
);
1410 OMX_ERRORTYPE
Exynos_WmvDec_GetExtensionIndex(
1411 OMX_IN OMX_HANDLETYPE hComponent
,
1412 OMX_IN OMX_STRING cParameterName
,
1413 OMX_OUT OMX_INDEXTYPE
*pIndexType
)
1415 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
1416 OMX_COMPONENTTYPE
*pOMXComponent
= NULL
;
1417 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= NULL
;
1421 if (hComponent
== NULL
) {
1422 ret
= OMX_ErrorBadParameter
;
1425 pOMXComponent
= (OMX_COMPONENTTYPE
*)hComponent
;
1426 ret
= Exynos_OMX_Check_SizeVersion(pOMXComponent
, sizeof(OMX_COMPONENTTYPE
));
1427 if (ret
!= OMX_ErrorNone
) {
1430 if (pOMXComponent
->pComponentPrivate
== NULL
) {
1431 ret
= OMX_ErrorBadParameter
;
1434 pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
1435 if ((cParameterName
== NULL
) || (pIndexType
== NULL
)) {
1436 ret
= OMX_ErrorBadParameter
;
1439 if (pExynosComponent
->currentState
== OMX_StateInvalid
) {
1440 ret
= OMX_ErrorInvalidState
;
1444 if (Exynos_OSAL_Strcmp(cParameterName
, EXYNOS_INDEX_PARAM_ENABLE_THUMBNAIL
) == 0) {
1445 EXYNOS_WMVDEC_HANDLE
*pWmvDec
= (EXYNOS_WMVDEC_HANDLE
*)((EXYNOS_OMX_VIDEODEC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
1446 *pIndexType
= OMX_IndexVendorThumbnailMode
;
1447 ret
= OMX_ErrorNone
;
1449 ret
= Exynos_OMX_VideoDecodeGetExtensionIndex(hComponent
, cParameterName
, pIndexType
);
1458 OMX_ERRORTYPE
Exynos_WmvDec_ComponentRoleEnum(
1459 OMX_HANDLETYPE hComponent
,
1463 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
1464 OMX_COMPONENTTYPE
*pOMXComponent
= NULL
;
1465 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= NULL
;
1469 if ((hComponent
== NULL
) || (cRole
== NULL
)) {
1470 ret
= OMX_ErrorBadParameter
;
1473 if (nIndex
== (MAX_COMPONENT_ROLE_NUM
-1)) {
1474 Exynos_OSAL_Strcpy((char *)cRole
, EXYNOS_OMX_COMPONENT_WMV_DEC_ROLE
);
1475 ret
= OMX_ErrorNone
;
1477 ret
= OMX_ErrorNoMore
;
1487 OMX_ERRORTYPE
Exynos_WmvDec_Init(OMX_COMPONENTTYPE
*pOMXComponent
)
1489 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
1490 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
1491 EXYNOS_OMX_VIDEODEC_COMPONENT
*pVideoDec
= (EXYNOS_OMX_VIDEODEC_COMPONENT
*)pExynosComponent
->hComponentHandle
;
1492 EXYNOS_OMX_BASEPORT
*pExynosInputPort
= &pExynosComponent
->pExynosPort
[INPUT_PORT_INDEX
];
1493 EXYNOS_OMX_BASEPORT
*pExynosOutputPort
= &pExynosComponent
->pExynosPort
[OUTPUT_PORT_INDEX
];
1494 EXYNOS_WMVDEC_HANDLE
*pWmvDec
= (EXYNOS_WMVDEC_HANDLE
*)pVideoDec
->hCodecHandle
;
1495 OMX_PTR hMFCHandle
= pWmvDec
->hMFCWmvHandle
.hMFCHandle
;
1497 ExynosVideoDecOps
*pDecOps
= NULL
;
1498 ExynosVideoDecBufferOps
*pInbufOps
= NULL
;
1499 ExynosVideoDecBufferOps
*pOutbufOps
= NULL
;
1501 CSC_METHOD csc_method
= CSC_METHOD_SW
;
1506 pWmvDec
->hMFCWmvHandle
.bConfiguredMFCSrc
= OMX_FALSE
;
1507 pWmvDec
->hMFCWmvHandle
.bConfiguredMFCDst
= OMX_FALSE
;
1508 pExynosComponent
->bUseFlagEOF
= OMX_TRUE
;
1509 pExynosComponent
->bSaveFlagEOS
= OMX_FALSE
;
1510 pExynosComponent
->bBehaviorEOS
= OMX_FALSE
;
1512 /* WMV Codec Open */
1513 ret
= WmvCodecOpen(pWmvDec
);
1514 if (ret
!= OMX_ErrorNone
) {
1518 pDecOps
= pWmvDec
->hMFCWmvHandle
.pDecOps
;
1519 pInbufOps
= pWmvDec
->hMFCWmvHandle
.pInbufOps
;
1520 pOutbufOps
= pWmvDec
->hMFCWmvHandle
.pOutbufOps
;
1522 if (pExynosInputPort
->bufferProcessType
& BUFFER_COPY
) {
1523 OMX_U32 nPlaneSize
[MFC_INPUT_BUFFER_PLANE
] = {DEFAULT_MFC_INPUT_BUFFER_SIZE
};
1524 Exynos_OSAL_SemaphoreCreate(&pExynosInputPort
->codecSemID
);
1525 Exynos_OSAL_QueueCreate(&pExynosInputPort
->codecBufferQ
, MAX_QUEUE_ELEMENTS
);
1526 ret
= Exynos_Allocate_CodecBuffers(pOMXComponent
, INPUT_PORT_INDEX
, MFC_INPUT_BUFFER_NUM_MAX
, nPlaneSize
);
1527 if (ret
!= OMX_ErrorNone
)
1530 for (i
= 0; i
< MFC_INPUT_BUFFER_NUM_MAX
; i
++)
1531 Exynos_CodecBufferEnQueue(pExynosComponent
, INPUT_PORT_INDEX
, pVideoDec
->pMFCDecInputBuffer
[i
]);
1532 } else if (pExynosInputPort
->bufferProcessType
& BUFFER_SHARE
) {
1536 /* Does not require any actions. */
1539 if (pExynosOutputPort
->bufferProcessType
& BUFFER_COPY
) {
1540 Exynos_OSAL_SemaphoreCreate(&pExynosOutputPort
->codecSemID
);
1541 Exynos_OSAL_QueueCreate(&pExynosOutputPort
->codecBufferQ
, MAX_QUEUE_ELEMENTS
);
1542 } else if (pExynosOutputPort
->bufferProcessType
& BUFFER_SHARE
) {
1546 /* Does not require any actions. */
1549 pWmvDec
->bSourceStart
= OMX_FALSE
;
1550 Exynos_OSAL_SignalCreate(&pWmvDec
->hSourceStartEvent
);
1551 pWmvDec
->bDestinationStart
= OMX_FALSE
;
1552 Exynos_OSAL_SignalCreate(&pWmvDec
->hDestinationStartEvent
);
1554 Exynos_OSAL_Memset(pExynosComponent
->timeStamp
, -19771003, sizeof(OMX_TICKS
) * MAX_TIMESTAMP
);
1555 Exynos_OSAL_Memset(pExynosComponent
->nFlags
, 0, sizeof(OMX_U32
) * MAX_FLAGS
);
1556 pWmvDec
->hMFCWmvHandle
.indexTimestamp
= 0;
1557 pWmvDec
->hMFCWmvHandle
.outputIndexTimestamp
= 0;
1558 /* Default WMV codec format is set as VC1*/
1559 pWmvDec
->hMFCWmvHandle
.wmvFormat
= WMV_FORMAT_VC1
;
1561 pExynosComponent
->getAllDelayBuffer
= OMX_FALSE
;
1564 csc_method
= CSC_METHOD_HW
;
1566 pVideoDec
->csc_handle
= csc_init(csc_method
);
1567 if (pVideoDec
->csc_handle
== NULL
) {
1568 ret
= OMX_ErrorInsufficientResources
;
1571 pVideoDec
->csc_set_format
= OMX_FALSE
;
1580 OMX_ERRORTYPE
Exynos_WmvDec_Terminate(OMX_COMPONENTTYPE
*pOMXComponent
)
1582 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
1583 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
1584 EXYNOS_OMX_VIDEODEC_COMPONENT
*pVideoDec
= (EXYNOS_OMX_VIDEODEC_COMPONENT
*)pExynosComponent
->hComponentHandle
;
1585 EXYNOS_OMX_BASEPORT
*pExynosInputPort
= &pExynosComponent
->pExynosPort
[INPUT_PORT_INDEX
];
1586 EXYNOS_OMX_BASEPORT
*pExynosOutputPort
= &pExynosComponent
->pExynosPort
[OUTPUT_PORT_INDEX
];
1587 EXYNOS_WMVDEC_HANDLE
*pWmvDec
= (EXYNOS_WMVDEC_HANDLE
*)((EXYNOS_OMX_VIDEODEC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
1588 OMX_PTR hMFCHandle
= pWmvDec
->hMFCWmvHandle
.hMFCHandle
;
1590 ExynosVideoDecOps
*pDecOps
= pWmvDec
->hMFCWmvHandle
.pDecOps
;
1591 ExynosVideoDecBufferOps
*pInbufOps
= pWmvDec
->hMFCWmvHandle
.pInbufOps
;
1592 ExynosVideoDecBufferOps
*pOutbufOps
= pWmvDec
->hMFCWmvHandle
.pOutbufOps
;
1598 if (pVideoDec
->csc_handle
!= NULL
) {
1599 csc_deinit(pVideoDec
->csc_handle
);
1600 pVideoDec
->csc_handle
= NULL
;
1603 Exynos_OSAL_SignalTerminate(pWmvDec
->hDestinationStartEvent
);
1604 pWmvDec
->hDestinationStartEvent
= NULL
;
1605 pWmvDec
->bDestinationStart
= OMX_FALSE
;
1606 Exynos_OSAL_SignalTerminate(pWmvDec
->hSourceStartEvent
);
1607 pWmvDec
->hSourceStartEvent
= NULL
;
1608 pWmvDec
->bSourceStart
= OMX_FALSE
;
1610 if (pExynosOutputPort
->bufferProcessType
& BUFFER_COPY
) {
1611 Exynos_Free_CodecBuffers(pOMXComponent
, OUTPUT_PORT_INDEX
);
1612 Exynos_OSAL_QueueTerminate(&pExynosOutputPort
->codecBufferQ
);
1613 Exynos_OSAL_SemaphoreTerminate(pExynosOutputPort
->codecSemID
);
1614 } else if (pExynosOutputPort
->bufferProcessType
& BUFFER_SHARE
) {
1618 /* Does not require any actions. */
1621 if (pExynosInputPort
->bufferProcessType
& BUFFER_COPY
) {
1622 Exynos_Free_CodecBuffers(pOMXComponent
, INPUT_PORT_INDEX
);
1623 Exynos_OSAL_QueueTerminate(&pExynosInputPort
->codecBufferQ
);
1624 Exynos_OSAL_SemaphoreTerminate(pExynosInputPort
->codecSemID
);
1625 } else if (pExynosInputPort
->bufferProcessType
& BUFFER_SHARE
) {
1629 /* Does not require any actions. */
1631 WmvCodecClose(pWmvDec
);
1633 Exynos_ResetAllPortConfig(pOMXComponent
);
1641 OMX_ERRORTYPE
Exynos_WmvDec_SrcIn(OMX_COMPONENTTYPE
*pOMXComponent
, EXYNOS_OMX_DATA
*pSrcInputData
)
1643 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
1644 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
1645 EXYNOS_OMX_VIDEODEC_COMPONENT
*pVideoDec
= (EXYNOS_OMX_VIDEODEC_COMPONENT
*)pExynosComponent
->hComponentHandle
;
1646 EXYNOS_WMVDEC_HANDLE
*pWmvDec
= (EXYNOS_WMVDEC_HANDLE
*)((EXYNOS_OMX_VIDEODEC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
1647 void *hMFCHandle
= pWmvDec
->hMFCWmvHandle
.hMFCHandle
;
1648 EXYNOS_OMX_BASEPORT
*pExynosInputPort
= &pExynosComponent
->pExynosPort
[INPUT_PORT_INDEX
];
1649 EXYNOS_OMX_BASEPORT
*pExynosOutputPort
= &pExynosComponent
->pExynosPort
[OUTPUT_PORT_INDEX
];
1650 OMX_U32 oneFrameSize
= pSrcInputData
->dataLen
;
1651 OMX_BOOL bStartCode
= OMX_FALSE
;
1652 ExynosVideoDecOps
*pDecOps
= pWmvDec
->hMFCWmvHandle
.pDecOps
;
1653 ExynosVideoDecBufferOps
*pInbufOps
= pWmvDec
->hMFCWmvHandle
.pInbufOps
;
1654 ExynosVideoDecBufferOps
*pOutbufOps
= pWmvDec
->hMFCWmvHandle
.pOutbufOps
;
1655 ExynosVideoErrorType codecReturn
= VIDEO_ERROR_NONE
;
1660 if (pWmvDec
->hMFCWmvHandle
.bConfiguredMFCSrc
== OMX_FALSE
) {
1661 ret
= WmvCodecSrcSetup(pOMXComponent
, pSrcInputData
);
1664 if (pWmvDec
->hMFCWmvHandle
.bConfiguredMFCDst
== OMX_FALSE
) {
1665 ret
= WmvCodecDstSetup(pOMXComponent
);
1668 bStartCode
= Check_Stream_PrefixCode(pSrcInputData
->buffer
.singlePlaneBuffer
.dataBuffer
, oneFrameSize
, pWmvDec
->hMFCWmvHandle
.wmvFormat
);
1669 if ((bStartCode
== OMX_FALSE
) &&
1670 ((pSrcInputData
->nFlags
& OMX_BUFFERFLAG_EOS
) != OMX_BUFFERFLAG_EOS
)) {
1671 if (pSrcInputData
->allocSize
< oneFrameSize
+4) {
1672 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Can't attach startcode due to lack of buffer space");
1673 ret
= (OMX_ERRORTYPE
)OMX_ErrorCodecDecode
;
1677 bStartCode
= Make_Stream_StartCode(pSrcInputData
->buffer
.singlePlaneBuffer
.dataBuffer
, &oneFrameSize
, pWmvDec
->hMFCWmvHandle
.wmvFormat
);
1678 if (bStartCode
== OMX_FALSE
) {
1679 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Fail to Make Stream Start Code");
1680 ret
= (OMX_ERRORTYPE
)OMX_ErrorCodecDecode
;
1685 if ((bStartCode
== OMX_TRUE
) || ((pSrcInputData
->nFlags
& OMX_BUFFERFLAG_EOS
) == OMX_BUFFERFLAG_EOS
)){
1686 pExynosComponent
->timeStamp
[pWmvDec
->hMFCWmvHandle
.indexTimestamp
] = pSrcInputData
->timeStamp
;
1687 pExynosComponent
->nFlags
[pWmvDec
->hMFCWmvHandle
.indexTimestamp
] = pSrcInputData
->nFlags
;
1688 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
);
1689 pDecOps
->Set_FrameTag(hMFCHandle
, pWmvDec
->hMFCWmvHandle
.indexTimestamp
);
1690 pWmvDec
->hMFCWmvHandle
.indexTimestamp
++;
1691 pWmvDec
->hMFCWmvHandle
.indexTimestamp
%= MAX_TIMESTAMP
;
1693 /* queue work for input buffer */
1694 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "oneFrameSize: %d, bufferHeader: 0x%x, dataBuffer: 0x%x", oneFrameSize
, pSrcInputData
->bufferHeader
, pSrcInputData
->buffer
.singlePlaneBuffer
.dataBuffer
);
1695 codecReturn
= pInbufOps
->Enqueue(hMFCHandle
, (unsigned char **)&pSrcInputData
->buffer
.singlePlaneBuffer
.dataBuffer
,
1696 (unsigned int *)&oneFrameSize
, MFC_INPUT_BUFFER_PLANE
, pSrcInputData
->bufferHeader
);
1697 if (codecReturn
!= VIDEO_ERROR_NONE
) {
1698 ret
= (OMX_ERRORTYPE
)OMX_ErrorCodecDecode
;
1699 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "%s : %d", __FUNCTION__
, __LINE__
);
1702 WmvCodecStart(pOMXComponent
, INPUT_PORT_INDEX
);
1703 if (pWmvDec
->bSourceStart
== OMX_FALSE
) {
1704 pWmvDec
->bSourceStart
= OMX_TRUE
;
1705 Exynos_OSAL_SignalSet(pWmvDec
->hSourceStartEvent
);
1706 Exynos_OSAL_SleepMillisec(0);
1708 if (pWmvDec
->bDestinationStart
== OMX_FALSE
) {
1709 pWmvDec
->bDestinationStart
= OMX_TRUE
;
1710 Exynos_OSAL_SignalSet(pWmvDec
->hDestinationStartEvent
);
1711 Exynos_OSAL_SleepMillisec(0);
1715 ret
= OMX_ErrorNone
;
1723 OMX_ERRORTYPE
Exynos_WmvDec_SrcOut(OMX_COMPONENTTYPE
*pOMXComponent
, EXYNOS_OMX_DATA
*pSrcOutputData
)
1725 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
1726 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
1727 EXYNOS_OMX_VIDEODEC_COMPONENT
*pVideoDec
= (EXYNOS_OMX_VIDEODEC_COMPONENT
*)pExynosComponent
->hComponentHandle
;
1728 EXYNOS_WMVDEC_HANDLE
*pWmvDec
= (EXYNOS_WMVDEC_HANDLE
*)((EXYNOS_OMX_VIDEODEC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
1729 void *hMFCHandle
= pWmvDec
->hMFCWmvHandle
.hMFCHandle
;
1730 EXYNOS_OMX_BASEPORT
*pExynosInputPort
= &pExynosComponent
->pExynosPort
[INPUT_PORT_INDEX
];
1731 ExynosVideoDecOps
*pDecOps
= pWmvDec
->hMFCWmvHandle
.pDecOps
;
1732 ExynosVideoDecBufferOps
*pInbufOps
= pWmvDec
->hMFCWmvHandle
.pInbufOps
;
1733 ExynosVideoBuffer
*pVideoBuffer
;
1737 pVideoBuffer
= pInbufOps
->Dequeue(hMFCHandle
);
1739 pSrcOutputData
->dataLen
= 0;
1740 pSrcOutputData
->usedDataLen
= 0;
1741 pSrcOutputData
->remainDataLen
= 0;
1742 pSrcOutputData
->nFlags
= 0;
1743 pSrcOutputData
->timeStamp
= 0;
1745 if (pVideoBuffer
== NULL
) {
1746 pSrcOutputData
->buffer
.singlePlaneBuffer
.dataBuffer
= NULL
;
1747 pSrcOutputData
->allocSize
= 0;
1748 pSrcOutputData
->pPrivate
= NULL
;
1749 pSrcOutputData
->bufferHeader
= NULL
;
1751 pSrcOutputData
->buffer
.singlePlaneBuffer
.dataBuffer
= pVideoBuffer
->planes
[0].addr
;
1752 pSrcOutputData
->buffer
.singlePlaneBuffer
.fd
= pVideoBuffer
->planes
[0].fd
;
1753 pSrcOutputData
->allocSize
= pVideoBuffer
->planes
[0].allocSize
;
1755 if (pExynosInputPort
->bufferProcessType
& BUFFER_COPY
) {
1757 for (i
= 0; i
< MFC_INPUT_BUFFER_NUM_MAX
; i
++) {
1758 if (pSrcOutputData
->buffer
.singlePlaneBuffer
.dataBuffer
==
1759 pVideoDec
->pMFCDecInputBuffer
[i
]->pVirAddr
[0]) {
1760 pVideoDec
->pMFCDecInputBuffer
[i
]->dataSize
= 0;
1761 pSrcOutputData
->pPrivate
= pVideoDec
->pMFCDecInputBuffer
[i
];
1766 if (i
>= MFC_INPUT_BUFFER_NUM_MAX
) {
1767 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Can not find buffer");
1768 ret
= (OMX_ERRORTYPE
)OMX_ErrorCodecDecode
;
1773 /* For Share Buffer */
1774 pSrcOutputData
->bufferHeader
= (OMX_BUFFERHEADERTYPE
*)pVideoBuffer
->pPrivate
;
1777 ret
= OMX_ErrorNone
;
1785 OMX_ERRORTYPE
Exynos_WmvDec_DstIn(OMX_COMPONENTTYPE
*pOMXComponent
, EXYNOS_OMX_DATA
*pDstInputData
)
1787 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
1788 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
1789 EXYNOS_OMX_VIDEODEC_COMPONENT
*pVideoDec
= (EXYNOS_OMX_VIDEODEC_COMPONENT
*)pExynosComponent
->hComponentHandle
;
1790 EXYNOS_WMVDEC_HANDLE
*pWmvDec
= (EXYNOS_WMVDEC_HANDLE
*)((EXYNOS_OMX_VIDEODEC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
1791 void *hMFCHandle
= pWmvDec
->hMFCWmvHandle
.hMFCHandle
;
1792 ExynosVideoDecOps
*pDecOps
= pWmvDec
->hMFCWmvHandle
.pDecOps
;
1793 ExynosVideoDecBufferOps
*pOutbufOps
= pWmvDec
->hMFCWmvHandle
.pOutbufOps
;
1794 OMX_U32 dataLen
[2] = {0,};
1795 ExynosVideoErrorType codecReturn
= VIDEO_ERROR_NONE
;
1799 if (pDstInputData
->buffer
.multiPlaneBuffer
.dataBuffer
[0] == NULL
) {
1800 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Failed to find input buffer");
1801 ret
= OMX_ErrorBadParameter
;
1805 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "%s : %d => ADDR[0]: 0x%x, ADDR[1]: 0x%x", __FUNCTION__
, __LINE__
,
1806 pDstInputData
->buffer
.multiPlaneBuffer
.dataBuffer
[0],
1807 pDstInputData
->buffer
.multiPlaneBuffer
.dataBuffer
[1]);
1809 codecReturn
= pOutbufOps
->Enqueue(hMFCHandle
, (unsigned char **)pDstInputData
->buffer
.multiPlaneBuffer
.dataBuffer
,
1810 (unsigned int *)dataLen
, MFC_OUTPUT_BUFFER_PLANE
, pDstInputData
->bufferHeader
);
1812 if (codecReturn
!= VIDEO_ERROR_NONE
) {
1813 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "%s : %d", __FUNCTION__
, __LINE__
);
1814 ret
= (OMX_ERRORTYPE
)OMX_ErrorCodecDecode
;
1817 WmvCodecStart(pOMXComponent
, OUTPUT_PORT_INDEX
);
1819 ret
= OMX_ErrorNone
;
1827 OMX_ERRORTYPE
Exynos_WmvDec_DstOut(OMX_COMPONENTTYPE
*pOMXComponent
, EXYNOS_OMX_DATA
*pDstOutputData
)
1829 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
1830 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
1831 EXYNOS_OMX_VIDEODEC_COMPONENT
*pVideoDec
= (EXYNOS_OMX_VIDEODEC_COMPONENT
*)pExynosComponent
->hComponentHandle
;
1832 EXYNOS_WMVDEC_HANDLE
*pWmvDec
= (EXYNOS_WMVDEC_HANDLE
*)((EXYNOS_OMX_VIDEODEC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
1833 void *hMFCHandle
= pWmvDec
->hMFCWmvHandle
.hMFCHandle
;
1834 EXYNOS_OMX_BASEPORT
*pExynosInputPort
= &pExynosComponent
->pExynosPort
[INPUT_PORT_INDEX
];
1835 EXYNOS_OMX_BASEPORT
*pExynosOutputPort
= &pExynosComponent
->pExynosPort
[OUTPUT_PORT_INDEX
];
1836 ExynosVideoDecOps
*pDecOps
= pWmvDec
->hMFCWmvHandle
.pDecOps
;
1837 ExynosVideoDecBufferOps
*pOutbufOps
= pWmvDec
->hMFCWmvHandle
.pOutbufOps
;
1838 ExynosVideoBuffer
*pVideoBuffer
= NULL
;
1839 ExynosVideoFrameStatusType displayStatus
= VIDEO_FRAME_STATUS_UNKNOWN
;
1840 ExynosVideoGeometry
*bufferGeometry
;
1841 DECODE_CODEC_EXTRA_BUFFERINFO
*pBufferInfo
= NULL
;
1842 OMX_S32 indexTimestamp
= 0;
1847 if (pWmvDec
->bDestinationStart
== OMX_FALSE
) {
1848 ret
= OMX_ErrorNone
;
1853 pVideoBuffer
= pOutbufOps
->Dequeue(hMFCHandle
);
1854 if (pVideoBuffer
== (ExynosVideoBuffer
*)VIDEO_ERROR_DQBUF_EIO
) {
1855 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "HW is not available");
1856 ret
= OMX_ErrorHardware
;
1860 if (pVideoBuffer
== NULL
) {
1861 ret
= OMX_ErrorNone
;
1864 displayStatus
= pVideoBuffer
->displayStatus
;
1865 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "displayStatus: 0x%x", displayStatus
);
1867 if ((displayStatus
== VIDEO_FRAME_STATUS_DISPLAY_DECODING
) ||
1868 (displayStatus
== VIDEO_FRAME_STATUS_DISPLAY_ONLY
) ||
1869 (displayStatus
== VIDEO_FRAME_STATUS_CHANGE_RESOL
) ||
1870 (displayStatus
== VIDEO_FRAME_STATUS_DECODING_FINISHED
) ||
1871 (CHECK_PORT_BEING_FLUSHED(pExynosOutputPort
))) {
1872 ret
= OMX_ErrorNone
;
1877 pWmvDec
->hMFCWmvHandle
.outputIndexTimestamp
++;
1878 pWmvDec
->hMFCWmvHandle
.outputIndexTimestamp
%= MAX_TIMESTAMP
;
1880 pDstOutputData
->allocSize
= pDstOutputData
->dataLen
= 0;
1881 for (plane
= 0; plane
< MFC_OUTPUT_BUFFER_PLANE
; plane
++) {
1882 pDstOutputData
->buffer
.multiPlaneBuffer
.dataBuffer
[plane
] = pVideoBuffer
->planes
[plane
].addr
;
1883 pDstOutputData
->buffer
.multiPlaneBuffer
.fd
[plane
] = pVideoBuffer
->planes
[plane
].fd
;
1884 pDstOutputData
->allocSize
+= pVideoBuffer
->planes
[plane
].allocSize
;
1885 pDstOutputData
->dataLen
+= pVideoBuffer
->planes
[plane
].dataSize
;
1887 pDstOutputData
->usedDataLen
= 0;
1888 pDstOutputData
->pPrivate
= pVideoBuffer
;
1889 if (pExynosOutputPort
->bufferProcessType
& BUFFER_COPY
) {
1891 pDstOutputData
->pPrivate
= NULL
;
1892 for (i
= 0; i
< MFC_OUTPUT_BUFFER_NUM_MAX
; i
++) {
1893 if (pDstOutputData
->buffer
.multiPlaneBuffer
.dataBuffer
[0] ==
1894 pVideoDec
->pMFCDecOutputBuffer
[i
]->pVirAddr
[0]) {
1895 pDstOutputData
->pPrivate
= pVideoDec
->pMFCDecOutputBuffer
[i
];
1900 if (pDstOutputData
->pPrivate
== NULL
) {
1901 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "Can not find buffer");
1902 ret
= (OMX_ERRORTYPE
)OMX_ErrorCodecDecode
;
1907 /* For Share Buffer */
1908 pDstOutputData
->bufferHeader
= (OMX_BUFFERHEADERTYPE
*)pVideoBuffer
->pPrivate
;
1910 pBufferInfo
= (DECODE_CODEC_EXTRA_BUFFERINFO
*)pDstOutputData
->extInfo
;
1911 bufferGeometry
= &pWmvDec
->hMFCWmvHandle
.codecOutbufConf
;
1912 pBufferInfo
->imageWidth
= bufferGeometry
->nFrameWidth
;
1913 pBufferInfo
->imageHeight
= bufferGeometry
->nFrameHeight
;
1914 switch (bufferGeometry
->eColorFormat
) {
1915 case VIDEO_COLORFORMAT_NV12
:
1916 pBufferInfo
->ColorFormat
= OMX_COLOR_FormatYUV420SemiPlanar
;
1918 case VIDEO_COLORFORMAT_NV12_TILED
:
1920 pBufferInfo
->ColorFormat
= OMX_SEC_COLOR_FormatNV12Tiled
;
1924 indexTimestamp
= pDecOps
->Get_FrameTag(hMFCHandle
);
1925 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "out indexTimestamp: %d", indexTimestamp
);
1926 if ((indexTimestamp
< 0) || (indexTimestamp
>= MAX_TIMESTAMP
)) {
1927 if ((pExynosComponent
->checkTimeStamp
.needSetStartTimeStamp
!= OMX_TRUE
) &&
1928 (pExynosComponent
->checkTimeStamp
.needCheckStartTimeStamp
!= OMX_TRUE
)) {
1929 if (indexTimestamp
== INDEX_AFTER_EOS
) {
1930 pDstOutputData
->timeStamp
= 0x00;
1931 pDstOutputData
->nFlags
= 0x00;
1933 pDstOutputData
->timeStamp
= pExynosComponent
->timeStamp
[pWmvDec
->hMFCWmvHandle
.outputIndexTimestamp
];
1934 pDstOutputData
->nFlags
= pExynosComponent
->nFlags
[pWmvDec
->hMFCWmvHandle
.outputIndexTimestamp
];
1935 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "missing out indexTimestamp: %d", indexTimestamp
);
1938 pDstOutputData
->timeStamp
= 0x00;
1939 pDstOutputData
->nFlags
= 0x00;
1942 /* For timestamp correction. if mfc support frametype detect */
1943 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "disp_pic_frame_type: %d", pVideoBuffer
->frameType
);
1945 /* NEED TIMESTAMP REORDER */
1946 if (pVideoDec
->bDTSMode
== OMX_TRUE
) {
1947 if ((pVideoBuffer
->frameType
== VIDEO_FRAME_I
) ||
1948 ((pVideoBuffer
->frameType
== VIDEO_FRAME_OTHERS
) &&
1949 ((pExynosComponent
->nFlags
[indexTimestamp
] & OMX_BUFFERFLAG_EOS
) == OMX_BUFFERFLAG_EOS
)))
1950 pWmvDec
->hMFCWmvHandle
.outputIndexTimestamp
= indexTimestamp
;
1952 indexTimestamp
= pWmvDec
->hMFCWmvHandle
.outputIndexTimestamp
;
1955 pDstOutputData
->timeStamp
= pExynosComponent
->timeStamp
[indexTimestamp
];
1956 pDstOutputData
->nFlags
= pExynosComponent
->nFlags
[indexTimestamp
];
1958 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "timestamp %lld us (%.2f secs), indexTimestamp: %d, nFlags: 0x%x", pDstOutputData
->timeStamp
, pDstOutputData
->timeStamp
/ 1E6
, indexTimestamp
, pDstOutputData
->nFlags
);
1961 if ((displayStatus
== VIDEO_FRAME_STATUS_CHANGE_RESOL
) ||
1962 (displayStatus
== VIDEO_FRAME_STATUS_DECODING_FINISHED
) ||
1963 ((pDstOutputData
->nFlags
& OMX_BUFFERFLAG_EOS
) == OMX_BUFFERFLAG_EOS
)) {
1964 Exynos_OSAL_Log(EXYNOS_LOG_TRACE
, "displayStatus:%d, nFlags0x%x", displayStatus
, pDstOutputData
->nFlags
);
1965 pDstOutputData
->remainDataLen
= 0;
1967 if (((pDstOutputData
->nFlags
& OMX_BUFFERFLAG_EOS
) == OMX_BUFFERFLAG_EOS
) &&
1968 (pExynosComponent
->bBehaviorEOS
== OMX_TRUE
)) {
1969 pDstOutputData
->remainDataLen
= bufferGeometry
->nFrameWidth
* bufferGeometry
->nFrameHeight
* 3 / 2;
1970 pExynosComponent
->bBehaviorEOS
= OMX_FALSE
;
1973 pDstOutputData
->remainDataLen
= bufferGeometry
->nFrameWidth
* bufferGeometry
->nFrameHeight
* 3 / 2;
1976 ret
= OMX_ErrorNone
;
1984 OMX_ERRORTYPE
Exynos_WmvDec_srcInputBufferProcess(OMX_COMPONENTTYPE
*pOMXComponent
, EXYNOS_OMX_DATA
*pSrcInputData
)
1986 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
1987 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
1988 EXYNOS_WMVDEC_HANDLE
*pWmvDec
= (EXYNOS_WMVDEC_HANDLE
*)((EXYNOS_OMX_VIDEODEC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
1989 EXYNOS_OMX_BASEPORT
*pExynosInputPort
= &pExynosComponent
->pExynosPort
[INPUT_PORT_INDEX
];
1993 if ((!CHECK_PORT_ENABLED(pExynosInputPort
)) || (!CHECK_PORT_POPULATED(pExynosInputPort
))) {
1994 ret
= OMX_ErrorNone
;
1997 if (OMX_FALSE
== Exynos_Check_BufferProcess_State(pExynosComponent
, INPUT_PORT_INDEX
)) {
1998 ret
= OMX_ErrorNone
;
2002 ret
= Exynos_WmvDec_SrcIn(pOMXComponent
, pSrcInputData
);
2003 if ((ret
!= OMX_ErrorNone
) && (ret
!= OMX_ErrorInputDataDecodeYet
)) {
2004 pExynosComponent
->pCallbacks
->EventHandler((OMX_HANDLETYPE
)pOMXComponent
,
2005 pExynosComponent
->callbackData
,
2006 OMX_EventError
, ret
, 0, NULL
);
2015 OMX_ERRORTYPE
Exynos_WmvDec_srcOutputBufferProcess(OMX_COMPONENTTYPE
*pOMXComponent
, EXYNOS_OMX_DATA
*pSrcOutputData
)
2017 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
2018 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
2019 EXYNOS_WMVDEC_HANDLE
*pWmvDec
= (EXYNOS_WMVDEC_HANDLE
*)((EXYNOS_OMX_VIDEODEC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
2020 EXYNOS_OMX_BASEPORT
*pExynosInputPort
= &pExynosComponent
->pExynosPort
[INPUT_PORT_INDEX
];
2024 if ((!CHECK_PORT_ENABLED(pExynosInputPort
)) || (!CHECK_PORT_POPULATED(pExynosInputPort
))) {
2025 ret
= OMX_ErrorNone
;
2029 if (pExynosInputPort
->bufferProcessType
& BUFFER_COPY
) {
2030 if (OMX_FALSE
== Exynos_Check_BufferProcess_State(pExynosComponent
, INPUT_PORT_INDEX
)) {
2031 ret
= OMX_ErrorNone
;
2035 if ((pWmvDec
->bSourceStart
== OMX_FALSE
) &&
2036 (!CHECK_PORT_BEING_FLUSHED(pExynosInputPort
))) {
2037 Exynos_OSAL_SignalWait(pWmvDec
->hSourceStartEvent
, DEF_MAX_WAIT_TIME
);
2038 Exynos_OSAL_SignalReset(pWmvDec
->hSourceStartEvent
);
2041 ret
= Exynos_WmvDec_SrcOut(pOMXComponent
, pSrcOutputData
);
2042 if ((ret
!= OMX_ErrorNone
) &&
2043 (pExynosComponent
->currentState
== OMX_StateExecuting
)) {
2044 pExynosComponent
->pCallbacks
->EventHandler((OMX_HANDLETYPE
)pOMXComponent
,
2045 pExynosComponent
->callbackData
,
2046 OMX_EventError
, ret
, 0, NULL
);
2055 OMX_ERRORTYPE
Exynos_WmvDec_dstInputBufferProcess(OMX_COMPONENTTYPE
*pOMXComponent
, EXYNOS_OMX_DATA
*pDstInputData
)
2057 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
2058 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
2059 EXYNOS_WMVDEC_HANDLE
*pWmvDec
= (EXYNOS_WMVDEC_HANDLE
*)((EXYNOS_OMX_VIDEODEC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
2060 EXYNOS_OMX_BASEPORT
*pExynosOutputPort
= &pExynosComponent
->pExynosPort
[OUTPUT_PORT_INDEX
];
2064 if ((!CHECK_PORT_ENABLED(pExynosOutputPort
)) || (!CHECK_PORT_POPULATED(pExynosOutputPort
))) {
2065 ret
= OMX_ErrorNone
;
2068 if (OMX_FALSE
== Exynos_Check_BufferProcess_State(pExynosComponent
, OUTPUT_PORT_INDEX
)) {
2069 ret
= OMX_ErrorNone
;
2072 if (pExynosOutputPort
->bufferProcessType
& BUFFER_SHARE
) {
2073 if ((pWmvDec
->bDestinationStart
== OMX_FALSE
) &&
2074 (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort
))) {
2075 Exynos_OSAL_SignalWait(pWmvDec
->hDestinationStartEvent
, DEF_MAX_WAIT_TIME
);
2076 Exynos_OSAL_SignalReset(pWmvDec
->hDestinationStartEvent
);
2079 if (pWmvDec
->hMFCWmvHandle
.bConfiguredMFCDst
== OMX_TRUE
) {
2080 ret
= Exynos_WmvDec_DstIn(pOMXComponent
, pDstInputData
);
2081 if (ret
!= OMX_ErrorNone
) {
2082 pExynosComponent
->pCallbacks
->EventHandler((OMX_HANDLETYPE
)pOMXComponent
,
2083 pExynosComponent
->callbackData
,
2084 OMX_EventError
, ret
, 0, NULL
);
2094 OMX_ERRORTYPE
Exynos_WmvDec_dstOutputBufferProcess(OMX_COMPONENTTYPE
*pOMXComponent
, EXYNOS_OMX_DATA
*pDstOutputData
)
2096 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
2097 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
2098 EXYNOS_WMVDEC_HANDLE
*pWmvDec
= (EXYNOS_WMVDEC_HANDLE
*)((EXYNOS_OMX_VIDEODEC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
;
2099 EXYNOS_OMX_BASEPORT
*pExynosOutputPort
= &pExynosComponent
->pExynosPort
[OUTPUT_PORT_INDEX
];
2103 if ((!CHECK_PORT_ENABLED(pExynosOutputPort
)) || (!CHECK_PORT_POPULATED(pExynosOutputPort
))) {
2104 ret
= OMX_ErrorNone
;
2107 if (OMX_FALSE
== Exynos_Check_BufferProcess_State(pExynosComponent
, OUTPUT_PORT_INDEX
)) {
2108 ret
= OMX_ErrorNone
;
2112 if (pExynosOutputPort
->bufferProcessType
& BUFFER_COPY
) {
2113 if ((pWmvDec
->bDestinationStart
== OMX_FALSE
) &&
2114 (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort
))) {
2115 Exynos_OSAL_SignalWait(pWmvDec
->hDestinationStartEvent
, DEF_MAX_WAIT_TIME
);
2116 Exynos_OSAL_SignalReset(pWmvDec
->hDestinationStartEvent
);
2119 ret
= Exynos_WmvDec_DstOut(pOMXComponent
, pDstOutputData
);
2120 if ((ret
!= OMX_ErrorNone
) &&
2121 (pExynosComponent
->currentState
== OMX_StateExecuting
)) {
2122 pExynosComponent
->pCallbacks
->EventHandler((OMX_HANDLETYPE
)pOMXComponent
,
2123 pExynosComponent
->callbackData
,
2124 OMX_EventError
, ret
, 0, NULL
);
2133 OSCL_EXPORT_REF OMX_ERRORTYPE
Exynos_OMX_ComponentInit(
2134 OMX_HANDLETYPE hComponent
,
2135 OMX_STRING componentName
)
2137 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
2138 OMX_COMPONENTTYPE
*pOMXComponent
= NULL
;
2139 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= NULL
;
2140 EXYNOS_OMX_BASEPORT
*pExynosPort
= NULL
;
2141 EXYNOS_OMX_VIDEODEC_COMPONENT
*pVideoDec
= NULL
;
2142 EXYNOS_WMVDEC_HANDLE
*pWmvDec
= NULL
;
2143 OMX_S32 wmvFormat
= WMV_FORMAT_UNKNOWN
;
2148 if ((hComponent
== NULL
) || (componentName
== NULL
)) {
2149 ret
= OMX_ErrorBadParameter
;
2150 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "OMX_ErrorBadParameter, Line:%d", __LINE__
);
2153 if (Exynos_OSAL_Strcmp(EXYNOS_OMX_COMPONENT_WMV_DEC
, componentName
) != 0) {
2154 ret
= OMX_ErrorBadParameter
;
2155 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "OMX_ErrorBadParameter, componentName:%s, Line:%d", componentName
, __LINE__
);
2159 pOMXComponent
= (OMX_COMPONENTTYPE
*)hComponent
;
2160 ret
= Exynos_OMX_VideoDecodeComponentInit(pOMXComponent
);
2161 if (ret
!= OMX_ErrorNone
) {
2162 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "OMX_Error, Line:%d", __LINE__
);
2165 pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
2166 pExynosComponent
->codecType
= HW_VIDEO_DEC_CODEC
;
2168 pExynosComponent
->componentName
= (OMX_STRING
)Exynos_OSAL_Malloc(MAX_OMX_COMPONENT_NAME_SIZE
);
2169 if (pExynosComponent
->componentName
== NULL
) {
2170 Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent
);
2171 ret
= OMX_ErrorInsufficientResources
;
2172 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "OMX_ErrorInsufficientResources, Line:%d", __LINE__
);
2175 Exynos_OSAL_Memset(pExynosComponent
->componentName
, 0, MAX_OMX_COMPONENT_NAME_SIZE
);
2177 pWmvDec
= Exynos_OSAL_Malloc(sizeof(EXYNOS_WMVDEC_HANDLE
));
2178 if (pWmvDec
== NULL
) {
2179 Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent
);
2180 ret
= OMX_ErrorInsufficientResources
;
2181 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "OMX_ErrorInsufficientResources, Line:%d", __LINE__
);
2184 Exynos_OSAL_Memset(pWmvDec
, 0, sizeof(EXYNOS_WMVDEC_HANDLE
));
2185 pVideoDec
= (EXYNOS_OMX_VIDEODEC_COMPONENT
*)pExynosComponent
->hComponentHandle
;
2186 pVideoDec
->hCodecHandle
= (OMX_HANDLETYPE
)pWmvDec
;
2187 pWmvDec
->hMFCWmvHandle
.wmvFormat
= wmvFormat
;
2189 Exynos_OSAL_Strcpy(pExynosComponent
->componentName
, EXYNOS_OMX_COMPONENT_WMV_DEC
);
2191 /* Set componentVersion */
2192 pExynosComponent
->componentVersion
.s
.nVersionMajor
= VERSIONMAJOR_NUMBER
;
2193 pExynosComponent
->componentVersion
.s
.nVersionMinor
= VERSIONMINOR_NUMBER
;
2194 pExynosComponent
->componentVersion
.s
.nRevision
= REVISION_NUMBER
;
2195 pExynosComponent
->componentVersion
.s
.nStep
= STEP_NUMBER
;
2196 /* Set specVersion */
2197 pExynosComponent
->specVersion
.s
.nVersionMajor
= VERSIONMAJOR_NUMBER
;
2198 pExynosComponent
->specVersion
.s
.nVersionMinor
= VERSIONMINOR_NUMBER
;
2199 pExynosComponent
->specVersion
.s
.nRevision
= REVISION_NUMBER
;
2200 pExynosComponent
->specVersion
.s
.nStep
= STEP_NUMBER
;
2203 pExynosPort
= &pExynosComponent
->pExynosPort
[INPUT_PORT_INDEX
];
2204 pExynosPort
->portDefinition
.format
.video
.nFrameWidth
= DEFAULT_FRAME_WIDTH
;
2205 pExynosPort
->portDefinition
.format
.video
.nFrameHeight
= DEFAULT_FRAME_HEIGHT
;
2206 pExynosPort
->portDefinition
.format
.video
.nStride
= 0; /*DEFAULT_FRAME_WIDTH;*/
2207 pExynosPort
->portDefinition
.format
.video
.nSliceHeight
= 0;
2208 pExynosPort
->portDefinition
.nBufferSize
= DEFAULT_VIDEO_INPUT_BUFFER_SIZE
;
2209 pExynosPort
->portDefinition
.format
.video
.eCompressionFormat
= OMX_VIDEO_CodingWMV
;
2210 Exynos_OSAL_Memset(pExynosPort
->portDefinition
.format
.video
.cMIMEType
, 0, MAX_OMX_MIMETYPE_SIZE
);
2211 Exynos_OSAL_Strcpy(pExynosPort
->portDefinition
.format
.video
.cMIMEType
, "video/wmv");
2212 pExynosPort
->portDefinition
.format
.video
.pNativeRender
= 0;
2213 pExynosPort
->portDefinition
.format
.video
.bFlagErrorConcealment
= OMX_FALSE
;
2214 pExynosPort
->portDefinition
.format
.video
.eColorFormat
= OMX_COLOR_FormatUnused
;
2215 pExynosPort
->portDefinition
.bEnabled
= OMX_TRUE
;
2216 //pExynosPort->bufferProcessType = BUFFER_SHARE;
2217 pExynosPort
->bufferProcessType
= BUFFER_COPY
;
2218 pExynosPort
->portWayType
= WAY2_PORT
;
2221 pExynosPort
= &pExynosComponent
->pExynosPort
[OUTPUT_PORT_INDEX
];
2222 pExynosPort
->portDefinition
.format
.video
.nFrameWidth
= DEFAULT_FRAME_WIDTH
;
2223 pExynosPort
->portDefinition
.format
.video
.nFrameHeight
= DEFAULT_FRAME_HEIGHT
;
2224 pExynosPort
->portDefinition
.format
.video
.nStride
= 0; /*DEFAULT_FRAME_WIDTH;*/
2225 pExynosPort
->portDefinition
.format
.video
.nSliceHeight
= 0;
2226 pExynosPort
->portDefinition
.nBufferSize
= DEFAULT_VIDEO_OUTPUT_BUFFER_SIZE
;
2227 pExynosPort
->portDefinition
.format
.video
.eCompressionFormat
= OMX_VIDEO_CodingUnused
;
2228 Exynos_OSAL_Memset(pExynosPort
->portDefinition
.format
.video
.cMIMEType
, 0, MAX_OMX_MIMETYPE_SIZE
);
2229 Exynos_OSAL_Strcpy(pExynosPort
->portDefinition
.format
.video
.cMIMEType
, "raw/video");
2230 pExynosPort
->portDefinition
.format
.video
.pNativeRender
= 0;
2231 pExynosPort
->portDefinition
.format
.video
.bFlagErrorConcealment
= OMX_FALSE
;
2232 pExynosPort
->portDefinition
.format
.video
.eColorFormat
= OMX_COLOR_FormatYUV420Planar
;
2233 pExynosPort
->portDefinition
.bEnabled
= OMX_TRUE
;
2234 pExynosPort
->bufferProcessType
= BUFFER_COPY
| BUFFER_ANBSHARE
;
2235 pExynosPort
->portWayType
= WAY2_PORT
;
2237 for(i
= 0; i
< ALL_PORT_NUM
; i
++) {
2238 INIT_SET_SIZE_VERSION(&pWmvDec
->WmvComponent
[i
], OMX_VIDEO_PARAM_WMVTYPE
);
2239 pWmvDec
->WmvComponent
[i
].nPortIndex
= i
;
2240 pWmvDec
->WmvComponent
[i
].eFormat
= OMX_VIDEO_WMVFormat9
;
2243 pOMXComponent
->GetParameter
= &Exynos_WmvDec_GetParameter
;
2244 pOMXComponent
->SetParameter
= &Exynos_WmvDec_SetParameter
;
2245 pOMXComponent
->GetConfig
= &Exynos_WmvDec_GetConfig
;
2246 pOMXComponent
->SetConfig
= &Exynos_WmvDec_SetConfig
;
2247 pOMXComponent
->GetExtensionIndex
= &Exynos_WmvDec_GetExtensionIndex
;
2248 pOMXComponent
->ComponentRoleEnum
= &Exynos_WmvDec_ComponentRoleEnum
;
2249 pOMXComponent
->ComponentDeInit
= &Exynos_OMX_ComponentDeinit
;
2251 pExynosComponent
->exynos_codec_componentInit
= &Exynos_WmvDec_Init
;
2252 pExynosComponent
->exynos_codec_componentTerminate
= &Exynos_WmvDec_Terminate
;
2254 pVideoDec
->exynos_codec_srcInputProcess
= &Exynos_WmvDec_srcInputBufferProcess
;
2255 pVideoDec
->exynos_codec_srcOutputProcess
= &Exynos_WmvDec_srcOutputBufferProcess
;
2256 pVideoDec
->exynos_codec_dstInputProcess
= &Exynos_WmvDec_dstInputBufferProcess
;
2257 pVideoDec
->exynos_codec_dstOutputProcess
= &Exynos_WmvDec_dstOutputBufferProcess
;
2259 pVideoDec
->exynos_codec_start
= &WmvCodecStart
;
2260 pVideoDec
->exynos_codec_stop
= &WmvCodecStop
;
2261 pVideoDec
->exynos_codec_bufferProcessRun
= &WmvCodecOutputBufferProcessRun
;
2262 pVideoDec
->exynos_codec_enqueueAllBuffer
= &WmvCodecEnQueueAllBuffer
;
2264 pVideoDec
->exynos_checkInputFrame
= &Check_Wmv_Frame
;
2265 pVideoDec
->exynos_codec_getCodecInputPrivateData
= &GetCodecInputPrivateData
;
2266 pVideoDec
->exynos_codec_getCodecOutputPrivateData
= &GetCodecOutputPrivateData
;
2268 pVideoDec
->hSharedMemory
= Exynos_OSAL_SharedMemory_Open();
2269 if (pVideoDec
->hSharedMemory
== NULL
) {
2270 Exynos_OSAL_Log(EXYNOS_LOG_ERROR
, "OMX_ErrorInsufficientResources, Line:%d", __LINE__
);
2271 Exynos_OSAL_Free(pWmvDec
);
2272 pWmvDec
= ((EXYNOS_OMX_VIDEODEC_COMPONENT
*)pExynosComponent
->hComponentHandle
)->hCodecHandle
= NULL
;
2273 Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent
);
2274 ret
= OMX_ErrorInsufficientResources
;
2278 pExynosComponent
->currentState
= OMX_StateLoaded
;
2280 ret
= OMX_ErrorNone
;
2288 OMX_ERRORTYPE
Exynos_OMX_ComponentDeinit(
2289 OMX_HANDLETYPE hComponent
)
2291 OMX_ERRORTYPE ret
= OMX_ErrorNone
;
2292 OMX_COMPONENTTYPE
*pOMXComponent
= NULL
;
2293 EXYNOS_OMX_BASECOMPONENT
*pExynosComponent
= NULL
;
2294 EXYNOS_OMX_VIDEODEC_COMPONENT
*pVideoDec
= NULL
;
2295 EXYNOS_WMVDEC_HANDLE
*pWmvDec
= NULL
;
2299 if (hComponent
== NULL
) {
2300 ret
= OMX_ErrorBadParameter
;
2303 pOMXComponent
= (OMX_COMPONENTTYPE
*)hComponent
;
2304 pExynosComponent
= (EXYNOS_OMX_BASECOMPONENT
*)pOMXComponent
->pComponentPrivate
;
2305 pVideoDec
= (EXYNOS_OMX_VIDEODEC_COMPONENT
*)pExynosComponent
->hComponentHandle
;
2307 Exynos_OSAL_SharedMemory_Close(pVideoDec
->hSharedMemory
);
2309 Exynos_OSAL_Free(pExynosComponent
->componentName
);
2310 pExynosComponent
->componentName
= NULL
;
2312 pWmvDec
= (EXYNOS_WMVDEC_HANDLE
*)pVideoDec
->hCodecHandle
;
2313 if (pWmvDec
!= NULL
) {
2314 Exynos_OSAL_Free(pWmvDec
);
2315 pWmvDec
= pVideoDec
->hCodecHandle
= NULL
;
2318 ret
= Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent
);
2319 if (ret
!= OMX_ErrorNone
) {
2323 ret
= OMX_ErrorNone
;