Annotation of /branches/release-1_3-branch/xvidcore/dshow/src/CXvidDecoder.cpp

Revision 1916 - (view) (download)
Original Path: trunk/xvidcore/dshow/src/CXvidDecoder.cpp

1 :	edgomez	1384	/*****************************************************************************
2 :			*
3 :			* XVID MPEG-4 VIDEO CODEC
4 :	Isibaar	1896	* - Xvid Decoder part of the DShow Filter -
5 :	edgomez	1384	*
6 :	Isibaar	1896	* Copyright(C) 2002-2010 Peter Ross <pross@xvid.org>
7 :			* 2003-2010 Michael Militzer <michael@xvid.org>
8 :	edgomez	1384	*
9 :			* This program is free software ; you can redistribute it and/or modify
10 :			* it under the terms of the GNU General Public License as published by
11 :			* the Free Software Foundation ; either version 2 of the License, or
12 :			* (at your option) any later version.
13 :			*
14 :			* This program is distributed in the hope that it will be useful,
15 :			* but WITHOUT ANY WARRANTY ; without even the implied warranty of
16 :			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 :			* GNU General Public License for more details.
18 :			*
19 :			* You should have received a copy of the GNU General Public License
20 :			* along with this program ; if not, write to the Free Software
21 :			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 :			*
23 :	Isibaar	1916	* $Id: CXvidDecoder.cpp,v 1.25 2010-12-22 15:21:13 Isibaar Exp $
24 :	edgomez	1384	*
25 :			****************************************************************************/
26 :
27 :			/*
28 :			this requires the directx sdk
29 :			place these paths at the top of the Tools\|Options\|Directories list
30 :
31 :			headers:
32 :	suxen_drol	1521	C:\DX90SDK\Include
33 :			C:\DX90SDK\Samples\C++\DirectShow\BaseClasses
34 :	edgomez	1384
35 :	suxen_drol	1521	C:\DX90SDK\Samples\C++\DirectShow\BaseClasses\Release
36 :			C:\DX90SDK\Samples\C++\DirectShow\BaseClasses\Debug
37 :	edgomez	1384	*/
38 :
39 :	Isibaar	1916	#define XVID_USE_MFT
40 :			#define XVID_USE_TRAYICON
41 :	edgomez	1384
42 :			#include <windows.h>
43 :
44 :			#include <streams.h>
45 :			#include <initguid.h>
46 :			#include <olectl.h>
47 :			#if (1100 > _MSC_VER)
48 :			#include <olectlid.h>
49 :			#endif
50 :			#include <dvdmedia.h> // VIDEOINFOHEADER2
51 :
52 :	Isibaar	1898	#if defined(XVID_USE_MFT)
53 :			#define MFT_UNIQUE_METHOD_NAMES
54 :			#include <mftransform.h>
55 :			#include <mfapi.h>
56 :			#include <mferror.h>
57 :			#include <shlwapi.h>
58 :			#endif
59 :
60 :	Isibaar	1896	#include <shellapi.h>
61 :	edgomez	1384
62 :	Isibaar	1896	#include <xvid.h> // Xvid API
63 :
64 :			#include "resource.h"
65 :
66 :	edgomez	1384	#include "IXvidDecoder.h"
67 :			#include "CXvidDecoder.h"
68 :			#include "CAbout.h"
69 :			#include "config.h"
70 :			#include "debug.h"
71 :
72 :			static bool USE_IYUV;
73 :			static bool USE_YV12;
74 :			static bool USE_YUY2;
75 :			static bool USE_YVYU;
76 :			static bool USE_UYVY;
77 :			static bool USE_RGB32;
78 :			static bool USE_RGB24;
79 :			static bool USE_RG555;
80 :			static bool USE_RG565;
81 :
82 :			const AMOVIESETUP_MEDIATYPE sudInputPinTypes[] =
83 :			{
84 :			{ &MEDIATYPE_Video, &CLSID_XVID },
85 :			{ &MEDIATYPE_Video, &CLSID_XVID_UC },
86 :			{ &MEDIATYPE_Video, &CLSID_DIVX },
87 :			{ &MEDIATYPE_Video, &CLSID_DIVX_UC },
88 :			{ &MEDIATYPE_Video, &CLSID_DX50 },
89 :			{ &MEDIATYPE_Video, &CLSID_DX50_UC },
90 :			{ &MEDIATYPE_Video, &CLSID_MP4V },
91 :	suxen_drol	1647	{ &MEDIATYPE_Video, &CLSID_MP4V_UC },
92 :	edgomez	1384	};
93 :
94 :			const AMOVIESETUP_MEDIATYPE sudOutputPinTypes[] =
95 :			{
96 :			{ &MEDIATYPE_Video, &MEDIASUBTYPE_NULL }
97 :			};
98 :
99 :
100 :			const AMOVIESETUP_PIN psudPins[] =
101 :			{
102 :			{
103 :			L"Input", // String pin name
104 :			FALSE, // Is it rendered
105 :			FALSE, // Is it an output
106 :			FALSE, // Allowed none
107 :			FALSE, // Allowed many
108 :			&CLSID_NULL, // Connects to filter
109 :			L"Output", // Connects to pin
110 :			sizeof(sudInputPinTypes) / sizeof(AMOVIESETUP_MEDIATYPE), // Number of types
111 :			&sudInputPinTypes[0] // The pin details
112 :			},
113 :			{
114 :			L"Output", // String pin name
115 :			FALSE, // Is it rendered
116 :			TRUE, // Is it an output
117 :			FALSE, // Allowed none
118 :			FALSE, // Allowed many
119 :			&CLSID_NULL, // Connects to filter
120 :			L"Input", // Connects to pin
121 :			sizeof(sudOutputPinTypes) / sizeof(AMOVIESETUP_MEDIATYPE), // Number of types
122 :			sudOutputPinTypes // The pin details
123 :			}
124 :			};
125 :
126 :
127 :			const AMOVIESETUP_FILTER sudXvidDecoder =
128 :			{
129 :			&CLSID_XVID, // Filter CLSID
130 :			XVID_NAME_L, // Filter name
131 :			MERIT_PREFERRED, // Its merit
132 :			sizeof(psudPins) / sizeof(AMOVIESETUP_PIN), // Number of pins
133 :			psudPins // Pin details
134 :			};
135 :
136 :
137 :			// List of class IDs and creator functions for the class factory. This
138 :			// provides the link between the OLE entry point in the DLL and an object
139 :			// being created. The class factory will call the static CreateInstance
140 :
141 :			CFactoryTemplate g_Templates[] =
142 :			{
143 :			{
144 :			XVID_NAME_L,
145 :			&CLSID_XVID,
146 :			CXvidDecoder::CreateInstance,
147 :			NULL,
148 :			&sudXvidDecoder
149 :			},
150 :			{
151 :			XVID_NAME_L L"About",
152 :			&CLSID_CABOUT,
153 :			CAbout::CreateInstance
154 :			}
155 :
156 :			};
157 :
158 :			/* note: g_cTemplates must be global; used by strmbase.lib(dllentry.cpp,dllsetup.cpp) */
159 :			int g_cTemplates = sizeof(g_Templates) / sizeof(CFactoryTemplate);
160 :
161 :	Isibaar	1896	#ifdef XVID_USE_TRAYICON
162 :			extern HINSTANCE g_xvid_hInst;
163 :	edgomez	1384
164 :	Isibaar	1896	static int GUI_Page = 0;
165 :	Isibaar	1901	static int Tray_Icon = 0;
166 :	Isibaar	1896	extern "C" void CALLBACK Configure(HWND hWndParent, HINSTANCE hInstParent, LPSTR lpCmdLine, int nCmdShow );
167 :
168 :			LRESULT CALLBACK msg_proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
169 :			{
170 :			switch ( uMsg )
171 :			{
172 :			case WM_ICONMESSAGE:
173 :			switch(lParam)
174 :			{
175 :			case WM_LBUTTONDBLCLK:
176 :			if (!GUI_Page) {
177 :			GUI_Page = 1;
178 :			Configure(hwnd, g_xvid_hInst, "", 1);
179 :			GUI_Page = 0;
180 :			}
181 :			break;
182 :			default:
183 :			return DefWindowProc(hwnd, uMsg, wParam, lParam);
184 :			};
185 :			break;
186 :	Isibaar	1901
187 :			case WM_DESTROY:
188 :			NOTIFYICONDATA nid;
189 :			ZeroMemory(&nid,sizeof(NOTIFYICONDATA));
190 :
191 :			nid.cbSize = NOTIFYICONDATA_V1_SIZE;
192 :			nid.hWnd = hwnd;
193 :			nid.uID = 1456;
194 :	Isibaar	1896
195 :	Isibaar	1901	Shell_NotifyIcon(NIM_DELETE, &nid);
196 :			Tray_Icon = 0;
197 :	Isibaar	1896	default:
198 :			return DefWindowProc(hwnd, uMsg, wParam, lParam);
199 :			}
200 :
201 :			return TRUE; /* ok */
202 :			}
203 :			#endif
204 :
205 :	edgomez	1384	STDAPI DllRegisterServer()
206 :			{
207 :	Isibaar	1898	#if defined(XVID_USE_MFT)
208 :			int inputs_num = sizeof(sudInputPinTypes) / sizeof(AMOVIESETUP_MEDIATYPE);
209 :			int outputs_num = sizeof(sudOutputPinTypes) / sizeof(AMOVIESETUP_MEDIATYPE);
210 :			MFT_REGISTER_TYPE_INFO * mft_bs = new MFT_REGISTER_TYPE_INFO[inputs_num];
211 :			MFT_REGISTER_TYPE_INFO * mft_csp = new MFT_REGISTER_TYPE_INFO[outputs_num];
212 :
213 :			{
214 :			int i;
215 :			for(i=0;i<inputs_num;i++) {
216 :			mft_bs[i].guidMajorType = *sudInputPinTypes[i].clsMajorType;
217 :			mft_bs[i].guidSubtype = *sudInputPinTypes[i].clsMinorType;
218 :			}
219 :			for(i=0;i<outputs_num;i++) {
220 :			mft_csp[i].guidMajorType = *sudOutputPinTypes[i].clsMajorType;
221 :			mft_csp[i].guidSubtype = *sudOutputPinTypes[i].clsMinorType; // MFT and AM GUIDs really the same?
222 :			}
223 :			}
224 :
225 :			/* Register the MFT decoder */
226 :			MFTRegister(CLSID_XVID, // CLSID
227 :			MFT_CATEGORY_VIDEO_DECODER, // Category
228 :			const_cast<LPWSTR>(XVID_NAME_L), // Friendly name
229 :			0, // Flags
230 :			inputs_num, // Number of input types
231 :			mft_bs, // Input types
232 :			outputs_num, // Number of output types
233 :			mft_csp, // Output types
234 :			NULL // Attributes (optional)
235 :			);
236 :
237 :			delete[] mft_bs;
238 :			delete[] mft_csp;
239 :			#endif /* XVID_USE_MFT */
240 :
241 :	edgomez	1384	return AMovieDllRegisterServer2( TRUE );
242 :			}
243 :
244 :
245 :			STDAPI DllUnregisterServer()
246 :			{
247 :	Isibaar	1898	#if defined(XVID_USE_MFT)
248 :			MFTUnregister(CLSID_XVID);
249 :			#endif
250 :	edgomez	1384	return AMovieDllRegisterServer2( FALSE );
251 :			}
252 :
253 :
254 :			/* create instance */
255 :
256 :			CUnknown * WINAPI CXvidDecoder::CreateInstance(LPUNKNOWN punk, HRESULT *phr)
257 :			{
258 :			CXvidDecoder * pNewObject = new CXvidDecoder(punk, phr);
259 :			if (pNewObject == NULL)
260 :			{
261 :			*phr = E_OUTOFMEMORY;
262 :			}
263 :			return pNewObject;
264 :			}
265 :
266 :
267 :			/* query interfaces */
268 :
269 :			STDMETHODIMP CXvidDecoder::NonDelegatingQueryInterface(REFIID riid, void **ppv)
270 :			{
271 :			CheckPointer(ppv, E_POINTER);
272 :
273 :			if (riid == IID_IXvidDecoder)
274 :			{
275 :			return GetInterface((IXvidDecoder *) this, ppv);
276 :			}
277 :
278 :			if (riid == IID_ISpecifyPropertyPages)
279 :			{
280 :			return GetInterface((ISpecifyPropertyPages *) this, ppv);
281 :			}
282 :
283 :	Isibaar	1898	#if defined(XVID_USE_MFT)
284 :			if (riid == IID_IMFTransform)
285 :			{
286 :			return GetInterface((IMFTransform *) this, ppv);
287 :			}
288 :			#endif
289 :
290 :	edgomez	1384	return CVideoTransformFilter::NonDelegatingQueryInterface(riid, ppv);
291 :			}
292 :
293 :
294 :
295 :			/* constructor */
296 :
297 :			#define XVID_DLL_NAME "xvidcore.dll"
298 :
299 :			CXvidDecoder::CXvidDecoder(LPUNKNOWN punk, HRESULT *phr) :
300 :	Isibaar	1605	CVideoTransformFilter(NAME("CXvidDecoder"), punk, CLSID_XVID), m_hdll (NULL)
301 :	edgomez	1384	{
302 :			DPRINTF("Constructor");
303 :
304 :	Isibaar	1605	xvid_decore_func = NULL; // Hmm, some strange errors appearing if I try to initialize...
305 :			xvid_global_func = NULL; // ...this in constructor's init-list. So, they assigned here.
306 :
307 :	Isibaar	1898	#if defined(XVID_USE_MFT)
308 :			InitializeCriticalSection(&m_mft_lock);
309 :			m_pInputType = NULL;
310 :			m_pOutputType = NULL;
311 :			m_rtFrame = 0;
312 :			m_duration = 0;
313 :			m_discont = 0;
314 :			m_frameRate.Denominator = 1;
315 :			m_frameRate.Numerator = 1;
316 :			#endif
317 :
318 :	Isibaar	1605	LoadRegistryInfo();
319 :
320 :			*phr = OpenLib();
321 :			}
322 :
323 :			HRESULT CXvidDecoder::OpenLib()
324 :			{
325 :			DPRINTF("OpenLib");
326 :
327 :			if (m_hdll != NULL)
328 :			return E_UNEXPECTED; // Seems, that library already opened.
329 :
330 :	edgomez	1384	xvid_gbl_init_t init;
331 :			memset(&init, 0, sizeof(init));
332 :			init.version = XVID_VERSION;
333 :	Isibaar	1916	init.cpu_flags = g_config.cpu;
334 :	edgomez	1384
335 :	Isibaar	1912	xvid_gbl_info_t info;
336 :			memset(&info, 0, sizeof(info));
337 :			info.version = XVID_VERSION;
338 :
339 :	edgomez	1384	m_hdll = LoadLibrary(XVID_DLL_NAME);
340 :			if (m_hdll == NULL) {
341 :			DPRINTF("dll load failed");
342 :	syskin	1498	MessageBox(0, XVID_DLL_NAME " not found","Error", MB_TOPMOST);
343 :	Isibaar	1605	return E_FAIL;
344 :	edgomez	1384	}
345 :
346 :			xvid_global_func = (int (__cdecl )(void , int, void , void ))GetProcAddress(m_hdll, "xvid_global");
347 :			if (xvid_global_func == NULL) {
348 :	Isibaar	1605	FreeLibrary(m_hdll);
349 :			m_hdll = NULL;
350 :	syskin	1498	MessageBox(0, "xvid_global() not found", "Error", MB_TOPMOST);
351 :	Isibaar	1605	return E_FAIL;
352 :	edgomez	1384	}
353 :
354 :			xvid_decore_func = (int (__cdecl )(void , int, void , void ))GetProcAddress(m_hdll, "xvid_decore");
355 :			if (xvid_decore_func == NULL) {
356 :	Isibaar	1605	xvid_global_func = NULL;
357 :			FreeLibrary(m_hdll);
358 :			m_hdll = NULL;
359 :	syskin	1498	MessageBox(0, "xvid_decore() not found", "Error", MB_TOPMOST);
360 :	Isibaar	1605	return E_FAIL;
361 :	edgomez	1384	}
362 :
363 :			if (xvid_global_func(0, XVID_GBL_INIT, &init, NULL) < 0)
364 :			{
365 :	Isibaar	1605	xvid_global_func = NULL;
366 :			xvid_decore_func = NULL;
367 :			FreeLibrary(m_hdll);
368 :			m_hdll = NULL;
369 :	syskin	1498	MessageBox(0, "xvid_global() failed", "Error", MB_TOPMOST);
370 :	Isibaar	1605	return E_FAIL;
371 :	edgomez	1384	}
372 :
373 :	Isibaar	1912	if (xvid_global_func(0, XVID_GBL_INFO, &info, NULL) < 0)
374 :			{
375 :			xvid_global_func = NULL;
376 :			xvid_decore_func = NULL;
377 :			FreeLibrary(m_hdll);
378 :			m_hdll = NULL;
379 :			MessageBox(0, "xvid_global() failed", "Error", MB_TOPMOST);
380 :			return E_FAIL;
381 :			}
382 :
383 :	edgomez	1384	memset(&m_create, 0, sizeof(m_create));
384 :			m_create.version = XVID_VERSION;
385 :			m_create.handle = NULL;
386 :	Isibaar	1916	/* Decoder threads */
387 :			if (g_config.cpu & XVID_CPU_FORCE) {
388 :			m_create.num_threads = g_config.num_threads;
389 :			}
390 :			else {
391 :			m_create.num_threads = info.num_threads; /* Autodetect */
392 :			g_config.num_threads = info.num_threads;
393 :			}
394 :	edgomez	1384
395 :			memset(&m_frame, 0, sizeof(m_frame));
396 :			m_frame.version = XVID_VERSION;
397 :
398 :			USE_IYUV = false;
399 :			USE_YV12 = false;
400 :			USE_YUY2 = false;
401 :			USE_YVYU = false;
402 :			USE_UYVY = false;
403 :			USE_RGB32 = false;
404 :			USE_RGB24 = false;
405 :			USE_RG555 = false;
406 :			USE_RG565 = false;
407 :
408 :			switch ( g_config.nForceColorspace )
409 :			{
410 :			case FORCE_NONE:
411 :			USE_IYUV = true;
412 :			USE_YV12 = true;
413 :			USE_YUY2 = true;
414 :			USE_YVYU = true;
415 :			USE_UYVY = true;
416 :			USE_RGB32 = true;
417 :			USE_RGB24 = true;
418 :			USE_RG555 = true;
419 :			USE_RG565 = true;
420 :			break;
421 :			case FORCE_YV12:
422 :			USE_IYUV = true;
423 :			USE_YV12 = true;
424 :			break;
425 :			case FORCE_YUY2:
426 :			USE_YUY2 = true;
427 :			break;
428 :			case FORCE_RGB24:
429 :			USE_RGB24 = true;
430 :			break;
431 :			case FORCE_RGB32:
432 :			USE_RGB32 = true;
433 :			break;
434 :			}
435 :	syskin	1488
436 :			switch (g_config.aspect_ratio)
437 :			{
438 :	syskin	1498	case 0:
439 :			case 1:
440 :	syskin	1488	break;
441 :	syskin	1498	case 2:
442 :	syskin	1488	ar_x = 4;
443 :			ar_y = 3;
444 :			break;
445 :	syskin	1498	case 3:
446 :	syskin	1488	ar_x = 16;
447 :			ar_y = 9;
448 :			break;
449 :	syskin	1498	case 4:
450 :	syskin	1488	ar_x = 47;
451 :			ar_y = 20;
452 :			break;
453 :			}
454 :	Isibaar	1605
455 :			return S_OK;
456 :	edgomez	1384	}
457 :
458 :	syskin	1428	void CXvidDecoder::CloseLib()
459 :	edgomez	1384	{
460 :	Isibaar	1605	DPRINTF("CloseLib");
461 :	edgomez	1384
462 :	Isibaar	1605	if ((m_create.handle != NULL) && (xvid_decore_func != NULL))
463 :			{
464 :	edgomez	1384	xvid_decore_func(m_create.handle, XVID_DEC_DESTROY, 0, 0);
465 :			m_create.handle = NULL;
466 :			}
467 :
468 :	syskin	1428	if (m_hdll != NULL) {
469 :	edgomez	1384	FreeLibrary(m_hdll);
470 :			m_hdll = NULL;
471 :			}
472 :	Isibaar	1605	xvid_decore_func = NULL;
473 :			xvid_global_func = NULL;
474 :	edgomez	1384	}
475 :
476 :	syskin	1428	/* destructor */
477 :	edgomez	1384
478 :	syskin	1428	CXvidDecoder::~CXvidDecoder()
479 :			{
480 :	Isibaar	1605	DPRINTF("Destructor");
481 :	Isibaar	1896
482 :			#ifdef XVID_USE_TRAYICON
483 :	Isibaar	1901	if (Tray_Icon) { /* Destroy tray icon */
484 :	Isibaar	1896	NOTIFYICONDATA nid;
485 :	Isibaar	1901	ZeroMemory(&nid,sizeof(NOTIFYICONDATA));
486 :
487 :			nid.cbSize = NOTIFYICONDATA_V1_SIZE;
488 :	Isibaar	1896	nid.hWnd = MSG_hwnd;
489 :	Isibaar	1901	nid.uID = 1456;
490 :	Isibaar	1896
491 :	Isibaar	1901	Shell_NotifyIcon(NIM_DELETE, &nid);
492 :			Tray_Icon = 0;
493 :	Isibaar	1896	}
494 :			#endif
495 :	Isibaar	1898
496 :	Isibaar	1901	/* Close xvidcore library */
497 :			CloseLib();
498 :
499 :	Isibaar	1898	#if defined(XVID_USE_MFT)
500 :			DeleteCriticalSection(&m_mft_lock);
501 :			#endif
502 :	syskin	1428	}
503 :	edgomez	1384
504 :	syskin	1428
505 :
506 :	edgomez	1384	/* check input type */
507 :
508 :			HRESULT CXvidDecoder::CheckInputType(const CMediaType * mtIn)
509 :			{
510 :			DPRINTF("CheckInputType");
511 :			BITMAPINFOHEADER * hdr;
512 :	syskin	1498
513 :			ar_x = ar_y = 0;
514 :	edgomez	1384
515 :			if (*mtIn->Type() != MEDIATYPE_Video)
516 :			{
517 :			DPRINTF("Error: Unknown Type");
518 :	syskin	1428	CloseLib();
519 :	edgomez	1384	return VFW_E_TYPE_NOT_ACCEPTED;
520 :			}
521 :
522 :	Isibaar	1605	if (m_hdll == NULL)
523 :			{
524 :			HRESULT hr = OpenLib();
525 :
526 :			if (FAILED(hr) \|\| (m_hdll == NULL)) // Paranoid checks.
527 :			return VFW_E_TYPE_NOT_ACCEPTED;
528 :			}
529 :
530 :	edgomez	1384	if (*mtIn->FormatType() == FORMAT_VideoInfo)
531 :			{
532 :			VIDEOINFOHEADER * vih = (VIDEOINFOHEADER *) mtIn->Format();
533 :			hdr = &vih->bmiHeader;
534 :			}
535 :			else if (*mtIn->FormatType() == FORMAT_VideoInfo2)
536 :			{
537 :			VIDEOINFOHEADER2 * vih2 = (VIDEOINFOHEADER2 *) mtIn->Format();
538 :			hdr = &vih2->bmiHeader;
539 :	syskin	1498	if (g_config.aspect_ratio == 0 \|\| g_config.aspect_ratio == 1) {
540 :	syskin	1488	ar_x = vih2->dwPictAspectRatioX;
541 :			ar_y = vih2->dwPictAspectRatioY;
542 :			}
543 :	edgomez	1384	DPRINTF("VIDEOINFOHEADER2 AR: %d:%d", ar_x, ar_y);
544 :			}
545 :	suxen_drol	1647	else if (*mtIn->FormatType() == FORMAT_MPEG2Video) {
546 :			MPEG2VIDEOINFO * mpgvi = (MPEG2VIDEOINFO*)mtIn->Format();
547 :			VIDEOINFOHEADER2 * vih2 = &mpgvi->hdr;
548 :			hdr = &vih2->bmiHeader;
549 :			if (g_config.aspect_ratio == 0 \|\| g_config.aspect_ratio == 1) {
550 :			ar_x = vih2->dwPictAspectRatioX;
551 :			ar_y = vih2->dwPictAspectRatioY;
552 :			}
553 :			DPRINTF("VIDEOINFOHEADER2 AR: %d:%d", ar_x, ar_y);
554 :
555 :			/* haali media splitter reports VOL information in the format header */
556 :
557 :			if (mpgvi->cbSequenceHeader>0) {
558 :
559 :			xvid_dec_stats_t stats;
560 :			memset(&stats, 0, sizeof(stats));
561 :			stats.version = XVID_VERSION;
562 :
563 :			if (m_create.handle == NULL) {
564 :			if (xvid_decore_func == NULL)
565 :			return E_FAIL;
566 :			if (xvid_decore_func(0, XVID_DEC_CREATE, &m_create, 0) < 0) {
567 :			DPRINTF("*** XVID_DEC_CREATE error");
568 :	Isibaar	1868	return E_FAIL;
569 :	suxen_drol	1647	}
570 :			}
571 :
572 :			m_frame.general = 0;
573 :			m_frame.bitstream = (void*)mpgvi->dwSequenceHeader;
574 :			m_frame.length = mpgvi->cbSequenceHeader;
575 :			m_frame.output.csp = XVID_CSP_NULL;
576 :
577 :	Isibaar	1868	int ret = 0;
578 :			if ((ret=xvid_decore_func(m_create.handle, XVID_DEC_DECODE, &m_frame, &stats)) >= 0) {
579 :	suxen_drol	1647	/* honour video dimensions reported in VOL header */
580 :			if (stats.type == XVID_TYPE_VOL) {
581 :			hdr->biWidth = stats.data.vol.width;
582 :			hdr->biHeight = stats.data.vol.height;
583 :	Isibaar	1898	}
584 :			}
585 :	Isibaar	1868	if (ret == XVID_ERR_MEMORY) return E_FAIL;
586 :	Isibaar	1898	}
587 :	suxen_drol	1647	}
588 :	Isibaar	1898	else
589 :			{
590 :	edgomez	1384	DPRINTF("Error: Unknown FormatType");
591 :	syskin	1428	CloseLib();
592 :	edgomez	1384	return VFW_E_TYPE_NOT_ACCEPTED;
593 :	Isibaar	1898	}
594 :			if (hdr->biHeight < 0)
595 :			{
596 :			DPRINTF("colorspace: inverted input format not supported");
597 :			}
598 :
599 :			m_create.width = hdr->biWidth;
600 :			m_create.height = hdr->biHeight;
601 :
602 :			switch(hdr->biCompression)
603 :			{
604 :	suxen_drol	1647	case FOURCC_mp4v:
605 :	edgomez	1384	case FOURCC_MP4V:
606 :	syskin	1428	if (!(g_config.supported_4cc & SUPPORT_MP4V)) {
607 :			CloseLib();
608 :			return VFW_E_TYPE_NOT_ACCEPTED;
609 :			}
610 :	edgomez	1384	break;
611 :			case FOURCC_DIVX :
612 :	syskin	1428	if (!(g_config.supported_4cc & SUPPORT_DIVX)) {
613 :			CloseLib();
614 :			return VFW_E_TYPE_NOT_ACCEPTED;
615 :			}
616 :	edgomez	1384	break;
617 :			case FOURCC_DX50 :
618 :	syskin	1428	if (!(g_config.supported_4cc & SUPPORT_DX50)) {
619 :			CloseLib();
620 :			return VFW_E_TYPE_NOT_ACCEPTED;
621 :			}
622 :	edgomez	1384	case FOURCC_XVID :
623 :			break;
624 :
625 :
626 :			default :
627 :			DPRINTF("Unknown fourcc: 0x%08x (%c%c%c%c)",
628 :			hdr->biCompression,
629 :			(hdr->biCompression)&0xff,
630 :			(hdr->biCompression>>8)&0xff,
631 :			(hdr->biCompression>>16)&0xff,
632 :			(hdr->biCompression>>24)&0xff);
633 :	syskin	1428	CloseLib();
634 :	edgomez	1384	return VFW_E_TYPE_NOT_ACCEPTED;
635 :			}
636 :	Isibaar	1890
637 :			m_create.fourcc = hdr->biCompression;
638 :
639 :	edgomez	1384	return S_OK;
640 :			}
641 :
642 :
643 :			/* get list of supported output colorspaces */
644 :
645 :
646 :			HRESULT CXvidDecoder::GetMediaType(int iPosition, CMediaType *mtOut)
647 :			{
648 :			BITMAPINFOHEADER * bmih;
649 :			DPRINTF("GetMediaType");
650 :
651 :			if (m_pInput->IsConnected() == FALSE)
652 :			{
653 :			return E_UNEXPECTED;
654 :			}
655 :
656 :			if (!g_config.videoinfo_compat) {
657 :			VIDEOINFOHEADER2 * vih = (VIDEOINFOHEADER2 *) mtOut->ReallocFormatBuffer(sizeof(VIDEOINFOHEADER2));
658 :			if (vih == NULL) return E_OUTOFMEMORY;
659 :
660 :			ZeroMemory(vih, sizeof (VIDEOINFOHEADER2));
661 :			bmih = &(vih->bmiHeader);
662 :			mtOut->SetFormatType(&FORMAT_VideoInfo2);
663 :
664 :			if (ar_x != 0 && ar_y != 0) {
665 :			vih->dwPictAspectRatioX = ar_x;
666 :			vih->dwPictAspectRatioY = ar_y;
667 :	syskin	1498	forced_ar = true;
668 :	edgomez	1384	} else { // just to be safe
669 :			vih->dwPictAspectRatioX = m_create.width;
670 :			vih->dwPictAspectRatioY = abs(m_create.height);
671 :	syskin	1498	forced_ar = false;
672 :			}
673 :	edgomez	1384	} else {
674 :
675 :			VIDEOINFOHEADER * vih = (VIDEOINFOHEADER *) mtOut->ReallocFormatBuffer(sizeof(VIDEOINFOHEADER));
676 :			if (vih == NULL) return E_OUTOFMEMORY;
677 :
678 :			ZeroMemory(vih, sizeof (VIDEOINFOHEADER));
679 :			bmih = &(vih->bmiHeader);
680 :			mtOut->SetFormatType(&FORMAT_VideoInfo);
681 :			}
682 :
683 :			bmih->biSize = sizeof(BITMAPINFOHEADER);
684 :			bmih->biWidth = m_create.width;
685 :			bmih->biHeight = m_create.height;
686 :			bmih->biPlanes = 1;
687 :
688 :			if (iPosition < 0) return E_INVALIDARG;
689 :
690 :			switch(iPosition)
691 :			{
692 :
693 :			case 0:
694 :			if ( USE_YUY2 )
695 :			{
696 :			bmih->biCompression = MEDIASUBTYPE_YUY2.Data1;
697 :			bmih->biBitCount = 16;
698 :			mtOut->SetSubtype(&MEDIASUBTYPE_YUY2);
699 :			break;
700 :			}
701 :			case 1 :
702 :			if ( USE_YVYU )
703 :			{
704 :			bmih->biCompression = MEDIASUBTYPE_YVYU.Data1;
705 :			bmih->biBitCount = 16;
706 :			mtOut->SetSubtype(&MEDIASUBTYPE_YVYU);
707 :			break;
708 :			}
709 :			case 2 :
710 :			if ( USE_UYVY )
711 :			{
712 :			bmih->biCompression = MEDIASUBTYPE_UYVY.Data1;
713 :			bmih->biBitCount = 16;
714 :			mtOut->SetSubtype(&MEDIASUBTYPE_UYVY);
715 :			break;
716 :			}
717 :			case 3 :
718 :			if ( USE_IYUV )
719 :			{
720 :			bmih->biCompression = CLSID_MEDIASUBTYPE_IYUV.Data1;
721 :			bmih->biBitCount = 12;
722 :			mtOut->SetSubtype(&CLSID_MEDIASUBTYPE_IYUV);
723 :			break;
724 :			}
725 :			case 4 :
726 :			if ( USE_YV12 )
727 :			{
728 :			bmih->biCompression = MEDIASUBTYPE_YV12.Data1;
729 :			bmih->biBitCount = 12;
730 :			mtOut->SetSubtype(&MEDIASUBTYPE_YV12);
731 :			break;
732 :			}
733 :			case 5 :
734 :			if ( USE_RGB32 )
735 :			{
736 :			bmih->biCompression = BI_RGB;
737 :			bmih->biBitCount = 32;
738 :			mtOut->SetSubtype(&MEDIASUBTYPE_RGB32);
739 :			break;
740 :			}
741 :			case 6 :
742 :			if ( USE_RGB24 )
743 :			{
744 :			bmih->biCompression = BI_RGB;
745 :			bmih->biBitCount = 24;
746 :			mtOut->SetSubtype(&MEDIASUBTYPE_RGB24);
747 :			break;
748 :			}
749 :			case 7 :
750 :			if ( USE_RG555 )
751 :			{
752 :			bmih->biCompression = BI_RGB;
753 :			bmih->biBitCount = 16;
754 :			mtOut->SetSubtype(&MEDIASUBTYPE_RGB555);
755 :			break;
756 :			}
757 :			case 8 :
758 :			if ( USE_RG565 )
759 :			{
760 :			bmih->biCompression = BI_RGB;
761 :			bmih->biBitCount = 16;
762 :			mtOut->SetSubtype(&MEDIASUBTYPE_RGB565);
763 :			break;
764 :			}
765 :			default :
766 :			return VFW_S_NO_MORE_ITEMS;
767 :			}
768 :
769 :			bmih->biSizeImage = GetBitmapSize(bmih);
770 :
771 :			mtOut->SetType(&MEDIATYPE_Video);
772 :			mtOut->SetTemporalCompression(FALSE);
773 :			mtOut->SetSampleSize(bmih->biSizeImage);
774 :
775 :			return S_OK;
776 :			}
777 :
778 :
779 :			/* (internal function) change colorspace */
780 :	suxen_drol	1558	#define CALC_BI_STRIDE(width,bitcount) ((((width * bitcount) + 31) & ~31) >> 3)
781 :	edgomez	1384
782 :			HRESULT CXvidDecoder::ChangeColorspace(GUID subtype, GUID formattype, void * format)
783 :			{
784 :	suxen_drol	1558	DWORD biWidth;
785 :
786 :	edgomez	1384	if (formattype == FORMAT_VideoInfo)
787 :			{
788 :			VIDEOINFOHEADER * vih = (VIDEOINFOHEADER * )format;
789 :	suxen_drol	1558	biWidth = vih->bmiHeader.biWidth;
790 :	Isibaar	1898	out_stride = CALC_BI_STRIDE(vih->bmiHeader.biWidth, vih->bmiHeader.biBitCount);
791 :	edgomez	1384	rgb_flip = (vih->bmiHeader.biHeight < 0 ? 0 : XVID_CSP_VFLIP);
792 :			}
793 :			else if (formattype == FORMAT_VideoInfo2)
794 :			{
795 :			VIDEOINFOHEADER2 * vih2 = (VIDEOINFOHEADER2 * )format;
796 :	suxen_drol	1558	biWidth = vih2->bmiHeader.biWidth;
797 :	Isibaar	1898	out_stride = CALC_BI_STRIDE(vih2->bmiHeader.biWidth, vih2->bmiHeader.biBitCount);
798 :	edgomez	1384	rgb_flip = (vih2->bmiHeader.biHeight < 0 ? 0 : XVID_CSP_VFLIP);
799 :			}
800 :			else
801 :			{
802 :			return S_FALSE;
803 :			}
804 :
805 :			if (subtype == CLSID_MEDIASUBTYPE_IYUV)
806 :			{
807 :			DPRINTF("IYUV");
808 :			rgb_flip = 0;
809 :			m_frame.output.csp = XVID_CSP_I420;
810 :	Isibaar	1898	out_stride = CALC_BI_STRIDE(biWidth, 8); /* planar format fix */
811 :	edgomez	1384	}
812 :			else if (subtype == MEDIASUBTYPE_YV12)
813 :			{
814 :			DPRINTF("YV12");
815 :			rgb_flip = 0;
816 :			m_frame.output.csp = XVID_CSP_YV12;
817 :	Isibaar	1898	out_stride = CALC_BI_STRIDE(biWidth, 8); /* planar format fix */
818 :	edgomez	1384	}
819 :			else if (subtype == MEDIASUBTYPE_YUY2)
820 :			{
821 :			DPRINTF("YUY2");
822 :			rgb_flip = 0;
823 :			m_frame.output.csp = XVID_CSP_YUY2;
824 :			}
825 :			else if (subtype == MEDIASUBTYPE_YVYU)
826 :			{
827 :			DPRINTF("YVYU");
828 :			rgb_flip = 0;
829 :			m_frame.output.csp = XVID_CSP_YVYU;
830 :			}
831 :			else if (subtype == MEDIASUBTYPE_UYVY)
832 :			{
833 :			DPRINTF("UYVY");
834 :			rgb_flip = 0;
835 :			m_frame.output.csp = XVID_CSP_UYVY;
836 :			}
837 :			else if (subtype == MEDIASUBTYPE_RGB32)
838 :			{
839 :			DPRINTF("RGB32");
840 :			m_frame.output.csp = rgb_flip \| XVID_CSP_BGRA;
841 :			}
842 :			else if (subtype == MEDIASUBTYPE_RGB24)
843 :			{
844 :			DPRINTF("RGB24");
845 :			m_frame.output.csp = rgb_flip \| XVID_CSP_BGR;
846 :			}
847 :			else if (subtype == MEDIASUBTYPE_RGB555)
848 :			{
849 :			DPRINTF("RGB555");
850 :			m_frame.output.csp = rgb_flip \| XVID_CSP_RGB555;
851 :			}
852 :			else if (subtype == MEDIASUBTYPE_RGB565)
853 :			{
854 :			DPRINTF("RGB565");
855 :			m_frame.output.csp = rgb_flip \| XVID_CSP_RGB565;
856 :			}
857 :			else if (subtype == GUID_NULL)
858 :			{
859 :			m_frame.output.csp = XVID_CSP_NULL;
860 :			}
861 :			else
862 :			{
863 :			return S_FALSE;
864 :			}
865 :
866 :			return S_OK;
867 :			}
868 :
869 :
870 :			/* set output colorspace */
871 :
872 :			HRESULT CXvidDecoder::SetMediaType(PIN_DIRECTION direction, const CMediaType *pmt)
873 :			{
874 :			DPRINTF("SetMediaType");
875 :
876 :			if (direction == PINDIR_OUTPUT)
877 :			{
878 :			return ChangeColorspace(pmt->Subtype(), pmt->FormatType(), pmt->Format());
879 :			}
880 :
881 :			return S_OK;
882 :			}
883 :
884 :
885 :			/* check input<->output compatiblity */
886 :
887 :			HRESULT CXvidDecoder::CheckTransform(const CMediaType mtIn, const CMediaType mtOut)
888 :			{
889 :			DPRINTF("CheckTransform");
890 :	Isibaar	1896
891 :	edgomez	1384	return S_OK;
892 :			}
893 :
894 :	Isibaar	1896	/* input/output pin connection complete */
895 :	edgomez	1384
896 :	Isibaar	1896	HRESULT CXvidDecoder::CompleteConnect(PIN_DIRECTION direction, IPin *pReceivePin)
897 :			{
898 :			DPRINTF("CompleteConnect");
899 :
900 :			#ifdef XVID_USE_TRAYICON
901 :	Isibaar	1901	if ((direction == PINDIR_OUTPUT) && (Tray_Icon == 0))
902 :	Isibaar	1896	{
903 :			WNDCLASSEX wc;
904 :
905 :			wc.cbSize = sizeof(WNDCLASSEX);
906 :			wc.lpfnWndProc = msg_proc;
907 :			wc.style = CS_HREDRAW \| CS_VREDRAW;
908 :			wc.cbWndExtra = 0;
909 :			wc.cbClsExtra = 0;
910 :			wc.hInstance = (HINSTANCE) g_xvid_hInst;
911 :			wc.hbrBackground = (HBRUSH) GetStockObject(NULL_BRUSH);
912 :			wc.lpszMenuName = NULL;
913 :			wc.lpszClassName = "XVID_MSG_WINDOW";
914 :			wc.hIcon = NULL;
915 :			wc.hIconSm = NULL;
916 :			wc.hCursor = NULL;
917 :			RegisterClassEx(&wc);
918 :
919 :			MSG_hwnd = CreateWindowEx(0, "XVID_MSG_WINDOW", NULL, 0, CW_USEDEFAULT,
920 :			CW_USEDEFAULT, 0, 0, HWND_MESSAGE, NULL, (HINSTANCE) g_xvid_hInst, NULL);
921 :
922 :			/* display the tray icon */
923 :			NOTIFYICONDATA nid;
924 :	Isibaar	1901	ZeroMemory(&nid,sizeof(NOTIFYICONDATA));
925 :
926 :			nid.cbSize = NOTIFYICONDATA_V1_SIZE;
927 :	Isibaar	1896	nid.hWnd = MSG_hwnd;
928 :	Isibaar	1901	nid.uID = 1456;
929 :	Isibaar	1896	nid.uCallbackMessage = WM_ICONMESSAGE;
930 :			nid.hIcon = LoadIcon(g_xvid_hInst, MAKEINTRESOURCE(IDI_ICON));
931 :			strcpy_s(nid.szTip, 19, "Xvid Video Decoder");
932 :			nid.uFlags = NIF_MESSAGE \| NIF_ICON \| NIF_TIP;
933 :
934 :			Shell_NotifyIcon(NIM_ADD, &nid);
935 :	Isibaar	1901
936 :			DestroyIcon(nid.hIcon);
937 :			Tray_Icon = 1;
938 :	Isibaar	1896	}
939 :			#endif
940 :
941 :			return S_OK;
942 :			}
943 :
944 :			/* input/output pin disconnected */
945 :			HRESULT CXvidDecoder::BreakConnect(PIN_DIRECTION direction)
946 :			{
947 :			DPRINTF("BreakConnect");
948 :
949 :			return S_OK;
950 :			}
951 :
952 :	edgomez	1384	/* alloc output buffer */
953 :
954 :			HRESULT CXvidDecoder::DecideBufferSize(IMemAllocator pAlloc, ALLOCATOR_PROPERTIES ppropInputRequest)
955 :			{
956 :			DPRINTF("DecideBufferSize");
957 :			HRESULT result;
958 :			ALLOCATOR_PROPERTIES ppropActual;
959 :
960 :			if (m_pInput->IsConnected() == FALSE)
961 :			{
962 :			return E_UNEXPECTED;
963 :			}
964 :
965 :			ppropInputRequest->cBuffers = 1;
966 :			ppropInputRequest->cbBuffer = m_create.width * m_create.height * 4;
967 :			// cbAlign causes problems with the resize filter */
968 :			// ppropInputRequest->cbAlign = 16;
969 :			ppropInputRequest->cbPrefix = 0;
970 :
971 :			result = pAlloc->SetProperties(ppropInputRequest, &ppropActual);
972 :			if (result != S_OK)
973 :			{
974 :			return result;
975 :			}
976 :
977 :			if (ppropActual.cbBuffer < ppropInputRequest->cbBuffer)
978 :			{
979 :			return E_FAIL;
980 :			}
981 :
982 :			return S_OK;
983 :			}
984 :
985 :
986 :			/* decode frame */
987 :
988 :			HRESULT CXvidDecoder::Transform(IMediaSample pIn, IMediaSample pOut)
989 :			{
990 :			DPRINTF("Transform");
991 :			xvid_dec_stats_t stats;
992 :			int length;
993 :
994 :			memset(&stats, 0, sizeof(stats));
995 :			stats.version = XVID_VERSION;
996 :
997 :			if (m_create.handle == NULL)
998 :			{
999 :	Isibaar	1605	if (xvid_decore_func == NULL)
1000 :			return E_FAIL;
1001 :
1002 :	edgomez	1384	if (xvid_decore_func(0, XVID_DEC_CREATE, &m_create, 0) < 0)
1003 :			{
1004 :			DPRINTF("*** XVID_DEC_CREATE error");
1005 :	Isibaar	1868	return E_FAIL;
1006 :	edgomez	1384	}
1007 :			}
1008 :
1009 :			AM_MEDIA_TYPE * mtOut;
1010 :			pOut->GetMediaType(&mtOut);
1011 :			if (mtOut != NULL)
1012 :			{
1013 :			HRESULT result;
1014 :
1015 :			result = ChangeColorspace(mtOut->subtype, mtOut->formattype, mtOut->pbFormat);
1016 :			DeleteMediaType(mtOut);
1017 :
1018 :			if (result != S_OK)
1019 :			{
1020 :			DPRINTF("*** ChangeColorspace error");
1021 :			return result;
1022 :			}
1023 :			}
1024 :
1025 :			m_frame.length = pIn->GetActualDataLength();
1026 :			if (pIn->GetPointer((BYTE**)&m_frame.bitstream) != S_OK)
1027 :			{
1028 :			return S_FALSE;
1029 :			}
1030 :
1031 :			if (pOut->GetPointer((BYTE**)&m_frame.output.plane[0]) != S_OK)
1032 :			{
1033 :			return S_FALSE;
1034 :			}
1035 :
1036 :			m_frame.general = XVID_LOWDELAY;
1037 :
1038 :			if (pIn->IsDiscontinuity() == S_OK)
1039 :	syskin	1427	m_frame.general \|= XVID_DISCONTINUITY;
1040 :	edgomez	1384
1041 :			if (g_config.nDeblock_Y)
1042 :			m_frame.general \|= XVID_DEBLOCKY;
1043 :
1044 :			if (g_config.nDeblock_UV)
1045 :			m_frame.general \|= XVID_DEBLOCKUV;
1046 :	syskin	1437
1047 :			if (g_config.nDering_Y)
1048 :			m_frame.general \|= XVID_DERINGY;
1049 :
1050 :			if (g_config.nDering_UV)
1051 :			m_frame.general \|= XVID_DERINGUV;
1052 :
1053 :	edgomez	1384	if (g_config.nFilmEffect)
1054 :			m_frame.general \|= XVID_FILMEFFECT;
1055 :
1056 :	suxen_drol	1397	m_frame.brightness = g_config.nBrightness;
1057 :
1058 :	edgomez	1384	m_frame.output.csp &= ~XVID_CSP_VFLIP;
1059 :			m_frame.output.csp \|= rgb_flip^(g_config.nFlipVideo ? XVID_CSP_VFLIP : 0);
1060 :	Isibaar	1898	m_frame.output.stride[0] = out_stride;
1061 :	edgomez	1384
1062 :	Isibaar	1605	// Paranoid check.
1063 :			if (xvid_decore_func == NULL)
1064 :			return E_FAIL;
1065 :	syskin	1498
1066 :
1067 :	edgomez	1384	repeat :
1068 :
1069 :			if (pIn->IsPreroll() != S_OK)
1070 :			{
1071 :			length = xvid_decore_func(m_create.handle, XVID_DEC_DECODE, &m_frame, &stats);
1072 :	Isibaar	1868
1073 :			if (length == XVID_ERR_MEMORY)
1074 :			return E_FAIL;
1075 :			else if (length < 0)
1076 :	edgomez	1384	{
1077 :			DPRINTF("*** XVID_DEC_DECODE");
1078 :			return S_FALSE;
1079 :	syskin	1498	} else
1080 :			if (g_config.aspect_ratio == 0 \|\| g_config.aspect_ratio == 1 && forced_ar == false) {
1081 :	suxen_drol	1633
1082 :			if (stats.type != XVID_TYPE_NOTHING) { /* dont attempt to set vmr aspect ratio if no frame was returned by decoder */
1083 :	syskin	1498	// inspired by minolta! works for VMR 7 + 9
1084 :			IMediaSample2 *pOut2 = NULL;
1085 :			AM_SAMPLE2_PROPERTIES outProp2;
1086 :			if (SUCCEEDED(pOut->QueryInterface(IID_IMediaSample2, (void **)&pOut2)) &&
1087 :			SUCCEEDED(pOut2->GetProperties(FIELD_OFFSET(AM_SAMPLE2_PROPERTIES, tStart), (PBYTE)&outProp2)))
1088 :			{
1089 :			CMediaType mtOut2 = m_pOutput->CurrentMediaType();
1090 :			VIDEOINFOHEADER2* vihOut2 = (VIDEOINFOHEADER2*)mtOut2.Format();
1091 :	suxen_drol	1502
1092 :			if (*mtOut2.FormatType() == FORMAT_VideoInfo2 &&
1093 :			vihOut2->dwPictAspectRatioX != ar_x && vihOut2->dwPictAspectRatioY != ar_y)
1094 :	syskin	1498	{
1095 :			vihOut2->dwPictAspectRatioX = ar_x;
1096 :			vihOut2->dwPictAspectRatioY = ar_y;
1097 :			pOut2->SetMediaType(&mtOut2);
1098 :			m_pOutput->SetMediaType(&mtOut2);
1099 :			}
1100 :			pOut2->Release();
1101 :			}
1102 :	suxen_drol	1633	}
1103 :	edgomez	1384	}
1104 :			}
1105 :			else
1106 :			{ /* Preroll frame - won't be displayed */
1107 :			int tmp = m_frame.output.csp;
1108 :			int tmp_gen = m_frame.general;
1109 :
1110 :			m_frame.output.csp = XVID_CSP_NULL;
1111 :
1112 :			/* Disable postprocessing to speed-up seeking */
1113 :			m_frame.general &= ~XVID_DEBLOCKY;
1114 :			m_frame.general &= ~XVID_DEBLOCKUV;
1115 :	Isibaar	1605	/m_frame.general &= ~XVID_DERING;/
1116 :	edgomez	1384	m_frame.general &= ~XVID_FILMEFFECT;
1117 :
1118 :			length = xvid_decore_func(m_create.handle, XVID_DEC_DECODE, &m_frame, &stats);
1119 :	Isibaar	1868	if (length == XVID_ERR_MEMORY)
1120 :			return E_FAIL;
1121 :			else if (length < 0)
1122 :	edgomez	1384	{
1123 :			DPRINTF("*** XVID_DEC_DECODE");
1124 :			return S_FALSE;
1125 :			}
1126 :
1127 :			m_frame.output.csp = tmp;
1128 :			m_frame.general = tmp_gen;
1129 :			}
1130 :
1131 :			if (stats.type == XVID_TYPE_NOTHING && length > 0) {
1132 :	edgomez	1432	DPRINTF(" B-Frame decoder lag");
1133 :	edgomez	1384	return S_FALSE;
1134 :			}
1135 :
1136 :
1137 :			if (stats.type == XVID_TYPE_VOL)
1138 :			{
1139 :			if (stats.data.vol.width != m_create.width \|\|
1140 :			stats.data.vol.height != m_create.height)
1141 :			{
1142 :			DPRINTF("TODO: auto-resize");
1143 :			return S_FALSE;
1144 :			}
1145 :	syskin	1498
1146 :	edgomez	1384	pOut->SetSyncPoint(TRUE);
1147 :
1148 :	syskin	1498	if (g_config.aspect_ratio == 0 \|\| g_config.aspect_ratio == 1) { /* auto */
1149 :			int par_x, par_y;
1150 :			if (stats.data.vol.par == XVID_PAR_EXT) {
1151 :			par_x = stats.data.vol.par_width;
1152 :			par_y = stats.data.vol.par_height;
1153 :			} else {
1154 :	syskin	1529	par_x = PARS[stats.data.vol.par-1][0];
1155 :			par_y = PARS[stats.data.vol.par-1][1];
1156 :	syskin	1498	}
1157 :
1158 :			ar_x = par_x * stats.data.vol.width;
1159 :			ar_y = par_y * stats.data.vol.height;
1160 :			}
1161 :
1162 :	edgomez	1384	m_frame.bitstream = (BYTE*)m_frame.bitstream + length;
1163 :			m_frame.length -= length;
1164 :			goto repeat;
1165 :			}
1166 :
1167 :			if (pIn->IsPreroll() == S_OK) {
1168 :			return S_FALSE;
1169 :			}
1170 :
1171 :			return S_OK;
1172 :			}
1173 :
1174 :
1175 :			/* get property page list */
1176 :
1177 :			STDMETHODIMP CXvidDecoder::GetPages(CAUUID * pPages)
1178 :			{
1179 :			DPRINTF("GetPages");
1180 :
1181 :			pPages->cElems = 1;
1182 :			pPages->pElems = (GUID )CoTaskMemAlloc(pPages->cElems sizeof(GUID));
1183 :			if (pPages->pElems == NULL)
1184 :			{
1185 :			return E_OUTOFMEMORY;
1186 :			}
1187 :			pPages->pElems[0] = CLSID_CABOUT;
1188 :
1189 :			return S_OK;
1190 :			}
1191 :
1192 :
1193 :			/* cleanup pages */
1194 :
1195 :			STDMETHODIMP CXvidDecoder::FreePages(CAUUID * pPages)
1196 :			{
1197 :			DPRINTF("FreePages");
1198 :			CoTaskMemFree(pPages->pElems);
1199 :			return S_OK;
1200 :			}
1201 :	Isibaar	1898
1202 :			/*===============================================================================
1203 :			// MFT Interface
1204 :			//=============================================================================*/
1205 :			#if defined(XVID_USE_MFT)
1206 :			#include <limits.h> // _I64_MAX
1207 :			#define INVALID_TIME _I64_MAX
1208 :
1209 :			HRESULT CXvidDecoder::MFTGetStreamLimits(DWORD pdwInputMinimum, DWORD pdwInputMaximum, DWORD pdwOutputMinimum, DWORD pdwOutputMaximum)
1210 :			{
1211 :			DPRINTF("(MFT)GetStreamLimits");
1212 :
1213 :			if ((pdwInputMinimum == NULL) \|\| (pdwInputMaximum == NULL) \|\| (pdwOutputMinimum == NULL) \|\| (pdwOutputMaximum == NULL))
1214 :			return E_POINTER;
1215 :
1216 :			/* Just a fixed number of streams allowed */
1217 :			pdwInputMinimum = pdwInputMaximum = 1;
1218 :			pdwOutputMinimum = pdwOutputMaximum = 1;
1219 :
1220 :			return S_OK;
1221 :			}
1222 :
1223 :			HRESULT CXvidDecoder::MFTGetStreamCount(DWORD pcInputStreams, DWORD pcOutputStreams)
1224 :			{
1225 :			DPRINTF("(MFT)GetStreamCount");
1226 :
1227 :			if ((pcInputStreams == NULL) \|\| (pcOutputStreams == NULL))
1228 :			return E_POINTER;
1229 :
1230 :			/* We have a fixed number of streams */
1231 :			*pcInputStreams = 1;
1232 :			*pcOutputStreams = 1;
1233 :
1234 :			return S_OK;
1235 :			}
1236 :
1237 :			HRESULT CXvidDecoder::MFTGetStreamIDs(DWORD dwInputIDArraySize, DWORD pdwInputIDs, DWORD dwOutputIDArraySize, DWORD pdwOutputIDs)
1238 :			{
1239 :			DPRINTF("(MFT)GetStreamIDs");
1240 :			return E_NOTIMPL; /* We have fixed number of streams, so stream ID match stream index */
1241 :			}
1242 :
1243 :			HRESULT CXvidDecoder::MFTGetInputStreamInfo(DWORD dwInputStreamID, MFT_INPUT_STREAM_INFO *pStreamInfo)
1244 :			{
1245 :			DPRINTF("(MFT)GetInputStreamInfo");
1246 :
1247 :			if (pStreamInfo == NULL)
1248 :			return E_POINTER;
1249 :
1250 :			if (dwInputStreamID != 0)
1251 :			return MF_E_INVALIDSTREAMNUMBER;
1252 :
1253 :			EnterCriticalSection(&m_mft_lock);
1254 :
1255 :			pStreamInfo->dwFlags = MFT_INPUT_STREAM_WHOLE_SAMPLES \| MFT_INPUT_STREAM_SINGLE_SAMPLE_PER_BUFFER;
1256 :			pStreamInfo->hnsMaxLatency = 0;
1257 :
1258 :			pStreamInfo->cbSize = 1; /* Need atleast 1 byte input */
1259 :			pStreamInfo->cbMaxLookahead = 0;
1260 :			pStreamInfo->cbAlignment = 1;
1261 :
1262 :			LeaveCriticalSection(&m_mft_lock);
1263 :			return S_OK;
1264 :			}
1265 :
1266 :			HRESULT CXvidDecoder::MFTGetOutputStreamInfo(DWORD dwOutputStreamID, MFT_OUTPUT_STREAM_INFO *pStreamInfo)
1267 :			{
1268 :			DPRINTF("(MFT)GetOutputStreamInfo");
1269 :
1270 :			if (pStreamInfo == NULL)
1271 :			return E_POINTER;
1272 :
1273 :			if (dwOutputStreamID != 0)
1274 :			return MF_E_INVALIDSTREAMNUMBER;
1275 :
1276 :			EnterCriticalSection(&m_mft_lock);
1277 :
1278 :			pStreamInfo->dwFlags = MFT_OUTPUT_STREAM_WHOLE_SAMPLES \| MFT_OUTPUT_STREAM_SINGLE_SAMPLE_PER_BUFFER \| MFT_OUTPUT_STREAM_FIXED_SAMPLE_SIZE \| MFT_OUTPUT_STREAM_DISCARDABLE;
1279 :
1280 :			if (m_pOutputType == NULL) {
1281 :			pStreamInfo->cbSize = 0;
1282 :			pStreamInfo->cbAlignment = 0;
1283 :			}
1284 :			else {
1285 :			pStreamInfo->cbSize = m_create.width * abs(m_create.height) * 4; // XXX
1286 :			pStreamInfo->cbAlignment = 1;
1287 :			}
1288 :
1289 :			LeaveCriticalSection(&m_mft_lock);
1290 :			return S_OK;
1291 :			}
1292 :
1293 :			HRESULT CXvidDecoder::GetAttributes(IMFAttributes** pAttributes)
1294 :			{
1295 :			DPRINTF("(MFT)GetAttributes");
1296 :			return E_NOTIMPL; /* We don't support any attributes */
1297 :			}
1298 :
1299 :			HRESULT CXvidDecoder::GetInputStreamAttributes(DWORD dwInputStreamID, IMFAttributes **ppAttributes)
1300 :			{
1301 :			DPRINTF("(MFT)GetInputStreamAttributes");
1302 :			return E_NOTIMPL; /* We don't support any attributes */
1303 :			}
1304 :
1305 :			HRESULT CXvidDecoder::GetOutputStreamAttributes(DWORD dwOutputStreamID, IMFAttributes **ppAttributes)
1306 :			{
1307 :			DPRINTF("(MFT)GetOutputStreamAttributes");
1308 :			return E_NOTIMPL; /* We don't support any attributes */
1309 :			}
1310 :
1311 :			HRESULT CXvidDecoder::MFTDeleteInputStream(DWORD dwStreamID)
1312 :			{
1313 :			DPRINTF("(MFT)DeleteInputStream");
1314 :			return E_NOTIMPL; /* We have a fixed number of streams */
1315 :			}
1316 :
1317 :			HRESULT CXvidDecoder::MFTAddInputStreams(DWORD cStreams, DWORD *adwStreamIDs)
1318 :			{
1319 :			DPRINTF("(MFT)AddInputStreams");
1320 :			return E_NOTIMPL; /* We have a fixed number of streams */
1321 :			}
1322 :
1323 :			HRESULT CXvidDecoder::MFTGetInputAvailableType(DWORD dwInputStreamID, DWORD dwTypeIndex, IMFMediaType **ppType)
1324 :			{
1325 :			DPRINTF("(MFT)GetInputAvailableType");
1326 :
1327 :			if (dwInputStreamID != 0)
1328 :			return MF_E_INVALIDSTREAMNUMBER;
1329 :
1330 :			DWORD i = 0;
1331 :			GUID *bs_guid_table[8];
1332 :
1333 :			bs_guid_table[i++] = (GUID *)&CLSID_XVID;
1334 :			bs_guid_table[i++] = (GUID *)&CLSID_XVID_UC;
1335 :
1336 :			if (g_config.supported_4cc & SUPPORT_DX50) {
1337 :			bs_guid_table[i++] = (GUID *)&CLSID_DX50;
1338 :			bs_guid_table[i++] = (GUID *)&CLSID_DX50_UC;
1339 :			}
1340 :			if (g_config.supported_4cc & SUPPORT_DIVX) {
1341 :			bs_guid_table[i++] = (GUID *)&CLSID_DIVX;
1342 :			bs_guid_table[i++] = (GUID *)&CLSID_DIVX_UC;
1343 :			}
1344 :			if (g_config.supported_4cc & SUPPORT_MP4V) {
1345 :			bs_guid_table[i++] = (GUID *)&CLSID_MP4V;
1346 :			bs_guid_table[i++] = (GUID *)&CLSID_MP4V_UC;
1347 :			}
1348 :
1349 :			const GUID *subtype;
1350 :			if (dwTypeIndex < i) {
1351 :			subtype = bs_guid_table[dwTypeIndex];
1352 :			}
1353 :			else {
1354 :			return MF_E_NO_MORE_TYPES;
1355 :			}
1356 :
1357 :			EnterCriticalSection(&m_mft_lock);
1358 :
1359 :			HRESULT hr = S_OK;
1360 :
1361 :			if (ppType) {
1362 :			IMFMediaType *pInputType = NULL;
1363 :			hr = MFCreateMediaType(&pInputType);
1364 :
1365 :			if (SUCCEEDED(hr))
1366 :			hr = pInputType->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video);
1367 :
1368 :			if (SUCCEEDED(hr))
1369 :			hr = pInputType->SetGUID(MF_MT_SUBTYPE, *subtype);
1370 :
1371 :			if (SUCCEEDED(hr)) {
1372 :			*ppType = pInputType;
1373 :			(*ppType)->AddRef();
1374 :			}
1375 :			if (pInputType) pInputType->Release();
1376 :			}
1377 :
1378 :			LeaveCriticalSection(&m_mft_lock);
1379 :
1380 :			return hr;
1381 :			}
1382 :
1383 :			HRESULT CXvidDecoder::MFTGetOutputAvailableType(DWORD dwOutputStreamID, DWORD dwTypeIndex, IMFMediaType **ppType)
1384 :			{
1385 :			DPRINTF("(MFT)GetOutputAvailableType");
1386 :
1387 :			if (ppType == NULL)
1388 :			return E_INVALIDARG;
1389 :
1390 :			if (dwOutputStreamID != 0)
1391 :			return MF_E_INVALIDSTREAMNUMBER;
1392 :
1393 :			if (dwTypeIndex < 0) return E_INVALIDARG;
1394 :
1395 :			GUID csp;
1396 :			int bitdepth = 8;
1397 :			switch(dwTypeIndex)
1398 :			{
1399 :			case 0:
1400 :			if ( USE_YUY2 )
1401 :			{
1402 :			csp = MFVideoFormat_YUY2;
1403 :			bitdepth = 4;
1404 :			break;
1405 :			}
1406 :			case 1 :
1407 :			if ( USE_UYVY )
1408 :			{
1409 :			csp = MFVideoFormat_UYVY;
1410 :			bitdepth = 4;
1411 :			break;
1412 :			}
1413 :			case 2 :
1414 :			if ( USE_IYUV )
1415 :			{
1416 :			csp = MFVideoFormat_IYUV;
1417 :			bitdepth = 3;
1418 :			break;
1419 :			}
1420 :			case 3 :
1421 :			if ( USE_YV12 )
1422 :			{
1423 :			csp = MFVideoFormat_YV12;
1424 :			bitdepth = 3;
1425 :			break;
1426 :			}
1427 :			case 4 :
1428 :			if ( USE_RGB32 )
1429 :			{
1430 :			csp = MFVideoFormat_RGB32;
1431 :			bitdepth = 8;
1432 :			break;
1433 :			}
1434 :			case 5 :
1435 :			if ( USE_RGB24 )
1436 :			{
1437 :			csp = MFVideoFormat_RGB24;
1438 :			bitdepth = 6;
1439 :			break;
1440 :			}
1441 :			case 6 :
1442 :			if ( USE_RG555 )
1443 :			{
1444 :			csp = MFVideoFormat_RGB555;
1445 :			bitdepth = 4;
1446 :			break;
1447 :			}
1448 :			case 7 :
1449 :			if ( USE_RG565 )
1450 :			{
1451 :			csp = MFVideoFormat_RGB565;
1452 :			bitdepth = 4;
1453 :			break;
1454 :			}
1455 :			default :
1456 :			return MF_E_NO_MORE_TYPES;
1457 :			}
1458 :
1459 :			if (m_pInputType == NULL)
1460 :			return MF_E_TRANSFORM_TYPE_NOT_SET;
1461 :
1462 :			EnterCriticalSection(&m_mft_lock);
1463 :
1464 :			HRESULT hr = S_OK;
1465 :
1466 :			IMFMediaType *pOutputType = NULL;
1467 :			hr = MFCreateMediaType(&pOutputType);
1468 :
1469 :			if (SUCCEEDED(hr)) {
1470 :			hr = pOutputType->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video);
1471 :			}
1472 :
1473 :			if (SUCCEEDED(hr)) {
1474 :			hr = pOutputType->SetGUID(MF_MT_SUBTYPE, csp);
1475 :			}
1476 :
1477 :			if (SUCCEEDED(hr)) {
1478 :			hr = pOutputType->SetUINT32(MF_MT_FIXED_SIZE_SAMPLES, TRUE);
1479 :			}
1480 :
1481 :			if (SUCCEEDED(hr)) {
1482 :			hr = pOutputType->SetUINT32(MF_MT_ALL_SAMPLES_INDEPENDENT, TRUE);
1483 :			}
1484 :
1485 :			if (SUCCEEDED(hr)) {
1486 :			hr = pOutputType->SetUINT32(MF_MT_SAMPLE_SIZE, (m_create.height * m_create.width * bitdepth)>>1);
1487 :			}
1488 :
1489 :			if (SUCCEEDED(hr)) {
1490 :			hr = MFSetAttributeSize(pOutputType, MF_MT_FRAME_SIZE, m_create.width, m_create.height);
1491 :			}
1492 :
1493 :			if (SUCCEEDED(hr)) {
1494 :			hr = MFSetAttributeRatio(pOutputType, MF_MT_FRAME_RATE, m_frameRate.Numerator, m_frameRate.Denominator);
1495 :			}
1496 :
1497 :			if (SUCCEEDED(hr)) {
1498 :			hr = pOutputType->SetUINT32(MF_MT_INTERLACE_MODE, MFVideoInterlace_Progressive);
1499 :			}
1500 :
1501 :			if (SUCCEEDED(hr)) {
1502 :			hr = MFSetAttributeRatio(pOutputType, MF_MT_PIXEL_ASPECT_RATIO, ar_x, ar_y);
1503 :			}
1504 :
1505 :			if (SUCCEEDED(hr)) {
1506 :			*ppType = pOutputType;
1507 :			(*ppType)->AddRef();
1508 :			}
1509 :
1510 :			if (pOutputType) pOutputType->Release();
1511 :
1512 :			LeaveCriticalSection(&m_mft_lock);
1513 :			return hr;
1514 :			}
1515 :
1516 :			HRESULT CXvidDecoder::MFTSetInputType(DWORD dwInputStreamID, IMFMediaType *pType, DWORD dwFlags)
1517 :			{
1518 :			DPRINTF("(MFT)SetInputType");
1519 :
1520 :			if (dwInputStreamID != 0)
1521 :			return MF_E_INVALIDSTREAMNUMBER;
1522 :
1523 :			if (dwFlags & ~MFT_SET_TYPE_TEST_ONLY)
1524 :			return E_INVALIDARG;
1525 :
1526 :			EnterCriticalSection(&m_mft_lock);
1527 :
1528 :			HRESULT hr = S_OK;
1529 :
1530 :			/* Actually set the type or just test it? */
1531 :			BOOL bReallySet = ((dwFlags & MFT_SET_TYPE_TEST_ONLY) == 0);
1532 :
1533 :			/* If we have samples pending the type can't be changed right now */
1534 :			if (HasPendingOutput())
1535 :			hr = MF_E_TRANSFORM_CANNOT_CHANGE_MEDIATYPE_WHILE_PROCESSING;
1536 :
1537 :			if (SUCCEEDED(hr)) {
1538 :			if (pType) { // /* Check the type */
1539 :			hr = OnCheckInputType(pType);
1540 :			}
1541 :			}
1542 :
1543 :			if (SUCCEEDED(hr)) {
1544 :			if (bReallySet) { /* Set the type if needed */
1545 :			hr = OnSetInputType(pType);
1546 :			}
1547 :			}
1548 :
1549 :			LeaveCriticalSection(&m_mft_lock);
1550 :			return hr;
1551 :			}
1552 :
1553 :			HRESULT CXvidDecoder::MFTSetOutputType(DWORD dwOutputStreamID, IMFMediaType *pType, DWORD dwFlags)
1554 :			{
1555 :			DPRINTF("(MFT)SetOutputType");
1556 :
1557 :			if (dwOutputStreamID != 0)
1558 :			return MF_E_INVALIDSTREAMNUMBER;
1559 :
1560 :			if (dwFlags & ~MFT_SET_TYPE_TEST_ONLY)
1561 :			return E_INVALIDARG;
1562 :
1563 :			HRESULT hr = S_OK;
1564 :
1565 :			EnterCriticalSection(&m_mft_lock);
1566 :
1567 :	Isibaar	1899	/* Actually set the type or just test it? */
1568 :	Isibaar	1898	BOOL bReallySet = ((dwFlags & MFT_SET_TYPE_TEST_ONLY) == 0);
1569 :
1570 :			/* If we have samples pending the type can't be changed right now */
1571 :			if (HasPendingOutput())
1572 :			hr = MF_E_TRANSFORM_CANNOT_CHANGE_MEDIATYPE_WHILE_PROCESSING;
1573 :
1574 :			if (SUCCEEDED(hr)) {
1575 :			if (pType) { /* Check the type */
1576 :			AM_MEDIA_TYPE *am;
1577 :			hr = MFCreateAMMediaTypeFromMFMediaType(pType, GUID_NULL, &am);
1578 :
1579 :			if (SUCCEEDED(hr)) {
1580 :			if (FAILED(ChangeColorspace(am->subtype, am->formattype, am->pbFormat))) {
1581 :			DPRINTF("(MFT)InternalCheckOutputType (MF_E_INVALIDTYPE)");
1582 :			return MF_E_INVALIDTYPE;
1583 :			}
1584 :
1585 :			CoTaskMemFree(am->pbFormat);
1586 :			CoTaskMemFree(am);
1587 :			}
1588 :			}
1589 :			}
1590 :
1591 :			if (SUCCEEDED(hr)) {
1592 :			if (bReallySet) { /* Set the type if needed */
1593 :			hr = OnSetOutputType(pType);
1594 :			}
1595 :			}
1596 :			#ifdef XVID_USE_TRAYICON
1597 :	Isibaar	1901	if (SUCCEEDED(hr) && Tray_Icon == 0) /* Create message passing window */
1598 :	Isibaar	1898	{
1599 :			WNDCLASSEX wc;
1600 :
1601 :			wc.cbSize = sizeof(WNDCLASSEX);
1602 :			wc.lpfnWndProc = msg_proc;
1603 :			wc.style = CS_HREDRAW \| CS_VREDRAW;
1604 :			wc.cbWndExtra = 0;
1605 :			wc.cbClsExtra = 0;
1606 :			wc.hInstance = (HINSTANCE) g_xvid_hInst;
1607 :			wc.hbrBackground = (HBRUSH) GetStockObject(NULL_BRUSH);
1608 :			wc.lpszMenuName = NULL;
1609 :			wc.lpszClassName = "XVID_MSG_WINDOW";
1610 :			wc.hIcon = NULL;
1611 :			wc.hIconSm = NULL;
1612 :			wc.hCursor = NULL;
1613 :			RegisterClassEx(&wc);
1614 :
1615 :			MSG_hwnd = CreateWindowEx(0, "XVID_MSG_WINDOW", NULL, 0, CW_USEDEFAULT,
1616 :			CW_USEDEFAULT, 0, 0, HWND_MESSAGE, NULL, (HINSTANCE) g_xvid_hInst, NULL);
1617 :
1618 :			/* display the tray icon */
1619 :			NOTIFYICONDATA nid;
1620 :	Isibaar	1901	ZeroMemory(&nid,sizeof(NOTIFYICONDATA));
1621 :
1622 :			nid.cbSize = NOTIFYICONDATA_V1_SIZE;
1623 :	Isibaar	1898	nid.hWnd = MSG_hwnd;
1624 :	Isibaar	1901	nid.uID = 1456;
1625 :	Isibaar	1898	nid.uCallbackMessage = WM_ICONMESSAGE;
1626 :			nid.hIcon = LoadIcon(g_xvid_hInst, MAKEINTRESOURCE(IDI_ICON));
1627 :			strcpy_s(nid.szTip, 19, "Xvid Video Decoder");
1628 :			nid.uFlags = NIF_MESSAGE \| NIF_ICON \| NIF_TIP;
1629 :	Isibaar	1916
1630 :	Isibaar	1898	Shell_NotifyIcon(NIM_ADD, &nid);
1631 :	Isibaar	1901
1632 :			DestroyIcon(nid.hIcon);
1633 :			Tray_Icon = 1;
1634 :	Isibaar	1898	}
1635 :			#endif
1636 :
1637 :			LeaveCriticalSection(&m_mft_lock);
1638 :			return hr;
1639 :			}
1640 :
1641 :			HRESULT CXvidDecoder::MFTGetInputCurrentType(DWORD dwInputStreamID, IMFMediaType **ppType)
1642 :			{
1643 :			DPRINTF("(MFT)GetInputCurrentType");
1644 :
1645 :			if (ppType == NULL)
1646 :			return E_POINTER;
1647 :
1648 :			if (dwInputStreamID != 0)
1649 :			return MF_E_INVALIDSTREAMNUMBER;
1650 :
1651 :			EnterCriticalSection(&m_mft_lock);
1652 :
1653 :			HRESULT hr = S_OK;
1654 :
1655 :			if (!m_pInputType)
1656 :			hr = MF_E_TRANSFORM_TYPE_NOT_SET;
1657 :
1658 :			if (SUCCEEDED(hr)) {
1659 :			*ppType = m_pInputType;
1660 :			(*ppType)->AddRef();
1661 :			}
1662 :
1663 :			LeaveCriticalSection(&m_mft_lock);
1664 :			return hr;
1665 :			}
1666 :
1667 :			HRESULT CXvidDecoder::MFTGetOutputCurrentType(DWORD dwOutputStreamID, IMFMediaType **ppType)
1668 :			{
1669 :			DPRINTF("(MFT)GetOutputCurrentType");
1670 :
1671 :			if (ppType == NULL)
1672 :			return E_POINTER;
1673 :
1674 :			if (dwOutputStreamID != 0)
1675 :			return MF_E_INVALIDSTREAMNUMBER;
1676 :
1677 :			EnterCriticalSection(&m_mft_lock);
1678 :
1679 :			HRESULT hr = S_OK;
1680 :
1681 :			if (!m_pOutputType)
1682 :			hr = MF_E_TRANSFORM_TYPE_NOT_SET;
1683 :
1684 :			if (SUCCEEDED(hr)) {
1685 :			*ppType = m_pOutputType;
1686 :			(*ppType)->AddRef();
1687 :			}
1688 :
1689 :			LeaveCriticalSection(&m_mft_lock);
1690 :			return hr;
1691 :			}
1692 :
1693 :			HRESULT CXvidDecoder::MFTGetInputStatus(DWORD dwInputStreamID, DWORD *pdwFlags)
1694 :			{
1695 :			DPRINTF("(MFT)GetInputStatus");
1696 :
1697 :			if (pdwFlags == NULL)
1698 :			return E_POINTER;
1699 :
1700 :			if (dwInputStreamID != 0)
1701 :			return MF_E_INVALIDSTREAMNUMBER;
1702 :
1703 :			EnterCriticalSection(&m_mft_lock);
1704 :
1705 :			/* If there's pending output sampels we don't accept new
1706 :			input data until ProcessOutput() or Flush() was called */
1707 :			if (!HasPendingOutput()) {
1708 :			*pdwFlags = MFT_INPUT_STATUS_ACCEPT_DATA;
1709 :			}
1710 :			else {
1711 :			*pdwFlags = 0;
1712 :			}
1713 :
1714 :			LeaveCriticalSection(&m_mft_lock);
1715 :
1716 :			return S_OK;
1717 :			}
1718 :
1719 :			HRESULT CXvidDecoder::MFTGetOutputStatus(DWORD *pdwFlags)
1720 :			{
1721 :			DPRINTF("(MFT)GetOutputStatus");
1722 :
1723 :			if (pdwFlags == NULL)
1724 :			return E_POINTER;
1725 :
1726 :			EnterCriticalSection(&m_mft_lock);
1727 :
1728 :			/* We can render an output sample only after we
1729 :			have decoded one */
1730 :			if (HasPendingOutput()) {
1731 :			*pdwFlags = MFT_OUTPUT_STATUS_SAMPLE_READY;
1732 :			}
1733 :			else {
1734 :			*pdwFlags = 0;
1735 :			}
1736 :
1737 :			LeaveCriticalSection(&m_mft_lock);
1738 :
1739 :			return S_OK;
1740 :			}
1741 :
1742 :			HRESULT CXvidDecoder::MFTSetOutputBounds(LONGLONG hnsLowerBound, LONGLONG hnsUpperBound)
1743 :			{
1744 :			DPRINTF("(MFT)SetOutputBounds");
1745 :			return E_NOTIMPL;
1746 :			}
1747 :
1748 :			HRESULT CXvidDecoder::MFTProcessEvent(DWORD dwInputStreamID, IMFMediaEvent *pEvent)
1749 :			{
1750 :			DPRINTF("(MFT)ProcessEvent");
1751 :			return E_NOTIMPL; /* We don't handle any stream events */
1752 :			}
1753 :
1754 :			HRESULT CXvidDecoder::MFTProcessMessage(MFT_MESSAGE_TYPE eMessage, ULONG_PTR ulParam)
1755 :			{
1756 :			DPRINTF("(MFT)ProcessMessage");
1757 :			HRESULT hr = S_OK;
1758 :
1759 :			EnterCriticalSection(&m_mft_lock);
1760 :
1761 :			switch (eMessage)
1762 :			{
1763 :			case MFT_MESSAGE_COMMAND_FLUSH:
1764 :			if (m_create.handle != NULL) {
1765 :			DPRINTF("(MFT)CommandFlush");
1766 :
1767 :			xvid_dec_stats_t stats;
1768 :			int used_bytes;
1769 :
1770 :			memset(&stats, 0, sizeof(stats));
1771 :			stats.version = XVID_VERSION;
1772 :
1773 :			int csp = m_frame.output.csp;
1774 :
1775 :			m_frame.output.csp = XVID_CSP_INTERNAL;
1776 :			m_frame.bitstream = NULL;
1777 :			m_frame.length = -1;
1778 :			m_frame.general = XVID_LOWDELAY;
1779 :
1780 :			do {
1781 :			used_bytes = xvid_decore_func(m_create.handle, XVID_DEC_DECODE, &m_frame, &stats);
1782 :			} while(used_bytes>=0 && stats.type <= 0);
1783 :
1784 :			m_frame.output.csp = csp;
1785 :			m_frame.output.plane[1] = NULL; /* Don't display flushed samples */
1786 :
1787 :			//m_timestamp = INVALID_TIME;
1788 :			//m_timelength = INVALID_TIME;
1789 :			//m_rtFrame = 0;
1790 :			}
1791 :			break;
1792 :
1793 :			case MFT_MESSAGE_COMMAND_DRAIN:
1794 :			m_discont = 1; /* Set discontinuity flag */
1795 :			m_rtFrame = 0;
1796 :			break;
1797 :
1798 :			case MFT_MESSAGE_SET_D3D_MANAGER:
1799 :			hr = E_NOTIMPL;
1800 :			break;
1801 :
1802 :			case MFT_MESSAGE_NOTIFY_BEGIN_STREAMING:
1803 :			case MFT_MESSAGE_NOTIFY_END_STREAMING:
1804 :			break;
1805 :
1806 :			case MFT_MESSAGE_NOTIFY_START_OF_STREAM:
1807 :			case MFT_MESSAGE_NOTIFY_END_OF_STREAM:
1808 :			break;
1809 :			}
1810 :
1811 :			LeaveCriticalSection(&m_mft_lock);
1812 :
1813 :			return hr;
1814 :			}
1815 :
1816 :			HRESULT CXvidDecoder::MFTProcessInput(DWORD dwInputStreamID, IMFSample *pSample, DWORD dwFlags)
1817 :			{
1818 :			DPRINTF("(MFT)ProcessInput");
1819 :
1820 :			if (pSample == NULL)
1821 :			return E_POINTER;
1822 :
1823 :			if (dwInputStreamID != 0)
1824 :			return MF_E_INVALIDSTREAMNUMBER;
1825 :
1826 :			if (dwFlags != 0)
1827 :			return E_INVALIDARG;
1828 :
1829 :			if (!m_pInputType \|\| !m_pOutputType) {
1830 :			return MF_E_NOTACCEPTING; /* Must have set input and output types */
1831 :			}
1832 :			else if (HasPendingOutput()) {
1833 :			return MF_E_NOTACCEPTING; /* We still have output samples to render */
1834 :			}
1835 :
1836 :			xvid_dec_stats_t stats;
1837 :			int length;
1838 :
1839 :			memset(&stats, 0, sizeof(stats));
1840 :			stats.version = XVID_VERSION;
1841 :
1842 :			if (m_create.handle == NULL)
1843 :			{
1844 :			if (xvid_decore_func == NULL)
1845 :			return E_FAIL;
1846 :			if (xvid_decore_func(0, XVID_DEC_CREATE, &m_create, 0) < 0)
1847 :			{
1848 :			DPRINTF("*** XVID_DEC_CREATE error");
1849 :			return E_FAIL;
1850 :			}
1851 :			}
1852 :
1853 :			EnterCriticalSection(&m_mft_lock);
1854 :
1855 :			HRESULT hr = S_OK;
1856 :			IMFMediaBuffer *pBuffer;
1857 :
1858 :			if (SUCCEEDED(hr)) {
1859 :			hr = pSample->ConvertToContiguousBuffer(&pBuffer);
1860 :			}
1861 :
1862 :			if (SUCCEEDED(hr)) {
1863 :			hr = pBuffer->Lock((BYTE*)&m_frame.bitstream, NULL, (DWORD )&m_frame.length);
1864 :			}
1865 :
1866 :			m_frame.general = XVID_LOWDELAY;
1867 :
1868 :			if (m_discont == 1) {
1869 :			m_frame.general \|= XVID_DISCONTINUITY;
1870 :			m_discont = 0;
1871 :			}
1872 :
1873 :			if (g_config.nDeblock_Y)
1874 :			m_frame.general \|= XVID_DEBLOCKY;
1875 :
1876 :			if (g_config.nDeblock_UV)
1877 :			m_frame.general \|= XVID_DEBLOCKUV;
1878 :
1879 :			if (g_config.nDering_Y)
1880 :			m_frame.general \|= XVID_DERINGY;
1881 :
1882 :			if (g_config.nDering_UV)
1883 :			m_frame.general \|= XVID_DERINGUV;
1884 :
1885 :			if (g_config.nFilmEffect)
1886 :			m_frame.general \|= XVID_FILMEFFECT;
1887 :
1888 :			m_frame.brightness = g_config.nBrightness;
1889 :
1890 :			m_frame.output.csp &= ~XVID_CSP_VFLIP;
1891 :			m_frame.output.csp \|= rgb_flip^(g_config.nFlipVideo ? XVID_CSP_VFLIP : 0);
1892 :
1893 :			int csp = m_frame.output.csp;
1894 :			m_frame.output.csp = XVID_CSP_INTERNAL;
1895 :
1896 :			// Paranoid check.
1897 :			if (xvid_decore_func == NULL) {
1898 :			hr = E_FAIL;
1899 :			goto END_LOOP;
1900 :			}
1901 :
1902 :			repeat :
1903 :			length = xvid_decore_func(m_create.handle, XVID_DEC_DECODE, &m_frame, &stats);
1904 :
1905 :			if (length == XVID_ERR_MEMORY) {
1906 :			hr = E_FAIL;
1907 :			goto END_LOOP;
1908 :			}
1909 :			else if (length < 0)
1910 :			{
1911 :			DPRINTF("*** XVID_DEC_DECODE");
1912 :			goto END_LOOP;
1913 :			}
1914 :
1915 :			if (stats.type == XVID_TYPE_NOTHING && length > 0) {
1916 :			DPRINTF(" B-Frame decoder lag");
1917 :			m_frame.output.plane[1] = NULL;
1918 :			goto END_LOOP;
1919 :			}
1920 :
1921 :			if (stats.type == XVID_TYPE_VOL)
1922 :			{
1923 :			if (stats.data.vol.width != m_create.width \|\|
1924 :			stats.data.vol.height != m_create.height)
1925 :			{
1926 :			DPRINTF("TODO: auto-resize");
1927 :			m_frame.output.plane[1] = NULL;
1928 :			hr = E_FAIL;
1929 :			}
1930 :
1931 :			if (g_config.aspect_ratio == 0 \|\| g_config.aspect_ratio == 1) { /* auto */
1932 :			int par_x, par_y;
1933 :			if (stats.data.vol.par == XVID_PAR_EXT) {
1934 :			par_x = stats.data.vol.par_width;
1935 :			par_y = stats.data.vol.par_height;
1936 :			} else {
1937 :			par_x = PARS[stats.data.vol.par-1][0];
1938 :			par_y = PARS[stats.data.vol.par-1][1];
1939 :			}
1940 :
1941 :			ar_x = par_x * stats.data.vol.width;
1942 :			ar_y = par_y * stats.data.vol.height;
1943 :			}
1944 :
1945 :			m_frame.bitstream = (BYTE*)m_frame.bitstream + length;
1946 :			m_frame.length -= length;
1947 :			goto repeat;
1948 :			}
1949 :
1950 :			END_LOOP:
1951 :			m_frame.output.csp = csp;
1952 :
1953 :			if (pBuffer) {
1954 :			pBuffer->Unlock();
1955 :			pBuffer->Release();
1956 :			}
1957 :
1958 :			if (SUCCEEDED(hr)) {
1959 :			/* Try to get a timestamp */
1960 :			if (FAILED(pSample->GetSampleTime(&m_timestamp)))
1961 :			m_timestamp = INVALID_TIME;
1962 :
1963 :			if (FAILED(pSample->GetSampleDuration(&m_timelength))) {
1964 :			m_timelength = INVALID_TIME;
1965 :			}
1966 :	Isibaar	1916	if (m_timestamp != INVALID_TIME && stats.type == XVID_TYPE_IVOP) {
1967 :			m_rtFrame = m_timestamp;
1968 :			}
1969 :	Isibaar	1898	}
1970 :
1971 :			LeaveCriticalSection(&m_mft_lock);
1972 :
1973 :			return hr;
1974 :			}
1975 :
1976 :			HRESULT CXvidDecoder::MFTProcessOutput(DWORD dwFlags, DWORD cOutputBufferCount, MFT_OUTPUT_DATA_BUFFER pOutputSamples, DWORD pdwStatus)
1977 :			{
1978 :			DPRINTF("(MFT)ProcessOutput");
1979 :
1980 :			/* Preroll in MFT ??
1981 :			Flags ?? -> TODO... */
1982 :			if (dwFlags != 0)
1983 :			return E_INVALIDARG;
1984 :
1985 :			if (pOutputSamples == NULL \|\| pdwStatus == NULL)
1986 :			return E_POINTER;
1987 :
1988 :			if (cOutputBufferCount != 1) /* Must be exactly one output buffer */
1989 :			return E_INVALIDARG;
1990 :
1991 :			if (pOutputSamples[0].pSample == NULL) /* Must have a sample */
1992 :			return E_INVALIDARG;
1993 :
1994 :			if (!HasPendingOutput()) { /* If there's no sample we need to decode one first */
1995 :			return MF_E_TRANSFORM_NEED_MORE_INPUT;
1996 :			}
1997 :
1998 :			EnterCriticalSection(&m_mft_lock);
1999 :
2000 :			HRESULT hr = S_OK;
2001 :
2002 :			BYTE *Dst = NULL;
2003 :			DWORD buffer_size;
2004 :
2005 :			IMFMediaBuffer *pOutput = NULL;
2006 :
2007 :			if (SUCCEEDED(hr)) {
2008 :			hr = pOutputSamples[0].pSample->GetBufferByIndex(0, &pOutput); /* Get output buffer */
2009 :			}
2010 :
2011 :			if (SUCCEEDED(hr)) {
2012 :			hr = pOutput->GetMaxLength(&buffer_size);
2013 :			}
2014 :
2015 :			if (SUCCEEDED(hr))
2016 :			hr = pOutput->Lock(&Dst, NULL, NULL);
2017 :
2018 :			if (SUCCEEDED(hr)) {
2019 :			xvid_gbl_convert_t convert;
2020 :
2021 :			memset(&convert, 0, sizeof(convert));
2022 :			convert.version = XVID_VERSION;
2023 :
2024 :			convert.input.csp = XVID_CSP_INTERNAL;
2025 :			convert.input.plane[0] = m_frame.output.plane[0];
2026 :			convert.input.plane[1] = m_frame.output.plane[1];
2027 :			convert.input.plane[2] = m_frame.output.plane[2];
2028 :			convert.input.stride[0] = m_frame.output.stride[0];
2029 :			convert.input.stride[1] = m_frame.output.stride[1];
2030 :			convert.input.stride[2] = m_frame.output.stride[2];
2031 :
2032 :			convert.output.csp = m_frame.output.csp;
2033 :			convert.output.plane[0] = Dst;
2034 :			convert.output.stride[0] = out_stride;
2035 :
2036 :			convert.width = m_create.width;
2037 :			convert.height = m_create.height;
2038 :			convert.interlacing = 0;
2039 :
2040 :			if (m_frame.output.plane[1] != NULL && Dst != NULL && xvid_global_func != NULL)
2041 :			if (xvid_global_func(0, XVID_GBL_CONVERT, &convert, NULL) < 0) /* CSP convert into output buffer */
2042 :			hr = E_FAIL;
2043 :
2044 :			m_frame.output.plane[1] = NULL;
2045 :			}
2046 :
2047 :			*pdwStatus = 0;
2048 :
2049 :			if (SUCCEEDED(hr)) {
2050 :			if (SUCCEEDED(hr))
2051 :			hr = pOutputSamples[0].pSample->SetUINT32(MFSampleExtension_CleanPoint, TRUE); // key frame
2052 :
2053 :			if (SUCCEEDED(hr)) { /* Set timestamp of output sample */
2054 :			if (m_timestamp != INVALID_TIME)
2055 :			hr = pOutputSamples[0].pSample->SetSampleTime(m_timestamp);
2056 :			else
2057 :			hr = pOutputSamples[0].pSample->SetSampleTime(m_rtFrame);
2058 :
2059 :			if (m_timelength != INVALID_TIME)
2060 :			hr = pOutputSamples[0].pSample->SetSampleDuration(m_timelength);
2061 :			else
2062 :			hr = pOutputSamples[0].pSample->SetSampleDuration(m_duration);
2063 :
2064 :			m_rtFrame += m_duration;
2065 :			}
2066 :
2067 :			if (SUCCEEDED(hr))
2068 :			hr = pOutput->SetCurrentLength(m_create.width * abs(m_create.height) * 4); // XXX
2069 :			}
2070 :
2071 :			if (pOutput) {
2072 :			pOutput->Unlock();
2073 :			pOutput->Release();
2074 :			}
2075 :
2076 :			LeaveCriticalSection(&m_mft_lock);
2077 :
2078 :			return hr;
2079 :			}
2080 :
2081 :			HRESULT CXvidDecoder::OnCheckInputType(IMFMediaType *pmt)
2082 :			{
2083 :			DPRINTF("(MFT)CheckInputType");
2084 :
2085 :			HRESULT hr = S_OK;
2086 :
2087 :			/* Check if input type is already set. Reject any type that is not identical */
2088 :			if (m_pInputType) {
2089 :			DWORD dwFlags = 0;
2090 :			if (S_OK == m_pInputType->IsEqual(pmt, &dwFlags)) {
2091 :			return S_OK;
2092 :			}
2093 :			else {
2094 :			return MF_E_INVALIDTYPE;
2095 :			}
2096 :			}
2097 :
2098 :			GUID majortype = {0}, subtype = {0};
2099 :			UINT32 width = 0, height = 0;
2100 :
2101 :			hr = pmt->GetMajorType(&majortype);
2102 :
2103 :			if (SUCCEEDED(hr)) {
2104 :			if (majortype != MFMediaType_Video) { /* Must be Video */
2105 :			hr = MF_E_INVALIDTYPE;
2106 :			}
2107 :			}
2108 :
2109 :			if (m_hdll == NULL) {
2110 :			HRESULT hr = OpenLib();
2111 :
2112 :			if (FAILED(hr) \|\| (m_hdll == NULL)) // Paranoid checks.
2113 :			hr = MF_E_INVALIDTYPE;
2114 :			}
2115 :
2116 :			if (SUCCEEDED(hr)) {
2117 :			hr = MFGetAttributeSize(pmt, MF_MT_FRAME_SIZE, &width, &height);
2118 :			}
2119 :
2120 :			/* Check the frame size */
2121 :			if (SUCCEEDED(hr)) {
2122 :			if (width > 4096 \|\| height > 4096) {
2123 :			hr = MF_E_INVALIDTYPE;
2124 :			}
2125 :			}
2126 :			m_create.width = width;
2127 :			m_create.height = height;
2128 :
2129 :			if (SUCCEEDED(hr)) {
2130 :			if (g_config.aspect_ratio == 0 \|\| g_config.aspect_ratio == 1) {
2131 :			hr = MFGetAttributeRatio(pmt, MF_MT_PIXEL_ASPECT_RATIO, (UINT32)&ar_x, (UINT32)&ar_y);
2132 :			}
2133 :			}
2134 :
2135 :			/* TODO1: Make sure there really is a frame rate after all!
2136 :			TODO2: Use the framerate for something! */
2137 :			MFRatio fps = {0};
2138 :			if (SUCCEEDED(hr)) {
2139 :			hr = MFGetAttributeRatio(pmt, MF_MT_FRAME_RATE, (UINT32)&fps.Numerator, (UINT32)&fps.Denominator);
2140 :			}
2141 :
2142 :			if (SUCCEEDED(hr)) {
2143 :			hr = pmt->GetGUID(MF_MT_SUBTYPE, &subtype);
2144 :			}
2145 :
2146 :			if (subtype == CLSID_MP4V \|\| subtype == CLSID_MP4V_UC) {
2147 :			if (!(g_config.supported_4cc & SUPPORT_MP4V)) {
2148 :			CloseLib();
2149 :			hr = MF_E_INVALIDTYPE;
2150 :			}
2151 :			else m_create.fourcc = FOURCC_MP4V;
2152 :			}
2153 :			else if (subtype == CLSID_DIVX \|\| subtype == CLSID_DIVX_UC) {
2154 :			if (!(g_config.supported_4cc & SUPPORT_DIVX)) {
2155 :			CloseLib();
2156 :			hr = MF_E_INVALIDTYPE;
2157 :			}
2158 :			else m_create.fourcc = FOURCC_DIVX;
2159 :			}
2160 :			else if (subtype == CLSID_DX50 \|\| subtype == CLSID_DX50_UC) {
2161 :			if (!(g_config.supported_4cc & SUPPORT_DX50)) {
2162 :			CloseLib();
2163 :			hr = MF_E_INVALIDTYPE;
2164 :			}
2165 :			else m_create.fourcc = FOURCC_DX50;
2166 :			}
2167 :			else if (subtype == CLSID_XVID \|\| subtype == CLSID_XVID_UC) {
2168 :			m_create.fourcc = FOURCC_XVID;
2169 :			}
2170 :			else {
2171 :			DPRINTF("Unknown subtype!");
2172 :			CloseLib();
2173 :			hr = MF_E_INVALIDTYPE;
2174 :			}
2175 :
2176 :			/* haali media splitter reports VOL information in the format header */
2177 :			if (SUCCEEDED(hr))
2178 :			{
2179 :			UINT32 cbSeqHeader = 0;
2180 :
2181 :			(void)pmt->GetBlobSize(MF_MT_MPEG_SEQUENCE_HEADER, &cbSeqHeader);
2182 :
2183 :			if (cbSeqHeader>0) {
2184 :			xvid_dec_stats_t stats;
2185 :			memset(&stats, 0, sizeof(stats));
2186 :			stats.version = XVID_VERSION;
2187 :
2188 :			if (m_create.handle == NULL) {
2189 :			if (xvid_decore_func == NULL)
2190 :			hr = E_FAIL;
2191 :			if (xvid_decore_func(0, XVID_DEC_CREATE, &m_create, 0) < 0) {
2192 :			DPRINTF("*** XVID_DEC_CREATE error");
2193 :			hr = E_FAIL;
2194 :			}
2195 :			}
2196 :
2197 :			if (SUCCEEDED(hr)) {
2198 :			(void)pmt->GetAllocatedBlob(MF_MT_MPEG_SEQUENCE_HEADER, (UINT8 *)&m_frame.bitstream, (UINT32 )&m_frame.length);
2199 :			m_frame.general = 0;
2200 :			m_frame.output.csp = XVID_CSP_NULL;
2201 :
2202 :			int ret = 0;
2203 :			if ((ret=xvid_decore_func(m_create.handle, XVID_DEC_DECODE, &m_frame, &stats)) >= 0) {
2204 :			/* honour video dimensions reported in VOL header */
2205 :			if (stats.type == XVID_TYPE_VOL) {
2206 :			m_create.width = stats.data.vol.width;
2207 :			m_create.height = stats.data.vol.height;
2208 :			}
2209 :			}
2210 :
2211 :			if (ret == XVID_ERR_MEMORY) hr = E_FAIL;
2212 :			CoTaskMemFree(m_frame.bitstream);
2213 :			}
2214 :			}
2215 :			}
2216 :
2217 :			return hr;
2218 :			}
2219 :
2220 :			HRESULT CXvidDecoder::OnSetInputType(IMFMediaType *pmt)
2221 :			{
2222 :			HRESULT hr = S_OK;
2223 :			UINT32 w, h;
2224 :
2225 :			if (m_pInputType) m_pInputType->Release();
2226 :
2227 :			hr = MFGetAttributeSize(pmt, MF_MT_FRAME_SIZE, &w, &h);
2228 :			m_create.width = w; m_create.height = h;
2229 :
2230 :			if (SUCCEEDED(hr))
2231 :			hr = MFGetAttributeRatio(pmt, MF_MT_FRAME_RATE, (UINT32)&m_frameRate.Numerator, (UINT32)&m_frameRate.Denominator);
2232 :
2233 :			if (SUCCEEDED(hr)) { /* Store frame duration, derived from the frame rate */
2234 :			hr = MFFrameRateToAverageTimePerFrame(m_frameRate.Numerator, m_frameRate.Denominator, &m_duration);
2235 :			}
2236 :
2237 :			if (SUCCEEDED(hr)) {
2238 :			m_pInputType = pmt;
2239 :			m_pInputType->AddRef();
2240 :			}
2241 :
2242 :			return hr;
2243 :			}
2244 :
2245 :			HRESULT CXvidDecoder::OnSetOutputType(IMFMediaType *pmt)
2246 :			{
2247 :			if (m_pOutputType) m_pOutputType->Release();
2248 :
2249 :			m_pOutputType = pmt;
2250 :			m_pOutputType->AddRef();
2251 :
2252 :			return S_OK;
2253 :			}
2254 :
2255 :			#endif /* XVID_USE_MFT */

No admin address has been configured	ViewVC Help
Powered by ViewVC 1.0.4