[svn] / trunk / xvidcore / dshow / src / CXvidDecoder.cpp Repository:
ViewVC logotype

Annotation of /trunk/xvidcore/dshow/src/CXvidDecoder.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1912 - (view) (download)

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

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