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