src/apps/mplayerc/FGManager.cpp

   1 /*
   2  *      Copyright (C) 2003-2006 Gabest
   3  *      http://www.gabest.org
   4  *
   5  *  This Program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2, or (at your option)
   8  *  any later version.
   9  *
  10  *  This Program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with GNU Make; see the file COPYING.  If not, write to
  17  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  18  *  http://www.gnu.org/copyleft/gpl.html
  19  *
  20  */
  21
  22 #include "stdafx.h"
  23 #include "mplayerc.h"
  24 #include "FGManager.h"
  25 #include "..\..\DSUtil\DSUtil.h"
  26 #include "..\..\Filters\Filters.h"
  27 #include "DX7AllocatorPresenter.h"
  28 #include "DX9AllocatorPresenter.h"
  29 #include "DeinterlacerFilter.h"
  30 #include <initguid.h>
  31 #include "..\..\..\include\moreuuids.h"
  32 #include <dmodshow.h>
  33 #include <D3d9.h>
  34 #include <Vmr9.h>
  35
  36 //
  37 // CFGManager
  38 //
  39
  40 CFGManager::CFGManager(LPCTSTR pName, LPUNKNOWN pUnk)
  41         : CUnknown(pName, pUnk)
  42         , m_dwRegister(0)
  43 {
  44         m_pUnkInner.CoCreateInstance(CLSID_FilterGraph, GetOwner());
  45         m_pFM.CoCreateInstance(CLSID_FilterMapper2);
  46 }
  47
  48 CFGManager::~CFGManager()
  49 {
  50         CAutoLock cAutoLock(this);
  51         while(!m_source.IsEmpty()) delete m_source.RemoveHead();
  52         while(!m_transform.IsEmpty()) delete m_transform.RemoveHead();
  53         while(!m_override.IsEmpty()) delete m_override.RemoveHead();
  54         m_pUnks.RemoveAll();
  55         m_pUnkInner.Release();
  56 }
  57
  58 STDMETHODIMP CFGManager::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  59 {
  60     CheckPointer(ppv, E_POINTER);
  61
  62         return
  63                 QI(IFilterGraph)
  64                 QI(IGraphBuilder)
  65                 QI(IFilterGraph2)
  66                 QI(IGraphBuilder2)
  67                 QI(IGraphBuilderDeadEnd)
  68                 m_pUnkInner && (riid != IID_IUnknown && SUCCEEDED(m_pUnkInner->QueryInterface(riid, ppv))) ? S_OK :
  69                 __super::NonDelegatingQueryInterface(riid, ppv);
  70 }
  71
  72 //
  73
  74 void CFGManager::CStreamPath::Append(IBaseFilter* pBF, IPin* pPin)
  75 {
  76         path_t p;
  77         p.clsid = GetCLSID(pBF);
  78         p.filter = GetFilterName(pBF);
  79         p.pin = GetPinName(pPin);
  80         AddTail(p);
  81 }
  82
  83 bool CFGManager::CStreamPath::Compare(const CStreamPath& path)
  84 {
  85         POSITION pos1 = GetHeadPosition();
  86         POSITION pos2 = path.GetHeadPosition();
  87
  88         while(pos1 && pos2)
  89         {
  90                 const path_t& p1 = GetNext(pos1);
  91                 const path_t& p2 = path.GetNext(pos2);
  92
  93                 if(p1.filter != p2.filter) return true;
  94                 else if(p1.pin != p2.pin) return false;
  95         }
  96
  97         return true;
  98 }
  99
 100 //
 101
 102 bool CFGManager::CheckBytes(HANDLE hFile, CString chkbytes)
 103 {
 104         CAtlList<CString> sl;
 105         Explode(chkbytes, sl, ',');
 106
 107         if(sl.GetCount() < 4)
 108                 return false;
 109
 110         ASSERT(!(sl.GetCount()&3));
 111
 112         LARGE_INTEGER size = {0, 0};
 113         size.LowPart = GetFileSize(hFile, (DWORD*)&size.HighPart);
 114
 115         POSITION pos = sl.GetHeadPosition();
 116         while(sl.GetCount() >= 4)
 117         {
 118                 CString offsetstr = sl.RemoveHead();
 119                 CString cbstr = sl.RemoveHead();
 120                 CString maskstr = sl.RemoveHead();
 121                 CString valstr = sl.RemoveHead();
 122
 123                 long cb = _ttol(cbstr);
 124
 125                 if(offsetstr.IsEmpty() || cbstr.IsEmpty()
 126                 || valstr.IsEmpty() || (valstr.GetLength() & 1)
 127                 || cb*2 != valstr.GetLength())
 128                         return false;
 129
 130                 LARGE_INTEGER offset;
 131                 offset.QuadPart = _ttoi64(offsetstr);
 132                 if(offset.QuadPart < 0) offset.QuadPart = size.QuadPart - offset.QuadPart;
 133                 SetFilePointer(hFile, offset.LowPart, &offset.HighPart, FILE_BEGIN);
 134
 135                 // LAME
 136                 while(maskstr.GetLength() < valstr.GetLength())
 137                         maskstr += 'F';
 138
 139                 CAtlArray<BYTE> mask, val;
 140                 CStringToBin(maskstr, mask);
 141                 CStringToBin(valstr, val);
 142
 143                 for(size_t i = 0; i < val.GetCount(); i++)
 144                 {
 145                         BYTE b;
 146                         DWORD r;
 147                         if(!ReadFile(hFile, &b, 1, &r, NULL) || (b & mask[i]) != val[i])
 148                                 return false;
 149                 }
 150         }
 151
 152         return sl.IsEmpty();
 153 }
 154
 155 HRESULT CFGManager::EnumSourceFilters(LPCWSTR lpcwstrFileName, CFGFilterList& fl)
 156 {
 157         // TODO: use overrides
 158
 159         CheckPointer(lpcwstrFileName, E_POINTER);
 160
 161         fl.RemoveAll();
 162
 163         CStringW fn = CStringW(lpcwstrFileName).TrimLeft();
 164         CStringW protocol = fn.Left(fn.Find(':')+1).TrimRight(':').MakeLower();
 165         CStringW ext = CPathW(fn).GetExtension().MakeLower();
 166
 167         HANDLE hFile = INVALID_HANDLE_VALUE;
 168
 169         if(protocol.GetLength() <= 1 || protocol == L"file")
 170         {
 171                 hFile = CreateFile(CString(fn), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, (HANDLE)NULL);
 172
 173                 if(hFile == INVALID_HANDLE_VALUE)
 174                 {
 175                         return VFW_E_NOT_FOUND;
 176                 }
 177         }
 178
 179         // exceptions first
 180
 181         if(ext == _T(".dvr-ms")) // doh, this is stupid
 182         {
 183                 fl.Insert(new CFGFilterRegistry(CLSID_StreamBufferSource, MERIT64_PREFERRED), 0);
 184         }
 185
 186         TCHAR buff[256], buff2[256];
 187         ULONG len, len2;
 188
 189         if(hFile == INVALID_HANDLE_VALUE)
 190         {
 191                 // internal / protocol
 192
 193                 POSITION pos = m_source.GetHeadPosition();
 194                 while(pos)
 195                 {
 196                         CFGFilter* pFGF = m_source.GetNext(pos);
 197                         if(pFGF->m_protocols.Find(CString(protocol)))
 198                                 fl.Insert(pFGF, 0, false, false);
 199                 }
 200         }
 201         else
 202         {
 203                 // internal / check bytes
 204
 205                 POSITION pos = m_source.GetHeadPosition();
 206                 while(pos)
 207                 {
 208                         CFGFilter* pFGF = m_source.GetNext(pos);
 209
 210                         POSITION pos2 = pFGF->m_chkbytes.GetHeadPosition();
 211                         while(pos2)
 212                         {
 213                                 if(CheckBytes(hFile, pFGF->m_chkbytes.GetNext(pos2)))
 214                                 {
 215                                         fl.Insert(pFGF, 1, false, false);
 216                                         break;
 217                                 }
 218                         }
 219                 }
 220         }
 221
 222         if(!ext.IsEmpty())
 223         {
 224                 // internal / file extension
 225
 226                 POSITION pos = m_source.GetHeadPosition();
 227                 while(pos)
 228                 {
 229                         CFGFilter* pFGF = m_source.GetNext(pos);
 230                         if(pFGF->m_extensions.Find(CString(ext)))
 231                                 fl.Insert(pFGF, 2, false, false);
 232                 }
 233         }
 234
 235         {
 236                 // internal / the rest
 237
 238                 POSITION pos = m_source.GetHeadPosition();
 239                 while(pos)
 240                 {
 241                         CFGFilter* pFGF = m_source.GetNext(pos);
 242                         if(pFGF->m_protocols.IsEmpty() && pFGF->m_chkbytes.IsEmpty() && pFGF->m_extensions.IsEmpty())
 243                                 fl.Insert(pFGF, 3, false, false);
 244                 }
 245         }
 246
 247         if(hFile == INVALID_HANDLE_VALUE)
 248         {
 249                 // protocol
 250
 251                 CRegKey key;
 252                 if(ERROR_SUCCESS == key.Open(HKEY_CLASSES_ROOT, CString(protocol), KEY_READ))
 253                 {
 254                         CRegKey exts;
 255                         if(ERROR_SUCCESS == exts.Open(key, _T("Extensions"), KEY_READ))
 256                         {
 257                                 len = countof(buff);
 258                                 if(ERROR_SUCCESS == exts.QueryStringValue(CString(ext), buff, &len))
 259                                         fl.Insert(new CFGFilterRegistry(GUIDFromCString(buff)), 4);
 260                         }
 261
 262                         len = countof(buff);
 263                         if(ERROR_SUCCESS == key.QueryStringValue(_T("Source Filter"), buff, &len))
 264                                 fl.Insert(new CFGFilterRegistry(GUIDFromCString(buff)), 5);
 265                 }
 266
 267                 fl.Insert(new CFGFilterRegistry(CLSID_URLReader), 6);
 268         }
 269         else
 270         {
 271                 // check bytes
 272
 273                 CRegKey key;
 274                 if(ERROR_SUCCESS == key.Open(HKEY_CLASSES_ROOT, _T("Media Type"), KEY_READ))
 275                 {
 276                         FILETIME ft;
 277                         len = countof(buff);
 278                         for(DWORD i = 0; ERROR_SUCCESS == key.EnumKey(i, buff, &len, &ft); i++, len = countof(buff))
 279                         {
 280                                 GUID majortype;
 281                                 if(FAILED(GUIDFromCString(buff, majortype)))
 282                                         continue;
 283
 284                                 CRegKey majorkey;
 285                                 if(ERROR_SUCCESS == majorkey.Open(key, buff, KEY_READ))
 286                                 {
 287                                         len = countof(buff);
 288                                         for(DWORD j = 0; ERROR_SUCCESS == majorkey.EnumKey(j, buff, &len, &ft); j++, len = countof(buff))
 289                                         {
 290                                                 GUID subtype;
 291                                                 if(FAILED(GUIDFromCString(buff, subtype)))
 292                                                         continue;
 293
 294                                                 CRegKey subkey;
 295                                                 if(ERROR_SUCCESS == subkey.Open(majorkey, buff, KEY_READ))
 296                                                 {
 297                                                         len = countof(buff);
 298                                                         if(ERROR_SUCCESS != subkey.QueryStringValue(_T("Source Filter"), buff, &len))
 299                                                                 continue;
 300
 301                                                         GUID clsid = GUIDFromCString(buff);
 302
 303                                                         len = countof(buff);
 304                                                         len2 = sizeof(buff2);
 305                                                         for(DWORD k = 0, type;
 306                                                                 clsid != GUID_NULL && ERROR_SUCCESS == RegEnumValue(subkey, k, buff2, &len2, 0, &type, (BYTE*)buff, &len);
 307                                                                 k++, len = countof(buff), len2 = sizeof(buff2))
 308                                                         {
 309                                                                 if(CheckBytes(hFile, CString(buff)))
 310                                                                 {
 311                                                                         CFGFilter* pFGF = new CFGFilterRegistry(clsid);
 312                                                                         pFGF->AddType(majortype, subtype);
 313                                                                         fl.Insert(pFGF, 9);
 314                                                                         break;
 315                                                                 }
 316                                                         }
 317                                                 }
 318                                         }
 319                                 }
 320                         }
 321                 }
 322         }
 323
 324         if(!ext.IsEmpty())
 325         {
 326                 // file extension
 327
 328                 CRegKey key;
 329                 if(ERROR_SUCCESS == key.Open(HKEY_CLASSES_ROOT, _T("Media Type\\Extensions\\") + CString(ext), KEY_READ))
 330                 {
 331                         ULONG len = countof(buff);
 332                         memset(buff, 0, sizeof(buff));
 333                         LONG ret = key.QueryStringValue(_T("Source Filter"), buff, &len); // QueryStringValue can return ERROR_INVALID_DATA on bogus strings (radlight mpc v1003, fixed in v1004)
 334                         if(ERROR_SUCCESS == ret || ERROR_INVALID_DATA == ret && GUIDFromCString(buff) != GUID_NULL)
 335                         {
 336                                 GUID clsid = GUIDFromCString(buff);
 337                                 GUID majortype = GUID_NULL;
 338                                 GUID subtype = GUID_NULL;
 339
 340                                 len = countof(buff);
 341                                 if(ERROR_SUCCESS == key.QueryStringValue(_T("Media Type"), buff, &len))
 342                                         majortype = GUIDFromCString(buff);
 343
 344                                 len = countof(buff);
 345                                 if(ERROR_SUCCESS == key.QueryStringValue(_T("Subtype"), buff, &len))
 346                                         subtype = GUIDFromCString(buff);
 347
 348                                 CFGFilter* pFGF = new CFGFilterRegistry(clsid);
 349                                 pFGF->AddType(majortype, subtype);
 350                                 fl.Insert(pFGF, 7);
 351                         }
 352                 }
 353         }
 354
 355         if(hFile != INVALID_HANDLE_VALUE)
 356         {
 357                 CloseHandle(hFile);
 358         }
 359
 360         CFGFilter* pFGF = new CFGFilterRegistry(CLSID_AsyncReader);
 361         pFGF->AddType(MEDIATYPE_Stream, MEDIASUBTYPE_NULL);
 362         fl.Insert(pFGF, 9);
 363
 364         return S_OK;
 365 }
 366
 367 HRESULT CFGManager::AddSourceFilter(CFGFilter* pFGF, LPCWSTR lpcwstrFileName, LPCWSTR lpcwstrFilterName, IBaseFilter** ppBF)
 368 {
 369         TRACE(_T("FGM: AddSourceFilter trying '%s'\n"), CStringFromGUID(pFGF->GetCLSID()));
 370
 371         CheckPointer(lpcwstrFileName, E_POINTER);
 372         CheckPointer(ppBF, E_POINTER);
 373
 374         ASSERT(*ppBF == NULL);
 375
 376         HRESULT hr;
 377
 378         CComPtr<IBaseFilter> pBF;
 379         CInterfaceList<IUnknown, &IID_IUnknown> pUnks;
 380         if(FAILED(hr = pFGF->Create(&pBF, pUnks)))
 381                 return hr;
 382
 383         CComQIPtr<IFileSourceFilter> pFSF = pBF;
 384         if(!pFSF) return E_NOINTERFACE;
 385
 386         if(FAILED(hr = AddFilter(pBF, lpcwstrFilterName)))
 387                 return hr;
 388
 389         const AM_MEDIA_TYPE* pmt = NULL;
 390
 391         CMediaType mt;
 392         const CAtlList<GUID>& types = pFGF->GetTypes();
 393         if(types.GetCount() == 2 && (types.GetHead() != GUID_NULL || types.GetTail() != GUID_NULL))
 394         {
 395                 mt.majortype = types.GetHead();
 396                 mt.subtype = types.GetTail();
 397                 pmt = &mt;
 398         }
 399
 400         if(FAILED(hr = pFSF->Load(lpcwstrFileName, pmt)))
 401         {
 402                 RemoveFilter(pBF);
 403                 return hr;
 404         }
 405
 406         // doh :P
 407         BeginEnumMediaTypes(GetFirstPin(pBF, PINDIR_OUTPUT), pEMT, pmt)
 408         {
 409                 if(pmt->subtype == GUIDFromCString(_T("{640999A0-A946-11D0-A520-000000000000}"))
 410                 || pmt->subtype == GUIDFromCString(_T("{640999A1-A946-11D0-A520-000000000000}"))
 411                 || pmt->subtype == GUIDFromCString(_T("{D51BD5AE-7548-11CF-A520-0080C77EF58A}")))
 412                 {
 413                         RemoveFilter(pBF);
 414                         pFGF = new CFGFilterRegistry(CLSID_NetShowSource);
 415                         hr = AddSourceFilter(pFGF, lpcwstrFileName, lpcwstrFilterName, ppBF);
 416                         delete pFGF;
 417                         return hr;
 418                 }
 419         }
 420         EndEnumMediaTypes(pmt)
 421
 422         *ppBF = pBF.Detach();
 423
 424         m_pUnks.AddTailList(&pUnks);
 425
 426         return S_OK;
 427 }
 428
 429 // IFilterGraph
 430
 431 STDMETHODIMP CFGManager::AddFilter(IBaseFilter* pFilter, LPCWSTR pName)
 432 {
 433         if(!m_pUnkInner) return E_UNEXPECTED;
 434
 435         CAutoLock cAutoLock(this);
 436
 437         HRESULT hr;
 438
 439         if(FAILED(hr = CComQIPtr<IFilterGraph2>(m_pUnkInner)->AddFilter(pFilter, pName)))
 440                 return hr;
 441
 442         // TODO
 443         hr = pFilter->JoinFilterGraph(NULL, NULL);
 444         hr = pFilter->JoinFilterGraph(this, pName);
 445
 446         return hr;
 447 }
 448
 449 STDMETHODIMP CFGManager::RemoveFilter(IBaseFilter* pFilter)
 450 {
 451         if(!m_pUnkInner) return E_UNEXPECTED;
 452
 453         CAutoLock cAutoLock(this);
 454
 455         return CComQIPtr<IFilterGraph2>(m_pUnkInner)->RemoveFilter(pFilter);
 456 }
 457
 458 STDMETHODIMP CFGManager::EnumFilters(IEnumFilters** ppEnum)
 459 {
 460         if(!m_pUnkInner) return E_UNEXPECTED;
 461
 462         CAutoLock cAutoLock(this);
 463
 464         return CComQIPtr<IFilterGraph2>(m_pUnkInner)->EnumFilters(ppEnum);
 465 }
 466
 467 STDMETHODIMP CFGManager::FindFilterByName(LPCWSTR pName, IBaseFilter** ppFilter)
 468 {
 469         if(!m_pUnkInner) return E_UNEXPECTED;
 470
 471         CAutoLock cAutoLock(this);
 472
 473         return CComQIPtr<IFilterGraph2>(m_pUnkInner)->FindFilterByName(pName, ppFilter);
 474 }
 475
 476 STDMETHODIMP CFGManager::ConnectDirect(IPin* pPinOut, IPin* pPinIn, const AM_MEDIA_TYPE* pmt)
 477 {
 478         if(!m_pUnkInner) return E_UNEXPECTED;
 479
 480         CAutoLock cAutoLock(this);
 481
 482         CComPtr<IBaseFilter> pBF = GetFilterFromPin(pPinIn);
 483         CLSID clsid = GetCLSID(pBF);
 484
 485         // TODO: GetUpStreamFilter goes up on the first input pin only
 486         for(CComPtr<IBaseFilter> pBFUS = GetFilterFromPin(pPinOut); pBFUS; pBFUS = GetUpStreamFilter(pBFUS))
 487         {
 488                 if(pBFUS == pBF) return VFW_E_CIRCULAR_GRAPH;
 489         if(GetCLSID(pBFUS) == clsid) return VFW_E_CANNOT_CONNECT;
 490         }
 491
 492         return CComQIPtr<IFilterGraph2>(m_pUnkInner)->ConnectDirect(pPinOut, pPinIn, pmt);
 493 }
 494
 495 STDMETHODIMP CFGManager::Reconnect(IPin* ppin)
 496 {
 497         if(!m_pUnkInner) return E_UNEXPECTED;
 498
 499         CAutoLock cAutoLock(this);
 500
 501         return CComQIPtr<IFilterGraph2>(m_pUnkInner)->Reconnect(ppin);
 502 }
 503
 504 STDMETHODIMP CFGManager::Disconnect(IPin* ppin)
 505 {
 506         if(!m_pUnkInner) return E_UNEXPECTED;
 507
 508         CAutoLock cAutoLock(this);
 509
 510         return CComQIPtr<IFilterGraph2>(m_pUnkInner)->Disconnect(ppin);
 511 }
 512
 513 STDMETHODIMP CFGManager::SetDefaultSyncSource()
 514 {
 515         if(!m_pUnkInner) return E_UNEXPECTED;
 516
 517         CAutoLock cAutoLock(this);
 518
 519         return CComQIPtr<IFilterGraph2>(m_pUnkInner)->SetDefaultSyncSource();
 520 }
 521
 522 // IGraphBuilder
 523
 524 STDMETHODIMP CFGManager::Connect(IPin* pPinOut, IPin* pPinIn)
 525 {
 526         CAutoLock cAutoLock(this);
 527
 528         CheckPointer(pPinOut, E_POINTER);
 529
 530         HRESULT hr;
 531
 532         if(S_OK != IsPinDirection(pPinOut, PINDIR_OUTPUT)
 533         || pPinIn && S_OK != IsPinDirection(pPinIn, PINDIR_INPUT))
 534                 return VFW_E_INVALID_DIRECTION;
 535
 536         if(S_OK == IsPinConnected(pPinOut)
 537         || pPinIn && S_OK == IsPinConnected(pPinIn))
 538                 return VFW_E_ALREADY_CONNECTED;
 539
 540         bool fDeadEnd = true;
 541
 542         if(pPinIn)
 543         {
 544                 // 1. Try a direct connection between the filters, with no intermediate filters
 545
 546                 if(SUCCEEDED(hr = ConnectDirect(pPinOut, pPinIn, NULL)))
 547                         return hr;
 548         }
 549         else
 550         {
 551                 // 1. Use IStreamBuilder
 552
 553                 if(CComQIPtr<IStreamBuilder> pSB = pPinOut)
 554                 {
 555                         if(SUCCEEDED(hr = pSB->Render(pPinOut, this)))
 556                                 return hr;
 557
 558                         pSB->Backout(pPinOut, this);
 559                 }
 560         }
 561
 562         // 2. Try cached filters
 563
 564         if(CComQIPtr<IGraphConfig> pGC = (IGraphBuilder2*)this)
 565         {
 566                 BeginEnumCachedFilters(pGC, pEF, pBF)
 567                 {
 568                         if(pPinIn && GetFilterFromPin(pPinIn) == pBF)
 569                                 continue;
 570
 571                         hr = pGC->RemoveFilterFromCache(pBF);
 572
 573                         // does RemoveFilterFromCache call AddFilter like AddFilterToCache calls RemoveFilter ?
 574
 575                         if(SUCCEEDED(hr = ConnectFilterDirect(pPinOut, pBF, NULL)))
 576                         {
 577                                 if(!IsStreamEnd(pBF)) fDeadEnd = false;
 578
 579                                 if(SUCCEEDED(hr = ConnectFilter(pBF, pPinIn)))
 580                                         return hr;
 581                         }
 582
 583                         hr = pGC->AddFilterToCache(pBF);
 584                 }
 585                 EndEnumCachedFilters
 586         }
 587
 588         // 3. Try filters in the graph
 589
 590         {
 591                 CInterfaceList<IBaseFilter> pBFs;
 592
 593                 BeginEnumFilters(this, pEF, pBF)
 594                 {
 595                         if(pPinIn && GetFilterFromPin(pPinIn) == pBF
 596                         || GetFilterFromPin(pPinOut) == pBF)
 597                                 continue;
 598
 599                         // HACK: ffdshow - audio capture filter
 600                         if(GetCLSID(pPinOut) == GUIDFromCString(_T("{04FE9017-F873-410E-871E-AB91661A4EF7}"))
 601                         && GetCLSID(pBF) == GUIDFromCString(_T("{E30629D2-27E5-11CE-875D-00608CB78066}")))
 602                                 continue;
 603
 604                         pBFs.AddTail(pBF);
 605                 }
 606                 EndEnumFilters
 607
 608                 POSITION pos = pBFs.GetHeadPosition();
 609                 while(pos)
 610                 {
 611                         IBaseFilter* pBF = pBFs.GetNext(pos);
 612
 613                         if(SUCCEEDED(hr = ConnectFilterDirect(pPinOut, pBF, NULL)))
 614                         {
 615                                 if(!IsStreamEnd(pBF)) fDeadEnd = false;
 616
 617                                 if(SUCCEEDED(hr = ConnectFilter(pBF, pPinIn)))
 618                                         return hr;
 619                         }
 620
 621                         EXECUTE_ASSERT(Disconnect(pPinOut));
 622                 }
 623         }
 624
 625         // 4. Look up filters in the registry
 626
 627         {
 628                 CFGFilterList fl;
 629
 630                 CAtlArray<GUID> types;
 631                 ExtractMediaTypes(pPinOut, types);
 632
 633                 POSITION pos = m_transform.GetHeadPosition();
 634                 while(pos)
 635                 {
 636                         CFGFilter* pFGF = m_transform.GetNext(pos);
 637                         if(pFGF->GetMerit() < MERIT64_DO_USE || pFGF->CheckTypes(types, false))
 638                                 fl.Insert(pFGF, 0, pFGF->CheckTypes(types, true), false);
 639                 }
 640
 641                 pos = m_override.GetHeadPosition();
 642                 while(pos)
 643                 {
 644                         CFGFilter* pFGF = m_override.GetNext(pos);
 645                         if(pFGF->GetMerit() < MERIT64_DO_USE || pFGF->CheckTypes(types, false))
 646                                 fl.Insert(pFGF, 0, pFGF->CheckTypes(types, true), false);
 647                 }
 648
 649                 CComPtr<IEnumMoniker> pEM;
 650                 if(types.GetCount() > 0
 651                 && SUCCEEDED(m_pFM->EnumMatchingFilters(
 652                         &pEM, 0, FALSE, MERIT_DO_NOT_USE+1,
 653                         TRUE, types.GetCount()/2, types.GetData(), NULL, NULL, FALSE,
 654                         !!pPinIn, 0, NULL, NULL, NULL)))
 655                 {
 656                         for(CComPtr<IMoniker> pMoniker; S_OK == pEM->Next(1, &pMoniker, NULL); pMoniker = NULL)
 657                         {
 658                                 CFGFilterRegistry* pFGF = new CFGFilterRegistry(pMoniker);
 659                                 fl.Insert(pFGF, 0, pFGF->CheckTypes(types, true));
 660                         }
 661                 }
 662
 663                 pos = fl.GetHeadPosition();
 664                 while(pos)
 665                 {
 666                         CFGFilter* pFGF = fl.GetNext(pos);
 667
 668                         TRACE(_T("FGM: Connecting '%s'\n"), pFGF->GetName());
 669
 670                         CComPtr<IBaseFilter> pBF;
 671                         CInterfaceList<IUnknown, &IID_IUnknown> pUnks;
 672                         if(FAILED(pFGF->Create(&pBF, pUnks)))
 673                                 continue;
 674
 675                         if(FAILED(hr = AddFilter(pBF, pFGF->GetName())))
 676                                 continue;
 677
 678                         hr = E_FAIL;
 679
 680                         if(FAILED(hr))
 681                         {
 682                                 hr = ConnectFilterDirect(pPinOut, pBF, NULL);
 683                         }
 684 /*
 685                         if(FAILED(hr))
 686                         {
 687                                 if(types.GetCount() >= 2 && types[0] == MEDIATYPE_Stream && types[1] != GUID_NULL)
 688                                 {
 689                                         CMediaType mt;
 690
 691                                         mt.majortype = types[0];
 692                                         mt.subtype = types[1];
 693                                         mt.formattype = FORMAT_None;
 694                                         if(FAILED(hr)) hr = ConnectFilterDirect(pPinOut, pBF, &mt);
 695
 696                                         mt.formattype = GUID_NULL;
 697                                         if(FAILED(hr)) hr = ConnectFilterDirect(pPinOut, pBF, &mt);
 698                                 }
 699                         }
 700 */
 701                         if(SUCCEEDED(hr))
 702                         {
 703                                 if(!IsStreamEnd(pBF)) fDeadEnd = false;
 704
 705                                 hr = ConnectFilter(pBF, pPinIn);
 706
 707                                 if(SUCCEEDED(hr))
 708                                 {
 709                                         m_pUnks.AddTailList(&pUnks);
 710
 711                                         // maybe the application should do this...
 712
 713                                         POSITION pos = pUnks.GetHeadPosition();
 714                                         while(pos)
 715                                         {
 716                                                 if(CComQIPtr<IMixerPinConfig, &IID_IMixerPinConfig> pMPC = pUnks.GetNext(pos))
 717                                                         pMPC->SetAspectRatioMode(AM_ARMODE_STRETCHED);
 718                                         }
 719
 720                                         if(CComQIPtr<IVMRAspectRatioControl> pARC = pBF)
 721                                                 pARC->SetAspectRatioMode(VMR_ARMODE_NONE);
 722
 723                                         if(CComQIPtr<IVMRAspectRatioControl9> pARC = pBF)
 724                                                 pARC->SetAspectRatioMode(VMR_ARMODE_NONE);
 725
 726                                         return hr;
 727                                 }
 728                         }
 729
 730                         EXECUTE_ASSERT(SUCCEEDED(RemoveFilter(pBF)));
 731
 732                         TRACE(_T("FGM: Connecting '%s' FAILED!\n"), pFGF->GetName());
 733                 }
 734         }
 735
 736         if(fDeadEnd)
 737         {
 738                 CAutoPtr<CStreamDeadEnd> psde(new CStreamDeadEnd());
 739                 psde->AddTailList(&m_streampath);
 740                 int skip = 0;
 741                 BeginEnumMediaTypes(pPinOut, pEM, pmt)
 742                 {
 743                         if(pmt->majortype == MEDIATYPE_Stream && pmt->subtype == MEDIASUBTYPE_NULL) skip++;
 744                         psde->mts.AddTail(CMediaType(*pmt));
 745                 }
 746                 EndEnumMediaTypes(pmt)
 747                 if(skip < psde->mts.GetCount())
 748                         m_deadends.Add(psde);
 749         }
 750
 751         return pPinIn ? VFW_E_CANNOT_CONNECT : VFW_E_CANNOT_RENDER;
 752 }
 753
 754 STDMETHODIMP CFGManager::Render(IPin* pPinOut)
 755 {
 756         CAutoLock cAutoLock(this);
 757
 758         return RenderEx(pPinOut, 0, NULL);
 759 }
 760
 761 STDMETHODIMP CFGManager::RenderFile(LPCWSTR lpcwstrFileName, LPCWSTR lpcwstrPlayList)
 762 {
 763         CAutoLock cAutoLock(this);
 764
 765         m_streampath.RemoveAll();
 766         m_deadends.RemoveAll();
 767
 768         HRESULT hr;
 769
 770 /*
 771         CComPtr<IBaseFilter> pBF;
 772         if(FAILED(hr = AddSourceFilter(lpcwstrFile, lpcwstrFile, &pBF)))
 773                 return hr;
 774
 775         return ConnectFilter(pBF, NULL);
 776 */
 777
 778         CFGFilterList fl;
 779         if(FAILED(hr = EnumSourceFilters(lpcwstrFileName, fl)))
 780                 return hr;
 781
 782         CAutoPtrArray<CStreamDeadEnd> deadends;
 783
 784         hr = VFW_E_CANNOT_RENDER;
 785
 786         POSITION pos = fl.GetHeadPosition();
 787         while(pos)
 788         {
 789                 CComPtr<IBaseFilter> pBF;
 790
 791                 if(SUCCEEDED(hr = AddSourceFilter(fl.GetNext(pos), lpcwstrFileName, lpcwstrFileName, &pBF)))
 792                 {
 793                         m_streampath.RemoveAll();
 794                         m_deadends.RemoveAll();
 795
 796                         if(SUCCEEDED(hr = ConnectFilter(pBF, NULL)))
 797                                 return hr;
 798
 799                         NukeDownstream(pBF);
 800                         RemoveFilter(pBF);
 801
 802                         deadends.Append(m_deadends);
 803                 }
 804         }
 805
 806         m_deadends.Copy(deadends);
 807
 808         return hr;
 809 }
 810
 811 STDMETHODIMP CFGManager::AddSourceFilter(LPCWSTR lpcwstrFileName, LPCWSTR lpcwstrFilterName, IBaseFilter** ppFilter)
 812 {
 813         CAutoLock cAutoLock(this);
 814
 815         HRESULT hr;
 816
 817         CFGFilterList fl;
 818         if(FAILED(hr = EnumSourceFilters(lpcwstrFileName, fl)))
 819                 return hr;
 820
 821         POSITION pos = fl.GetHeadPosition();
 822         while(pos)
 823         {
 824                 if(SUCCEEDED(hr = AddSourceFilter(fl.GetNext(pos), lpcwstrFileName, lpcwstrFilterName, ppFilter)))
 825                         return hr;
 826         }
 827
 828         return VFW_E_CANNOT_LOAD_SOURCE_FILTER;
 829 }
 830
 831 STDMETHODIMP CFGManager::SetLogFile(DWORD_PTR hFile)
 832 {
 833         if(!m_pUnkInner) return E_UNEXPECTED;
 834
 835         CAutoLock cAutoLock(this);
 836
 837         return CComQIPtr<IFilterGraph2>(m_pUnkInner)->SetLogFile(hFile);
 838 }
 839
 840 STDMETHODIMP CFGManager::Abort()
 841 {
 842         if(!m_pUnkInner) return E_UNEXPECTED;
 843
 844         CAutoLock cAutoLock(this);
 845
 846         return CComQIPtr<IFilterGraph2>(m_pUnkInner)->Abort();
 847 }
 848
 849 STDMETHODIMP CFGManager::ShouldOperationContinue()
 850 {
 851         if(!m_pUnkInner) return E_UNEXPECTED;
 852
 853         CAutoLock cAutoLock(this);
 854
 855         return CComQIPtr<IFilterGraph2>(m_pUnkInner)->ShouldOperationContinue();
 856 }
 857
 858 // IFilterGraph2
 859
 860 STDMETHODIMP CFGManager::AddSourceFilterForMoniker(IMoniker* pMoniker, IBindCtx* pCtx, LPCWSTR lpcwstrFilterName, IBaseFilter** ppFilter)
 861 {
 862         if(!m_pUnkInner) return E_UNEXPECTED;
 863
 864         CAutoLock cAutoLock(this);
 865
 866         return CComQIPtr<IFilterGraph2>(m_pUnkInner)->AddSourceFilterForMoniker(pMoniker, pCtx, lpcwstrFilterName, ppFilter);
 867 }
 868
 869 STDMETHODIMP CFGManager::ReconnectEx(IPin* ppin, const AM_MEDIA_TYPE* pmt)
 870 {
 871         if(!m_pUnkInner) return E_UNEXPECTED;
 872
 873         CAutoLock cAutoLock(this);
 874
 875         return CComQIPtr<IFilterGraph2>(m_pUnkInner)->ReconnectEx(ppin, pmt);
 876 }
 877
 878 STDMETHODIMP CFGManager::RenderEx(IPin* pPinOut, DWORD dwFlags, DWORD* pvContext)
 879 {
 880         CAutoLock cAutoLock(this);
 881
 882         m_streampath.RemoveAll();
 883         m_deadends.RemoveAll();
 884
 885         if(!pPinOut || dwFlags > AM_RENDEREX_RENDERTOEXISTINGRENDERERS || pvContext)
 886                 return E_INVALIDARG;
 887
 888         HRESULT hr;
 889
 890         if(dwFlags & AM_RENDEREX_RENDERTOEXISTINGRENDERERS)
 891         {
 892                 CInterfaceList<IBaseFilter> pBFs;
 893
 894                 BeginEnumFilters(this, pEF, pBF)
 895                 {
 896                         if(CComQIPtr<IAMFilterMiscFlags> pAMMF = pBF)
 897                         {
 898                                 if(pAMMF->GetMiscFlags() & AM_FILTER_MISC_FLAGS_IS_RENDERER)
 899                                 {
 900                                         pBFs.AddTail(pBF);
 901                                 }
 902                         }
 903                         else
 904                         {
 905                                 BeginEnumPins(pBF, pEP, pPin)
 906                                 {
 907                                         CComPtr<IPin> pPinIn;
 908                                         DWORD size = 1;
 909                                         if(SUCCEEDED(pPin->QueryInternalConnections(&pPinIn, &size)) && size == 0)
 910                                         {
 911                                                 pBFs.AddTail(pBF);
 912                                                 break;
 913                                         }
 914                                 }
 915                                 EndEnumPins
 916                         }
 917                 }
 918                 EndEnumFilters
 919
 920                 while(!pBFs.IsEmpty())
 921                 {
 922                         if(SUCCEEDED(hr = ConnectFilter(pPinOut, pBFs.RemoveHead())))
 923                                 return hr;
 924                 }
 925
 926                 return VFW_E_CANNOT_RENDER;
 927         }
 928
 929         return Connect(pPinOut, (IPin*)NULL);
 930 }
 931
 932 // IGraphBuilder2
 933
 934 STDMETHODIMP CFGManager::IsPinDirection(IPin* pPin, PIN_DIRECTION dir1)
 935 {
 936         CAutoLock cAutoLock(this);
 937
 938         CheckPointer(pPin, E_POINTER);
 939
 940         PIN_DIRECTION dir2;
 941         if(FAILED(pPin->QueryDirection(&dir2)))
 942                 return E_FAIL;
 943
 944         return dir1 == dir2 ? S_OK : S_FALSE;
 945 }
 946
 947 STDMETHODIMP CFGManager::IsPinConnected(IPin* pPin)
 948 {
 949         CAutoLock cAutoLock(this);
 950
 951         CheckPointer(pPin, E_POINTER);
 952
 953         CComPtr<IPin> pPinTo;
 954         return SUCCEEDED(pPin->ConnectedTo(&pPinTo)) && pPinTo ? S_OK : S_FALSE;
 955 }
 956
 957 STDMETHODIMP CFGManager::ConnectFilter(IBaseFilter* pBF, IPin* pPinIn)
 958 {
 959         CAutoLock cAutoLock(this);
 960
 961         CheckPointer(pBF, E_POINTER);
 962
 963         if(pPinIn && S_OK != IsPinDirection(pPinIn, PINDIR_INPUT))
 964                 return VFW_E_INVALID_DIRECTION;
 965
 966         int nTotal = 0, nRendered = 0;
 967
 968         BeginEnumPins(pBF, pEP, pPin)
 969         {
 970                 if(GetPinName(pPin)[0] != '~'
 971                 && S_OK == IsPinDirection(pPin, PINDIR_OUTPUT)
 972                 && S_OK != IsPinConnected(pPin))
 973                 {
 974                         m_streampath.Append(pBF, pPin);
 975
 976                         HRESULT hr = Connect(pPin, pPinIn);
 977
 978                         if(SUCCEEDED(hr))
 979                         {
 980                                 for(int i = m_deadends.GetCount()-1; i >= 0; i--)
 981                                         if(m_deadends[i]->Compare(m_streampath))
 982                                                 m_deadends.RemoveAt(i);
 983
 984                                 nRendered++;
 985                         }
 986
 987                         nTotal++;
 988
 989                         m_streampath.RemoveTail();
 990
 991                         if(SUCCEEDED(hr) && pPinIn)
 992                                 return S_OK;
 993                 }
 994         }
 995         EndEnumPins
 996
 997         return
 998                 nRendered == nTotal ? (nRendered > 0 ? S_OK : S_FALSE) :
 999                 nRendered > 0 ? VFW_S_PARTIAL_RENDER :
1000                 VFW_E_CANNOT_RENDER;
1001 }
1002
1003 STDMETHODIMP CFGManager::ConnectFilter(IPin* pPinOut, IBaseFilter* pBF)
1004 {
1005         CAutoLock cAutoLock(this);
1006
1007         CheckPointer(pPinOut, E_POINTER);
1008         CheckPointer(pBF, E_POINTER);
1009
1010         if(S_OK != IsPinDirection(pPinOut, PINDIR_OUTPUT))
1011                 return VFW_E_INVALID_DIRECTION;
1012
1013         HRESULT hr;
1014
1015         BeginEnumPins(pBF, pEP, pPin)
1016         {
1017                 if(GetPinName(pPin)[0] != '~'
1018                 && S_OK == IsPinDirection(pPin, PINDIR_INPUT)
1019                 && S_OK != IsPinConnected(pPin)
1020                 && SUCCEEDED(hr = Connect(pPinOut, pPin)))
1021                         return hr;
1022         }
1023         EndEnumPins
1024
1025         return VFW_E_CANNOT_CONNECT;
1026 }
1027
1028 STDMETHODIMP CFGManager::ConnectFilterDirect(IPin* pPinOut, IBaseFilter* pBF, const AM_MEDIA_TYPE* pmt)
1029 {
1030         CAutoLock cAutoLock(this);
1031
1032         CheckPointer(pPinOut, E_POINTER);
1033         CheckPointer(pBF, E_POINTER);
1034
1035         if(S_OK != IsPinDirection(pPinOut, PINDIR_OUTPUT))
1036                 return VFW_E_INVALID_DIRECTION;
1037
1038         HRESULT hr;
1039
1040         BeginEnumPins(pBF, pEP, pPin)
1041         {
1042                 if(GetPinName(pPin)[0] != '~'
1043                 && S_OK == IsPinDirection(pPin, PINDIR_INPUT)
1044                 && S_OK != IsPinConnected(pPin)
1045                 && SUCCEEDED(hr = ConnectDirect(pPinOut, pPin, pmt)))
1046                         return hr;
1047         }
1048         EndEnumPins
1049
1050         return VFW_E_CANNOT_CONNECT;
1051 }
1052
1053 STDMETHODIMP CFGManager::NukeDownstream(IUnknown* pUnk)
1054 {
1055         CAutoLock cAutoLock(this);
1056
1057         if(CComQIPtr<IBaseFilter> pBF = pUnk)
1058         {
1059                 BeginEnumPins(pBF, pEP, pPin)
1060                 {
1061                         NukeDownstream(pPin);
1062                 }
1063                 EndEnumPins
1064         }
1065         else if(CComQIPtr<IPin> pPin = pUnk)
1066         {
1067                 CComPtr<IPin> pPinTo;
1068                 if(S_OK == IsPinDirection(pPin, PINDIR_OUTPUT)
1069                 && SUCCEEDED(pPin->ConnectedTo(&pPinTo)) && pPinTo)
1070                 {
1071                         if(CComPtr<IBaseFilter> pBF = GetFilterFromPin(pPinTo))
1072                         {
1073                                 NukeDownstream(pBF);
1074                                 Disconnect(pPinTo);
1075                                 Disconnect(pPin);
1076                                 RemoveFilter(pBF);
1077                         }
1078                 }
1079         }
1080         else
1081         {
1082                 return E_INVALIDARG;
1083         }
1084
1085         return S_OK;
1086 }
1087
1088 STDMETHODIMP CFGManager::FindInterface(REFIID iid, void** ppv, BOOL bRemove)
1089 {
1090         CAutoLock cAutoLock(this);
1091
1092         CheckPointer(ppv, E_POINTER);
1093
1094         for(POSITION pos = m_pUnks.GetHeadPosition(); pos; m_pUnks.GetNext(pos))
1095         {
1096                 if(SUCCEEDED(m_pUnks.GetAt(pos)->QueryInterface(iid, ppv)))
1097                 {
1098                         if(bRemove) m_pUnks.RemoveAt(pos);
1099                         return S_OK;
1100                 }
1101         }
1102
1103         return E_NOINTERFACE;
1104 }
1105
1106 STDMETHODIMP CFGManager::AddToROT()
1107 {
1108         CAutoLock cAutoLock(this);
1109
1110     HRESULT hr;
1111
1112         if(m_dwRegister) return S_FALSE;
1113
1114     CComPtr<IRunningObjectTable> pROT;
1115         CComPtr<IMoniker> pMoniker;
1116         WCHAR wsz[256];
1117     swprintf(wsz, L"FilterGraph %08p pid %08x (MPC)", (DWORD_PTR)this, GetCurrentProcessId());
1118     if(SUCCEEDED(hr = GetRunningObjectTable(0, &pROT))
1119         && SUCCEEDED(hr = CreateItemMoniker(L"!", wsz, &pMoniker)))
1120         hr = pROT->Register(ROTFLAGS_REGISTRATIONKEEPSALIVE, (IGraphBuilder2*)this, pMoniker, &m_dwRegister);
1121
1122         return hr;
1123 }
1124
1125 STDMETHODIMP CFGManager::RemoveFromROT()
1126 {
1127         CAutoLock cAutoLock(this);
1128
1129         HRESULT hr;
1130
1131         if(!m_dwRegister) return S_FALSE;
1132
1133         CComPtr<IRunningObjectTable> pROT;
1134     if(SUCCEEDED(hr = GetRunningObjectTable(0, &pROT))
1135         && SUCCEEDED(hr = pROT->Revoke(m_dwRegister)))
1136                 m_dwRegister = 0;
1137
1138         return hr;
1139 }
1140
1141 // IGraphBuilderDeadEnd
1142
1143 STDMETHODIMP_(size_t) CFGManager::GetCount()
1144 {
1145         CAutoLock cAutoLock(this);
1146
1147         return m_deadends.GetCount();
1148 }
1149
1150 STDMETHODIMP CFGManager::GetDeadEnd(int iIndex, CAtlList<CStringW>& path, CAtlList<CMediaType>& mts)
1151 {
1152         CAutoLock cAutoLock(this);
1153
1154         if(iIndex < 0 || iIndex >= m_deadends.GetCount()) return E_FAIL;
1155
1156         path.RemoveAll();
1157         mts.RemoveAll();
1158
1159         POSITION pos = m_deadends[iIndex]->GetHeadPosition();
1160         while(pos)
1161         {
1162                 const path_t& p = m_deadends[iIndex]->GetNext(pos);
1163
1164                 CStringW str;
1165                 str.Format(L"%s::%s", p.filter, p.pin);
1166                 path.AddTail(str);
1167         }
1168
1169         mts.AddTailList(&m_deadends[iIndex]->mts);
1170
1171         return S_OK;
1172 }
1173
1174 //
1175 //      CFGManagerCustom
1176 //
1177
1178 CFGManagerCustom::CFGManagerCustom(LPCTSTR pName, LPUNKNOWN pUnk, UINT src, UINT tra)
1179         : CFGManager(pName, pUnk)
1180 {
1181         AppSettings& s = AfxGetAppSettings();
1182
1183         CFGFilter* pFGF;
1184
1185         // Source filters
1186
1187         if(src & SRC_SHOUTCAST)
1188         {
1189                 pFGF = new CFGFilterInternal<CShoutcastSource>();
1190                 pFGF->m_protocols.AddTail(_T("http"));
1191                 m_source.AddTail(pFGF);
1192         }
1193
1194 #if (_MSC_VER < 1500)
1195         // if(src & SRC_UDP)
1196         {
1197                 pFGF = new CFGFilterInternal<CUDPReader>();
1198                 pFGF->m_protocols.AddTail(_T("udp"));
1199                 m_source.AddTail(pFGF);
1200         }
1201 #endif
1202
1203         if(src & SRC_AVI)
1204         {
1205                 pFGF = new CFGFilterInternal<CAviSourceFilter>();
1206                 pFGF->m_chkbytes.AddTail(_T("0,4,,52494646,8,4,,41564920"));
1207                 pFGF->m_chkbytes.AddTail(_T("0,4,,52494646,8,4,,41564958"));
1208                 m_source.AddTail(pFGF);
1209         }
1210
1211         if(src & SRC_MP4)
1212         {
1213                 pFGF = new CFGFilterInternal<CMP4SourceFilter>();
1214                 pFGF->m_chkbytes.AddTail(_T("4,4,,66747970")); // ftyp
1215                 pFGF->m_chkbytes.AddTail(_T("4,4,,6d6f6f76")); // moov
1216                 pFGF->m_chkbytes.AddTail(_T("4,4,,6d646174")); // mdat
1217                 pFGF->m_chkbytes.AddTail(_T("4,4,,736b6970")); // skip
1218                 pFGF->m_chkbytes.AddTail(_T("4,12,ffffffff00000000ffffffff,77696465027fe3706d646174")); // wide ? mdat
1219                 pFGF->m_chkbytes.AddTail(_T("3,3,,000001")); // raw mpeg4 video
1220                 pFGF->m_extensions.AddTail(_T(".mov"));
1221                 m_source.AddTail(pFGF);
1222         }
1223
1224         if(src & SRC_FLV)
1225         {
1226                 pFGF = new CFGFilterInternal<CFLVSourceFilter>();
1227                 pFGF->m_chkbytes.AddTail(_T("0,4,,464C5601")); // FLV (v1)
1228                 m_source.AddTail(pFGF);
1229         }
1230
1231         if(src & SRC_MATROSKA)
1232         {
1233                 pFGF = new CFGFilterInternal<CMatroskaSourceFilter>();
1234                 pFGF->m_chkbytes.AddTail(_T("0,4,,1A45DFA3"));
1235                 m_source.AddTail(pFGF);
1236         }
1237
1238         if(src & SRC_REALMEDIA)
1239         {
1240                 pFGF = new CFGFilterInternal<CRealMediaSourceFilter>();
1241                 pFGF->m_chkbytes.AddTail(_T("0,4,,2E524D46"));
1242                 m_source.AddTail(pFGF);
1243         }
1244
1245         if(src & SRC_DSM)
1246         {
1247                 pFGF = new CFGFilterInternal<CDSMSourceFilter>();
1248                 pFGF->m_chkbytes.AddTail(_T("0,4,,44534D53"));
1249                 m_source.AddTail(pFGF);
1250         }
1251
1252         if(src & SRC_FLIC)
1253         {
1254                 pFGF = new CFGFilterInternal<CFLICSource>();
1255                 pFGF->m_chkbytes.AddTail(_T("4,2,,11AF"));
1256                 pFGF->m_chkbytes.AddTail(_T("4,2,,12AF"));
1257                 pFGF->m_extensions.AddTail(_T(".fli"));
1258                 pFGF->m_extensions.AddTail(_T(".flc"));
1259                 m_source.AddTail(pFGF);
1260         }
1261
1262         if(src & SRC_CDDA)
1263         {
1264                 pFGF = new CFGFilterInternal<CCDDAReader>();
1265                 pFGF->m_extensions.AddTail(_T(".cda"));
1266                 m_source.AddTail(pFGF);
1267         }
1268
1269         if(src & SRC_CDXA)
1270         {
1271                 pFGF = new CFGFilterInternal<CCDXAReader>();
1272                 pFGF->m_chkbytes.AddTail(_T("0,4,,52494646,8,4,,43445841"));
1273                 m_source.AddTail(pFGF);
1274         }
1275
1276         if(src & SRC_VTS)
1277         {
1278                 pFGF = new CFGFilterInternal<CVTSReader>();
1279                 pFGF->m_chkbytes.AddTail(_T("0,12,,445644564944454F2D565453"));
1280                 m_source.AddTail(pFGF);
1281         }
1282
1283         __if_exists(CD2VSource)
1284         {
1285         if(src & SRC_D2V)
1286         {
1287                 pFGF = new CFGFilterInternal<CD2VSource>();
1288                 pFGF->m_chkbytes.AddTail(_T("0,18,,4456443241564950726F6A65637446696C65"));
1289                 pFGF->m_extensions.AddTail(_T(".d2v"));
1290                 m_source.AddTail(pFGF);
1291         }
1292         }
1293
1294         __if_exists(CRadGtSourceFilter)
1295         {
1296         if(src & SRC_RADGT)
1297         {
1298                 pFGF = new CFGFilterInternal<CRadGtSourceFilter>();
1299                 pFGF->m_chkbytes.AddTail(_T("0,3,,534D4B"));
1300                 pFGF->m_chkbytes.AddTail(_T("0,3,,42494B"));
1301                 pFGF->m_extensions.AddTail(_T(".smk"));
1302                 pFGF->m_extensions.AddTail(_T(".bik"));
1303                 m_source.AddTail(pFGF);
1304         }
1305         }
1306
1307         if(src & SRC_ROQ)
1308         {
1309                 pFGF = new CFGFilterInternal<CRoQSourceFilter>();
1310                 pFGF->m_chkbytes.AddTail(_T("0,8,,8410FFFFFFFF1E00"));
1311                 m_source.AddTail(pFGF);
1312         }
1313
1314         if(src & SRC_OGG)
1315         {
1316                 pFGF = new CFGFilterInternal<COggSourceFilter>();
1317                 pFGF->m_chkbytes.AddTail(_T("0,4,,4F676753"));
1318                 m_source.AddTail(pFGF);
1319         }
1320
1321         __if_exists(CNutSourceFilter)
1322         {
1323         if(src & SRC_NUT)
1324         {
1325                 pFGF = new CFGFilterInternal<CNutSourceFilter>();
1326                 pFGF->m_chkbytes.AddTail(_T("0,8,,F9526A624E55544D"));
1327                 m_source.AddTail(pFGF);
1328         }
1329         }
1330
1331         __if_exists(CDiracSourceFilter)
1332         {
1333         if(src & SRC_DIRAC)
1334         {
1335                 pFGF = new CFGFilterInternal<CDiracSourceFilter>();
1336                 pFGF->m_chkbytes.AddTail(_T("0,8,,4B572D4449524143"));
1337                 m_source.AddTail(pFGF);
1338         }
1339         }
1340
1341         if(src & SRC_MPEG)
1342         {
1343                 pFGF = new CFGFilterInternal<CMpegSourceFilter>();
1344                 pFGF->m_chkbytes.AddTail(_T("0,16,FFFFFFFFF100010001800001FFFFFFFF,000001BA2100010001800001000001BB"));
1345                 pFGF->m_chkbytes.AddTail(_T("0,5,FFFFFFFFC0,000001BA40"));
1346                 pFGF->m_chkbytes.AddTail(_T("0,1,,47,188,1,,47,376,1,,47"));
1347                 pFGF->m_chkbytes.AddTail(_T("4,1,,47,196,1,,47,388,1,,47"));
1348                 pFGF->m_chkbytes.AddTail(_T("0,4,,54467263,1660,1,,47"));
1349                 pFGF->m_chkbytes.AddTail(_T("0,8,fffffc00ffe00000,4156000055000000"));
1350                 m_source.AddTail(pFGF);
1351         }
1352
1353         if(src & SRC_DTSAC3)
1354         {
1355                 pFGF = new CFGFilterInternal<CDTSAC3Source>();
1356                 pFGF->m_chkbytes.AddTail(_T("0,4,,7FFE8001"));
1357                 pFGF->m_chkbytes.AddTail(_T("0,2,,0B77"));
1358                 pFGF->m_chkbytes.AddTail(_T("0,2,,770B"));
1359                 pFGF->m_extensions.AddTail(_T(".ac3"));
1360                 pFGF->m_extensions.AddTail(_T(".dts"));
1361                 m_source.AddTail(pFGF);
1362         }
1363
1364         if(src & SRC_MPA)
1365         {
1366                 pFGF = new CFGFilterInternal<CMpaSourceFilter>();
1367                 pFGF->m_chkbytes.AddTail(_T("0,2,FFE0,FFE0"));
1368                 pFGF->m_chkbytes.AddTail(_T("0,10,FFFFFF00000080808080,49443300000000000000"));
1369                 m_source.AddTail(pFGF);
1370         }
1371
1372         if(AfxGetAppSettings().fUseWMASFReader)
1373         {
1374                 pFGF = new CFGFilterRegistry(CLSID_WMAsfReader);
1375                 pFGF->m_chkbytes.AddTail(_T("0,4,,3026B275"));
1376                 pFGF->m_chkbytes.AddTail(_T("0,4,,D129E2D6"));
1377                 m_source.AddTail(pFGF);
1378         }
1379
1380         // Transform filters
1381
1382         pFGF = new CFGFilterInternal<CAVI2AC3Filter>(L"AVI<->AC3/DTS", MERIT64(0x00680000)+1);
1383         pFGF->AddType(MEDIATYPE_Audio, MEDIASUBTYPE_WAVE_DOLBY_AC3);
1384         pFGF->AddType(MEDIATYPE_Audio, MEDIASUBTYPE_WAVE_DTS);
1385         m_transform.AddTail(pFGF);
1386
1387         if(src & SRC_MATROSKA) {
1388                 pFGF = new CFGFilterInternal<CMatroskaSplitterFilter>(L"Matroska Splitter", MERIT64_ABOVE_DSHOW);
1389         } else {
1390                 pFGF = new CFGFilterInternal<CMatroskaSplitterFilter>(L"Matroska Splitter (low merit)", MERIT64_DO_USE);
1391         }
1392         pFGF->AddType(MEDIATYPE_Stream, MEDIASUBTYPE_Matroska);
1393         pFGF->AddType(MEDIATYPE_Stream, GUID_NULL);
1394         m_transform.AddTail(pFGF);
1395
1396         if(src & SRC_REALMEDIA) {
1397                 pFGF = new CFGFilterInternal<CRealMediaSplitterFilter>(L"RealMedia Splitter", MERIT64_ABOVE_DSHOW);
1398         } else {
1399                 pFGF = new CFGFilterInternal<CRealMediaSplitterFilter>(L"RealMedia Splitter (low merit)", MERIT64_DO_USE);
1400         }
1401         pFGF->AddType(MEDIATYPE_Stream, MEDIASUBTYPE_RealMedia);
1402         pFGF->AddType(MEDIATYPE_Stream, GUID_NULL);
1403         m_transform.AddTail(pFGF);
1404
1405         if(src & SRC_AVI)       {
1406                 pFGF = new CFGFilterInternal<CAviSplitterFilter>(L"Avi Splitter", MERIT64_ABOVE_DSHOW);
1407         } else {
1408                 pFGF = new CFGFilterInternal<CAviSplitterFilter>(L"Avi Splitter (low merit)", MERIT64_DO_USE);
1409         }
1410         pFGF->AddType(MEDIATYPE_Stream, MEDIASUBTYPE_Avi);
1411         pFGF->AddType(MEDIATYPE_Stream, GUID_NULL);
1412         m_transform.AddTail(pFGF);
1413
1414         __if_exists(CRadGtSplitterFilter)
1415         {
1416         if(src & SRC_RADGT)     {
1417                 pFGF = new CFGFilterInternal<CRadGtSplitterFilter>(L"RadGt Splitter", MERIT64_ABOVE_DSHOW);
1418         } else {
1419                 pFGF = new CFGFilterInternal<CRadGtSplitterFilter>(L"RadGt Splitter (low merit)", MERIT64_DO_USE);
1420         }
1421         pFGF->AddType(MEDIATYPE_Stream, MEDIASUBTYPE_Bink);
1422         pFGF->AddType(MEDIATYPE_Stream, MEDIASUBTYPE_Smacker);
1423         pFGF->AddType(MEDIATYPE_Stream, GUID_NULL);
1424         m_transform.AddTail(pFGF);
1425         }
1426
1427         if(src & SRC_ROQ)       {
1428                 pFGF = new CFGFilterInternal<CRoQSplitterFilter>(L"RoQ Splitter", MERIT64_ABOVE_DSHOW);
1429         } else {
1430                 pFGF = new CFGFilterInternal<CRoQSplitterFilter>(L"RoQ Splitter (low merit)", MERIT64_DO_USE);
1431         }
1432         pFGF->AddType(MEDIATYPE_Stream, MEDIASUBTYPE_RoQ);
1433         pFGF->AddType(MEDIATYPE_Stream, GUID_NULL);
1434         m_transform.AddTail(pFGF);
1435
1436         if(src & SRC_OGG)       {
1437                 pFGF = new CFGFilterInternal<COggSplitterFilter>(L"Ogg Splitter", MERIT64_ABOVE_DSHOW);
1438         } else {
1439                 pFGF = new CFGFilterInternal<COggSplitterFilter>(L"Ogg Splitter (low merit)", MERIT64_DO_USE);
1440         }
1441         pFGF->AddType(MEDIATYPE_Stream, MEDIASUBTYPE_Ogg);
1442         pFGF->AddType(MEDIATYPE_Stream, GUID_NULL);
1443         m_transform.AddTail(pFGF);
1444
1445         __if_exists(CNutSplitterFilter)
1446         {
1447         if(src & SRC_NUT)       {
1448                 pFGF = new CFGFilterInternal<CNutSplitterFilter>(L"Nut Splitter", MERIT64_ABOVE_DSHOW);
1449         } else {
1450                 pFGF = new CFGFilterInternal<CNutSplitterFilter>(L"Nut Splitter (low merit)", MERIT64_DO_USE);
1451         }
1452         pFGF->AddType(MEDIATYPE_Stream, MEDIASUBTYPE_Nut);
1453         pFGF->AddType(MEDIATYPE_Stream, GUID_NULL);
1454         m_transform.AddTail(pFGF);
1455         }
1456
1457         if(src & SRC_MPEG) {
1458                 pFGF = new CFGFilterInternal<CMpegSplitterFilter>(L"Mpeg Splitter", MERIT64_ABOVE_DSHOW);
1459         } else {
1460                 pFGF = new CFGFilterInternal<CMpegSplitterFilter>(L"Mpeg Splitter (low merit)", MERIT64_DO_USE);
1461         }
1462         pFGF->AddType(MEDIATYPE_Stream, MEDIASUBTYPE_MPEG1System);
1463         pFGF->AddType(MEDIATYPE_Stream, MEDIASUBTYPE_MPEG2_PROGRAM);
1464         pFGF->AddType(MEDIATYPE_Stream, MEDIASUBTYPE_MPEG2_TRANSPORT);
1465         pFGF->AddType(MEDIATYPE_Stream, MEDIASUBTYPE_MPEG2_PVA);
1466         pFGF->AddType(MEDIATYPE_Stream, GUID_NULL);
1467         m_transform.AddTail(pFGF);
1468
1469         __if_exists(CDiracSplitterFilter)
1470         {
1471         if(src & SRC_DIRAC)     {
1472                 pFGF = new CFGFilterInternal<CDiracSplitterFilter>(L"Dirac Splitter", MERIT64_ABOVE_DSHOW);
1473         } else {
1474                 pFGF = new CFGFilterInternal<CDiracSplitterFilter>(L"Dirac Splitter (low merit)", MERIT64_DO_USE);
1475         }
1476         pFGF->AddType(MEDIATYPE_Stream, MEDIASUBTYPE_Dirac);
1477         pFGF->AddType(MEDIATYPE_Stream, GUID_NULL);
1478         m_transform.AddTail(pFGF);
1479         }
1480
1481         if(src & SRC_MPA) {
1482                 pFGF = new CFGFilterInternal<CMpaSplitterFilter>(L"Mpa Splitter", MERIT64_ABOVE_DSHOW);
1483         } else {
1484                 pFGF = new CFGFilterInternal<CMpaSplitterFilter>(L"Mpa Splitter (low merit)", MERIT64_DO_USE);
1485         }
1486         pFGF->AddType(MEDIATYPE_Stream, MEDIASUBTYPE_MPEG1Audio);
1487         pFGF->AddType(MEDIATYPE_Stream, GUID_NULL);
1488         m_transform.AddTail(pFGF);
1489
1490         if(src & SRC_DSM) {
1491                 pFGF = new CFGFilterInternal<CDSMSplitterFilter>(L"DSM Splitter", MERIT64_ABOVE_DSHOW);
1492         } else {
1493                 pFGF = new CFGFilterInternal<CDSMSplitterFilter>(L"DSM Splitter (low merit)", MERIT64_DO_USE);
1494         }
1495         pFGF->AddType(MEDIATYPE_Stream, MEDIASUBTYPE_DirectShowMedia);
1496         pFGF->AddType(MEDIATYPE_Stream, GUID_NULL);
1497         m_transform.AddTail(pFGF);
1498
1499         if(src & SRC_MP4)       {
1500                 pFGF = new CFGFilterInternal<CMP4SplitterFilter>(L"MP4 Splitter", MERIT64_ABOVE_DSHOW);
1501         } else {
1502                 pFGF = new CFGFilterInternal<CMP4SplitterFilter>(L"MP4 Splitter (low merit)", MERIT64_DO_USE);
1503         }
1504         pFGF->AddType(MEDIATYPE_Stream, MEDIASUBTYPE_MP4);
1505         pFGF->AddType(MEDIATYPE_Stream, GUID_NULL);
1506         m_transform.AddTail(pFGF);
1507
1508         if(src & SRC_FLV) {
1509                 pFGF = new CFGFilterInternal<CFLVSplitterFilter>(L"FLV Splitter", MERIT64_ABOVE_DSHOW);
1510         } else {
1511                 pFGF = new CFGFilterInternal<CFLVSplitterFilter>(L"FLV Splitter (low merit)", MERIT64_DO_USE);
1512         }
1513         pFGF->AddType(MEDIATYPE_Stream, MEDIASUBTYPE_FLV);
1514         pFGF->AddType(MEDIATYPE_Stream, GUID_NULL);
1515         m_transform.AddTail(pFGF);
1516
1517         pFGF = new CFGFilterInternal<CMpeg2DecFilter>(
1518                 (tra & TRA_MPEG1) ? L"MPEG-1 Video Decoder" : L"MPEG-1 Video Decoder (low merit)",
1519                 (tra & TRA_MPEG1) ? MERIT64_ABOVE_DSHOW : MERIT64_DO_USE);
1520         pFGF->AddType(MEDIATYPE_Video, MEDIASUBTYPE_MPEG1Packet);
1521         pFGF->AddType(MEDIATYPE_Video, MEDIASUBTYPE_MPEG1Payload);
1522         m_transform.AddTail(pFGF);
1523
1524         pFGF = new CFGFilterInternal<CMpeg2DecFilter>(
1525                 (tra & TRA_MPEG2) ? L"MPEG-2 Video Decoder" : L"MPEG-2 Video Decoder (low merit)",
1526                 (tra & TRA_MPEG2) ? MERIT64_ABOVE_DSHOW : MERIT64_DO_USE);
1527         pFGF->AddType(MEDIATYPE_DVD_ENCRYPTED_PACK, MEDIASUBTYPE_MPEG2_VIDEO);
1528         pFGF->AddType(MEDIATYPE_MPEG2_PACK, MEDIASUBTYPE_MPEG2_VIDEO);
1529         pFGF->AddType(MEDIATYPE_MPEG2_PES, MEDIASUBTYPE_MPEG2_VIDEO);
1530         pFGF->AddType(MEDIATYPE_Video, MEDIASUBTYPE_MPEG2_VIDEO);
1531         m_transform.AddTail(pFGF);
1532
1533         pFGF = new CFGFilterInternal<CMpaDecFilter>(
1534                 (tra & TRA_MPA) ? L"MPEG-1 Audio Decoder" : L"MPEG-1 Audio Decoder (low merit)",
1535                 (tra & TRA_MPA) ? MERIT64_ABOVE_DSHOW : MERIT64_DO_USE);
1536         pFGF->AddType(MEDIATYPE_Audio, MEDIASUBTYPE_MP3);
1537         pFGF->AddType(MEDIATYPE_Audio, MEDIASUBTYPE_MPEG1AudioPayload);
1538         pFGF->AddType(MEDIATYPE_Audio, MEDIASUBTYPE_MPEG1Payload);
1539         pFGF->AddType(MEDIATYPE_Audio, MEDIASUBTYPE_MPEG1Packet);
1540         m_transform.AddTail(pFGF);
1541
1542         pFGF = new CFGFilterInternal<CMpaDecFilter>(
1543                 (tra & TRA_MPA) ? L"MPEG-2 Audio Decoder" : L"MPEG-2 Audio Decoder (low merit)",
1544                 (tra & TRA_MPA) ? MERIT64_ABOVE_DSHOW : MERIT64_DO_USE);
1545         pFGF->AddType(MEDIATYPE_DVD_ENCRYPTED_PACK, MEDIASUBTYPE_MPEG2_AUDIO);
1546         pFGF->AddType(MEDIATYPE_MPEG2_PACK, MEDIASUBTYPE_MPEG2_AUDIO);
1547         pFGF->AddType(MEDIATYPE_MPEG2_PES, MEDIASUBTYPE_MPEG2_AUDIO);
1548         pFGF->AddType(MEDIATYPE_Audio, MEDIASUBTYPE_MPEG2_AUDIO);
1549         m_transform.AddTail(pFGF);
1550
1551         pFGF = new CFGFilterInternal<CMpaDecFilter>(
1552                 (tra & TRA_LPCM) ? L"LPCM Audio Decoder" : L"LPCM Audio Decoder (low merit)",
1553                 (tra & TRA_LPCM) ? MERIT64_ABOVE_DSHOW : MERIT64_DO_USE);
1554         pFGF->AddType(MEDIATYPE_DVD_ENCRYPTED_PACK, MEDIASUBTYPE_DVD_LPCM_AUDIO);
1555         pFGF->AddType(MEDIATYPE_MPEG2_PACK, MEDIASUBTYPE_DVD_LPCM_AUDIO);
1556         pFGF->AddType(MEDIATYPE_MPEG2_PES, MEDIASUBTYPE_DVD_LPCM_AUDIO);
1557         pFGF->AddType(MEDIATYPE_Audio, MEDIASUBTYPE_DVD_LPCM_AUDIO);
1558         m_transform.AddTail(pFGF);
1559
1560         pFGF = new CFGFilterInternal<CMpaDecFilter>(
1561                 (tra & TRA_AC3) ? L"AC3 Audio Decoder" : L"AC3 Audio Decoder (low merit)",
1562                 (tra & TRA_AC3) ? MERIT64_ABOVE_DSHOW : MERIT64_DO_USE);
1563         pFGF->AddType(MEDIATYPE_DVD_ENCRYPTED_PACK, MEDIASUBTYPE_DOLBY_AC3);
1564         pFGF->AddType(MEDIATYPE_MPEG2_PACK, MEDIASUBTYPE_DOLBY_AC3);
1565         pFGF->AddType(MEDIATYPE_MPEG2_PES, MEDIASUBTYPE_DOLBY_AC3);
1566         pFGF->AddType(MEDIATYPE_Audio, MEDIASUBTYPE_DOLBY_AC3);
1567         pFGF->AddType(MEDIATYPE_Audio, MEDIASUBTYPE_WAVE_DOLBY_AC3);
1568         m_transform.AddTail(pFGF);
1569
1570         pFGF = new CFGFilterInternal<CMpaDecFilter>(
1571                 (tra & TRA_DTS) ? L"DTS Decoder" : L"DTS Decoder (low merit)",
1572                 (tra & TRA_DTS) ? MERIT64_ABOVE_DSHOW : MERIT64_DO_USE);
1573         pFGF->AddType(MEDIATYPE_DVD_ENCRYPTED_PACK, MEDIASUBTYPE_DTS);
1574         pFGF->AddType(MEDIATYPE_MPEG2_PACK, MEDIASUBTYPE_DTS);
1575         pFGF->AddType(MEDIATYPE_MPEG2_PES, MEDIASUBTYPE_DTS);
1576         pFGF->AddType(MEDIATYPE_Audio, MEDIASUBTYPE_DTS);
1577         pFGF->AddType(MEDIATYPE_Audio, MEDIASUBTYPE_WAVE_DTS);
1578         m_transform.AddTail(pFGF);
1579
1580         pFGF = new CFGFilterInternal<CMpaDecFilter>(
1581                 (tra & TRA_AAC) ? L"AAC Decoder" : L"AAC Decoder (low merit)",
1582                 (tra & TRA_AAC) ? MERIT64_ABOVE_DSHOW+1 : MERIT64_DO_USE);
1583         pFGF->AddType(MEDIATYPE_DVD_ENCRYPTED_PACK, MEDIASUBTYPE_AAC);
1584         pFGF->AddType(MEDIATYPE_MPEG2_PACK, MEDIASUBTYPE_AAC);
1585         pFGF->AddType(MEDIATYPE_MPEG2_PES, MEDIASUBTYPE_AAC);
1586         pFGF->AddType(MEDIATYPE_Audio, MEDIASUBTYPE_AAC);
1587         pFGF->AddType(MEDIATYPE_DVD_ENCRYPTED_PACK, MEDIASUBTYPE_MP4A);
1588         pFGF->AddType(MEDIATYPE_MPEG2_PACK, MEDIASUBTYPE_MP4A);
1589         pFGF->AddType(MEDIATYPE_MPEG2_PES, MEDIASUBTYPE_MP4A);
1590         pFGF->AddType(MEDIATYPE_Audio, MEDIASUBTYPE_MP4A);
1591         pFGF->AddType(MEDIATYPE_DVD_ENCRYPTED_PACK, MEDIASUBTYPE_mp4a);
1592         pFGF->AddType(MEDIATYPE_MPEG2_PACK, MEDIASUBTYPE_mp4a);
1593         pFGF->AddType(MEDIATYPE_MPEG2_PES, MEDIASUBTYPE_mp4a);
1594         pFGF->AddType(MEDIATYPE_Audio, MEDIASUBTYPE_mp4a);
1595         m_transform.AddTail(pFGF);
1596
1597         pFGF = new CFGFilterInternal<CMpaDecFilter>(
1598                 (tra & TRA_PS2AUD) ? L"PS2 Audio Decoder" : L"PS2 Audio Decoder (low merit)",
1599                 (tra & TRA_PS2AUD) ? MERIT64_ABOVE_DSHOW : MERIT64_DO_USE);
1600         pFGF->AddType(MEDIATYPE_DVD_ENCRYPTED_PACK, MEDIASUBTYPE_PS2_PCM);
1601         pFGF->AddType(MEDIATYPE_MPEG2_PACK, MEDIASUBTYPE_PS2_PCM);
1602         pFGF->AddType(MEDIATYPE_MPEG2_PES, MEDIASUBTYPE_PS2_PCM);
1603         pFGF->AddType(MEDIATYPE_Audio, MEDIASUBTYPE_PS2_PCM);
1604         m_transform.AddTail(pFGF);
1605
1606         pFGF = new CFGFilterInternal<CRealVideoDecoder>(
1607                 (tra & TRA_RV) ? L"RealVideo Decoder" : L"RealVideo Decoder (low merit)",
1608                 (tra & TRA_RV) ? MERIT64_ABOVE_DSHOW : MERIT64_DO_USE);
1609         pFGF->AddType(MEDIATYPE_Video, MEDIASUBTYPE_RV10);
1610         pFGF->AddType(MEDIATYPE_Video, MEDIASUBTYPE_RV20);
1611         pFGF->AddType(MEDIATYPE_Video, MEDIASUBTYPE_RV30);
1612         pFGF->AddType(MEDIATYPE_Video, MEDIASUBTYPE_RV40);
1613         m_transform.AddTail(pFGF);
1614
1615         pFGF = new CFGFilterInternal<CRealAudioDecoder>(
1616                 (tra & TRA_RA) ? L"RealAudio Decoder" : L"RealAudio Decoder (low merit)",
1617                 (tra & TRA_RA) ? MERIT64_ABOVE_DSHOW : MERIT64_DO_USE);
1618         pFGF->AddType(MEDIATYPE_Audio, MEDIASUBTYPE_14_4);
1619         pFGF->AddType(MEDIATYPE_Audio, MEDIASUBTYPE_28_8);
1620         pFGF->AddType(MEDIATYPE_Audio, MEDIASUBTYPE_ATRC);
1621         pFGF->AddType(MEDIATYPE_Audio, MEDIASUBTYPE_COOK);
1622         pFGF->AddType(MEDIATYPE_Audio, MEDIASUBTYPE_DNET);
1623         pFGF->AddType(MEDIATYPE_Audio, MEDIASUBTYPE_SIPR);
1624         pFGF->AddType(MEDIATYPE_Audio, MEDIASUBTYPE_RAAC);
1625         m_transform.AddTail(pFGF);
1626
1627         pFGF = new CFGFilterInternal<CMpaDecFilter>(
1628                 (tra & TRA_VORBIS) ? L"Vorbis Audio Decoder" : L"Vorbis Audio Decoder (low merit)",
1629                 (tra & TRA_VORBIS) ? MERIT64_ABOVE_DSHOW : MERIT64_DO_USE);
1630         pFGF->AddType(MEDIATYPE_Audio, MEDIASUBTYPE_Vorbis2);
1631         m_transform.AddTail(pFGF);
1632
1633         pFGF = new CFGFilterInternal<CRoQVideoDecoder>(
1634                 (tra & TRA_RV) ? L"RoQ Video Decoder" : L"RoQ Video Decoder (low merit)",
1635                 (tra & TRA_RV) ? MERIT64_ABOVE_DSHOW : MERIT64_DO_USE);
1636         pFGF->AddType(MEDIATYPE_Video, MEDIASUBTYPE_RoQV);
1637         m_transform.AddTail(pFGF);
1638
1639         pFGF = new CFGFilterInternal<CRoQAudioDecoder>(
1640                 (tra & TRA_RA) ? L"RoQ Audio Decoder" : L"RoQ Audio Decoder (low merit)",
1641                 (tra & TRA_RA) ? MERIT64_ABOVE_DSHOW : MERIT64_DO_USE);
1642         pFGF->AddType(MEDIATYPE_Audio, MEDIASUBTYPE_RoQA);
1643         m_transform.AddTail(pFGF);
1644
1645         __if_exists(CDiracVideoDecoder)
1646         {
1647         pFGF = new CFGFilterInternal<CDiracVideoDecoder>(
1648                 (tra & TRA_DIRAC) ? L"Dirac Video Decoder" : L"Dirac Video Decoder (low merit)",
1649                 (tra & TRA_DIRAC) ? MERIT64_ABOVE_DSHOW : MERIT64_DO_USE);
1650         pFGF->AddType(MEDIATYPE_Video, MEDIASUBTYPE_DiracVideo);
1651         m_transform.AddTail(pFGF);
1652         }
1653
1654         pFGF = new CFGFilterInternal<CNullTextRenderer>(L"NullTextRenderer", MERIT64_DO_USE);
1655         pFGF->AddType(MEDIATYPE_Text, MEDIASUBTYPE_NULL);
1656         pFGF->AddType(MEDIATYPE_ScriptCommand, MEDIASUBTYPE_NULL);
1657         pFGF->AddType(MEDIATYPE_Subtitle, MEDIASUBTYPE_NULL);
1658         pFGF->AddType(MEDIATYPE_Text, MEDIASUBTYPE_NULL);
1659         pFGF->AddType(MEDIATYPE_NULL, MEDIASUBTYPE_DVD_SUBPICTURE);
1660         pFGF->AddType(MEDIATYPE_NULL, MEDIASUBTYPE_CVD_SUBPICTURE);
1661         pFGF->AddType(MEDIATYPE_NULL, MEDIASUBTYPE_SVCD_SUBPICTURE);
1662         m_transform.AddTail(pFGF);
1663
1664         __if_exists(CFLVVideoDecoder)
1665         {
1666         pFGF = new CFGFilterInternal<CFLVVideoDecoder>(L"FLV4 Video Decoder (low merit)",MERIT64_DO_USE);
1667         pFGF->AddType(MEDIATYPE_Video, MEDIASUBTYPE_FLV4);
1668         m_transform.AddTail(pFGF);
1669         }
1670
1671         // Blocked filters
1672
1673         // "Subtitle Mixer" makes an access violation around the
1674         // 11-12th media type when enumerating them on its output.
1675         m_transform.AddTail(new CFGFilterRegistry(GUIDFromCString(_T("{00A95963-3BE5-48C0-AD9F-3356D67EA09D}")), MERIT64_DO_NOT_USE));
1676
1677         // ISCR suxx
1678         m_transform.AddTail(new CFGFilterRegistry(GUIDFromCString(_T("{48025243-2D39-11CE-875D-00608CB78066}")), MERIT64_DO_NOT_USE));
1679
1680         // Samsung's "mpeg-4 demultiplexor" can even open matroska files, amazing...
1681         m_transform.AddTail(new CFGFilterRegistry(GUIDFromCString(_T("{99EC0C72-4D1B-411B-AB1F-D561EE049D94}")), MERIT64_DO_NOT_USE));
1682
1683         // LG Video Renderer (lgvid.ax) just crashes when trying to connect it
1684         m_transform.AddTail(new CFGFilterRegistry(GUIDFromCString(_T("{9F711C60-0668-11D0-94D4-0000C02BA972}")), MERIT64_DO_NOT_USE));
1685
1686         // palm demuxer crashes (even crashes graphedit when dropping an .ac3 onto it)
1687         m_transform.AddTail(new CFGFilterRegistry(GUIDFromCString(_T("{BE2CF8A7-08CE-4A2C-9A25-FD726A999196}")), MERIT64_DO_NOT_USE));
1688
1689         // DCDSPFilter (early versions crash mpc)
1690         {
1691                 CRegKey key;
1692
1693                 TCHAR buff[256];
1694                 ULONG len = sizeof(buff);
1695                 memset(buff, 0, len);
1696
1697                 CString clsid = _T("{B38C58A0-1809-11D6-A458-EDAE78F1DF12}");
1698
1699                 if(ERROR_SUCCESS == key.Open(HKEY_CLASSES_ROOT, _T("CLSID\\") + clsid + _T("\\InprocServer32"), KEY_READ)
1700                 && ERROR_SUCCESS == key.QueryStringValue(NULL, buff, &len)
1701                 && GetFileVersion(buff) < 0x0001000000030000ui64)
1702                 {
1703                         m_transform.AddTail(new CFGFilterRegistry(GUIDFromCString(clsid), MERIT64_DO_NOT_USE));
1704                 }
1705         }
1706 /*
1707         // NVIDIA Transport Demux crashed for someone, I could not reproduce it
1708         m_transform.AddTail(new CFGFilterRegistry(GUIDFromCString(_T("{735823C1-ACC4-11D3-85AC-006008376FB8}")), MERIT64_DO_NOT_USE));
1709 */
1710         // mainconcept color space converter
1711         m_transform.AddTail(new CFGFilterRegistry(GUIDFromCString(_T("{272D77A0-A852-4851-ADA4-9091FEAD4C86}")), MERIT64_DO_NOT_USE));
1712
1713
1714         // Block VSFilter when internal subtitle renderer will get used
1715         if(s.fAutoloadSubtitles && s.fBlockVSFilter) {
1716                 if(s.iDSVideoRendererType == VIDRNDT_DS_VMR7RENDERLESS || s.iDSVideoRendererType == VIDRNDT_DS_VMR9RENDERLESS || s.iDSVideoRendererType == VIDRNDT_DS_DXR) {
1717                         m_transform.AddTail(new CFGFilterRegistry(GUIDFromCString(_T("{9852A670-F845-491B-9BE6-EBD841B8A613}")), MERIT64_DO_NOT_USE));
1718                 }
1719         }
1720
1721
1722         // Overrides
1723
1724         WORD merit_low = 1;
1725
1726         POSITION pos = s.filters.GetTailPosition();
1727         while(pos)
1728         {
1729                 FilterOverride* fo = s.filters.GetPrev(pos);
1730
1731                 if(fo->fDisabled || fo->type == FilterOverride::EXTERNAL && !CPath(MakeFullPath(fo->path)).FileExists())
1732                         continue;
1733
1734                 ULONGLONG merit =
1735                         fo->iLoadType == FilterOverride::PREFERRED ? MERIT64_ABOVE_DSHOW :
1736                         fo->iLoadType == FilterOverride::MERIT ? MERIT64(fo->dwMerit) :
1737                         MERIT64_DO_NOT_USE; // fo->iLoadType == FilterOverride::BLOCKED
1738
1739                 merit += merit_low++;
1740
1741                 CFGFilter* pFGF = NULL;
1742
1743                 if(fo->type == FilterOverride::REGISTERED)
1744                 {
1745                         pFGF = new CFGFilterRegistry(fo->dispname, merit);
1746                 }
1747                 else if(fo->type == FilterOverride::EXTERNAL)
1748                 {
1749                         pFGF = new CFGFilterFile(fo->clsid, fo->path, CStringW(fo->name), merit);
1750                 }
1751
1752                 if(pFGF)
1753                 {
1754                         pFGF->SetTypes(fo->guids);
1755                         m_override.AddTail(pFGF);
1756                 }
1757         }
1758 }
1759
1760 STDMETHODIMP CFGManagerCustom::AddFilter(IBaseFilter* pBF, LPCWSTR pName)
1761 {
1762         CAutoLock cAutoLock(this);
1763
1764         HRESULT hr;
1765
1766         if(FAILED(hr = __super::AddFilter(pBF, pName)))
1767                 return hr;
1768
1769         AppSettings& s = AfxGetAppSettings();
1770
1771         if(GetCLSID(pBF) == CLSID_DMOWrapperFilter)
1772         {
1773                 if(CComQIPtr<IPropertyBag> pPB = pBF)
1774                 {
1775                         CComVariant var(true);
1776                         pPB->Write(CComBSTR(L"_HIRESOUTPUT"), &var);
1777                 }
1778         }
1779
1780         if(CComQIPtr<IAudioSwitcherFilter> pASF = pBF)
1781         {
1782                 pASF->EnableDownSamplingTo441(s.fDownSampleTo441);
1783                 pASF->SetSpeakerConfig(s.fCustomChannelMapping, s.pSpeakerToChannelMap);
1784                 pASF->SetAudioTimeShift(s.fAudioTimeShift ? 10000i64*s.tAudioTimeShift : 0);
1785                 pASF->SetNormalizeBoost(s.fAudioNormalize, s.fAudioNormalizeRecover, s.AudioBoost);
1786         }
1787
1788         return hr;
1789 }
1790
1791 //
1792 //      CFGManagerPlayer
1793 //
1794
1795 CFGManagerPlayer::CFGManagerPlayer(LPCTSTR pName, LPUNKNOWN pUnk, UINT src, UINT tra, HWND hWnd)
1796         : CFGManagerCustom(pName, pUnk, src, tra)
1797         , m_hWnd(hWnd)
1798         , m_vrmerit(MERIT64(MERIT_PREFERRED))
1799         , m_armerit(MERIT64(MERIT_PREFERRED))
1800 {
1801         CFGFilter* pFGF;
1802
1803         AppSettings& s = AfxGetAppSettings();
1804
1805         if(m_pFM)
1806         {
1807                 CComPtr<IEnumMoniker> pEM;
1808
1809                 GUID guids[] = {MEDIATYPE_Video, MEDIASUBTYPE_NULL};
1810
1811                 if(SUCCEEDED(m_pFM->EnumMatchingFilters(&pEM, 0, FALSE, MERIT_DO_NOT_USE+1,
1812                         TRUE, 1, guids, NULL, NULL, TRUE, FALSE, 0, NULL, NULL, NULL)))
1813                 {
1814                         for(CComPtr<IMoniker> pMoniker; S_OK == pEM->Next(1, &pMoniker, NULL); pMoniker = NULL)
1815                         {
1816                                 CFGFilterRegistry f(pMoniker);
1817                                 m_vrmerit = max(m_vrmerit, f.GetMerit());
1818                         }
1819                 }
1820
1821                 m_vrmerit += 0x100;
1822         }
1823
1824         if(m_pFM)
1825         {
1826                 CComPtr<IEnumMoniker> pEM;
1827
1828                 GUID guids[] = {MEDIATYPE_Audio, MEDIASUBTYPE_NULL};
1829
1830                 if(SUCCEEDED(m_pFM->EnumMatchingFilters(&pEM, 0, FALSE, MERIT_DO_NOT_USE+1,
1831                         TRUE, 1, guids, NULL, NULL, TRUE, FALSE, 0, NULL, NULL, NULL)))
1832                 {
1833                         for(CComPtr<IMoniker> pMoniker; S_OK == pEM->Next(1, &pMoniker, NULL); pMoniker = NULL)
1834                         {
1835                                 CFGFilterRegistry f(pMoniker);
1836                                 m_armerit = max(m_armerit, f.GetMerit());
1837                         }
1838                 }
1839
1840                 BeginEnumSysDev(CLSID_AudioRendererCategory, pMoniker)
1841                 {
1842                         CFGFilterRegistry f(pMoniker);
1843                         m_armerit = max(m_armerit, f.GetMerit());
1844                 }
1845                 EndEnumSysDev
1846
1847                 m_armerit += 0x100;
1848         }
1849
1850         // Switchers
1851
1852         if(s.fEnableAudioSwitcher)
1853         {
1854                 pFGF = new CFGFilterInternal<CAudioSwitcherFilter>(L"Audio Switcher", m_armerit + 0x100);
1855                 pFGF->AddType(MEDIATYPE_Audio, MEDIASUBTYPE_NULL);
1856                 m_transform.AddTail(pFGF);
1857
1858                 // morgan stream switcher
1859                 m_transform.AddTail(new CFGFilterRegistry(GUIDFromCString(_T("{D3CD7858-971A-4838-ACEC-40CA5D529DC8}")), MERIT64_DO_NOT_USE));
1860         }
1861
1862         // Renderers
1863
1864         if(s.iDSVideoRendererType == VIDRNDT_DS_OLDRENDERER)
1865                 m_transform.AddTail(new CFGFilterRegistry(CLSID_VideoRenderer, m_vrmerit));
1866         else if(s.iDSVideoRendererType == VIDRNDT_DS_OVERLAYMIXER)
1867                 m_transform.AddTail(new CFGFilterVideoRenderer(m_hWnd, CLSID_OverlayMixer, L"Overlay Mixer", m_vrmerit));
1868         else if(s.iDSVideoRendererType == VIDRNDT_DS_VMR7WINDOWED)
1869                 m_transform.AddTail(new CFGFilterVideoRenderer(m_hWnd, CLSID_VideoMixingRenderer, L"Video Mixing Render 7 (Windowed)", m_vrmerit));
1870         else if(s.iDSVideoRendererType == VIDRNDT_DS_VMR9WINDOWED)
1871                 m_transform.AddTail(new CFGFilterVideoRenderer(m_hWnd, CLSID_VideoMixingRenderer9, L"Video Mixing Render 9 (Windowed)", m_vrmerit));
1872         else if(s.iDSVideoRendererType == VIDRNDT_DS_VMR7RENDERLESS)
1873                 m_transform.AddTail(new CFGFilterVideoRenderer(m_hWnd, CLSID_VMR7AllocatorPresenter, L"Video Mixing Render 7 (Renderless)", m_vrmerit));
1874         else if(s.iDSVideoRendererType == VIDRNDT_DS_VMR9RENDERLESS)
1875                 m_transform.AddTail(new CFGFilterVideoRenderer(m_hWnd, CLSID_VMR9AllocatorPresenter, L"Video Mixing Render 9 (Renderless)", m_vrmerit));
1876         else if(s.iDSVideoRendererType == VIDRNDT_DS_DXR)
1877                 m_transform.AddTail(new CFGFilterVideoRenderer(m_hWnd, CLSID_DXRAllocatorPresenter, L"Haali's Video Renderer", m_vrmerit));
1878         else if(s.iDSVideoRendererType == VIDRNDT_DS_NULL_COMP)
1879         {
1880                 pFGF = new CFGFilterInternal<CNullVideoRenderer>(L"Null Video Renderer (Any)", MERIT64_ABOVE_DSHOW+2);
1881                 pFGF->AddType(MEDIATYPE_Video, MEDIASUBTYPE_NULL);
1882                 m_transform.AddTail(pFGF);
1883         }
1884         else if(s.iDSVideoRendererType == VIDRNDT_DS_NULL_UNCOMP)
1885         {
1886                 pFGF = new CFGFilterInternal<CNullUVideoRenderer>(L"Null Video Renderer (Uncompressed)", MERIT64_ABOVE_DSHOW+2);
1887                 pFGF->AddType(MEDIATYPE_Video, MEDIASUBTYPE_NULL);
1888                 m_transform.AddTail(pFGF);
1889         }
1890
1891         if(s.AudioRendererDisplayName == AUDRNDT_NULL_COMP)
1892         {
1893                 pFGF = new CFGFilterInternal<CNullAudioRenderer>(AUDRNDT_NULL_COMP, MERIT64_ABOVE_DSHOW+2);
1894                 pFGF->AddType(MEDIATYPE_Audio, MEDIASUBTYPE_NULL);
1895                 m_transform.AddTail(pFGF);
1896         }
1897         else if(s.AudioRendererDisplayName == AUDRNDT_NULL_UNCOMP)
1898         {
1899                 pFGF = new CFGFilterInternal<CNullUAudioRenderer>(AUDRNDT_NULL_UNCOMP, MERIT64_ABOVE_DSHOW+2);
1900                 pFGF->AddType(MEDIATYPE_Audio, MEDIASUBTYPE_NULL);
1901                 m_transform.AddTail(pFGF);
1902         }
1903         else if(!s.AudioRendererDisplayName.IsEmpty())
1904         {
1905                 pFGF = new CFGFilterRegistry(s.AudioRendererDisplayName, m_armerit);
1906                 pFGF->AddType(MEDIATYPE_Audio, MEDIASUBTYPE_NULL);
1907                 m_transform.AddTail(pFGF);
1908         }
1909 }
1910
1911 STDMETHODIMP CFGManagerPlayer::ConnectDirect(IPin* pPinOut, IPin* pPinIn, const AM_MEDIA_TYPE* pmt)
1912 {
1913         CAutoLock cAutoLock(this);
1914
1915         if(GetCLSID(pPinOut) == CLSID_MPEG2Demultiplexer)
1916         {
1917                 CComQIPtr<IMediaSeeking> pMS = pPinOut;
1918                 REFERENCE_TIME rtDur = 0;
1919                 if(!pMS || FAILED(pMS->GetDuration(&rtDur)) || rtDur <= 0)
1920                          return E_FAIL;
1921         }
1922
1923         return __super::ConnectDirect(pPinOut, pPinIn, pmt);
1924 }
1925
1926 //
1927 // CFGManagerDVD
1928 //
1929
1930 CFGManagerDVD::CFGManagerDVD(LPCTSTR pName, LPUNKNOWN pUnk, UINT src, UINT tra, HWND hWnd)
1931         : CFGManagerPlayer(pName, pUnk, src, tra, hWnd)
1932 {
1933         AppSettings& s = AfxGetAppSettings();
1934
1935         // have to avoid the old video renderer
1936         if(!s.fXpOrBetter && s.iDSVideoRendererType != VIDRNDT_DS_OVERLAYMIXER || s.iDSVideoRendererType == VIDRNDT_DS_OLDRENDERER)
1937                 m_transform.AddTail(new CFGFilterVideoRenderer(m_hWnd, CLSID_OverlayMixer, L"Overlay Mixer", m_vrmerit-1));
1938
1939         // elecard's decoder isn't suited for dvd playback (atm)
1940         m_transform.AddTail(new CFGFilterRegistry(GUIDFromCString(_T("{F50B3F13-19C4-11CF-AA9A-02608C9BABA2}")), MERIT64_DO_NOT_USE));
1941 }
1942
1943 #include "..\..\decss\VobFile.h"
1944
1945 class CResetDVD : public CDVDSession
1946 {
1947 public:
1948         CResetDVD(LPCTSTR path)
1949         {
1950                 if(Open(path))
1951                 {
1952                         if(BeginSession()) {Authenticate(); /*GetDiscKey();*/ EndSession();}
1953                         Close();
1954                 }
1955         }
1956 };
1957
1958 STDMETHODIMP CFGManagerDVD::RenderFile(LPCWSTR lpcwstrFile, LPCWSTR lpcwstrPlayList)
1959 {
1960         CAutoLock cAutoLock(this);
1961
1962         HRESULT hr;
1963
1964         CComPtr<IBaseFilter> pBF;
1965         if(FAILED(hr = AddSourceFilter(lpcwstrFile, lpcwstrFile, &pBF)))
1966                 return hr;
1967
1968         return ConnectFilter(pBF, NULL);
1969 }
1970
1971 STDMETHODIMP CFGManagerDVD::AddSourceFilter(LPCWSTR lpcwstrFileName, LPCWSTR lpcwstrFilterName, IBaseFilter** ppFilter)
1972 {
1973         CAutoLock cAutoLock(this);
1974
1975         CheckPointer(lpcwstrFileName, E_POINTER);
1976         CheckPointer(ppFilter, E_POINTER);
1977
1978         HRESULT hr;
1979
1980         CStringW fn = CStringW(lpcwstrFileName).TrimLeft();
1981         CStringW protocol = fn.Left(fn.Find(':')+1).TrimRight(':').MakeLower();
1982         CStringW ext = CPathW(fn).GetExtension().MakeLower();
1983
1984         GUID clsid = ext == L".ratdvd" ? GUIDFromCString(_T("{482d10b6-376e-4411-8a17-833800A065DB}")) : CLSID_DVDNavigator;
1985
1986         CComPtr<IBaseFilter> pBF;
1987         if(FAILED(hr = pBF.CoCreateInstance(clsid))
1988         || FAILED(hr = AddFilter(pBF, L"DVD Navigator")))
1989                 return VFW_E_CANNOT_LOAD_SOURCE_FILTER;
1990
1991         CComQIPtr<IDvdControl2> pDVDC;
1992         CComQIPtr<IDvdInfo2> pDVDI;
1993
1994         if(!((pDVDC = pBF) && (pDVDI = pBF)))
1995                 return E_NOINTERFACE;
1996
1997         WCHAR buff[MAX_PATH];
1998         ULONG len;
1999         if((!fn.IsEmpty()
2000         && FAILED(hr = pDVDC->SetDVDDirectory(fn))
2001         && FAILED(hr = pDVDC->SetDVDDirectory(fn + L"VIDEO_TS"))
2002         && FAILED(hr = pDVDC->SetDVDDirectory(fn + L"\\VIDEO_TS")))
2003         || FAILED(hr = pDVDI->GetDVDDirectory(buff, countof(buff), &len)) || len == 0)
2004                 return E_INVALIDARG;
2005
2006         pDVDC->SetOption(DVD_ResetOnStop, FALSE);
2007         pDVDC->SetOption(DVD_HMSF_TimeCodeEvents, TRUE);
2008
2009         if(clsid == CLSID_DVDNavigator)
2010                 CResetDVD(CString(buff));
2011
2012         *ppFilter = pBF.Detach();
2013
2014         return S_OK;
2015 }
2016
2017 //
2018 // CFGManagerCapture
2019 //
2020
2021 CFGManagerCapture::CFGManagerCapture(LPCTSTR pName, LPUNKNOWN pUnk, UINT src, UINT tra, HWND hWnd)
2022         : CFGManagerPlayer(pName, pUnk, src, tra, hWnd)
2023 {
2024         AppSettings& s = AfxGetAppSettings();
2025
2026         CFGFilter* pFGF = new CFGFilterInternal<CDeinterlacerFilter>(L"Deinterlacer", m_vrmerit + 0x100);
2027         pFGF->AddType(MEDIATYPE_Video, MEDIASUBTYPE_NULL);
2028         m_transform.AddTail(pFGF);
2029
2030         // morgan stream switcher
2031         m_transform.AddTail(new CFGFilterRegistry(GUIDFromCString(_T("{D3CD7858-971A-4838-ACEC-40CA5D529DC8}")), MERIT64_DO_NOT_USE));
2032 }
2033
2034 //
2035 // CFGManagerMuxer
2036 //
2037
2038 CFGManagerMuxer::CFGManagerMuxer(LPCTSTR pName, LPUNKNOWN pUnk)
2039         : CFGManagerCustom(pName, pUnk, ~0, ~0)
2040 {
2041         m_source.AddTail(new CFGFilterInternal<CSubtitleSourceASS>());
2042         m_source.AddTail(new CFGFilterInternal<CSSFSourceFilter>());
2043 }
2044
2045 //
2046 // CFGAggregator
2047 //
2048
2049 CFGAggregator::CFGAggregator(const CLSID& clsid, LPCTSTR pName, LPUNKNOWN pUnk, HRESULT& hr)
2050         : CUnknown(pName, pUnk)
2051 {
2052         hr = m_pUnkInner.CoCreateInstance(clsid, GetOwner());
2053 }
2054
2055 CFGAggregator::~CFGAggregator()
2056 {
2057         m_pUnkInner.Release();
2058 }
2059
2060 STDMETHODIMP CFGAggregator::NonDelegatingQueryInterface(REFIID riid, void** ppv)
2061 {
2062     CheckPointer(ppv, E_POINTER);
2063
2064         return
2065                 m_pUnkInner && (riid != IID_IUnknown && SUCCEEDED(m_pUnkInner->QueryInterface(riid, ppv))) ? S_OK :
2066                 __super::NonDelegatingQueryInterface(riid, ppv);
2067 }