projects / GitHub / LineageOS / android_hardware_samsung_slsi_openmax.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
vdec: cleaned up code
[GitHub/LineageOS/android_hardware_samsung_slsi_openmax.git] / component / video / dec / vc1 / Exynos_OMX_Wmvdec.c
CommitLineData
9c5c94d6
SKR		 1/*
2 *
3 * Copyright 2012 Samsung Electronics S.LSI Co. LTD
4 *
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
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
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.
16 */
17
18/*
19 * @file Exynos_OMX_Wmvdec.c
20 * @brief
21 * @author HyeYeon Chung (hyeon.chung@samsung.com)
22 * @author Satish Kumar Reddy (palli.satish@samsung.com)
23 * @version 2.0.0
24 * @history
25 * 2012.07.10 : Create
26 * : Support WMV3 (Vc-1 Simple/Main Profile)
27 * : Support WMvC1 (Vc-1 Advanced Profile)
28 */
29
30#include <stdio.h>
31#include <stdlib.h>
32#include <string.h>
33
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"
46
47#ifdef USE_ANB
48#include "Exynos_OSAL_Android.h"
49#endif
50
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 */
53#include "csc.h"
54
55#undef EXYNOS_LOG_TAG
56#define EXYNOS_LOG_TAG "EXYNOS_WMV_DEC"
57#define EXYNOS_LOG_OFF
58#include "Exynos_OSAL_Log.h"
59
60#define WMV_DEC_NUM_OF_EXTRA_BUFFERS 7
61
62//#define FULL_FRAME_SEARCH
63
64/* ASF parser does not send start code on Stagefright */
65#define WO_START_CODE
66/* Enable or disable "WMV3_ADDITIONAL_START_CODE" based on MFC F/W's need */
67#define WMV3_ADDITIONAL_START_CODE
68
69WMV_FORMAT gWvmFormat = WMV_FORMAT_UNKNOWN;
70
71const OMX_U32 wmv3 = 0x33564d57;
72const OMX_U32 wvc1 = 0x31435657;
73const OMX_U32 wmva = 0x41564d57;
74
75
76static OMX_ERRORTYPE GetCodecInputPrivateData(OMX_PTR codecBuffer, void *pVirtAddr, OMX_U32 *dataSize)
77{
78 OMX_ERRORTYPE ret = OMX_ErrorNone;
79
80EXIT:
81 return ret;
82}
83
84static OMX_ERRORTYPE GetCodecOutputPrivateData(OMX_PTR codecBuffer, void *addr[], int size[])
85{
86 OMX_ERRORTYPE ret = OMX_ErrorNone;
87 ExynosVideoBuffer *pCodecBuffer;
88
89 if (codecBuffer == NULL) {
90 ret = OMX_ErrorBadParameter;
91 goto EXIT;
92 }
93
94 pCodecBuffer = (ExynosVideoBuffer *)codecBuffer;
95
96 if (addr != NULL) {
97 addr[0] = pCodecBuffer->planes[0].addr;
98 addr[1] = pCodecBuffer->planes[1].addr;
99 addr[2] = pCodecBuffer->planes[2].addr;
100 }
101
102 if (size != NULL) {
103 size[0] = pCodecBuffer->planes[0].allocSize;
104 size[1] = pCodecBuffer->planes[1].allocSize;
105 size[2] = pCodecBuffer->planes[2].allocSize;
106 }
107
108EXIT:
109 return ret;
110}
111
112int Check_Wmv_Frame(
113 OMX_U8 *pInputStream,
114 OMX_U32 buffSize,
115 OMX_U32 flag,
116 OMX_BOOL bPreviousFrameEOF,
117 OMX_BOOL *pbEndOfFrame)
118{
119 OMX_U32 compressionID;
120 OMX_BOOL bFrameStart;
121 OMX_U32 len, readStream;
122 OMX_U32 startCode;
123
124 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "buffSize = %d", buffSize);
125
126 len = 0;
127 bFrameStart = OMX_FALSE;
128
129 if (flag & OMX_BUFFERFLAG_CODECCONFIG) {
130 BitmapInfoHhr *pBitmapInfoHeader;
131 pBitmapInfoHeader = (BitmapInfoHhr *)pInputStream;
132
133 compressionID = pBitmapInfoHeader->BiCompression;
134 if (compressionID == wmv3) {
135 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "WMV_FORMAT_WMV3");
136 gWvmFormat = WMV_FORMAT_WMV3;
137
138 *pbEndOfFrame = OMX_TRUE;
139 return buffSize;
140 }
141 else if ((compressionID == wvc1) || (compressionID == wmva)) {
142 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "WMV_FORMAT_VC1");
143 gWvmFormat = WMV_FORMAT_VC1;
144
145#ifdef WO_START_CODE
146/* ASF parser does not send start code on Stagefright */
147 *pbEndOfFrame = OMX_TRUE;
148 return buffSize;
149#endif
150 }
151 }
152
153 if (gWvmFormat == WMV_FORMAT_WMV3) {
154 *pbEndOfFrame = OMX_TRUE;
155 return buffSize;
156 }
157
158#ifdef WO_START_CODE
159/* ASF parser does not send start code on Stagefright */
160 if (gWvmFormat == WMV_FORMAT_VC1) {
161 *pbEndOfFrame = OMX_TRUE;
162 return buffSize;
163 }
164#else
165 /* TODO : for comformanc test based on common buffer scheme w/o parser */
166
167 if (bPreviousFrameEOF == OMX_FALSE)
168 bFrameStart = OMX_TRUE;
169
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;
176 len++;
177 if (len > buffSize)
178 goto EXIT;
179 }
180 }
181
182 /* find next Frame start code */
183 startCode = 0xFFFFFFFF;
184 while ((startCode != 0x10D)) {
185 readStream = *(pInputStream + len);
186 startCode = (startCode << 8) | readStream;
187 len++;
188 if (len > buffSize)
189 goto EXIT;
190 }
191
192 *pbEndOfFrame = OMX_TRUE;
193
194 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "1. Check_Wmv_Frame returned EOF = %d, len = %d, buffSize = %d", *pbEndOfFrame, len - 4, buffSize);
195
196 return len - 4;
197#endif
198
199EXIT :
200 *pbEndOfFrame = OMX_FALSE;
201
202 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "2. Check_Wmv_Frame returned EOF = %d, len = %d, buffSize = %d", *pbEndOfFrame, len - 1, buffSize);
203
204 return --len;
205}
206
207static OMX_BOOL Check_Stream_PrefixCode(
208 OMX_U8 *pInputStream,
209 OMX_U32 streamSize,
210 WMV_FORMAT wmvFormat)
211{
212 switch (wmvFormat) {
213 case WMV_FORMAT_WMV3:
214#ifdef WMV3_ADDITIONAL_START_CODE
215 return OMX_FALSE;
216#else
217 if (streamSize > 0)
218 return OMX_TRUE;
219 else
220 return OMX_FALSE;
221#endif
222 break;
223 case WMV_FORMAT_VC1:
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);
227 return OMX_FALSE;
228 } else if ((pInputStream[0] == 0x00) &&
229 (pInputStream[1] == 0x00) &&
230 (pInputStream[2] == 0x01)) {
231 return OMX_TRUE;
232 } else {
233 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: Cannot find prefix", __FUNCTION__);
234 return OMX_FALSE;
235 }
236 break;
237
238 default:
239 Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "%s: undefined wmvFormat (%d)", __FUNCTION__, wmvFormat);
240 return OMX_FALSE;
241 break;
242 }
243}
244
245static OMX_BOOL Make_Stream_MetaData(
246 OMX_U8 *pInputStream,
247 OMX_U32 *pStreamSize,
248 WMV_FORMAT wmvFormat)
249{
250 OMX_U8 *pCurrBuf = pInputStream;
251 OMX_U32 currPos = 0;
252 OMX_U32 width, height;
253
254 FunctionIn();
255
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};
264
265 switch (wmvFormat) {
266 case WMV_FORMAT_WMV3:
267 if (*pStreamSize >= BITMAPINFOHEADER_SIZE) {
268 BitmapInfoHhr *pBitmapInfoHeader;
269 pBitmapInfoHeader = (BitmapInfoHhr *)pInputStream;
270
271 width = pBitmapInfoHeader->BiWidth;
272 height = pBitmapInfoHeader->BiHeight;
273 if (*pStreamSize > BITMAPINFOHEADER_SIZE)
274 Exynos_OSAL_Memcpy(struct_C, pInputStream+BITMAPINFOHEADER_SIZE, 4);
275
276 Exynos_OSAL_Memcpy(pCurrBuf + currPos, const_C5, 4);
277 currPos +=4;
278
279 Exynos_OSAL_Memcpy(pCurrBuf + currPos, const_04, 4);
280 currPos +=4;
281
282 Exynos_OSAL_Memcpy(pCurrBuf + currPos, struct_C, 4);
283 currPos +=4;
284
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;
290 currPos +=4;
291
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;
297 currPos +=4;
298
299 Exynos_OSAL_Memcpy(pCurrBuf + currPos,const_0C, 4);
300 currPos +=4;
301
302 Exynos_OSAL_Memcpy(pCurrBuf + currPos, struct_B_1, 4);
303 currPos +=4;
304
305 Exynos_OSAL_Memcpy(pCurrBuf + currPos, struct_B_2, 4);
306 currPos +=4;
307
308 Exynos_OSAL_Memcpy(pCurrBuf + currPos, struct_B_3, 4);
309 currPos +=4;
310
311 *pStreamSize = currPos;
312 return OMX_TRUE;
313 } else {
314 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: *pStreamSize is too small to contain metadata(%d)", __FUNCTION__, *pStreamSize);
315 return OMX_FALSE;
316 }
317 break;
318 case WMV_FORMAT_VC1:
319 if (*pStreamSize >= BITMAPINFOHEADER_ASFBINDING_SIZE) {
320 Exynos_OSAL_Memcpy(pCurrBuf, pInputStream + BITMAPINFOHEADER_ASFBINDING_SIZE, *pStreamSize - BITMAPINFOHEADER_ASFBINDING_SIZE);
321 *pStreamSize -= BITMAPINFOHEADER_ASFBINDING_SIZE;
322 return OMX_TRUE;
323 } else {
324 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: *pStreamSize is too small to contain metadata(%d)", __FUNCTION__, *pStreamSize);
325 return OMX_FALSE;
326 }
327 break;
328 default:
329 Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "%s: It is not necessary to make bitstream metadata for wmvFormat (%d)", __FUNCTION__, wmvFormat);
330 return OMX_FALSE;
331 break;
332 }
333}
334
335static OMX_BOOL Make_Stream_StartCode(
336 OMX_U8 *pInputStream,
337 OMX_U32 *pStreamSize,
338 WMV_FORMAT wmvFormat)
339{
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};
344#endif
345 OMX_U32 i;
346
347 switch (wmvFormat) {
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);
352 *pStreamSize += 8;
353#endif
354 return OMX_TRUE;
355 break;
356
357 case WMV_FORMAT_VC1:
358 /* Should find better way to shift data */
359 Exynos_OSAL_Memmove(pInputStream+4, pInputStream, *pStreamSize);
360 Exynos_OSAL_Memcpy(pInputStream, frameStartCode, 4);
361 *pStreamSize += 4;
362 return OMX_TRUE;
363 break;
364
365 default:
366 Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "%s: undefined wmvFormat (%d)", __FUNCTION__, wmvFormat);
367 return OMX_FALSE;
368 break;
369 }
370}
371
372OMX_ERRORTYPE WmvCodecOpen(EXYNOS_WMVDEC_HANDLE *pWmvDec)
373{
374 OMX_ERRORTYPE ret = OMX_ErrorNone;
375 ExynosVideoDecOps *pDecOps = NULL;
376 ExynosVideoDecBufferOps *pInbufOps = NULL;
377 ExynosVideoDecBufferOps *pOutbufOps = NULL;
378
379 FunctionIn();
380
381 if (pWmvDec == NULL) {
382 ret = OMX_ErrorBadParameter;
383 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
384 goto EXIT;
385 }
386
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));
391
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;
395 goto EXIT;
396 }
397
398 pWmvDec->hMFCWmvHandle.pDecOps = pDecOps;
399 pWmvDec->hMFCWmvHandle.pInbufOps = pInbufOps;
400 pWmvDec->hMFCWmvHandle.pOutbufOps = pOutbufOps;
401
402 /* function pointer mapping */
403 pDecOps->nSize = sizeof(ExynosVideoDecOps);
404 pInbufOps->nSize = sizeof(ExynosVideoDecBufferOps);
405 pOutbufOps->nSize = sizeof(ExynosVideoDecBufferOps);
406
407 Exynos_Video_Register_Decoder(pDecOps, pInbufOps, pOutbufOps);
408
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;
415 goto EXIT;
416 }
417
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;
426 goto EXIT;
427 }
428
429 /* alloc context, open, querycap */
430#ifdef USE_DMA_BUF
431 pWmvDec->hMFCWmvHandle.hMFCHandle = pWmvDec->hMFCWmvHandle.pDecOps->Init(V4L2_MEMORY_DMABUF);
432#else
433 pWmvDec->hMFCWmvHandle.hMFCHandle = pWmvDec->hMFCWmvHandle.pDecOps->Init(V4L2_MEMORY_USERPTR);
434#endif
435 if (pWmvDec->hMFCWmvHandle.hMFCHandle == NULL) {
436 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to allocate context buffer");
437 ret = OMX_ErrorInsufficientResources;
438 goto EXIT;
439 }
440
441 ret = OMX_ErrorNone;
442
443EXIT:
444 if (ret != OMX_ErrorNone) {
445 if (pDecOps != NULL) {
446 Exynos_OSAL_Free(pDecOps);
447 pWmvDec->hMFCWmvHandle.pDecOps = NULL;
448 }
449 if (pInbufOps != NULL) {
450 Exynos_OSAL_Free(pInbufOps);
451 pWmvDec->hMFCWmvHandle.pInbufOps = NULL;
452 }
453 if (pOutbufOps != NULL) {
454 Exynos_OSAL_Free(pOutbufOps);
455 pWmvDec->hMFCWmvHandle.pOutbufOps = NULL;
456 }
457 }
458
459 FunctionOut();
460
461 return ret;
462}
463
464OMX_ERRORTYPE WmvCodecClose(EXYNOS_WMVDEC_HANDLE *pWmvDec)
465{
466 OMX_ERRORTYPE ret = OMX_ErrorNone;
467 void *hMFCHandle = NULL;
468 ExynosVideoDecOps *pDecOps = NULL;
469 ExynosVideoDecBufferOps *pInbufOps = NULL;
470 ExynosVideoDecBufferOps *pOutbufOps = NULL;
471
472 FunctionIn();
473
474 if (pWmvDec == NULL) {
475 ret = OMX_ErrorBadParameter;
476 goto EXIT;
477 }
478
479 hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
480 pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
481 pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
482 pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
483
484 if (hMFCHandle != NULL) {
485 pDecOps->Finalize(hMFCHandle);
486 pWmvDec->hMFCWmvHandle.hMFCHandle = NULL;
487 }
488 if (pOutbufOps != NULL) {
489 Exynos_OSAL_Free(pOutbufOps);
490 pWmvDec->hMFCWmvHandle.pOutbufOps = NULL;
491 }
492 if (pInbufOps != NULL) {
493 Exynos_OSAL_Free(pInbufOps);
494 pWmvDec->hMFCWmvHandle.pInbufOps = NULL;
495 }
496 if (pDecOps != NULL) {
497 Exynos_OSAL_Free(pDecOps);
498 pWmvDec->hMFCWmvHandle.pDecOps = NULL;
499 }
500
501 ret = OMX_ErrorNone;
502
503EXIT:
504 FunctionOut();
505
506 return ret;
507}
508
509OMX_ERRORTYPE WmvCodecStart(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
510{
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;
518
519 FunctionIn();
520
521 if (pOMXComponent == NULL) {
522 ret = OMX_ErrorBadParameter;
523 goto EXIT;
524 }
525
526 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
527 if (pVideoDec == NULL) {
528 ret = OMX_ErrorBadParameter;
529 goto EXIT;
530 }
531
532 pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
533 if (pWmvDec == NULL) {
534 ret = OMX_ErrorBadParameter;
535 goto EXIT;
536 }
537
538 hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
539 pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
540 pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
541 pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
542
543 if (nPortIndex == INPUT_PORT_INDEX)
544 pInbufOps->Run(hMFCHandle);
545 else if (nPortIndex == OUTPUT_PORT_INDEX)
546 pOutbufOps->Run(hMFCHandle);
547
548 ret = OMX_ErrorNone;
549
550EXIT:
551 FunctionOut();
552
553 return ret;
554}
555
556OMX_ERRORTYPE WmvCodecStop(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
557{
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;
565
566 FunctionIn();
567
568 if (pOMXComponent == NULL) {
569 ret = OMX_ErrorBadParameter;
570 goto EXIT;
571 }
572
573 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
574 if (pVideoDec == NULL) {
575 ret = OMX_ErrorBadParameter;
576 goto EXIT;
577 }
578 pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
579 if (pWmvDec == NULL) {
580 ret = OMX_ErrorBadParameter;
581 goto EXIT;
582 }
583
584 hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
585 pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
586 pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
587 pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
588
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);
593
594 ret = OMX_ErrorNone;
595
596EXIT:
597 FunctionOut();
598
599 return ret;
600}
601
602OMX_ERRORTYPE WmvCodecOutputBufferProcessRun(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
603{
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;
611
612 FunctionIn();
613
614 if (pOMXComponent == NULL) {
615 ret = OMX_ErrorBadParameter;
616 goto EXIT;
617 }
618
619 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
620 if (pVideoDec == NULL) {
621 ret = OMX_ErrorBadParameter;
622 goto EXIT;
623 }
624 pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
625 if (pWmvDec == NULL) {
626 ret = OMX_ErrorBadParameter;
627 goto EXIT;
628 }
629
630 hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
631 pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
632 pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
633 pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
634
635 if (nPortIndex == INPUT_PORT_INDEX) {
636 if (pWmvDec->bSourceStart == OMX_FALSE) {
637 Exynos_OSAL_SignalSet(pWmvDec->hSourceStartEvent);
638 Exynos_OSAL_SleepMillisec(0);
639 }
640 }
641
642 if (nPortIndex == OUTPUT_PORT_INDEX) {
643 if (pWmvDec->bDestinationStart == OMX_FALSE) {
644 Exynos_OSAL_SignalSet(pWmvDec->hDestinationStartEvent);
645 Exynos_OSAL_SleepMillisec(0);
646 }
647 }
648
649 ret = OMX_ErrorNone;
650
651EXIT:
652 FunctionOut();
653
654 return ret;
655}
656
0641ae29
TK		 657OMX_ERRORTYPE WMVCodecRegistCodecBuffers(
658 OMX_COMPONENTTYPE *pOMXComponent,
659 OMX_U32 nPortIndex,
660 OMX_U32 nBufferCnt)
661{
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;
670
671 OMX_U32 nPlaneCnt = 0;
672 int i, j;
673
674 FunctionIn();
675
676 if (nPortIndex == INPUT_PORT_INDEX) {
677 ppCodecBuffer = &(pVideoDec->pMFCDecInputBuffer[0]);
678 nPlaneCnt = MFC_INPUT_BUFFER_PLANE;
679 pBufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
680 } else {
681 ppCodecBuffer = &(pVideoDec->pMFCDecOutputBuffer[0]);
682 nPlaneCnt = MFC_OUTPUT_BUFFER_PLANE;
683 pBufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
684 }
685
686 pPlanes = (ExynosVideoPlane *)Exynos_OSAL_Malloc(sizeof(ExynosVideoPlane) * nPlaneCnt);
687 if (pPlanes == NULL) {
688 ret = OMX_ErrorInsufficientResources;
689 goto EXIT;
690 }
691
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];
698 }
699
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);
704 goto EXIT;
705 }
706 }
707
708 Exynos_OSAL_Free(pPlanes);
709
710 ret = OMX_ErrorNone;
711
712EXIT:
713 FunctionOut();
714
715 return ret;
716}
717
9c5c94d6
SKR		 718OMX_ERRORTYPE WmvCodecEnQueueAllBuffer(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
719{
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];
727 int i, nOutbufs;
728
729 ExynosVideoDecOps *pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
730 ExynosVideoDecBufferOps *pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
731 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
732
733 FunctionIn();
734
735 if ((nPortIndex != INPUT_PORT_INDEX) && (nPortIndex != OUTPUT_PORT_INDEX)) {
736 ret = OMX_ErrorBadPortIndex;
737 goto EXIT;
738 }
739
740 if ((nPortIndex == INPUT_PORT_INDEX) &&
741 (pWmvDec->bSourceStart == OMX_TRUE)) {
742 Exynos_CodecBufferReset(pExynosComponent, INPUT_PORT_INDEX);
743
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]);
747
748 Exynos_CodecBufferEnQueue(pExynosComponent, INPUT_PORT_INDEX, pVideoDec->pMFCDecInputBuffer[i]);
749 }
750
751 pInbufOps->Clear_Queue(hMFCHandle);
752 } else if ((nPortIndex == OUTPUT_PORT_INDEX) &&
753 (pWmvDec->bDestinationStart == OMX_TRUE)) {
9c5c94d6
SKR		 754 Exynos_CodecBufferReset(pExynosComponent, OUTPUT_PORT_INDEX);
755
e90eb9e8
TK		 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]);
759
760 Exynos_CodecBufferEnQueue(pExynosComponent, OUTPUT_PORT_INDEX, pVideoDec->pMFCDecOutputBuffer[i]);
9c5c94d6
SKR		 761 }
762 pOutbufOps->Clear_Queue(hMFCHandle);
763 }
764
765EXIT:
766 FunctionOut();
767
768 return ret;
769}
770
771OMX_ERRORTYPE WmvCodecSrcSetup(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
772{
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;
782
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;
788 int i;
789
790 FunctionIn();
791
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;
797 goto EXIT;
798 }
799
800 OMXBuffer->nTimeStamp = pSrcInputData->timeStamp;
801 OMXBuffer->nFlags = pSrcInputData->nFlags;
802 Exynos_OMX_OutputBufferReturn(pOMXComponent, OMXBuffer);
803
804 ret = OMX_ErrorNone;
805 goto EXIT;
806 }
807
808 if (pVideoDec->bThumbnailMode == OMX_TRUE)
809 pDecOps->Set_DisplayDelay(hMFCHandle, 0);
810
811 if (pSrcInputData->nFlags & OMX_BUFFERFLAG_CODECCONFIG) {
812 BitmapInfoHhr *pBitmapInfoHeader;
813 pBitmapInfoHeader = (BitmapInfoHhr *)pSrcInputData->buffer.singlePlaneBuffer.dataBuffer;
814 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "OMX_BUFFERFLAG_CODECCONFIG");
815 if (pBitmapInfoHeader->BiCompression == wmv3) {
816 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "WMV_FORMAT_WMV3");
817 pWmvDec->hMFCWmvHandle.wmvFormat = WMV_FORMAT_WMV3;
818 } else if ((pBitmapInfoHeader->BiCompression == wvc1) || (pBitmapInfoHeader->BiCompression == wmva)) {
819 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "WMV_FORMAT_VC1");
820 pWmvDec->hMFCWmvHandle.wmvFormat = WMV_FORMAT_VC1;
821 }
822 }
823
824 /* input buffer info */
825 Exynos_OSAL_Memset(&bufferConf, 0, sizeof(bufferConf));
826 if (pWmvDec->hMFCWmvHandle.wmvFormat == WMV_FORMAT_WMV3) {
827 bufferConf.eCompressionFormat = VIDEO_CODING_VC1_RCV;
828 } else if (pWmvDec->hMFCWmvHandle.wmvFormat == WMV_FORMAT_VC1) {
829 bufferConf.eCompressionFormat = VIDEO_CODING_VC1;
830 } else {
831 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Unsupported WMV Codec Format Type");
832 ret = OMX_ErrorUndefined;
833 goto EXIT;
834 }
835
836 pInbufOps->Set_Shareable(hMFCHandle);
837 if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
838 bufferConf.nSizeImage = pExynosInputPort->portDefinition.format.video.nFrameWidth
839 * pExynosInputPort->portDefinition.format.video.nFrameHeight * 3 / 2;
840 inputBufferNumber = MAX_VIDEO_INPUTBUFFER_NUM;
841 } else if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
842 bufferConf.nSizeImage = DEFAULT_MFC_INPUT_BUFFER_SIZE;
843 inputBufferNumber = MFC_INPUT_BUFFER_NUM_MAX;
844 }
845
846 /* should be done before prepare input buffer */
847 if (pInbufOps->Enable_Cacheable(hMFCHandle) != VIDEO_ERROR_NONE) {
848 ret = OMX_ErrorInsufficientResources;
849 goto EXIT;
850 }
851
852 /* set input buffer geometry */
853 if (pInbufOps->Set_Geometry(hMFCHandle, &bufferConf) != VIDEO_ERROR_NONE) {
854 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to set geometry for input buffer");
855 ret = OMX_ErrorInsufficientResources;
856 goto EXIT;
857 }
858
859 /* setup input buffer */
860 if (pInbufOps->Setup(hMFCHandle, inputBufferNumber) != VIDEO_ERROR_NONE) {
861 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to setup input buffer");
862 ret = OMX_ErrorInsufficientResources;
863 goto EXIT;
864 }
865
866 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
0641ae29
TK		 867 ret = WMVCodecRegistCodecBuffers(pOMXComponent, INPUT_PORT_INDEX, MFC_INPUT_BUFFER_NUM_MAX);
868 if (ret != OMX_ErrorNone)
869 goto EXIT;
9c5c94d6
SKR		 870 } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
871 /* Register input buffer */
872 for (i = 0; i < pExynosInputPort->portDefinition.nBufferCountActual; i++) {
873 ExynosVideoPlane plane;
874 plane.addr = pExynosInputPort->extendBufferHeader[i].OMXBufferHeader->pBuffer;
875 plane.allocSize = pExynosInputPort->extendBufferHeader[i].OMXBufferHeader->nAllocLen;
876 plane.fd = pExynosInputPort->extendBufferHeader[i].buf_fd[0];
877 if (pInbufOps->Register(hMFCHandle, &plane, MFC_INPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
878 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register input buffer");
879 ret = OMX_ErrorInsufficientResources;
880 goto EXIT;
881 }
882 }
883 }
884
885 /* set output geometry */
886 Exynos_OSAL_Memset(&bufferConf, 0, sizeof(bufferConf));
887 pWmvDec->hMFCWmvHandle.MFCOutputColorType = bufferConf.eColorFormat = VIDEO_COLORFORMAT_NV12_TILED;
888 if (pOutbufOps->Set_Geometry(hMFCHandle, &bufferConf) != VIDEO_ERROR_NONE) {
889 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to set geometry for output buffer");
890 ret = OMX_ErrorInsufficientResources;
891 goto EXIT;
892 }
893
894 bMetaData = Make_Stream_MetaData(pSrcInputData->buffer.singlePlaneBuffer.dataBuffer, &oneFrameSize, pWmvDec->hMFCWmvHandle.wmvFormat);
895 if (bMetaData == OMX_FALSE) {
896 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Fail to Make Stream MetaData");
897 ret = OMX_ErrorInsufficientResources;
898 goto EXIT;
899 }
900
901 /* input buffer enqueue for header parsing */
902 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "oneFrameSize: %d", oneFrameSize);
903 if (pInbufOps->Enqueue(hMFCHandle, (unsigned char **)&pSrcInputData->buffer.singlePlaneBuffer.dataBuffer,
904 (unsigned int *)&oneFrameSize, MFC_INPUT_BUFFER_PLANE, pSrcInputData->bufferHeader) != VIDEO_ERROR_NONE) {
905 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to enqueue input buffer for header parsing");
906// ret = OMX_ErrorInsufficientResources;
907 ret = (OMX_ERRORTYPE)OMX_ErrorCodecInit;
908 goto EXIT;
909 }
910
911 /* start header parsing */
912 if (pInbufOps->Run(hMFCHandle) != VIDEO_ERROR_NONE) {
913 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to run input buffer for header parsing");
914 ret = OMX_ErrorCodecInit;
915 goto EXIT;
916 }
917
918 /* get geometry for output */
919 Exynos_OSAL_Memset(&pWmvDec->hMFCWmvHandle.codecOutbufConf, 0, sizeof(ExynosVideoGeometry));
920 if (pOutbufOps->Get_Geometry(hMFCHandle, &pWmvDec->hMFCWmvHandle.codecOutbufConf) != VIDEO_ERROR_NONE) {
921 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get geometry for parsed header info");
922 ret = OMX_ErrorInsufficientResources;
923 goto EXIT;
924 }
925
926 /* get dpb count */
927 pWmvDec->hMFCWmvHandle.maxDPBNum = pDecOps->Get_ActualBufferCount(hMFCHandle);
928 if (pVideoDec->bThumbnailMode == OMX_FALSE)
929 pWmvDec->hMFCWmvHandle.maxDPBNum += EXTRA_DPB_NUM;
930 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "WmvCodecSetup nOutbufs: %d", pWmvDec->hMFCWmvHandle.maxDPBNum);
931
932 pWmvDec->hMFCWmvHandle.bConfiguredMFCSrc = OMX_TRUE;
933
934 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
935 if ((pExynosInputPort->portDefinition.format.video.nFrameWidth != pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth) ||
936 (pExynosInputPort->portDefinition.format.video.nFrameHeight != pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight)) {
a947bcc1
TK		 937 pExynosOutputPort->exceptionFlag = NEED_PORT_DISABLE;
938
9c5c94d6
SKR		 939 pExynosInputPort->portDefinition.format.video.nFrameWidth = pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth;
940 pExynosInputPort->portDefinition.format.video.nFrameHeight = pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight;
941 pExynosInputPort->portDefinition.format.video.nStride = ((pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth + 15) & (~15));
942 pExynosInputPort->portDefinition.format.video.nSliceHeight = ((pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight + 15) & (~15));
943
944 Exynos_UpdateFrameSize(pOMXComponent);
9c5c94d6
SKR		 945
946 /** Send Port Settings changed call back **/
947 (*(pExynosComponent->pCallbacks->EventHandler))
948 (pOMXComponent,
949 pExynosComponent->callbackData,
950 OMX_EventPortSettingsChanged, /* The command was completed */
951 OMX_DirOutput, /* This is the port index */
952 0,
953 NULL);
954 }
955 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
956 if ((pExynosInputPort->portDefinition.format.video.nFrameWidth != pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth) ||
957 (pExynosInputPort->portDefinition.format.video.nFrameHeight != pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight) ||
958 (pExynosOutputPort->portDefinition.nBufferCountActual != pWmvDec->hMFCWmvHandle.maxDPBNum)) {
a947bcc1
TK		 959 pExynosOutputPort->exceptionFlag = NEED_PORT_DISABLE;
960
9c5c94d6
SKR		 961 pExynosInputPort->portDefinition.format.video.nFrameWidth = pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth;
962 pExynosInputPort->portDefinition.format.video.nFrameHeight = pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight;
963 pExynosInputPort->portDefinition.format.video.nStride = ((pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameWidth + 15) & (~15));
964 pExynosInputPort->portDefinition.format.video.nSliceHeight = ((pWmvDec->hMFCWmvHandle.codecOutbufConf.nFrameHeight + 15) & (~15));
965
966 pExynosOutputPort->portDefinition.nBufferCountActual = pWmvDec->hMFCWmvHandle.maxDPBNum - 2;
967 pExynosOutputPort->portDefinition.nBufferCountMin = pWmvDec->hMFCWmvHandle.maxDPBNum - 2;
968
969 Exynos_UpdateFrameSize(pOMXComponent);
9c5c94d6
SKR		 970
971 /** Send Port Settings changed call back **/
972 (*(pExynosComponent->pCallbacks->EventHandler))
973 (pOMXComponent,
974 pExynosComponent->callbackData,
975 OMX_EventPortSettingsChanged, /* The command was completed */
976 OMX_DirOutput, /* This is the port index */
977 0,
978 NULL);
979 }
980 }
981 Exynos_OSAL_SleepMillisec(0);
982 ret = OMX_ErrorInputDataDecodeYet;
983 WmvCodecStop(pOMXComponent, INPUT_PORT_INDEX);
984
985EXIT:
986 FunctionOut();
987
988 return ret;
989}
990
991OMX_ERRORTYPE WmvCodecDstSetup(OMX_COMPONENTTYPE *pOMXComponent)
992{
993 OMX_ERRORTYPE ret = OMX_ErrorNone;
994 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
995 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
996 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
997 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
998 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
999 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1000
1001 ExynosVideoDecOps *pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
1002 ExynosVideoDecBufferOps *pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
1003 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
1004
1005 int i, nOutbufs;
1006
e02ebaac
TK		 1007 OMX_U32 nAllocLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
1008 OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
1009
9c5c94d6
SKR		 1010 FunctionIn();
1011
e02ebaac
TK		 1012 nAllocLen[0] = pWmvDec->hMFCWmvHandle.codecOutbufConf.nAlignPlaneSize[0];
1013 nAllocLen[1] = pWmvDec->hMFCWmvHandle.codecOutbufConf.nAlignPlaneSize[1];
1014
1015 pOutbufOps->Set_Shareable(hMFCHandle);
1016
9c5c94d6
SKR		 1017 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1018 /* should be done before prepare output buffer */
1019 if (pOutbufOps->Enable_Cacheable(hMFCHandle) != VIDEO_ERROR_NONE) {
1020 ret = OMX_ErrorInsufficientResources;
1021 goto EXIT;
1022 }
9c5c94d6 1023
a38b0597
TK		 1024 /* get dpb count */
1025 nOutbufs = pWmvDec->hMFCWmvHandle.maxDPBNum;
1026 if (pOutbufOps->Setup(hMFCHandle, nOutbufs) != VIDEO_ERROR_NONE) {
1027 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to setup output buffer");
1028 ret = OMX_ErrorInsufficientResources;
1029 goto EXIT;
1030 }
1031
0641ae29
TK		 1032 ret = Exynos_Allocate_CodecBuffers(pOMXComponent, OUTPUT_PORT_INDEX, nOutbufs, nAllocLen);
1033 if (ret != OMX_ErrorNone)
1034 goto EXIT;
9c5c94d6 1035
0641ae29
TK		 1036 ret = WMVCodecRegistCodecBuffers(pOMXComponent, OUTPUT_PORT_INDEX, nOutbufs);
1037 if (ret != OMX_ErrorNone)
1038 goto EXIT;
1039
1040 /* Enqueue output buffer */
1041 for (i = 0; i < nOutbufs; i++) {
9c5c94d6
SKR		 1042 pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr,
1043 (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
1044 }
1045 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
e02ebaac
TK		 1046 ExynosVideoPlane planes[MFC_OUTPUT_BUFFER_PLANE];
1047 int plane;
1048
a38b0597
TK		 1049 /* get dpb count */
1050 nOutbufs = pExynosOutputPort->portDefinition.nBufferCountActual;
1051 if (pOutbufOps->Setup(hMFCHandle, nOutbufs) != VIDEO_ERROR_NONE) {
1052 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to setup output buffer");
1053 ret = OMX_ErrorInsufficientResources;
1054 goto EXIT;
1055 }
1056
9c5c94d6
SKR		 1057 /* Register output buffer */
1058 /*************/
1059 /* TBD */
1060 /*************/
1061#ifdef USE_ANB
1062 if (pExynosOutputPort->bIsANBEnabled == OMX_TRUE) {
1063 for (i = 0; i < pExynosOutputPort->assignedBufferNum; i++) {
1064 for (plane = 0; plane < MFC_OUTPUT_BUFFER_PLANE; plane++) {
1065 planes[plane].fd = pExynosOutputPort->extendBufferHeader[i].buf_fd[plane];
1066 planes[plane].addr = pExynosOutputPort->extendBufferHeader[i].pYUVBuf[plane];
1067 planes[plane].allocSize = nAllocLen[plane];
1068 }
1069
1070 if (pOutbufOps->Register(hMFCHandle, planes, MFC_OUTPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
1071 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register output buffer");
1072 ret = OMX_ErrorInsufficientResources;
1073 goto EXIT;
1074 }
1075 pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pExynosOutputPort->extendBufferHeader[i].pYUVBuf,
1076 (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
1077 }
1078 } else {
1079 ret = OMX_ErrorNotImplemented;
1080 goto EXIT;
1081 }
1082#else
1083 ret = OMX_ErrorNotImplemented;
1084 goto EXIT;
1085#endif
1086 }
1087
1088 if (pOutbufOps->Run(hMFCHandle) != VIDEO_ERROR_NONE) {
1089 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to run output buffer");
1090 ret = OMX_ErrorInsufficientResources;
1091 goto EXIT;
1092 }
1093
1094 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1095 WmvCodecStop (pOMXComponent, OUTPUT_PORT_INDEX);
1096 }
1097 pWmvDec->hMFCWmvHandle.bConfiguredMFCDst = OMX_TRUE;
1098
1099 ret = OMX_ErrorNone;
1100
1101EXIT:
1102 FunctionOut();
1103
1104 return ret;
1105}
1106
1107OMX_ERRORTYPE Exynos_WmvDec_GetParameter(
1108 OMX_IN OMX_HANDLETYPE hComponent,
1109 OMX_IN OMX_INDEXTYPE nParamIndex,
1110 OMX_INOUT OMX_PTR pComponentParameterStructure)
1111{
1112 OMX_ERRORTYPE ret = OMX_ErrorNone;
1113 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1114 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1115
1116 FunctionIn();
1117
1118 if (hComponent == NULL || pComponentParameterStructure == NULL) {
1119 ret = OMX_ErrorBadParameter;
1120 goto EXIT;
1121 }
1122 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1123 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1124 if (ret != OMX_ErrorNone) {
1125 goto EXIT;
1126 }
1127 if (pOMXComponent->pComponentPrivate == NULL) {
1128 ret = OMX_ErrorBadParameter;
1129 goto EXIT;
1130 }
1131
1132 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1133 if (pExynosComponent->currentState == OMX_StateInvalid ) {
1134 ret = OMX_ErrorInvalidState;
1135 goto EXIT;
1136 }
1137
1138 switch (nParamIndex) {
1139 case OMX_IndexParamVideoWmv:
1140 {
1141 OMX_VIDEO_PARAM_WMVTYPE *pDstWmvParam = (OMX_VIDEO_PARAM_WMVTYPE *)pComponentParameterStructure;
1142 OMX_VIDEO_PARAM_WMVTYPE *pSrcWmvParam = NULL;
1143 EXYNOS_WMVDEC_HANDLE *pWmvDec = NULL;
1144 ret = Exynos_OMX_Check_SizeVersion(pDstWmvParam, sizeof(OMX_VIDEO_PARAM_WMVTYPE));
1145 if (ret != OMX_ErrorNone) {
1146 goto EXIT;
1147 }
1148
1149 if (pDstWmvParam->nPortIndex > OUTPUT_PORT_INDEX) {
1150 ret = OMX_ErrorBadPortIndex;
1151 }
1152
1153 pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1154 pSrcWmvParam = &pWmvDec->WmvComponent[pDstWmvParam->nPortIndex];
1155
1156 Exynos_OSAL_Memcpy(pDstWmvParam, pSrcWmvParam, sizeof(OMX_VIDEO_PARAM_WMVTYPE));
1157 }
1158 break;
1159
1160 case OMX_IndexParamStandardComponentRole:
1161 {
1162 OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE *)pComponentParameterStructure;
1163 ret = Exynos_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1164 if (ret != OMX_ErrorNone) {
1165 goto EXIT;
1166 }
1167
1168 Exynos_OSAL_Strcpy((char *)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_WMV_DEC_ROLE);
1169 }
1170 break;
1171 case OMX_IndexParamVideoErrorCorrection:
1172 {
1173 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
1174 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = NULL;
1175 EXYNOS_WMVDEC_HANDLE *pWmvDec = NULL;
1176
1177 ret = Exynos_OMX_Check_SizeVersion(pDstErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
1178 if (ret != OMX_ErrorNone) {
1179 goto EXIT;
1180 }
1181
1182 if (pDstErrorCorrectionType->nPortIndex != INPUT_PORT_INDEX) {
1183 ret = OMX_ErrorBadPortIndex;
1184 goto EXIT;
1185 }
1186
1187 pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1188 pSrcErrorCorrectionType = &pWmvDec->errorCorrectionType[INPUT_PORT_INDEX];
1189
1190 pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
1191 pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
1192 pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
1193 pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
1194 pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
1195 }
1196 break;
1197 default:
1198 ret = Exynos_OMX_VideoDecodeGetParameter(hComponent, nParamIndex, pComponentParameterStructure);
1199 break;
1200 }
1201EXIT:
1202 FunctionOut();
1203
1204 return ret;
1205}
1206
1207OMX_ERRORTYPE Exynos_WmvDec_SetParameter(
1208 OMX_IN OMX_HANDLETYPE hComponent,
1209 OMX_IN OMX_INDEXTYPE nIndex,
1210 OMX_IN OMX_PTR pComponentParameterStructure)
1211{
1212 OMX_ERRORTYPE ret = OMX_ErrorNone;
1213 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1214 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1215
1216 FunctionIn();
1217
1218 if (hComponent == NULL || pComponentParameterStructure == NULL) {
1219 ret = OMX_ErrorBadParameter;
1220 goto EXIT;
1221 }
1222 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1223 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1224 if (ret != OMX_ErrorNone) {
1225 goto EXIT;
1226 }
1227 if (pOMXComponent->pComponentPrivate == NULL) {
1228 ret = OMX_ErrorBadParameter;
1229 goto EXIT;
1230 }
1231
1232 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1233 if (pExynosComponent->currentState == OMX_StateInvalid ) {
1234 ret = OMX_ErrorInvalidState;
1235 goto EXIT;
1236 }
1237
1238 switch (nIndex) {
1239 case OMX_IndexParamVideoWmv:
1240 {
1241 OMX_VIDEO_PARAM_WMVTYPE *pDstWmvParam = NULL;
1242 OMX_VIDEO_PARAM_WMVTYPE *pSrcWmvParam = (OMX_VIDEO_PARAM_WMVTYPE *)pComponentParameterStructure;
1243 EXYNOS_WMVDEC_HANDLE *pWmvDec = NULL;
1244 ret = Exynos_OMX_Check_SizeVersion(pSrcWmvParam, sizeof(OMX_VIDEO_PARAM_WMVTYPE));
1245 if (ret != OMX_ErrorNone) {
1246 goto EXIT;
1247 }
1248
1249 if (pSrcWmvParam->nPortIndex > OUTPUT_PORT_INDEX) {
1250 ret = OMX_ErrorBadPortIndex;
1251 goto EXIT;
1252 }
1253
1254 pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1255 pDstWmvParam = &pWmvDec->WmvComponent[pSrcWmvParam->nPortIndex];
1256
1257 Exynos_OSAL_Memcpy(pDstWmvParam, pSrcWmvParam, sizeof(OMX_VIDEO_PARAM_WMVTYPE));
1258 }
1259 break;
1260 case OMX_IndexParamStandardComponentRole:
1261 {
1262 OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE*)pComponentParameterStructure;
1263
1264 ret = Exynos_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1265 if (ret != OMX_ErrorNone) {
1266 goto EXIT;
1267 }
1268
1269 if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1270 ret = OMX_ErrorIncorrectStateOperation;
1271 goto EXIT;
1272 }
1273
1274 if (!Exynos_OSAL_Strcmp((char*)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_WMV_DEC_ROLE)) {
1275 pExynosComponent->pExynosPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingWMV;
1276 } else {
1277 ret = OMX_ErrorBadParameter;
1278 goto EXIT;
1279 }
1280 }
1281 break;
1282 case OMX_IndexParamVideoErrorCorrection:
1283 {
1284 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
1285 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = NULL;
1286 EXYNOS_WMVDEC_HANDLE *pWmvDec = NULL;
1287
1288 ret = Exynos_OMX_Check_SizeVersion(pSrcErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
1289 if (ret != OMX_ErrorNone) {
1290 goto EXIT;
1291 }
1292
1293 if (pSrcErrorCorrectionType->nPortIndex != INPUT_PORT_INDEX) {
1294 ret = OMX_ErrorBadPortIndex;
1295 goto EXIT;
1296 }
1297
1298 pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1299 pDstErrorCorrectionType = &pWmvDec->errorCorrectionType[INPUT_PORT_INDEX];
1300
1301 pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
1302 pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
1303 pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
1304 pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
1305 pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
1306 }
1307 break;
1308 default:
1309 ret = Exynos_OMX_VideoDecodeSetParameter(hComponent, nIndex, pComponentParameterStructure);
1310 break;
1311 }
1312EXIT:
1313 FunctionOut();
1314
1315 return ret;
1316}
1317
1318OMX_ERRORTYPE Exynos_WmvDec_GetConfig(
1319 OMX_HANDLETYPE hComponent,
1320 OMX_INDEXTYPE nIndex,
1321 OMX_PTR pComponentConfigStructure)
1322{
1323 OMX_ERRORTYPE ret = OMX_ErrorNone;
1324 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1325 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1326
1327 FunctionIn();
1328
1329 if (hComponent == NULL || pComponentConfigStructure == NULL) {
1330 ret = OMX_ErrorBadParameter;
1331 goto EXIT;
1332 }
1333 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1334 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1335 if (ret != OMX_ErrorNone) {
1336 goto EXIT;
1337 }
1338 if (pOMXComponent->pComponentPrivate == NULL) {
1339 ret = OMX_ErrorBadParameter;
1340 goto EXIT;
1341 }
1342 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1343 if (pExynosComponent->currentState == OMX_StateInvalid) {
1344 ret = OMX_ErrorInvalidState;
1345 goto EXIT;
1346 }
1347
1348 switch (nIndex) {
1349 default:
1350 ret = Exynos_OMX_VideoDecodeGetConfig(hComponent, nIndex, pComponentConfigStructure);
1351 break;
1352 }
1353
1354EXIT:
1355 FunctionOut();
1356
1357 return ret;
1358}
1359
1360OMX_ERRORTYPE Exynos_WmvDec_SetConfig(
1361 OMX_HANDLETYPE hComponent,
1362 OMX_INDEXTYPE nIndex,
1363 OMX_PTR pComponentConfigStructure)
1364{
1365 OMX_ERRORTYPE ret = OMX_ErrorNone;
1366 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1367 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1368
1369 FunctionIn();
1370
1371 if (hComponent == NULL || pComponentConfigStructure == NULL) {
1372 ret = OMX_ErrorBadParameter;
1373 goto EXIT;
1374 }
1375 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1376 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1377 if (ret != OMX_ErrorNone) {
1378 goto EXIT;
1379 }
1380 if (pOMXComponent->pComponentPrivate == NULL) {
1381 ret = OMX_ErrorBadParameter;
1382 goto EXIT;
1383 }
1384 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1385 if (pExynosComponent->currentState == OMX_StateInvalid) {
1386 ret = OMX_ErrorInvalidState;
1387 goto EXIT;
1388 }
1389
1390 switch (nIndex) {
1391 default:
1392 ret = Exynos_OMX_VideoDecodeSetConfig(hComponent, nIndex, pComponentConfigStructure);
1393 break;
1394 }
1395
1396EXIT:
1397 FunctionOut();
1398
1399 return ret;
1400}
1401
1402OMX_ERRORTYPE Exynos_WmvDec_GetExtensionIndex(
1403 OMX_IN OMX_HANDLETYPE hComponent,
1404 OMX_IN OMX_STRING cParameterName,
1405 OMX_OUT OMX_INDEXTYPE *pIndexType)
1406{
1407 OMX_ERRORTYPE ret = OMX_ErrorNone;
1408 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1409 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1410
1411 FunctionIn();
1412
1413 if (hComponent == NULL) {
1414 ret = OMX_ErrorBadParameter;
1415 goto EXIT;
1416 }
1417 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1418 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1419 if (ret != OMX_ErrorNone) {
1420 goto EXIT;
1421 }
1422 if (pOMXComponent->pComponentPrivate == NULL) {
1423 ret = OMX_ErrorBadParameter;
1424 goto EXIT;
1425 }
1426 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1427 if ((cParameterName == NULL) || (pIndexType == NULL)) {
1428 ret = OMX_ErrorBadParameter;
1429 goto EXIT;
1430 }
1431 if (pExynosComponent->currentState == OMX_StateInvalid) {
1432 ret = OMX_ErrorInvalidState;
1433 goto EXIT;
1434 }
1435
1436 if (Exynos_OSAL_Strcmp(cParameterName, EXYNOS_INDEX_PARAM_ENABLE_THUMBNAIL) == 0) {
1437 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1438 *pIndexType = OMX_IndexVendorThumbnailMode;
1439 ret = OMX_ErrorNone;
1440 } else {
1441 ret = Exynos_OMX_VideoDecodeGetExtensionIndex(hComponent, cParameterName, pIndexType);
1442 }
1443
1444EXIT:
1445 FunctionOut();
1446
1447 return ret;
1448}
1449
1450OMX_ERRORTYPE Exynos_WmvDec_ComponentRoleEnum(
1451 OMX_HANDLETYPE hComponent,
1452 OMX_U8 *cRole,
1453 OMX_U32 nIndex)
1454{
1455 OMX_ERRORTYPE ret = OMX_ErrorNone;
1456 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1457 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1458
1459 FunctionIn();
1460
1461 if ((hComponent == NULL) || (cRole == NULL)) {
1462 ret = OMX_ErrorBadParameter;
1463 goto EXIT;
1464 }
1465 if (nIndex == (MAX_COMPONENT_ROLE_NUM-1)) {
1466 Exynos_OSAL_Strcpy((char *)cRole, EXYNOS_OMX_COMPONENT_WMV_DEC_ROLE);
1467 ret = OMX_ErrorNone;
1468 } else {
1469 ret = OMX_ErrorNoMore;
1470 }
1471
1472EXIT:
1473 FunctionOut();
1474
1475 return ret;
1476}
1477
1478/* MFC Init */
1479OMX_ERRORTYPE Exynos_WmvDec_Init(OMX_COMPONENTTYPE *pOMXComponent)
1480{
1481 OMX_ERRORTYPE ret = OMX_ErrorNone;
1482 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1483 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1484 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1485 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1486 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
1487 OMX_PTR hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
1488
1489 ExynosVideoDecOps *pDecOps = NULL;
1490 ExynosVideoDecBufferOps *pInbufOps = NULL;
1491 ExynosVideoDecBufferOps *pOutbufOps = NULL;
1492
1493 CSC_METHOD csc_method = CSC_METHOD_SW;
1494 int i, plane;
1495
1496 FunctionIn();
1497
1498 pWmvDec->hMFCWmvHandle.bConfiguredMFCSrc = OMX_FALSE;
1499 pWmvDec->hMFCWmvHandle.bConfiguredMFCDst = OMX_FALSE;
1500 pExynosComponent->bUseFlagEOF = OMX_TRUE;
1501 pExynosComponent->bSaveFlagEOS = OMX_FALSE;
1502
1503 /* WMV Codec Open */
1504 ret = WmvCodecOpen(pWmvDec);
1505 if (ret != OMX_ErrorNone) {
1506 goto EXIT;
1507 }
1508
1509 pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
1510 pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
1511 pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
1512
1513 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
0641ae29 1514 OMX_U32 nPlaneSize[MFC_INPUT_BUFFER_PLANE] = {DEFAULT_MFC_INPUT_BUFFER_SIZE};
9c5c94d6
SKR		 1515 Exynos_OSAL_SemaphoreCreate(&pExynosInputPort->codecSemID);
1516 Exynos_OSAL_QueueCreate(&pExynosInputPort->codecBufferQ, MAX_QUEUE_ELEMENTS);
0641ae29
TK		 1517 ret = Exynos_Allocate_CodecBuffers(pOMXComponent, INPUT_PORT_INDEX, MFC_INPUT_BUFFER_NUM_MAX, nPlaneSize);
1518 if (ret != OMX_ErrorNone)
1519 goto EXIT;
9c5c94d6 1520
0641ae29 1521 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++)
9c5c94d6 1522 Exynos_CodecBufferEnQueue(pExynosComponent, INPUT_PORT_INDEX, pVideoDec->pMFCDecInputBuffer[i]);
9c5c94d6
SKR		 1523 } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
1524 /*************/
1525 /* TBD */
1526 /*************/
1527 /* Does not require any actions. */
1528 }
1529
1530 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1531 Exynos_OSAL_SemaphoreCreate(&pExynosOutputPort->codecSemID);
1532 Exynos_OSAL_QueueCreate(&pExynosOutputPort->codecBufferQ, MAX_QUEUE_ELEMENTS);
1533 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1534 /*************/
1535 /* TBD */
1536 /*************/
1537 /* Does not require any actions. */
1538 }
1539
1540 pWmvDec->bSourceStart = OMX_FALSE;
1541 Exynos_OSAL_SignalCreate(&pWmvDec->hSourceStartEvent);
1542 pWmvDec->bDestinationStart = OMX_FALSE;
1543 Exynos_OSAL_SignalCreate(&pWmvDec->hDestinationStartEvent);
1544
1545 Exynos_OSAL_Memset(pExynosComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
1546 Exynos_OSAL_Memset(pExynosComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
1547 pWmvDec->hMFCWmvHandle.indexTimestamp = 0;
1548 pWmvDec->hMFCWmvHandle.outputIndexTimestamp = 0;
1549 /* Default WMV codec format is set as VC1*/
1550 pWmvDec->hMFCWmvHandle.wmvFormat = WMV_FORMAT_VC1;
1551
1552 pExynosComponent->getAllDelayBuffer = OMX_FALSE;
1553
a80c3bc5
TK		 1554#ifdef USE_CSC_HW
1555 csc_method = CSC_METHOD_HW;
9c5c94d6
SKR		 1556#endif
1557 pVideoDec->csc_handle = csc_init(csc_method);
1558 if (pVideoDec->csc_handle == NULL) {
1559 ret = OMX_ErrorInsufficientResources;
1560 goto EXIT;
1561 }
1562 pVideoDec->csc_set_format = OMX_FALSE;
1563
1564EXIT:
1565 FunctionOut();
1566
1567 return ret;
1568}
1569
1570/* MFC Terminate */
1571OMX_ERRORTYPE Exynos_WmvDec_Terminate(OMX_COMPONENTTYPE *pOMXComponent)
1572{
1573 OMX_ERRORTYPE ret = OMX_ErrorNone;
1574 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1575 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1576 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1577 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1578 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1579 OMX_PTR hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
1580
1581 ExynosVideoDecOps *pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
1582 ExynosVideoDecBufferOps *pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
1583 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
1584
1585 int i, plane;
1586
1587 FunctionIn();
1588
1589 if (pVideoDec->csc_handle != NULL) {
1590 csc_deinit(pVideoDec->csc_handle);
1591 pVideoDec->csc_handle = NULL;
1592 }
1593
1594 Exynos_OSAL_SignalTerminate(pWmvDec->hDestinationStartEvent);
1595 pWmvDec->hDestinationStartEvent = NULL;
1596 pWmvDec->bDestinationStart = OMX_FALSE;
1597 Exynos_OSAL_SignalTerminate(pWmvDec->hSourceStartEvent);
1598 pWmvDec->hSourceStartEvent = NULL;
1599 pWmvDec->bSourceStart = OMX_FALSE;
1600
1601 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
0641ae29 1602 Exynos_Free_CodecBuffers(pOMXComponent, OUTPUT_PORT_INDEX);
9c5c94d6
SKR		 1603 Exynos_OSAL_QueueTerminate(&pExynosOutputPort->codecBufferQ);
1604 Exynos_OSAL_SemaphoreTerminate(pExynosOutputPort->codecSemID);
1605 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1606 /*************/
1607 /* TBD */
1608 /*************/
1609 /* Does not require any actions. */
1610 }
1611
1612 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
0641ae29 1613 Exynos_Free_CodecBuffers(pOMXComponent, INPUT_PORT_INDEX);
9c5c94d6
SKR		 1614 Exynos_OSAL_QueueTerminate(&pExynosInputPort->codecBufferQ);
1615 Exynos_OSAL_SemaphoreTerminate(pExynosInputPort->codecSemID);
1616 } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
1617 /*************/
1618 /* TBD */
1619 /*************/
1620 /* Does not require any actions. */
1621 }
1622 WmvCodecClose(pWmvDec);
1623
1624EXIT:
1625 FunctionOut();
1626
1627 return ret;
1628}
1629
1630OMX_ERRORTYPE Exynos_WmvDec_SrcIn(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
1631{
1632 OMX_ERRORTYPE ret = OMX_ErrorNone;
1633 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1634 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1635 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1636 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
1637 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1638 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1639 OMX_U32 oneFrameSize = pSrcInputData->dataLen;
1640 OMX_BOOL bStartCode = OMX_FALSE;
1641 ExynosVideoDecOps *pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
1642 ExynosVideoDecBufferOps *pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
1643 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
1644 ExynosVideoErrorType codecReturn = VIDEO_ERROR_NONE;
1645 int i;
1646
1647 FunctionIn();
1648
1649 if (pWmvDec->hMFCWmvHandle.bConfiguredMFCSrc == OMX_FALSE) {
1650 ret = WmvCodecSrcSetup(pOMXComponent, pSrcInputData);
1651 goto EXIT;
1652 }
1653 if (pWmvDec->hMFCWmvHandle.bConfiguredMFCDst == OMX_FALSE) {
1654 ret = WmvCodecDstSetup(pOMXComponent);
1655 }
1656
1657 bStartCode = Check_Stream_PrefixCode(pSrcInputData->buffer.singlePlaneBuffer.dataBuffer, oneFrameSize, pWmvDec->hMFCWmvHandle.wmvFormat);
09ccc01b
TK		 1658 if ((bStartCode == OMX_FALSE) &&
1659 ((pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS)) {
9c5c94d6
SKR		 1660 if (pSrcInputData->allocSize < oneFrameSize+4) {
1661 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Can't attach startcode due to lack of buffer space");
1662 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
1663 goto EXIT;
1664 }
1665
1666 bStartCode = Make_Stream_StartCode(pSrcInputData->buffer.singlePlaneBuffer.dataBuffer, &oneFrameSize, pWmvDec->hMFCWmvHandle.wmvFormat);
1667 if (bStartCode == OMX_FALSE) {
1668 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Fail to Make Stream Start Code");
1669 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
1670 goto EXIT;
1671 }
1672 }
1673
1674 if ((bStartCode == OMX_TRUE) || ((pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)){
1675 pExynosComponent->timeStamp[pWmvDec->hMFCWmvHandle.indexTimestamp] = pSrcInputData->timeStamp;
1676 pExynosComponent->nFlags[pWmvDec->hMFCWmvHandle.indexTimestamp] = pSrcInputData->nFlags;
1677 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);
1678 pDecOps->Set_FrameTag(hMFCHandle, pWmvDec->hMFCWmvHandle.indexTimestamp);
1679 pWmvDec->hMFCWmvHandle.indexTimestamp++;
1680 pWmvDec->hMFCWmvHandle.indexTimestamp %= MAX_TIMESTAMP;
1681
1682 /* queue work for input buffer */
1683 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "oneFrameSize: %d, bufferHeader: 0x%x, dataBuffer: 0x%x", oneFrameSize, pSrcInputData->bufferHeader, pSrcInputData->buffer.singlePlaneBuffer.dataBuffer);
1684 codecReturn = pInbufOps->Enqueue(hMFCHandle, (unsigned char **)&pSrcInputData->buffer.singlePlaneBuffer.dataBuffer,
1685 (unsigned int *)&oneFrameSize, MFC_INPUT_BUFFER_PLANE, pSrcInputData->bufferHeader);
1686 if (codecReturn != VIDEO_ERROR_NONE) {
1687 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
1688 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s : %d", __FUNCTION__, __LINE__);
1689 goto EXIT;
1690 }
1691 WmvCodecStart(pOMXComponent, INPUT_PORT_INDEX);
1692 if (pWmvDec->bSourceStart == OMX_FALSE) {
1693 pWmvDec->bSourceStart = OMX_TRUE;
1694 Exynos_OSAL_SignalSet(pWmvDec->hSourceStartEvent);
1695 Exynos_OSAL_SleepMillisec(0);
1696 }
1697 if (pWmvDec->bDestinationStart == OMX_FALSE) {
1698 pWmvDec->bDestinationStart = OMX_TRUE;
1699 Exynos_OSAL_SignalSet(pWmvDec->hDestinationStartEvent);
1700 Exynos_OSAL_SleepMillisec(0);
1701 }
1702 }
1703
1704 ret = OMX_ErrorNone;
1705
1706EXIT:
1707 FunctionOut();
1708
1709 return ret;
1710}
1711
1712OMX_ERRORTYPE Exynos_WmvDec_SrcOut(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcOutputData)
1713{
1714 OMX_ERRORTYPE ret = OMX_ErrorNone;
1715 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1716 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1717 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1718 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
1719 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1720 ExynosVideoDecOps *pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
1721 ExynosVideoDecBufferOps *pInbufOps = pWmvDec->hMFCWmvHandle.pInbufOps;
1722 ExynosVideoBuffer *pVideoBuffer;
1723
1724 FunctionIn();
1725
1726 pVideoBuffer = pInbufOps->Dequeue(hMFCHandle);
1727
1728 pSrcOutputData->dataLen = 0;
1729 pSrcOutputData->usedDataLen = 0;
1730 pSrcOutputData->remainDataLen = 0;
1731 pSrcOutputData->nFlags = 0;
1732 pSrcOutputData->timeStamp = 0;
1733
1734 if (pVideoBuffer == NULL) {
1735 pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer = NULL;
1736 pSrcOutputData->allocSize = 0;
1737 pSrcOutputData->pPrivate = NULL;
1738 pSrcOutputData->bufferHeader = NULL;
1739 } else {
1740 pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer = pVideoBuffer->planes[0].addr;
1741 pSrcOutputData->buffer.singlePlaneBuffer.fd = pVideoBuffer->planes[0].fd;
1742 pSrcOutputData->allocSize = pVideoBuffer->planes[0].allocSize;
1743
1744 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
1745 int i = 0;
1746 while (pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer != pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[0]) {
1747 if (i >= MFC_INPUT_BUFFER_NUM_MAX) {
1748 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Can not find buffer");
1749 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
1750 goto EXIT;
1751 }
1752 i++;
1753 }
1754 pVideoDec->pMFCDecInputBuffer[i]->dataSize = 0;
1755 pSrcOutputData->pPrivate = pVideoDec->pMFCDecInputBuffer[i];
1756 }
1757
1758 /* For Share Buffer */
1759 pSrcOutputData->bufferHeader = (OMX_BUFFERHEADERTYPE*)pVideoBuffer->pPrivate;
1760 }
1761
1762 ret = OMX_ErrorNone;
1763
1764EXIT:
1765 FunctionOut();
1766
1767 return ret;
1768}
1769
1770OMX_ERRORTYPE Exynos_WmvDec_DstIn(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstInputData)
1771{
1772 OMX_ERRORTYPE ret = OMX_ErrorNone;
1773 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1774 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1775 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1776 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
1777 ExynosVideoDecOps *pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
1778 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
1779 OMX_U32 dataLen[2] = {0,};
1780 ExynosVideoErrorType codecReturn = VIDEO_ERROR_NONE;
1781
1782 FunctionIn();
1783
1784 if (pDstInputData->buffer.multiPlaneBuffer.dataBuffer[0] == NULL) {
1785 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to find input buffer");
1786 ret = OMX_ErrorBadParameter;
1787 goto EXIT;
1788 }
1789
1790 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "%s : %d => ADDR[0]: 0x%x, ADDR[1]: 0x%x", __FUNCTION__, __LINE__,
1791 pDstInputData->buffer.multiPlaneBuffer.dataBuffer[0],
1792 pDstInputData->buffer.multiPlaneBuffer.dataBuffer[1]);
1793
1794 codecReturn = pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pDstInputData->buffer.multiPlaneBuffer.dataBuffer,
1795 (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, pDstInputData->bufferHeader);
1796
1797 if (codecReturn != VIDEO_ERROR_NONE) {
1798 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s : %d", __FUNCTION__, __LINE__);
1799 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
1800 goto EXIT;
1801 }
1802 WmvCodecStart(pOMXComponent, OUTPUT_PORT_INDEX);
1803
1804 ret = OMX_ErrorNone;
1805
1806EXIT:
1807 FunctionOut();
1808
1809 return ret;
1810}
1811
1812OMX_ERRORTYPE Exynos_WmvDec_DstOut(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstOutputData)
1813{
1814 OMX_ERRORTYPE ret = OMX_ErrorNone;
1815 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1816 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1817 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1818 void *hMFCHandle = pWmvDec->hMFCWmvHandle.hMFCHandle;
1819 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1820 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1821 ExynosVideoDecOps *pDecOps = pWmvDec->hMFCWmvHandle.pDecOps;
1822 ExynosVideoDecBufferOps *pOutbufOps = pWmvDec->hMFCWmvHandle.pOutbufOps;
1823 ExynosVideoBuffer *pVideoBuffer = NULL;
1824 ExynosVideoFrameStatusType displayStatus = VIDEO_FRAME_STATUS_UNKNOWN;
1825 ExynosVideoGeometry *bufferGeometry;
1826 DECODE_CODEC_EXTRA_BUFFERINFO *pBufferInfo = NULL;
1827 OMX_S32 indexTimestamp = 0;
1828 int plane;
1829
1830 FunctionIn();
1831
1832 if (pWmvDec->bDestinationStart == OMX_FALSE) {
1833 ret = OMX_ErrorNone;
1834 goto EXIT;
1835 }
1836
1837 while (1) {
1838 if ((pVideoBuffer = pOutbufOps->Dequeue(hMFCHandle)) == NULL) {
1839 ret = OMX_ErrorNone;
1840 goto EXIT;
1841 }
1842 displayStatus = pVideoBuffer->displayStatus;
1843 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "displayStatus: 0x%x", displayStatus);
1844
1845 if ((displayStatus == VIDEO_FRAME_STATUS_DISPLAY_DECODING) ||
1846 (displayStatus == VIDEO_FRAME_STATUS_DISPLAY_ONLY) ||
1847 (displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) ||
405399e5 1848 (displayStatus == VIDEO_FRAME_STATUS_DECODING_FINISHED) ||
9c5c94d6
SKR		 1849 (CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
1850 ret = OMX_ErrorNone;
1851 break;
1852 }
1853 }
1854
1855 pWmvDec->hMFCWmvHandle.outputIndexTimestamp++;
1856 pWmvDec->hMFCWmvHandle.outputIndexTimestamp %= MAX_TIMESTAMP;
1857
1858 pDstOutputData->allocSize = pDstOutputData->dataLen = 0;
1859 for (plane = 0; plane < MFC_OUTPUT_BUFFER_PLANE; plane++) {
1860 pDstOutputData->buffer.multiPlaneBuffer.dataBuffer[plane] = pVideoBuffer->planes[plane].addr;
1861 pDstOutputData->buffer.multiPlaneBuffer.fd[plane] = pVideoBuffer->planes[plane].fd;
1862 pDstOutputData->allocSize += pVideoBuffer->planes[plane].allocSize;
1863 pDstOutputData->dataLen += pVideoBuffer->planes[plane].dataSize;
1864 }
1865 pDstOutputData->usedDataLen = 0;
1866 pDstOutputData->pPrivate = pVideoBuffer;
e90eb9e8
TK		 1867 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1868 int i = 0;
1869 pDstOutputData->pPrivate = NULL;
1870 for (i = 0; i < MFC_OUTPUT_BUFFER_NUM_MAX; i++) {
1871 if (pDstOutputData->buffer.multiPlaneBuffer.dataBuffer[0] ==
1872 pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[0]) {
1873 pDstOutputData->pPrivate = pVideoDec->pMFCDecOutputBuffer[i];
1874 break;
1875 }
1876 }
1877
1878 if (pDstOutputData->pPrivate == NULL) {
1879 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Can not find buffer");
1880 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
1881 goto EXIT;
1882 }
1883 }
1884
9c5c94d6
SKR		 1885 /* For Share Buffer */
1886 pDstOutputData->bufferHeader = (OMX_BUFFERHEADERTYPE *)pVideoBuffer->pPrivate;
1887
1888 pBufferInfo = (DECODE_CODEC_EXTRA_BUFFERINFO *)pDstOutputData->extInfo;
1889 bufferGeometry = &pWmvDec->hMFCWmvHandle.codecOutbufConf;
1890 pBufferInfo->imageWidth = bufferGeometry->nFrameWidth;
1891 pBufferInfo->imageHeight = bufferGeometry->nFrameHeight;
1892 switch (bufferGeometry->eColorFormat) {
1893 case VIDEO_COLORFORMAT_NV12:
1894 pBufferInfo->ColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
1895 break;
1896 case VIDEO_COLORFORMAT_NV12_TILED:
1897 default:
1898 pBufferInfo->ColorFormat = OMX_SEC_COLOR_FormatNV12Tiled;
1899 break;
1900 }
1901
1902 indexTimestamp = pDecOps->Get_FrameTag(hMFCHandle);
1903 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "out indexTimestamp: %d", indexTimestamp);
1904 if ((indexTimestamp < 0) || (indexTimestamp >= MAX_TIMESTAMP)) {
1905 if ((pExynosComponent->checkTimeStamp.needSetStartTimeStamp != OMX_TRUE) &&
1906 (pExynosComponent->checkTimeStamp.needCheckStartTimeStamp != OMX_TRUE)) {
1907 pDstOutputData->timeStamp = pExynosComponent->timeStamp[pWmvDec->hMFCWmvHandle.outputIndexTimestamp];
1908 pDstOutputData->nFlags = pExynosComponent->nFlags[pWmvDec->hMFCWmvHandle.outputIndexTimestamp];
1909 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "missing out indexTimestamp: %d", indexTimestamp);
1910 } else {
1911 pDstOutputData->timeStamp = 0x00;
1912 pDstOutputData->nFlags = 0x00;
1913 }
1914 } else {
1915 /* For timestamp correction. if mfc support frametype detect */
1916 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "disp_pic_frame_type: %d", pVideoBuffer->frameType);
1917#ifdef NEED_TIMESTAMP_REORDER
fe0939d0
TK		 1918 if ((pVideoBuffer->frameType == VIDEO_FRAME_I) ||
1919 ((pVideoBuffer->frameType == VIDEO_FRAME_OTHERS) &&
1920 ((pExynosComponent->nFlags[indexTimestamp] & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS))) {
9c5c94d6
SKR		 1921 pDstOutputData->timeStamp = pExynosComponent->timeStamp[indexTimestamp];
1922 pDstOutputData->nFlags = pExynosComponent->nFlags[indexTimestamp];
1923 pWmvDec->hMFCWmvHandle.outputIndexTimestamp = indexTimestamp;
1924 } else {
1925 pDstOutputData->timeStamp = pExynosComponent->timeStamp[pWmvDec->hMFCWmvHandle.outputIndexTimestamp];
1926 pDstOutputData->nFlags = pExynosComponent->nFlags[pWmvDec->hMFCWmvHandle.outputIndexTimestamp];
1927 }
1928#else
1929 pDstOutputData->timeStamp = pExynosComponent->timeStamp[indexTimestamp];
1930 pDstOutputData->nFlags = pExynosComponent->nFlags[indexTimestamp];
1931#endif
1932 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "timestamp %lld us (%.2f secs), indexTimestamp: %d, nFlags: 0x%x", pDstOutputData->timeStamp, pDstOutputData->timeStamp / 1E6, indexTimestamp, pDstOutputData->nFlags);
1933 }
1934
1935 if ((displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) ||
405399e5 1936 (displayStatus == VIDEO_FRAME_STATUS_DECODING_FINISHED) ||
9c5c94d6
SKR		 1937 ((pDstOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)) {
1938 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "displayStatus:%d, nFlags0x%x", displayStatus, pDstOutputData->nFlags);
1939 pDstOutputData->remainDataLen = 0;
1940 } else {
1941 pDstOutputData->remainDataLen = bufferGeometry->nFrameWidth * bufferGeometry->nFrameHeight * 3 / 2;
1942 }
1943
1944 ret = OMX_ErrorNone;
1945
1946EXIT:
1947 FunctionOut();
1948
1949 return ret;
1950}
1951
1952OMX_ERRORTYPE Exynos_WmvDec_srcInputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
1953{
1954 OMX_ERRORTYPE ret = OMX_ErrorNone;
1955 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1956 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1957 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1958
1959 FunctionIn();
1960
1961 if ((!CHECK_PORT_ENABLED(pExynosInputPort)) || (!CHECK_PORT_POPULATED(pExynosInputPort))) {
1962 ret = OMX_ErrorNone;
1963 goto EXIT;
1964 }
1965 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, INPUT_PORT_INDEX)) {
1966 ret = OMX_ErrorNone;
1967 goto EXIT;
1968 }
1969
1970 ret = Exynos_WmvDec_SrcIn(pOMXComponent, pSrcInputData);
1971 if ((ret != OMX_ErrorNone) && (ret != OMX_ErrorInputDataDecodeYet)) {
1972 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
1973 pExynosComponent->callbackData,
1974 OMX_EventError, ret, 0, NULL);
1975 }
1976
1977EXIT:
1978 FunctionOut();
1979
1980 return ret;
1981}
1982
1983OMX_ERRORTYPE Exynos_WmvDec_srcOutputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcOutputData)
1984{
1985 OMX_ERRORTYPE ret = OMX_ErrorNone;
1986 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1987 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1988 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1989
1990 FunctionIn();
1991
1992 if ((!CHECK_PORT_ENABLED(pExynosInputPort)) || (!CHECK_PORT_POPULATED(pExynosInputPort))) {
1993 ret = OMX_ErrorNone;
1994 goto EXIT;
1995 }
1996
1997 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
1998 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, INPUT_PORT_INDEX)) {
1999 ret = OMX_ErrorNone;
2000 goto EXIT;
2001 }
2002 }
2003 if ((pWmvDec->bSourceStart == OMX_FALSE) &&
2004 (!CHECK_PORT_BEING_FLUSHED(pExynosInputPort))) {
2005 Exynos_OSAL_SignalWait(pWmvDec->hSourceStartEvent, DEF_MAX_WAIT_TIME);
2006 Exynos_OSAL_SignalReset(pWmvDec->hSourceStartEvent);
2007 }
2008
2009 ret = Exynos_WmvDec_SrcOut(pOMXComponent, pSrcOutputData);
2010 if ((ret != OMX_ErrorNone) &&
2011 (pExynosComponent->currentState == OMX_StateExecuting)) {
2012 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2013 pExynosComponent->callbackData,
2014 OMX_EventError, ret, 0, NULL);
2015 }
2016
2017EXIT:
2018 FunctionOut();
2019
2020 return ret;
2021}
2022
2023OMX_ERRORTYPE Exynos_WmvDec_dstInputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstInputData)
2024{
2025 OMX_ERRORTYPE ret = OMX_ErrorNone;
2026 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2027 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2028 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2029
2030 FunctionIn();
2031
2032 if ((!CHECK_PORT_ENABLED(pExynosOutputPort)) || (!CHECK_PORT_POPULATED(pExynosOutputPort))) {
2033 ret = OMX_ErrorNone;
2034 goto EXIT;
2035 }
2036 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, OUTPUT_PORT_INDEX)) {
2037 ret = OMX_ErrorNone;
2038 goto EXIT;
2039 }
2040 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
2041 if ((pWmvDec->bDestinationStart == OMX_FALSE) &&
2042 (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2043 Exynos_OSAL_SignalWait(pWmvDec->hDestinationStartEvent, DEF_MAX_WAIT_TIME);
2044 Exynos_OSAL_SignalReset(pWmvDec->hDestinationStartEvent);
2045 }
2046 }
2047 if (pWmvDec->hMFCWmvHandle.bConfiguredMFCDst == OMX_TRUE) {
2048 ret = Exynos_WmvDec_DstIn(pOMXComponent, pDstInputData);
2049 if (ret != OMX_ErrorNone) {
2050 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2051 pExynosComponent->callbackData,
2052 OMX_EventError, ret, 0, NULL);
2053 }
2054 }
2055
2056EXIT:
2057 FunctionOut();
2058
2059 return ret;
2060}
2061
2062OMX_ERRORTYPE Exynos_WmvDec_dstOutputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstOutputData)
2063{
2064 OMX_ERRORTYPE ret = OMX_ErrorNone;
2065 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2066 EXYNOS_WMVDEC_HANDLE *pWmvDec = (EXYNOS_WMVDEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2067 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2068
2069 FunctionIn();
2070
2071 if ((!CHECK_PORT_ENABLED(pExynosOutputPort)) || (!CHECK_PORT_POPULATED(pExynosOutputPort))) {
2072 ret = OMX_ErrorNone;
2073 goto EXIT;
2074 }
2075 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, OUTPUT_PORT_INDEX)) {
2076 ret = OMX_ErrorNone;
2077 goto EXIT;
2078 }
2079
2080 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
2081 if ((pWmvDec->bDestinationStart == OMX_FALSE) &&
2082 (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2083 Exynos_OSAL_SignalWait(pWmvDec->hDestinationStartEvent, DEF_MAX_WAIT_TIME);
2084 Exynos_OSAL_SignalReset(pWmvDec->hDestinationStartEvent);
2085 }
2086 }
2087 ret = Exynos_WmvDec_DstOut(pOMXComponent, pDstOutputData);
2088 if ((ret != OMX_ErrorNone) &&
2089 (pExynosComponent->currentState == OMX_StateExecuting)) {
2090 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2091 pExynosComponent->callbackData,
2092 OMX_EventError, ret, 0, NULL);
2093 }
2094
2095EXIT:
2096 FunctionOut();
2097
2098 return ret;
2099}
2100
2101OSCL_EXPORT_REF OMX_ERRORTYPE Exynos_OMX_ComponentInit(
2102 OMX_HANDLETYPE hComponent,
2103 OMX_STRING componentName)
2104{
2105 OMX_ERRORTYPE ret = OMX_ErrorNone;
2106 OMX_COMPONENTTYPE *pOMXComponent = NULL;
2107 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
2108 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
2109 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
2110 EXYNOS_WMVDEC_HANDLE *pWmvDec = NULL;
2111 OMX_S32 wmvFormat = WMV_FORMAT_UNKNOWN;
2112 int i = 0;
2113
2114 FunctionIn();
2115
2116 if ((hComponent == NULL) || (componentName == NULL)) {
2117 ret = OMX_ErrorBadParameter;
2118 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
2119 goto EXIT;
2120 }
2121 if (Exynos_OSAL_Strcmp(EXYNOS_OMX_COMPONENT_WMV_DEC, componentName) != 0) {
2122 ret = OMX_ErrorBadParameter;
2123 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, componentName:%s, Line:%d", componentName, __LINE__);
2124 goto EXIT;
2125 }
2126
2127 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2128 ret = Exynos_OMX_VideoDecodeComponentInit(pOMXComponent);
2129 if (ret != OMX_ErrorNone) {
2130 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_Error, Line:%d", __LINE__);
2131 goto EXIT;
2132 }
2133 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2134 pExynosComponent->codecType = HW_VIDEO_DEC_CODEC;
2135
2136 pExynosComponent->componentName = (OMX_STRING)Exynos_OSAL_Malloc(MAX_OMX_COMPONENT_NAME_SIZE);
2137 if (pExynosComponent->componentName == NULL) {
2138 Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2139 ret = OMX_ErrorInsufficientResources;
2140 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2141 goto EXIT;
2142 }
2143 Exynos_OSAL_Memset(pExynosComponent->componentName, 0, MAX_OMX_COMPONENT_NAME_SIZE);
2144
2145 pWmvDec = Exynos_OSAL_Malloc(sizeof(EXYNOS_WMVDEC_HANDLE));
2146 if (pWmvDec == NULL) {
2147 Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2148 ret = OMX_ErrorInsufficientResources;
2149 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2150 goto EXIT;
2151 }
2152 Exynos_OSAL_Memset(pWmvDec, 0, sizeof(EXYNOS_WMVDEC_HANDLE));
2153 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2154 pVideoDec->hCodecHandle = (OMX_HANDLETYPE)pWmvDec;
2155 pWmvDec->hMFCWmvHandle.wmvFormat = wmvFormat;
2156
2157 Exynos_OSAL_Strcpy(pExynosComponent->componentName, EXYNOS_OMX_COMPONENT_WMV_DEC);
2158
2159 /* Set componentVersion */
2160 pExynosComponent->componentVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
2161 pExynosComponent->componentVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
2162 pExynosComponent->componentVersion.s.nRevision = REVISION_NUMBER;
2163 pExynosComponent->componentVersion.s.nStep = STEP_NUMBER;
2164 /* Set specVersion */
2165 pExynosComponent->specVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
2166 pExynosComponent->specVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
2167 pExynosComponent->specVersion.s.nRevision = REVISION_NUMBER;
2168 pExynosComponent->specVersion.s.nStep = STEP_NUMBER;
2169
2170 /* Input port */
2171 pExynosPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2172 pExynosPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
2173 pExynosPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
2174 pExynosPort->portDefinition.format.video.nStride = 0; /*DEFAULT_FRAME_WIDTH;*/
2175 pExynosPort->portDefinition.format.video.nSliceHeight = 0;
2176 pExynosPort->portDefinition.nBufferSize = DEFAULT_VIDEO_INPUT_BUFFER_SIZE;
2177 pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingWMV;
2178 Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2179 Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "video/wmv");
2180 pExynosPort->portDefinition.format.video.pNativeRender = 0;
2181 pExynosPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
2182 pExynosPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatUnused;
2183 pExynosPort->portDefinition.bEnabled = OMX_TRUE;
2184 //pExynosPort->bufferProcessType = BUFFER_SHARE;
2185 pExynosPort->bufferProcessType = BUFFER_COPY;
2186 pExynosPort->portWayType = WAY2_PORT;
2187
2188 /* Output port */
2189 pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2190 pExynosPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
2191 pExynosPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
2192 pExynosPort->portDefinition.format.video.nStride = 0; /*DEFAULT_FRAME_WIDTH;*/
2193 pExynosPort->portDefinition.format.video.nSliceHeight = 0;
2194 pExynosPort->portDefinition.nBufferSize = DEFAULT_VIDEO_OUTPUT_BUFFER_SIZE;
2195 pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused;
2196 Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2197 Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "raw/video");
2198 pExynosPort->portDefinition.format.video.pNativeRender = 0;
2199 pExynosPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
2200 pExynosPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
2201 pExynosPort->portDefinition.bEnabled = OMX_TRUE;
2202 pExynosPort->bufferProcessType = BUFFER_COPY | BUFFER_ANBSHARE;
2203 pExynosPort->portWayType = WAY2_PORT;
2204
2205 for(i = 0; i < ALL_PORT_NUM; i++) {
2206 INIT_SET_SIZE_VERSION(&pWmvDec->WmvComponent[i], OMX_VIDEO_PARAM_WMVTYPE);
2207 pWmvDec->WmvComponent[i].nPortIndex = i;
2208 pWmvDec->WmvComponent[i].eFormat = OMX_VIDEO_WMVFormat9;
2209 }
2210
2211 pOMXComponent->GetParameter = &Exynos_WmvDec_GetParameter;
2212 pOMXComponent->SetParameter = &Exynos_WmvDec_SetParameter;
2213 pOMXComponent->GetConfig = &Exynos_WmvDec_GetConfig;
2214 pOMXComponent->SetConfig = &Exynos_WmvDec_SetConfig;
2215 pOMXComponent->GetExtensionIndex = &Exynos_WmvDec_GetExtensionIndex;
2216 pOMXComponent->ComponentRoleEnum = &Exynos_WmvDec_ComponentRoleEnum;
2217 pOMXComponent->ComponentDeInit = &Exynos_OMX_ComponentDeinit;
2218
2219 pExynosComponent->exynos_codec_componentInit = &Exynos_WmvDec_Init;
2220 pExynosComponent->exynos_codec_componentTerminate = &Exynos_WmvDec_Terminate;
2221
2222 pVideoDec->exynos_codec_srcInputProcess = &Exynos_WmvDec_srcInputBufferProcess;
2223 pVideoDec->exynos_codec_srcOutputProcess = &Exynos_WmvDec_srcOutputBufferProcess;
2224 pVideoDec->exynos_codec_dstInputProcess = &Exynos_WmvDec_dstInputBufferProcess;
2225 pVideoDec->exynos_codec_dstOutputProcess = &Exynos_WmvDec_dstOutputBufferProcess;
2226
2227 pVideoDec->exynos_codec_start = &WmvCodecStart;
2228 pVideoDec->exynos_codec_stop = &WmvCodecStop;
2229 pVideoDec->exynos_codec_bufferProcessRun = &WmvCodecOutputBufferProcessRun;
2230 pVideoDec->exynos_codec_enqueueAllBuffer = &WmvCodecEnQueueAllBuffer;
2231
2232 pVideoDec->exynos_checkInputFrame = &Check_Wmv_Frame;
2233 pVideoDec->exynos_codec_getCodecInputPrivateData = &GetCodecInputPrivateData;
2234 pVideoDec->exynos_codec_getCodecOutputPrivateData = &GetCodecOutputPrivateData;
2235
2236 pVideoDec->hSharedMemory = Exynos_OSAL_SharedMemory_Open();
2237 if (pVideoDec->hSharedMemory == NULL) {
2238 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2239 Exynos_OSAL_Free(pWmvDec);
2240 pWmvDec = ((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle = NULL;
2241 Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2242 ret = OMX_ErrorInsufficientResources;
2243 goto EXIT;
2244 }
2245
2246 pExynosComponent->currentState = OMX_StateLoaded;
2247
2248 ret = OMX_ErrorNone;
2249
2250EXIT:
2251 FunctionOut();
2252
2253 return ret;
2254}
2255
2256OMX_ERRORTYPE Exynos_OMX_ComponentDeinit(
2257 OMX_HANDLETYPE hComponent)
2258{
2259 OMX_ERRORTYPE ret = OMX_ErrorNone;
2260 OMX_COMPONENTTYPE *pOMXComponent = NULL;
2261 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
2262 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
2263 EXYNOS_WMVDEC_HANDLE *pWmvDec = NULL;
2264
2265 FunctionIn();
2266
2267 if (hComponent == NULL) {
2268 ret = OMX_ErrorBadParameter;
2269 goto EXIT;
2270 }
2271 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2272 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2273 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2274
2275 Exynos_OSAL_SharedMemory_Close(pVideoDec->hSharedMemory);
2276
2277 Exynos_OSAL_Free(pExynosComponent->componentName);
2278 pExynosComponent->componentName = NULL;
2279
2280 pWmvDec = (EXYNOS_WMVDEC_HANDLE *)pVideoDec->hCodecHandle;
2281 if (pWmvDec != NULL) {
2282 Exynos_OSAL_Free(pWmvDec);
2283 pWmvDec = pVideoDec->hCodecHandle = NULL;
2284 }
2285
2286 ret = Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2287 if (ret != OMX_ErrorNone) {
2288 goto EXIT;
2289 }
2290
2291 ret = OMX_ErrorNone;
2292
2293EXIT:
2294 FunctionOut();
2295
2296 return ret;
2297}