开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
GraphBuilder.cpp
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：60k
源码类别：

多媒体编程

开发平台：

Visual C++

GraphBuilder.cpp：源码内容
  1. /* 
  2.  * Copyright (C) 2003-2005 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.  */
  22. #include "stdafx.h"
  23. #include "mplayerc.h"
  24. #include "GraphBuilder.h"
  25. #include "....DSUtilDSUtil.h"
  26. #include "....filtersfilters.h"
  27. #include "......includemoreuuids.h"
  28. #include "......includeOggOggDS.h"
  29. #include "......includematroskamatroska.h"
  30. #include "DX7AllocatorPresenter.h"
  31. #include "DX9AllocatorPresenter.h"
  32. #include "DeinterlacerFilter.h"
  34. #include <initguid.h>
  35. #include <dmodshow.h>
  37. #include <D3d9.h>
  38. #include <Vmr9.h>
  40. static void CheckStupidSharedFilesourceFilter()
  41. {
  42. CRegKey key;
  43. CString str(_T("CLSID\{E436EBB5-524F-11CE-9F53-0020AF0BA770}\InprocServer32"));
  45. if(ERROR_SUCCESS == key.Open(HKEY_CLASSES_ROOT, str, KEY_READ))
  46. {
  47. ULONG nChars = 0;
  48. if(ERROR_SUCCESS == key.QueryStringValue(NULL, NULL, &nChars))
  49. {
  50. CString dll;
  51. if(ERROR_SUCCESS == key.QueryStringValue(NULL, dll.GetBuffer(nChars), &nChars))
  52. {
  53. dll.ReleaseBuffer(nChars);
  54. dll.MakeLower();
  55. if(dll.Find(_T("shared_filesource.ax")) >= 0
  56. || dll.Find(_T("shared~1.ax")) >= 0)
  57. {
  58. if(IDYES == AfxMessageBox(
  59. _T("Warning: MPC has detected that DirectShow's "File Source (async)" filtern")
  60. _T("was replaced by shared_filesource.ax. Please run "regsvr32.exe quartz.dll"n")
  61. _T("in your system folder to restore it. If you are a user with administratorn")
  62. _T("rights, MPC can also do this for you. Do you want to re-register quartz.dll now?"), 
  63. MB_YESNO|MB_ICONEXCLAMATION))
  64. {
  65. TCHAR buff[MAX_PATH+1];
  66. GetSystemDirectory(buff, sizeof(buff));
  68. CString path = CString(buff) + _T("\quartz.dll");
  70. HRESULT hr = E_FAIL;
  72. if(HMODULE hModule = LoadLibrary(path))
  73. {
  74. typedef HRESULT (__stdcall * PDllRegisterServer)();
  75. if(PDllRegisterServer p = (PDllRegisterServer)GetProcAddress(hModule, "DllRegisterServer"))
  76. hr = p();
  77. }
  79. if(SUCCEEDED(hr))
  80. AfxMessageBox(_T("Successfully re-registered quartz.dll, you may need to restart the player now."), MB_OK);
  81. else
  82. AfxMessageBox(_T("Failed to re-register quartz.dll!"), MB_OK|MB_ICONEXCLAMATION);
  83. }
  84. }
  85. }
  86. }
  87. }
  88. }
  90. //
  91. // CGraphBuilder
  92. //
  94. CGraphBuilder::CGraphBuilder(IGraphBuilder* pGB, HWND hWnd)
  95. : m_pGB(pGB), m_hWnd(hWnd)
  96. , m_nTotalStreams(0)
  97. , m_nCurrentStream(0)
  98. , m_VRMerit(LMERIT(MERIT_PREFERRED+1)+0x100)
  99. , m_ARMerit(LMERIT(MERIT_PREFERRED+1)+0x100)
  100. {
  101. AppSettings& s = AfxGetAppSettings();
  103. m_pFM.CoCreateInstance(CLSID_FilterMapper2);
  104. if(!m_pFM) return;
  106. {
  107. CArray<GUID> guids;
  108. CComPtr<IEnumMoniker> pEM;
  110. m_VRMerit = LMERIT(MERIT_PREFERRED);
  112. guids.Add(MEDIATYPE_Video);
  113. guids.Add(MEDIASUBTYPE_NULL);
  114. if(guids.GetCount() > 0
  115. && SUCCEEDED(m_pFM->EnumMatchingFilters(
  116. &pEM, 0, FALSE, MERIT_DO_NOT_USE+1,
  117. TRUE, guids.GetCount()/2, guids.GetData(), NULL, NULL, TRUE,
  118. FALSE, 0, NULL, NULL, NULL)))
  119. {
  120. for(CComPtr<IMoniker> pMoniker; S_OK == pEM->Next(1, &pMoniker, NULL); pMoniker = NULL)
  121. {
  122. CGraphRegFilter gf(pMoniker);
  123. m_VRMerit = max(m_VRMerit, gf.GetMerit());
  124. }
  125. }
  126. guids.RemoveAll();
  127. pEM = NULL;
  129. m_VRMerit += 0x100;
  131. m_ARMerit = LMERIT(MERIT_PREFERRED);
  133. guids.Add(MEDIATYPE_Audio);
  134. guids.Add(MEDIASUBTYPE_NULL);
  135. if(guids.GetCount() > 0
  136. && SUCCEEDED(m_pFM->EnumMatchingFilters(
  137. &pEM, 0, FALSE, MERIT_DO_NOT_USE+1,
  138. TRUE, guids.GetCount()/2, guids.GetData(), NULL, NULL, TRUE,
  139. FALSE, 0, NULL, NULL, NULL)))
  140. {
  141. for(CComPtr<IMoniker> pMoniker; S_OK == pEM->Next(1, &pMoniker, NULL); pMoniker = NULL)
  142. {
  143. CGraphRegFilter gf(pMoniker);
  144. m_ARMerit = max(m_ARMerit, gf.GetMerit());
  145. }
  146. }
  148. BeginEnumSysDev(CLSID_AudioRendererCategory, pMoniker)
  149. {
  150. CGraphRegFilter gf(pMoniker);
  151. m_ARMerit = max(m_ARMerit, gf.GetMerit());
  152. }
  153. EndEnumSysDev
  155. guids.RemoveAll();
  156. pEM = NULL;
  158. m_ARMerit += 0x100;
  159. }
  161. // transform filters
  163. CList<GUID> guids;
  165. guids.AddTail(MEDIATYPE_Audio);
  166. guids.AddTail(MEDIASUBTYPE_WAVE_DOLBY_AC3);
  167. guids.AddTail(MEDIATYPE_Audio);
  168. guids.AddTail(MEDIASUBTYPE_WAVE_DTS);
  169. AddFilter(new CGraphCustomFilter(__uuidof(CAVI2AC3Filter), guids, L"AVI<->AC3/DTS", LMERIT(0x00680000)+1));
  170. guids.RemoveAll();
  172. {
  173. guids.AddTail(MEDIATYPE_Stream);
  174. guids.AddTail(MEDIASUBTYPE_Matroska);
  175. AddFilter(new CGraphCustomFilter(__uuidof(CMatroskaSplitterFilter), guids, 
  176. (s.SrcFilters&SRC_MATROSKA) ? L"Matroska Splitter" : L"Matroska Splitter (low merit)", 
  177. (s.SrcFilters&SRC_MATROSKA) ? LMERIT_ABOVE_DSHOW : LMERIT_DO_USE));
  178. guids.RemoveAll();
  179. }
  181. {
  182. guids.AddTail(MEDIATYPE_Stream);
  183. guids.AddTail(MEDIASUBTYPE_RealMedia);
  184. AddFilter(new CGraphCustomFilter(__uuidof(CRealMediaSplitterFilter), guids, 
  185. (s.SrcFilters&SRC_REALMEDIA) ? L"RealMedia Splitter" : L"RealMedia Splitter (low merit)", 
  186. (s.SrcFilters&SRC_REALMEDIA) ? LMERIT_ABOVE_DSHOW : LMERIT_DO_USE));
  187. guids.RemoveAll();
  188. }
  190. {
  191. guids.AddTail(MEDIATYPE_Stream);
  192. guids.AddTail(MEDIASUBTYPE_Avi);
  193. AddFilter(new CGraphCustomFilter(__uuidof(CAviSplitterFilter), guids, 
  194. (s.SrcFilters&SRC_AVI) ? L"Avi Splitter" : L"Avi Splitter (low merit)",
  195. (s.SrcFilters&SRC_AVI) ? LMERIT_ABOVE_DSHOW : LMERIT_DO_USE));
  196. guids.RemoveAll();
  197. }
  199. __if_exists(CRadGtSplitterFilter)
  200. {
  201. guids.AddTail(MEDIATYPE_Stream);
  202. guids.AddTail(MEDIASUBTYPE_Bink);
  203. guids.AddTail(MEDIATYPE_Stream);
  204. guids.AddTail(MEDIASUBTYPE_Smacker);
  205. AddFilter(new CGraphCustomFilter(__uuidof(CRadGtSplitterFilter), guids, 
  206. (s.SrcFilters&SRC_RADGT) ? L"RadGt Splitter" : L"RadGt Splitter (low merit)",
  207. (s.SrcFilters&SRC_RADGT) ? LMERIT_ABOVE_DSHOW : LMERIT_DO_USE));
  208. guids.RemoveAll();
  209. }
  211. {
  212. guids.AddTail(MEDIATYPE_Stream);
  213. guids.AddTail(MEDIASUBTYPE_RoQ);
  214. AddFilter(new CGraphCustomFilter(__uuidof(CRoQSplitterFilter), guids, 
  215. (s.SrcFilters&SRC_ROQ) ? L"RoQ Splitter" : L"RoQ Splitter (low merit)",
  216. (s.SrcFilters&SRC_ROQ) ? LMERIT_ABOVE_DSHOW : LMERIT_DO_USE));
  217. guids.RemoveAll();
  218. }
  220. {
  221. guids.AddTail(MEDIATYPE_Stream);
  222. guids.AddTail(MEDIASUBTYPE_Ogg);
  223. AddFilter(new CGraphCustomFilter(__uuidof(COggSplitterFilter), guids, 
  224. (s.SrcFilters&SRC_OGG) ? L"Ogg Splitter" : L"Ogg Splitter (low merit)",
  225. (s.SrcFilters&SRC_OGG) ? LMERIT_ABOVE_DSHOW : LMERIT_DO_USE));
  226. guids.RemoveAll();
  227. }
  229. {
  230. guids.AddTail(MEDIATYPE_Stream);
  231. guids.AddTail(MEDIASUBTYPE_Nut);
  232. AddFilter(new CGraphCustomFilter(__uuidof(CNutSplitterFilter), guids, 
  233. (s.SrcFilters&SRC_NUT) ? L"Nut Splitter" : L"Nut Splitter (low merit)",
  234. (s.SrcFilters&SRC_NUT) ? LMERIT_ABOVE_DSHOW : LMERIT_DO_USE));
  235. guids.RemoveAll();
  236. }
  238. {
  239. guids.AddTail(MEDIATYPE_Stream);
  240. guids.AddTail(MEDIASUBTYPE_MPEG1System);
  241. guids.AddTail(MEDIATYPE_Stream);
  242. guids.AddTail(MEDIASUBTYPE_MPEG2_PROGRAM);
  243. guids.AddTail(MEDIATYPE_Stream);
  244. guids.AddTail(MEDIASUBTYPE_MPEG2_TRANSPORT);
  245. guids.AddTail(MEDIATYPE_Stream);
  246. guids.AddTail(MEDIASUBTYPE_MPEG2_PVA);
  247. AddFilter(new CGraphCustomFilter(__uuidof(CMpegSplitterFilter), guids, 
  248. (s.SrcFilters&SRC_MPEG) ? L"Mpeg Splitter" : L"Mpeg Splitter (low merit)",
  249. (s.SrcFilters&SRC_MPEG) ? LMERIT_ABOVE_DSHOW : LMERIT_DO_USE));
  250. guids.RemoveAll();
  251. }
  253. {
  254. guids.AddTail(MEDIATYPE_Video);
  255. guids.AddTail(MEDIASUBTYPE_MPEG1Packet);
  256. guids.AddTail(MEDIATYPE_Video);
  257. guids.AddTail(MEDIASUBTYPE_MPEG1Payload);
  258. AddFilter(new CGraphCustomFilter(__uuidof(CMpeg2DecFilter), guids, 
  259. (s.TraFilters&TRA_MPEG1) ? L"MPEG-1 Video Decoder" : L"MPEG-1 Video Decoder (low merit)", 
  260. (s.TraFilters&TRA_MPEG1) ? LMERIT_ABOVE_DSHOW : LMERIT_DO_USE));
  261. guids.RemoveAll();
  262. }
  264. {
  265. guids.AddTail(MEDIATYPE_DVD_ENCRYPTED_PACK);
  266. guids.AddTail(MEDIASUBTYPE_MPEG2_VIDEO);
  267. guids.AddTail(MEDIATYPE_MPEG2_PACK);
  268. guids.AddTail(MEDIASUBTYPE_MPEG2_VIDEO);
  269. guids.AddTail(MEDIATYPE_MPEG2_PES);
  270. guids.AddTail(MEDIASUBTYPE_MPEG2_VIDEO);
  271. guids.AddTail(MEDIATYPE_Video);
  272. guids.AddTail(MEDIASUBTYPE_MPEG2_VIDEO);
  273. AddFilter(new CGraphCustomFilter(__uuidof(CMpeg2DecFilter), guids,
  274. (s.TraFilters&TRA_MPEG2) ? L"MPEG-2 Video Decoder" : L"MPEG-2 Video Decoder (low merit)", 
  275. (s.TraFilters&TRA_MPEG2) ? LMERIT_ABOVE_DSHOW : LMERIT_DO_USE));
  276. guids.RemoveAll();
  277. }
  279. {
  280. guids.AddTail(MEDIATYPE_Audio);
  281. guids.AddTail(MEDIASUBTYPE_MP3);
  282. guids.AddTail(MEDIATYPE_Audio);
  283. guids.AddTail(MEDIASUBTYPE_MPEG1AudioPayload);
  284. guids.AddTail(MEDIATYPE_Audio);
  285. guids.AddTail(MEDIASUBTYPE_MPEG1Payload);
  286. guids.AddTail(MEDIATYPE_Audio);
  287. guids.AddTail(MEDIASUBTYPE_MPEG1Packet);
  288. AddFilter(new CGraphCustomFilter(__uuidof(CMpaDecFilter), guids, 
  289. (s.TraFilters&TRA_MPA) ? L"MPEG-1 Audio Decoder" : L"MPEG-1 Audio Decoder (low merit)",
  290. (s.TraFilters&TRA_MPA) ? LMERIT_ABOVE_DSHOW : LMERIT_DO_USE));
  291. guids.RemoveAll();
  292. }
  294. {
  295. guids.AddTail(MEDIATYPE_DVD_ENCRYPTED_PACK);
  296. guids.AddTail(MEDIASUBTYPE_MPEG2_AUDIO);
  297. guids.AddTail(MEDIATYPE_MPEG2_PACK);
  298. guids.AddTail(MEDIASUBTYPE_MPEG2_AUDIO);
  299. guids.AddTail(MEDIATYPE_MPEG2_PES);
  300. guids.AddTail(MEDIASUBTYPE_MPEG2_AUDIO);
  301. guids.AddTail(MEDIATYPE_Audio);
  302. guids.AddTail(MEDIASUBTYPE_MPEG2_AUDIO);
  303. AddFilter(new CGraphCustomFilter(__uuidof(CMpaDecFilter), guids, 
  304. (s.TraFilters&TRA_MPA) ? L"MPEG-2 Audio Decoder" : L"MPEG-2 Audio Decoder (low merit)",
  305. (s.TraFilters&TRA_MPA) ? LMERIT_ABOVE_DSHOW : LMERIT_DO_USE));
  306. guids.RemoveAll();
  307. }
  309. {
  310. guids.AddTail(MEDIATYPE_DVD_ENCRYPTED_PACK);
  311. guids.AddTail(MEDIASUBTYPE_DVD_LPCM_AUDIO);
  312. guids.AddTail(MEDIATYPE_MPEG2_PACK);
  313. guids.AddTail(MEDIASUBTYPE_DVD_LPCM_AUDIO);
  314. guids.AddTail(MEDIATYPE_MPEG2_PES);
  315. guids.AddTail(MEDIASUBTYPE_DVD_LPCM_AUDIO);
  316. guids.AddTail(MEDIATYPE_Audio);
  317. guids.AddTail(MEDIASUBTYPE_DVD_LPCM_AUDIO);
  318. AddFilter(new CGraphCustomFilter(__uuidof(CMpaDecFilter), guids, 
  319. (s.TraFilters&TRA_LPCM) ? L"LPCM Audio Decoder" : L"LPCM Audio Decoder (low merit)",
  320. (s.TraFilters&TRA_LPCM) ? LMERIT_ABOVE_DSHOW : LMERIT_DO_USE));
  321. guids.RemoveAll();
  322. }
  324. {
  325. guids.AddTail(MEDIATYPE_DVD_ENCRYPTED_PACK);
  326. guids.AddTail(MEDIASUBTYPE_DOLBY_AC3);
  327. guids.AddTail(MEDIATYPE_MPEG2_PACK);
  328. guids.AddTail(MEDIASUBTYPE_DOLBY_AC3);
  329. guids.AddTail(MEDIATYPE_MPEG2_PES);
  330. guids.AddTail(MEDIASUBTYPE_DOLBY_AC3);
  331. guids.AddTail(MEDIATYPE_Audio);
  332. guids.AddTail(MEDIASUBTYPE_DOLBY_AC3);
  333. guids.AddTail(MEDIATYPE_Audio);
  334. guids.AddTail(MEDIASUBTYPE_WAVE_DOLBY_AC3);
  335. AddFilter(new CGraphCustomFilter(__uuidof(CMpaDecFilter), guids, 
  336. (s.TraFilters&TRA_AC3) ? L"AC3 Audio Decoder" : L"AC3 Audio Decoder (low merit)",
  337. (s.TraFilters&TRA_AC3) ? LMERIT_ABOVE_DSHOW : LMERIT_DO_USE));
  338. guids.RemoveAll();
  339. }
  341. {
  342. guids.AddTail(MEDIATYPE_DVD_ENCRYPTED_PACK);
  343. guids.AddTail(MEDIASUBTYPE_DTS);
  344. guids.AddTail(MEDIATYPE_MPEG2_PACK);
  345. guids.AddTail(MEDIASUBTYPE_DTS);
  346. guids.AddTail(MEDIATYPE_MPEG2_PES);
  347. guids.AddTail(MEDIASUBTYPE_DTS);
  348. guids.AddTail(MEDIATYPE_Audio);
  349. guids.AddTail(MEDIASUBTYPE_DTS);
  350. guids.AddTail(MEDIATYPE_Audio);
  351. guids.AddTail(MEDIASUBTYPE_WAVE_DTS);
  352. AddFilter(new CGraphCustomFilter(__uuidof(CMpaDecFilter), guids, 
  353. (s.TraFilters&TRA_DTS) ? L"DTS Decoder" : L"DTS Decoder (low merit)",
  354. (s.TraFilters&TRA_DTS) ? LMERIT_ABOVE_DSHOW : LMERIT_DO_USE));
  355. guids.RemoveAll();
  356. }
  358. {
  359. guids.AddTail(MEDIATYPE_DVD_ENCRYPTED_PACK);
  360. guids.AddTail(MEDIASUBTYPE_AAC);
  361. guids.AddTail(MEDIATYPE_MPEG2_PACK);
  362. guids.AddTail(MEDIASUBTYPE_AAC);
  363. guids.AddTail(MEDIATYPE_MPEG2_PES);
  364. guids.AddTail(MEDIASUBTYPE_AAC);
  365. guids.AddTail(MEDIATYPE_Audio);
  366. guids.AddTail(MEDIASUBTYPE_AAC);
  367. guids.AddTail(MEDIATYPE_DVD_ENCRYPTED_PACK);
  368. guids.AddTail(MEDIASUBTYPE_MP4A);
  369. guids.AddTail(MEDIATYPE_MPEG2_PACK);
  370. guids.AddTail(MEDIASUBTYPE_MP4A);
  371. guids.AddTail(MEDIATYPE_MPEG2_PES);
  372. guids.AddTail(MEDIASUBTYPE_MP4A);
  373. guids.AddTail(MEDIATYPE_Audio);
  374. guids.AddTail(MEDIASUBTYPE_MP4A);
  375. AddFilter(new CGraphCustomFilter(__uuidof(CMpaDecFilter), guids, 
  376. (s.TraFilters&TRA_AAC) ? L"AAC Decoder" : L"AAC Decoder (low merit)",
  377. (s.TraFilters&TRA_AAC) ? LMERIT_ABOVE_DSHOW+1 : LMERIT_DO_USE));
  378. guids.RemoveAll();
  379. }
  381. {
  382. guids.AddTail(MEDIATYPE_DVD_ENCRYPTED_PACK);
  383. guids.AddTail(MEDIASUBTYPE_PS2_PCM);
  384. guids.AddTail(MEDIATYPE_MPEG2_PACK);
  385. guids.AddTail(MEDIASUBTYPE_PS2_PCM);
  386. guids.AddTail(MEDIATYPE_MPEG2_PES);
  387. guids.AddTail(MEDIASUBTYPE_PS2_PCM);
  388. guids.AddTail(MEDIATYPE_Audio);
  389. guids.AddTail(MEDIASUBTYPE_PS2_PCM);
  390. AddFilter(new CGraphCustomFilter(__uuidof(CMpaDecFilter), guids, 
  391. (s.TraFilters&TRA_PS2AUD) ? L"PS2 Audio Decoder" : L"PS2 Audio Decoder (low merit)",
  392. (s.TraFilters&TRA_PS2AUD) ? LMERIT_ABOVE_DSHOW : LMERIT_DO_USE));
  393. guids.RemoveAll();
  394. }
  396. {
  397. guids.AddTail(MEDIATYPE_Video);
  398. guids.AddTail(MEDIASUBTYPE_RV10);
  399. guids.AddTail(MEDIATYPE_Video);
  400. guids.AddTail(MEDIASUBTYPE_RV20);
  401. guids.AddTail(MEDIATYPE_Video);
  402. guids.AddTail(MEDIASUBTYPE_RV30);
  403. guids.AddTail(MEDIATYPE_Video);
  404. guids.AddTail(MEDIASUBTYPE_RV40);
  405. AddFilter(new CGraphCustomFilter(__uuidof(CRealVideoDecoder), guids,
  406. (s.TraFilters&TRA_RV) ? L"RealVideo Decoder" : L"RealVideo Decoder (low merit)",
  407. (s.TraFilters&TRA_RV) ? LMERIT_ABOVE_DSHOW : LMERIT_DO_USE));
  408. guids.RemoveAll();
  409. }
  411. {
  412. guids.AddTail(MEDIATYPE_Audio);
  413. guids.AddTail(MEDIASUBTYPE_14_4);
  414. guids.AddTail(MEDIATYPE_Audio);
  415. guids.AddTail(MEDIASUBTYPE_28_8);
  416. guids.AddTail(MEDIATYPE_Audio);
  417. guids.AddTail(MEDIASUBTYPE_ATRC);
  418. guids.AddTail(MEDIATYPE_Audio);
  419. guids.AddTail(MEDIASUBTYPE_COOK);
  420. guids.AddTail(MEDIATYPE_Audio);
  421. guids.AddTail(MEDIASUBTYPE_DNET);
  422. guids.AddTail(MEDIATYPE_Audio);
  423. guids.AddTail(MEDIASUBTYPE_SIPR);
  424. guids.AddTail(MEDIATYPE_Audio);
  425. guids.AddTail(MEDIASUBTYPE_RAAC);
  426. AddFilter(new CGraphCustomFilter(__uuidof(CRealAudioDecoder), guids, 
  427. (s.TraFilters&TRA_RA) ? L"RealAudio Decoder" : L"RealAudio Decoder (low merit)",
  428. (s.TraFilters&TRA_RA) ? LMERIT_ABOVE_DSHOW : LMERIT_DO_USE));
  429. guids.RemoveAll();
  430. }
  432. {
  433. guids.AddTail(MEDIATYPE_Video);
  434. guids.AddTail(MEDIASUBTYPE_RoQV);
  435. AddFilter(new CGraphCustomFilter(__uuidof(CRoQVideoDecoder), guids,
  436. (s.TraFilters&TRA_RV) ? L"RoQ Video Decoder" : L"RoQ Video Decoder (low merit)",
  437. (s.TraFilters&TRA_RV) ? LMERIT_ABOVE_DSHOW : LMERIT_DO_USE));
  438. guids.RemoveAll();
  439. }
  441. {
  442. guids.AddTail(MEDIATYPE_Audio);
  443. guids.AddTail(MEDIASUBTYPE_RoQA);
  444. AddFilter(new CGraphCustomFilter(__uuidof(CRoQAudioDecoder), guids,
  445. (s.TraFilters&TRA_RV) ? L"RoQ Audio Decoder" : L"RoQ Audio Decoder (low merit)",
  446. (s.TraFilters&TRA_RV) ? LMERIT_ABOVE_DSHOW : LMERIT_DO_USE));
  447. guids.RemoveAll();
  448. }
  450. {
  451. guids.AddTail(MEDIATYPE_Stream);
  452. guids.AddTail(MEDIASUBTYPE_Dirac);
  453. AddFilter(new CGraphCustomFilter(__uuidof(CDiracSplitterFilter), guids, 
  454. (s.SrcFilters&SRC_DIRAC) ? L"Dirac Splitter" : L"Dirac Splitter (low merit)",
  455. (s.SrcFilters&SRC_DIRAC) ? LMERIT_ABOVE_DSHOW : LMERIT_DO_USE));
  456. guids.RemoveAll();
  457. }
  459. {
  460. guids.AddTail(MEDIATYPE_Video);
  461. guids.AddTail(MEDIASUBTYPE_DiracVideo);
  462. AddFilter(new CGraphCustomFilter(__uuidof(CDiracVideoDecoder), guids,
  463. (s.TraFilters&TRA_DIRAC) ? L"Dirac Video Decoder" : L"Dirac Video Decoder (low merit)",
  464. (s.TraFilters&TRA_DIRAC) ? LMERIT_ABOVE_DSHOW : LMERIT_DO_USE));
  465. guids.RemoveAll();
  466. }
  468. {
  469. guids.AddTail(MEDIATYPE_Stream);
  470. guids.AddTail(MEDIASUBTYPE_MPEG1Audio);
  471. AddFilter(new CGraphCustomFilter(__uuidof(CMpaSplitterFilter), guids, 
  472. (s.SrcFilters&SRC_MPA) ? L"Mpa Splitter" : L"Mpa Splitter (low merit)",
  473. (s.SrcFilters&SRC_MPA) ? LMERIT_ABOVE_DSHOW : LMERIT_DO_USE));
  474. guids.RemoveAll();
  475. }
  477. {
  478. guids.AddTail(MEDIATYPE_Stream);
  479. guids.AddTail(MEDIASUBTYPE_DirectShowMedia);
  480. AddFilter(new CGraphCustomFilter(__uuidof(CDSMSplitterFilter), guids, 
  481. (s.SrcFilters&SRC_DSM) ? L"DSM Splitter" : L"DSM Splitter (low merit)",
  482. (s.SrcFilters&SRC_DSM) ? LMERIT_ABOVE_DSHOW : LMERIT_DO_USE));
  483. guids.RemoveAll();
  484. }
  486. {
  487. guids.AddTail(MEDIATYPE_Stream);
  488. guids.AddTail(MEDIASUBTYPE_MP4);
  489. AddFilter(new CGraphCustomFilter(__uuidof(CMP4SplitterFilter), guids, 
  490. (s.SrcFilters&SRC_MP4) ? L"MP4 Splitter" : L"MP4 Splitter (low merit)",
  491. (s.SrcFilters&SRC_MP4) ? LMERIT_ABOVE_DSHOW : LMERIT_DO_USE));
  492. guids.RemoveAll();
  493. }
  495. // renderer filters
  497. switch(s.iDSVideoRendererType)
  498. {
  499. default: 
  500. case VIDRNDT_DS_DEFAULT: 
  501. break;
  502. case VIDRNDT_DS_OLDRENDERER: 
  503. AddFilter(new CGraphRegFilter(CLSID_VideoRenderer, m_VRMerit));
  504. break;
  505. case VIDRNDT_DS_OVERLAYMIXER:
  506. AddFilter(new CGraphRendererFilter(CLSID_OverlayMixer, m_hWnd, L"Overlay Mixer", m_VRMerit));
  507. break;
  508. case VIDRNDT_DS_VMR7WINDOWED:
  509. AddFilter(new CGraphRendererFilter(CLSID_VideoMixingRenderer, m_hWnd, L"Video Mixing Render 7 (Windowed)", m_VRMerit));
  510. break;
  511. case VIDRNDT_DS_VMR9WINDOWED:
  512. AddFilter(new CGraphRendererFilter(CLSID_VideoMixingRenderer9, m_hWnd, L"Video Mixing Render 9 (Windowed)", m_VRMerit));
  513. break;
  514. case VIDRNDT_DS_VMR7RENDERLESS:
  515. AddFilter(new CGraphRendererFilter(CLSID_VMR7AllocatorPresenter, m_hWnd, L"Video Mixing Render 7 (Renderless)", m_VRMerit));
  516. break;
  517. case VIDRNDT_DS_VMR9RENDERLESS:
  518. AddFilter(new CGraphRendererFilter(CLSID_VMR9AllocatorPresenter, m_hWnd, L"Video Mixing Render 9 (Renderless)", m_VRMerit));
  519. break;
  520. case VIDRNDT_DS_NULL_COMP:
  521. guids.AddTail(MEDIATYPE_Video);
  522. guids.AddTail(MEDIASUBTYPE_NULL);
  523. AddFilter(new CGraphCustomFilter(__uuidof(CNullVideoRenderer), guids, L"Null Video Renderer (Any)", LMERIT_ABOVE_DSHOW+2));
  524. guids.RemoveAll();
  525. break;
  526. case VIDRNDT_DS_NULL_UNCOMP:
  527. guids.AddTail(MEDIATYPE_Video);
  528. guids.AddTail(MEDIASUBTYPE_NULL);
  529. AddFilter(new CGraphCustomFilter(__uuidof(CNullUVideoRenderer), guids, L"Null Video Renderer (Uncompressed)", LMERIT_ABOVE_DSHOW+2));
  530. guids.RemoveAll();
  531. break;
  532. }
  534. if(s.AudioRendererDisplayName == AUDRNDT_NULL_COMP)
  535. {
  536. guids.AddTail(MEDIATYPE_Audio);
  537. guids.AddTail(MEDIASUBTYPE_NULL);
  538. AddFilter(new CGraphCustomFilter(__uuidof(CNullAudioRenderer), guids, AUDRNDT_NULL_COMP, LMERIT_ABOVE_DSHOW+2));
  539. guids.RemoveAll();
  540. }
  541. else if(s.AudioRendererDisplayName == AUDRNDT_NULL_UNCOMP)
  542. {
  543. guids.AddTail(MEDIATYPE_Audio);
  544. guids.AddTail(MEDIASUBTYPE_NULL);
  545. AddFilter(new CGraphCustomFilter(__uuidof(CNullUAudioRenderer), guids, AUDRNDT_NULL_UNCOMP, LMERIT_ABOVE_DSHOW+2));
  546. guids.RemoveAll();
  547. }
  548. else if(!s.AudioRendererDisplayName.IsEmpty())
  549. {
  550. AddFilter(new CGraphRegFilter(s.AudioRendererDisplayName, m_ARMerit));
  551. }
  553. WORD lowmerit = 1;
  554. POSITION pos = s.filters.GetTailPosition();
  555. while(pos)
  556. {
  557. Filter* f = s.filters.GetPrev(pos);
  559. if(f->fDisabled
  560. || f->type == Filter::EXTERNAL && !CPath(MakeFullPath(f->path)).FileExists()) 
  561. continue;
  563. ULONGLONG merit = 
  564. f->iLoadType == Filter::PREFERRED ? LMERIT_ABOVE_DSHOW : 
  565. f->iLoadType == Filter::MERIT ? LMERIT(f->dwMerit) : 
  566. LMERIT_DO_NOT_USE; // f->iLoadType == Filter::BLOCKED
  568. merit += lowmerit++;
  570. CGraphFilter* gf = NULL;
  572. if(f->type == Filter::REGISTERED)
  573. {
  574. gf = new CGraphRegFilter(f->dispname, merit);
  575. }
  576. else if(f->type == Filter::EXTERNAL)
  577. {
  578. gf = new CGraphFileFilter(f->clsid, f->guids, f->path, CStringW(f->name), merit);
  579. }
  581. if(gf)
  582. {
  583. gf->SetGUIDs(f->guids);
  584. AddFilter(gf);
  585. }
  586. }
  588. guids.AddTail(MEDIATYPE_Text);
  589. guids.AddTail(MEDIASUBTYPE_NULL);
  590. guids.AddTail(MEDIATYPE_ScriptCommand);
  591. guids.AddTail(MEDIASUBTYPE_NULL);
  592. guids.AddTail(MEDIATYPE_Subtitle);
  593. guids.AddTail(MEDIASUBTYPE_NULL);
  594. guids.AddTail(MEDIATYPE_NULL);
  595. guids.AddTail(MEDIASUBTYPE_DVD_SUBPICTURE);
  596. guids.AddTail(MEDIATYPE_NULL);
  597. guids.AddTail(MEDIASUBTYPE_CVD_SUBPICTURE);
  598. guids.AddTail(MEDIATYPE_NULL);
  599. guids.AddTail(MEDIASUBTYPE_SVCD_SUBPICTURE);
  601. AddFilter(new CGraphCustomFilter(__uuidof(CNullTextRenderer), guids, L"NullTextRenderer", LMERIT_DO_USE));
  602. guids.RemoveAll();
  604. // FIXME: "Subtitle Mixer" makes an access violation around 
  605. // the 11-12th media type when enumerating them on its output.
  606. CLSID CLSID_SubtitlerMixer = GUIDFromCString(_T("{00A95963-3BE5-48C0-AD9F-3356D67EA09D}"));
  607. AddFilter(new CGraphRegFilter(CLSID_SubtitlerMixer, LMERIT_DO_NOT_USE));
  609. // ISCR suxx
  610. AddFilter(new CGraphRegFilter(GUIDFromCString(_T("{48025243-2D39-11CE-875D-00608CB78066}")), LMERIT_DO_NOT_USE));
  611. }
  613. CGraphBuilder::~CGraphBuilder()
  614. {
  615. }
  616. /*
  617. void CGraphBuilder::LOG(LPCTSTR fmt, ...)
  618. {
  619. va_list args;
  620. va_start(args, fmt);
  621. if(TCHAR* buff = new TCHAR[_vsctprintf(fmt, args) + 1])
  622. {
  623. _vstprintf(buff, fmt, args);
  624. m_log.AddTail(buff);
  625. TRACE(_T("GraphBuilder: Stream[%d]: %sn"), m_iStream, buff);
  626. if(FILE* f = _tfopen(_T("c:\mpcgb.txt"), _T("at")))
  627. {
  628. fseek(f, 0, 2);
  629. _ftprintf(f, _T("Stream[%d]: %sn"), m_iStream, buff);
  630. fclose(f);
  631. }
  632. delete [] buff;
  633. }
  634. va_end(args);
  635. }
  636. */
  638. void CGraphBuilder::ExtractMediaTypes(IPin* pPin, CArray<GUID>& guids)
  639. {
  640. guids.RemoveAll();
  642.     BeginEnumMediaTypes(pPin, pEM, pmt)
  643. {
  644. bool fFound = false;
  646. for(int i = 0; !fFound && i < guids.GetCount(); i += 2)
  647. {
  648. if(guids[i] == pmt->majortype && guids[i+1] == pmt->subtype)
  649. fFound = true;
  650. }
  652. if(!fFound)
  653. {
  654. guids.Add(pmt->majortype);
  655. guids.Add(pmt->subtype);
  656. }
  657. }
  658. EndEnumMediaTypes(pmt)
  659. }
  661. void CGraphBuilder::ExtractMediaTypes(IPin* pPin, CList<CMediaType>& mts)
  662. {
  663. mts.RemoveAll();
  665.     BeginEnumMediaTypes(pPin, pEM, pmt)
  666. {
  667. bool fFound = false;
  669. POSITION pos = mts.GetHeadPosition();
  670. while(!fFound && pos)
  671. {
  672. CMediaType& mt = mts.GetNext(pos);
  673. if(mt.majortype == pmt->majortype && mt.subtype == pmt->subtype)
  674. fFound = true;
  675. }
  677. if(!fFound)
  678. {
  679. mts.AddTail(CMediaType(*pmt));
  680. }
  681. }
  682. EndEnumMediaTypes(pmt)
  683. }
  685. void CGraphBuilder::SaveFilters(CInterfaceList<IBaseFilter>& bfl)
  686. {
  687. bfl.RemoveAll();
  688. BeginEnumFilters(m_pGB, pEF, pBF)
  689. bfl.AddTail(pBF);
  690. EndEnumFilters
  691. }
  693. void CGraphBuilder::RestoreFilters(CInterfaceList<IBaseFilter>& bfl)
  694. {
  695. BeginEnumFilters(m_pGB, pEF, pBF)
  696. if(!bfl.Find(pBF)) {m_pGB->RemoveFilter(pBF); pEF->Reset();}
  697. EndEnumFilters
  698. }
  700. HRESULT CGraphBuilder::SafeAddFilter(IBaseFilter* pBF, LPCWSTR pName)
  701. {
  702. if(!m_pGB || !pBF)
  703. return E_FAIL;
  705. bool fFound = false;
  706. BeginEnumFilters(m_pGB, pEF, pBF2)
  707. if(pBF == pBF2) fFound = true;
  708. EndEnumFilters
  709. if(fFound) return S_OK;
  711. CFilterInfo fi;
  712. if(SUCCEEDED(pBF->QueryFilterInfo(&fi)))
  713. {
  714. if(!fi.pGraph) // not in graph yet?
  715. {
  716. CStringW name;
  718. if(pName && wcslen(pName) > 0)
  719. {
  720. name = pName;
  721. }
  722. else
  723. {
  724. if(CComQIPtr<IFileSourceFilter> pFSF = pBF)
  725. {
  726. CMediaType mt;
  727. LPOLESTR str = NULL;
  728. if(SUCCEEDED(pFSF->GetCurFile(&str, &mt))) name = str;
  729. if(str) CoTaskMemFree(str);
  730. }
  732. if(name.IsEmpty())
  733. {
  734. CLSID clsid = GetCLSID(pBF);
  735. name = clsid == GUID_NULL ? L"Unknown Filter" : CStringFromGUID(clsid);
  736. }
  737. }
  739. if(FAILED(m_pGB->AddFilter(pBF, name)))
  740. {
  741. return E_FAIL;
  742. }
  743. }
  745. return S_OK;
  746. }
  748. return E_FAIL;
  749. }
  751. void CGraphBuilder::Reset()
  752. {
  753. m_nTotalStreams = 0;
  754. m_nCurrentStream = 0;
  755. m_pUnks.RemoveAll();
  756. m_DeadEnds.RemoveAll();
  757. // m_log.RemoveAll();
  758. }
  760. HRESULT CGraphBuilder::AddSourceFilter(LPCTSTR lpsz, IBaseFilter** ppBF, UINT SrcFilters)
  761. {
  762. CheckPointer(lpsz, E_POINTER);
  763. CheckPointer(ppBF, E_POINTER);
  765. if(!m_pGB) return E_UNEXPECTED;
  767. CString fn = CString(lpsz).Trim();
  768. if(fn.IsEmpty()) return E_FAIL;
  769. CStringW fnw = fn;
  770. CString ext = CPath(fn).GetExtension().MakeLower();
  772. HRESULT hr;
  774. CComQIPtr<IBaseFilter> pBF;
  776. CComQIPtr<IGraphEngine> pGE = m_pGB;
  777. if(!pGE || pGE->GetEngine() == DirectShow)
  778. {
  779. /*
  780. if(!pBF && fn.Find(_T("://")) > 0)
  781. {
  782. CList<CString> mms;
  783. CString ct = GetContentType(fn, &mms); // TODO: if there are more to check, do GetContentType only once
  784. if(ct == _T("video/x-ms-asf") || ct == _T("video/x-ms-wmv")
  785. || ct == _T("video/x-ms-wvx") || ct == _T("video/x-ms-wax")
  786. || ct == _T("video/x-ms-wmp"))
  787. {
  788. if(!mms.IsEmpty()) fnw = mms.GetHead();
  789. fnw.Replace(L"&MSWMExt=.asf", L"");
  791. CComPtr<IFileSourceFilter> pReader;
  792. hr = pReader.CoCreateInstance(CLSID_NetShowSource);
  793. if(SUCCEEDED(hr) && SUCCEEDED(pReader->Load(fnw, NULL)))
  794. pBF = pReader;
  795. }
  796. }
  797. */
  798. if((SrcFilters&SRC_SUBS) && !pBF)
  799. {
  800. hr = S_OK;
  801. CComPtr<IFileSourceFilter> pReader = new CSubtitleSourceASS(NULL, &hr);
  802. if(SUCCEEDED(hr) && SUCCEEDED(pReader->Load(fnw, NULL)))
  803. pBF = pReader;
  804. }
  806. if((SrcFilters&SRC_CDDA) && !pBF && ext == _T(".cda"))
  807. {
  808. hr = S_OK;
  809. CComPtr<IFileSourceFilter> pReader = new CCDDAReader(NULL, &hr);
  810. if(SUCCEEDED(hr) && SUCCEEDED(pReader->Load(fnw, NULL)))
  811. pBF = pReader;
  812. }
  814. if((SrcFilters&SRC_CDXA) && !pBF)
  815. {
  816. hr = S_OK;
  817. CComPtr<IFileSourceFilter> pReader = new CCDXAReader(NULL, &hr);
  818. if(SUCCEEDED(hr) && SUCCEEDED(pReader->Load(fnw, NULL)))
  819. pBF = pReader;
  820. }
  822. if((SrcFilters&SRC_VTS) && !pBF) //&& ext == _T(".ifo"))
  823. {
  824. hr = S_OK;
  825. CComPtr<IFileSourceFilter> pReader = new CVTSReader(NULL, &hr);
  826. if(SUCCEEDED(hr) && SUCCEEDED(pReader->Load(fnw, NULL)))
  827. pBF = pReader;
  828. }
  830. if((SrcFilters&SRC_FLIC) && !pBF) //&& (ext == _T(".fli") || ext == _T(".flc")))
  831. {
  832. hr = S_OK;
  833. CComPtr<IFileSourceFilter> pReader = new CFLICSource(NULL, &hr);
  834. if(SUCCEEDED(hr) && SUCCEEDED(pReader->Load(fnw, NULL)))
  835. pBF = pReader;
  836. }
  838. if((SrcFilters&SRC_D2V) && !pBF) //&& ext == _T(".d2v"))
  839. {
  840. hr = S_OK;
  841. CComPtr<IFileSourceFilter> pReader = new CD2VSource(NULL, &hr);
  842. if(SUCCEEDED(hr) && SUCCEEDED(pReader->Load(fnw, NULL)))
  843. pBF = pReader;
  844. }
  846. if((SrcFilters&SRC_DTSAC3) && !pBF) //&& (ext == _T(".dts") || ext == _T(".ac3")))
  847. {
  848. hr = S_OK;
  849. CComPtr<IFileSourceFilter> pReader = new CDTSAC3Source(NULL, &hr);
  850. if(SUCCEEDED(hr) && SUCCEEDED(pReader->Load(fnw, NULL)))
  851. pBF = pReader;
  852. }
  854. if((SrcFilters&SRC_SHOUTCAST) && !pBF && fn.Find(_T("://")) >= 0)
  855. {
  856. hr = S_OK;
  857. CComPtr<IFileSourceFilter> pReader = new CShoutcastSource(NULL, &hr);
  858. if(SUCCEEDED(hr) && SUCCEEDED(pReader->Load(fnw, NULL)))
  859. pBF = pReader;
  860. }
  862. if((SrcFilters&SRC_MATROSKA) && !pBF) //&& (ext == _T(".mkv") || ext == _T(".mka") || ext == _T(".mks")))
  863. {
  864. hr = S_OK;
  865. CComPtr<IFileSourceFilter> pReader = new CMatroskaSourceFilter(NULL, &hr);
  866. if(SUCCEEDED(hr) && SUCCEEDED(pReader->Load(fnw, NULL)))
  867. pBF = pReader;
  868. }
  870. if((SrcFilters&SRC_REALMEDIA) && !pBF)
  871. {
  872. hr = S_OK;
  873. CComPtr<IFileSourceFilter> pReader = new CRealMediaSourceFilter(NULL, &hr);
  874. if(SUCCEEDED(hr) && SUCCEEDED(pReader->Load(fnw, NULL)))
  875. pBF = pReader;
  876. }
  878. if((SrcFilters&SRC_AVI) && !pBF)
  879. {
  880. hr = S_OK;
  881. CComPtr<IFileSourceFilter> pReader = new CAviSourceFilter(NULL, &hr);
  882. if(SUCCEEDED(hr) && SUCCEEDED(pReader->Load(fnw, NULL)))
  883. pBF = pReader;
  884. }
  886. __if_exists(CRadGtSplitterFilter)
  887. {
  888. if((SrcFilters&SRC_RADGT) && !pBF)
  889. {
  890. hr = S_OK;
  891. CComPtr<IFileSourceFilter> pReader = new CRadGtSourceFilter(NULL, &hr);
  892. if(SUCCEEDED(hr) && SUCCEEDED(pReader->Load(fnw, NULL)))
  893. pBF = pReader;
  894. }
  895. }
  897. if((SrcFilters&SRC_ROQ) && !pBF)
  898. {
  899. hr = S_OK;
  900. CComPtr<IFileSourceFilter> pReader = new CRoQSourceFilter(NULL, &hr);
  901. if(SUCCEEDED(hr) && SUCCEEDED(pReader->Load(fnw, NULL)))
  902. pBF = pReader;
  903. }
  905. if((SrcFilters&SRC_OGG) && !pBF)
  906. {
  907. hr = S_OK;
  908. CComPtr<IFileSourceFilter> pReader = new COggSourceFilter(NULL, &hr);
  909. if(SUCCEEDED(hr) && SUCCEEDED(pReader->Load(fnw, NULL)))
  910. pBF = pReader;
  911. }
  913. if((SrcFilters&SRC_NUT) && !pBF)
  914. {
  915. hr = S_OK;
  916. CComPtr<IFileSourceFilter> pReader = new CNutSourceFilter(NULL, &hr);
  917. if(SUCCEEDED(hr) && SUCCEEDED(pReader->Load(fnw, NULL)))
  918. pBF = pReader;
  919. }
  921. if((SrcFilters&SRC_MPEG) && !pBF)
  922. {
  923. hr = S_OK;
  924. CComPtr<IFileSourceFilter> pReader = new CMpegSourceFilter(NULL, &hr);
  925. if(SUCCEEDED(hr) && SUCCEEDED(pReader->Load(fnw, NULL)))
  926. pBF = pReader;
  927. }
  929. if((SrcFilters&SRC_DIRAC) && !pBF)
  930. {
  931. hr = S_OK;
  932. CComPtr<IFileSourceFilter> pReader = new CDiracSourceFilter(NULL, &hr);
  933. if(SUCCEEDED(hr) && SUCCEEDED(pReader->Load(fnw, NULL)))
  934. pBF = pReader;
  935. }
  937. if((SrcFilters&SRC_MPA) && !pBF)
  938. {
  939. hr = S_OK;
  940. CComPtr<IFileSourceFilter> pReader = new CMpaSourceFilter(NULL, &hr);
  941. if(SUCCEEDED(hr) && SUCCEEDED(pReader->Load(fnw, NULL)))
  942. pBF = pReader;
  943. }
  945. if((SrcFilters&SRC_DSM) && !pBF)
  946. {
  947. hr = S_OK;
  948. CComPtr<IFileSourceFilter> pReader = new CDSMSourceFilter(NULL, &hr);
  949. if(SUCCEEDED(hr) && SUCCEEDED(pReader->Load(fnw, NULL)))
  950. pBF = pReader;
  951. }
  953. if((SrcFilters&SRC_MP4) && !pBF)
  954. {
  955. hr = S_OK;
  956. CComPtr<IFileSourceFilter> pReader = new CMP4SourceFilter(NULL, &hr);
  957. if(SUCCEEDED(hr) && SUCCEEDED(pReader->Load(fnw, NULL)))
  958. pBF = pReader;
  959. }
  961. if(!pBF && fn.Find(_T("://")) < 0)
  962. {
  963. bool fWindowsMedia = (ext == _T(".asf") || ext == _T(".wmv") || ext == _T(".wma"));
  965. if(!fWindowsMedia)
  966. {
  967. CFile f;
  968. if(f.Open(fn, CFile::modeRead))
  969. {
  970. BYTE buff[4];
  971. memset(buff, 0, sizeof(buff));
  972. f.Read(buff, sizeof(buff));
  973. if(*(DWORD*)buff == 0x75b22630)
  974. fWindowsMedia = true;
  975. }
  976. }
  978. if(fWindowsMedia)
  979. {
  980. CComPtr<IFileSourceFilter> pReader;
  981. hr = pReader.CoCreateInstance(AfxGetAppSettings().fUseWMASFReader ? CLSID_WMAsfReader : CLSID_NetShowSource);
  982. if(SUCCEEDED(hr) && SUCCEEDED(pReader->Load(fnw, NULL)))
  983. pBF = pReader;
  984. }
  985. }
  986. /*
  987. if(!pBF && fn.Find(_T("://")) < 0)
  988. {
  989. CFile f;
  990. if(f.Open(fn, CFile::modeRead|CFile::shareDenyWrite))
  991. {
  992. ULONGLONG len = f.GetLength();
  993. BYTE buff[12];
  994. memset(buff, 0, sizeof(buff));
  995. f.Read(buff, sizeof(buff));
  996. if(*((DWORD*)&buff[0]) == 'FFIR' && *((DWORD*)&buff[8]) == ' IVA')
  997. {
  998. if(len < *((DWORD*)&buff[4])+8)
  999. {
  1000. MessageBeep(-1);
  1002. CComPtr<IFileSourceFilter> pReader;
  1003. hr = pReader.CoCreateInstance(CLSID_AVIDoc);
  1004. if(SUCCEEDED(hr) && SUCCEEDED(pReader->Load(fnw, NULL)))
  1005. pBF = pReader;
  1006. }
  1007. }
  1008. }
  1009. }
  1010. */
  1011. }
  1013. if(!pBF)
  1014. {
  1015. CheckStupidSharedFilesourceFilter();
  1017. if(FAILED(hr = m_pGB->AddSourceFilter(fnw, fnw, &pBF)))
  1018. return hr;
  1020. if(SUCCEEDED(hr) && !pBF) // custom graphs don't need filters
  1021. return hr;
  1022. }
  1024. ASSERT(pBF);
  1026. if(FAILED(SafeAddFilter(pBF, NULL)))
  1027. return E_FAIL;
  1029. *ppBF = pBF.Detach();
  1031. return S_OK;
  1032. }
  1034. HRESULT CGraphBuilder::Render(LPCTSTR lpsz)
  1035. {
  1036. CComPtr<IBaseFilter> pBF;
  1038. HRESULT hr = AddSourceFilter(lpsz, &pBF, AfxGetAppSettings().SrcFilters & ~SRC_SUBS);
  1039. if(FAILED(hr)) return hr;
  1041. return pBF ? Render(pBF) : S_OK;
  1042. }
  1044. HRESULT CGraphBuilder::Render(IBaseFilter* pBF)
  1045. {
  1046. if(!m_pGB || !m_pFM || !pBF)
  1047. return E_FAIL;
  1049. if(FAILED(SafeAddFilter(pBF, NULL)))
  1050. return E_FAIL;
  1052. CInterfaceList<IPin> pOutputs;
  1053. BeginEnumPins(pBF, pEP, pPin)
  1054. {
  1055. PIN_DIRECTION dir;
  1056. CComPtr<IPin> pTmp;
  1057. CPinInfo pi;
  1058. if(FAILED(pPin->QueryDirection(&dir)) || dir != PINDIR_OUTPUT // not an output?
  1059. || SUCCEEDED(pPin->ConnectedTo(&pTmp)) // already connected?
  1060. || FAILED(pPin->QueryPinInfo(&pi)) || pi.achName[0] == '~') // hidden?
  1061. continue;
  1063. pOutputs.AddTail(pPin);
  1064. }
  1065. EndEnumPins
  1067. int nRendered = 0;
  1069. if(pOutputs.GetCount() > 0)
  1070. {
  1071. POSITION pos = pOutputs.GetHeadPosition();
  1072. while(pos)
  1073. {
  1074. if(SUCCEEDED(Render(pOutputs.GetNext(pos)))) nRendered++;
  1075. if(pOutputs.GetCount() > 1) m_nCurrentStream++;
  1076. }
  1077. }
  1078. else
  1079. {
  1080. m_nTotalStreams++;
  1082. for(int i = 0; i < m_DeadEnds.GetCount(); i++)
  1083. {
  1084. if(m_DeadEnds[i]->nStream == m_nCurrentStream)
  1085. m_DeadEnds.RemoveAt(i--);
  1086. }
  1087. }
  1089. return 
  1090. nRendered == pOutputs.GetCount() ? (nRendered > 0 ? S_OK : S_FALSE) :
  1091. nRendered > 0 ? VFW_S_PARTIAL_RENDER :
  1092. VFW_E_CANNOT_RENDER;
  1093. }
  1095. typedef struct {CGraphFilter* pFilter; bool fExactMatch;} SortFilter;
  1097. static int compare(const void* arg1, const void* arg2)
  1098. {
  1099. SortFilter* sf1 = (SortFilter*)arg1;
  1100. SortFilter* sf2 = (SortFilter*)arg2;
  1101. /*
  1102. if(sf1->pFilter->GetMerit() < LMERIT(MERIT_PREFERRED) && sf2->pFilter->GetMerit() < LMERIT(MERIT_PREFERRED))
  1103. {
  1104. if(!sf1->fExactMatch && sf2->fExactMatch) return 1;
  1105. else if(sf1->fExactMatch && !sf2->fExactMatch) return -1;
  1106. }
  1107. */
  1108. if(sf1->pFilter->GetCLSID() == sf2->pFilter->GetCLSID())
  1109. {
  1110. // prefer externals
  1111. CGraphFileFilter* f1 = dynamic_cast<CGraphFileFilter*>(sf1->pFilter);
  1112. CGraphFileFilter* f2 = dynamic_cast<CGraphFileFilter*>(sf2->pFilter);
  1113. if(!f1 && f2) return 1;
  1114. if(f1 && !f2) return -1;
  1115. }
  1117. if(sf1->pFilter->GetMerit() < sf2->pFilter->GetMerit()) return 1;
  1118. else if(sf1->pFilter->GetMerit() > sf2->pFilter->GetMerit()) return -1;
  1120. if(!sf1->fExactMatch && sf2->fExactMatch) return 1;
  1121. else if(sf1->fExactMatch && !sf2->fExactMatch) return -1;
  1123. return 0;
  1124. }
  1126. HRESULT CGraphBuilder::Render(IPin* pPin)
  1127. {
  1128. if(!m_pGB || !m_pFM || !pPin)
  1129. return E_FAIL;
  1131. PIN_DIRECTION dir;
  1132. CComPtr<IPin> pPinTmp;
  1133. if(FAILED(pPin->QueryDirection(&dir)) || dir != PINDIR_OUTPUT
  1134. || SUCCEEDED(pPin->ConnectedTo(&pPinTmp)))
  1135. return E_UNEXPECTED;
  1137. if(GetCLSID(pPin) == CLSID_MPEG2Demultiplexer)
  1138. {
  1139. CComQIPtr<IMediaSeeking> pMS = pPin;
  1140. if(!pMS) return E_FAIL;
  1141. REFERENCE_TIME rtDur = 0;
  1142. if(FAILED(pMS->GetDuration(&rtDur)) || rtDur <= 0)
  1143.  return E_FAIL;
  1144. rtDur = rtDur;
  1145. }
  1147. bool fDeadEnd = true;
  1149. // 1. stream builder interface
  1151. if(CComQIPtr<IStreamBuilder> pSB = pPin)
  1152. {
  1153. CInterfaceList<IBaseFilter> bfl;
  1154. SaveFilters(bfl);
  1156. if(SUCCEEDED(pSB->Render(pPin, m_pGB)))
  1157. return S_OK;
  1159. pSB->Backout(pPin, m_pGB);
  1161. RestoreFilters(bfl);
  1162. }
  1164. // 2. filter cache
  1166. if(CComQIPtr<IGraphConfig> pGC = m_pGB)
  1167. {
  1168. CComPtr<IEnumFilters> pEF;
  1169. if(SUCCEEDED(pGC->EnumCacheFilter(&pEF)))
  1170. {
  1171. for(CComPtr<IBaseFilter> pBF; S_OK == pEF->Next(1, &pBF, NULL); pBF = NULL)
  1172. {
  1173. CInterfaceList<IBaseFilter> bfl;
  1174. SaveFilters(bfl);
  1176. pGC->RemoveFilterFromCache(pBF);
  1178. if(SUCCEEDED(ConnectDirect(pPin, pBF)))
  1179. {
  1180. fDeadEnd = false;
  1182. HRESULT hr;
  1183. if(SUCCEEDED(hr = Render(pBF)))
  1184. return hr;
  1185. }
  1187. pGC->AddFilterToCache(pBF);
  1189. RestoreFilters(bfl);
  1190. }
  1191. }
  1192. }
  1194. // 3. disconnected inputs
  1196. CInterfaceList<IBaseFilter> pFilters;
  1197. SaveFilters(pFilters);
  1199. POSITION pos;
  1201. // FIXME: ffdshow likes to connect to the audio capture filter's fake input pins
  1202. if(!dynamic_cast<CGraphBuilderCapture*>(this))
  1203. {
  1204. pos = pFilters.GetHeadPosition();
  1205. while(pos)
  1206. {
  1207. CComPtr<IBaseFilter> pBF = pFilters.GetNext(pos);
  1209. if(SUCCEEDED(ConnectDirect(pPin, pBF)))
  1210. {
  1211. fDeadEnd = false;
  1213. HRESULT hr;
  1214. if(SUCCEEDED(hr = Render(pBF)))
  1215. return hr;
  1216. }
  1217. }
  1218. }
  1220. // 4. registry+internal+external
  1222. // TODO: try media types one-by-one and pass pmt to ConnectDirect (this may not be better than the current!!!)
  1224. CArray<GUID> guids;
  1225.     ExtractMediaTypes(pPin, guids);
  1227. if(guids.GetCount() == 2 && guids[0] == MEDIATYPE_Stream && guids[1] == MEDIASUBTYPE_NULL)
  1228. {
  1229. if(CComQIPtr<IAsyncReader> pReader = pPin)
  1230. {
  1231. BYTE buff[4];
  1232. if(S_OK == pReader->SyncRead(0, 4, buff) && *(DWORD*)buff == 'SggO')
  1233. guids[1] = MEDIASUBTYPE_Ogg;
  1234. }
  1235. }
  1236. else if(guids.GetCount() == 2 && guids[0] == MEDIATYPE_Video && guids[1] == FOURCCMap('MGXD'))
  1237. {
  1238. guids[1] = FOURCCMap('XVID');
  1239. }
  1241. CAutoPtrList<CGraphFilter> autogfs;
  1242. CArray<CGraphFilter*> gfs;
  1244. CComPtr<IEnumMoniker> pEM;
  1245. if(guids.GetCount() > 0 
  1246. && SUCCEEDED(m_pFM->EnumMatchingFilters(
  1247. &pEM, 0, FALSE, MERIT_DO_NOT_USE+1, 
  1248. TRUE, guids.GetCount()/2, guids.GetData(), NULL, NULL, FALSE,
  1249. FALSE, 0, NULL, NULL, NULL)))
  1250. {
  1251. for(CComPtr<IMoniker> pMoniker; S_OK == pEM->Next(1, &pMoniker, NULL); pMoniker = NULL)
  1252. {
  1253. CAutoPtr<CGraphFilter> pGraphFilter(new CGraphRegFilter(pMoniker));
  1255. if(pGraphFilter)
  1256. {
  1257. POSITION pos = m_pMoreFilters.GetHeadPosition();
  1258. while(pos)
  1259. {
  1260. CGraphRegFilter* f = dynamic_cast<CGraphRegFilter*>((CGraphFilter*)m_pMoreFilters.GetNext(pos));
  1261. if(!f) continue;
  1263. if(f->GetMoniker() && S_OK == pMoniker->IsEqual(f->GetMoniker())
  1264. || f->GetCLSID() != GUID_NULL && f->GetCLSID() == pGraphFilter->GetCLSID())
  1265. {
  1266. pGraphFilter.Free();
  1267. break;
  1268. }
  1269. }
  1270. }
  1272. if(pGraphFilter)
  1273. {
  1274. autogfs.AddTail(pGraphFilter);
  1275. }
  1276. }
  1277. }
  1279. pos = autogfs.GetHeadPosition();
  1280. while(pos)
  1281. {
  1282. CGraphFilter* f = autogfs.GetNext(pos);
  1284. bool fFound = false;
  1286. POSITION pos2 = m_chain.GetHeadPosition();
  1287. while(pos2)
  1288. {
  1289. if(f->GetCLSID() == m_chain.GetNext(pos2)->GetCLSID())
  1290. {
  1291. fFound = true;
  1292. break;
  1293. }
  1294. }
  1296. if(!fFound)
  1297. gfs.Add(f);
  1298. }
  1300. pos = m_pMoreFilters.GetHeadPosition();
  1301. while(pos)
  1302. {
  1303. CGraphFilter* f = m_pMoreFilters.GetNext(pos);
  1304. if(f->GetMerit() >= LMERIT_DO_USE && !m_chain.Find(f) && f->IsCompatible(guids))
  1305. gfs.Add(f);
  1306. }
  1308. CArray<SortFilter> sfs;
  1309. sfs.SetSize(gfs.GetCount());
  1310. for(int i = 0; i < gfs.GetCount(); i++)
  1311. {
  1312. sfs[i].pFilter = gfs[i];
  1313. sfs[i].fExactMatch = gfs[i]->IsExactMatch(guids);
  1314. }
  1315. if(sfs.GetCount() > 1) qsort(sfs.GetData(), sfs.GetCount(), sizeof(SortFilter), compare);
  1317. for(int i = 0; i < sfs.GetCount(); i++)
  1318. {
  1319. CGraphFilter* gf = sfs[i].pFilter;
  1320. if(!gf) continue;
  1322. CComPtr<IBaseFilter> pBF;
  1323. CComPtr<IUnknown> pUnk;
  1324. if(FAILED(gf->Create(&pBF, &pUnk)))
  1325. continue;
  1327. CInterfaceList<IBaseFilter> bfl;
  1328. SaveFilters(bfl);
  1330. if(FAILED(SafeAddFilter(pBF, gf->GetName())))
  1331. continue;
  1333. if(gf->GetCLSID() == CLSID_DMOWrapperFilter)
  1334. {
  1335. if(CComQIPtr<IPropertyBag> pPBag = pBF)
  1336. {
  1337. CComVariant var(true);
  1338. pPBag->Write(CComBSTR(L"_HIRESOUTPUT"), &var);
  1339. }
  1340. }
  1342. if(CComQIPtr<IMpeg2DecFilter> m_pMpeg2DecFilter = pBF)
  1343. {
  1344. AppSettings& s = AfxGetAppSettings();
  1345. m_pMpeg2DecFilter->SetDeinterlaceMethod((ditype)s.mpegdi);
  1346. m_pMpeg2DecFilter->SetBrightness(s.mpegbright);
  1347. m_pMpeg2DecFilter->SetContrast(s.mpegcont);
  1348. m_pMpeg2DecFilter->SetHue(s.mpeghue);
  1349. m_pMpeg2DecFilter->SetSaturation(s.mpegsat);
  1350. m_pMpeg2DecFilter->EnableForcedSubtitles(s.mpegforcedsubs);
  1351. m_pMpeg2DecFilter->EnablePlanarYUV(s.mpegplanaryuv);
  1352. }
  1354. if(CComQIPtr<IMpaDecFilter> m_pMpaDecFilter = pBF)
  1355. {
  1356. AppSettings& s = AfxGetAppSettings();
  1357. m_pMpaDecFilter->SetSampleFormat((SampleFormat)s.mpasf);
  1358. m_pMpaDecFilter->SetNormalize(s.mpanormalize);
  1359. m_pMpaDecFilter->SetSpeakerConfig(IMpaDecFilter::ac3, s.ac3sc);
  1360. m_pMpaDecFilter->SetDynamicRangeControl(IMpaDecFilter::ac3, s.ac3drc);
  1361. m_pMpaDecFilter->SetSpeakerConfig(IMpaDecFilter::dts, s.dtssc);
  1362. m_pMpaDecFilter->SetDynamicRangeControl(IMpaDecFilter::dts, s.dtsdrc);
  1363. m_pMpaDecFilter->SetSpeakerConfig(IMpaDecFilter::aac, s.aacsc);
  1364. m_pMpaDecFilter->SetBoost(s.mpaboost);
  1365. }
  1367. HRESULT hr = E_FAIL;
  1369. if(guids.GetCount() == 2 && guids[0] == MEDIATYPE_Stream && guids[1] != MEDIATYPE_NULL)
  1370. {
  1371. CMediaType mt;
  1372. mt.majortype = guids[0];
  1373. mt.subtype = guids[1];
  1374. mt.formattype = FORMAT_None;
  1375. hr = ConnectDirect(pPin, pBF, &mt);
  1377. if(FAILED(hr))
  1378. {
  1379. mt.formattype = GUID_NULL;
  1380. hr = ConnectDirect(pPin, pBF, &mt);
  1381. }
  1382. }
  1384. if(SUCCEEDED(hr) || SUCCEEDED(ConnectDirect(pPin, pBF, NULL)))
  1385. {
  1386. fDeadEnd = false;
  1388. int nCurrentStream = m_nCurrentStream;
  1390. m_chain.AddTail(gf);
  1392. hr = Render(pBF);
  1394. m_chain.RemoveTail();
  1396. if(SUCCEEDED(hr))
  1397. {
  1398. if(pUnk) m_pUnks.AddTail(pUnk);
  1400. // maybe the application should do this...
  1401. if(CComQIPtr<IMixerPinConfig, &IID_IMixerPinConfig> pMPC = pUnk)
  1402. pMPC->SetAspectRatioMode(AM_ARMODE_STRETCHED);
  1403. if(CComQIPtr<IVMRAspectRatioControl> pARC = pBF)
  1404. pARC->SetAspectRatioMode(VMR_ARMODE_NONE);
  1405. if(CComQIPtr<IVMRAspectRatioControl9> pARC = pBF)
  1406. pARC->SetAspectRatioMode(VMR_ARMODE_NONE);
  1408. return hr;
  1409. }
  1411. m_nCurrentStream = nCurrentStream;
  1412. }
  1414. m_pGB->RemoveFilter(pBF);
  1416. RestoreFilters(bfl);
  1417. }
  1419. // 5. record filter/pin/mts if this was the end of a chain
  1421. if(fDeadEnd)
  1422. {
  1423. CAutoPtr<DeadEnd> de(new DeadEnd);
  1424. de->nStream = m_nCurrentStream;
  1425. de->clsid = CStringFromGUID(GetCLSID(pPin));
  1426. de->filter = GetFilterName(GetFilterFromPin(pPin));
  1427. de->pin = GetPinName(pPin);
  1428. ExtractMediaTypes(pPin, de->mts);
  1429. if(!(m_chain.GetCount() == 0 && de->mts.GetCount() == 1
  1430. && de->mts.GetHead().majortype == MEDIATYPE_Stream && de->mts.GetHead().subtype == MEDIASUBTYPE_NULL))
  1431. {
  1432. CString str;
  1433. str.Format(_T("Stream %d"), m_nCurrentStream);
  1434. de->path.AddTail(str);
  1435. POSITION pos = m_chain.GetHeadPosition();
  1436. while(pos) de->path.AddTail(CString(m_chain.GetNext(pos)->GetName()));
  1437. m_DeadEnds.Add(de);
  1438. }
  1439. }
  1441. return E_FAIL;
  1442. }
  1444. HRESULT CGraphBuilder::ConnectDirect(IPin* pPin, IBaseFilter* pBF, const AM_MEDIA_TYPE* pmt)
  1445. {
  1446. if(!pPin || !pBF)
  1447. return E_INVALIDARG;
  1449. if(FAILED(SafeAddFilter(pBF, NULL)))
  1450. return E_FAIL;
  1452. BeginEnumPins(pBF, pEP, pPinTo)
  1453. {
  1454. PIN_DIRECTION dir;
  1455. CComPtr<IPin> pTmp;
  1456. if(FAILED(pPinTo->QueryDirection(&dir)) || dir != PINDIR_INPUT
  1457. || SUCCEEDED(pPinTo->ConnectedTo(&pTmp)))
  1458. continue;
  1460. if(SUCCEEDED(m_pGB->ConnectDirect(pPin, pPinTo, pmt)))
  1461. return S_OK;
  1462. }
  1463. EndEnumPins
  1465. return VFW_E_CANNOT_CONNECT;
  1466. }
  1468. HRESULT CGraphBuilder::FindInterface(REFIID iid, void** ppv)
  1469. {
  1470. CheckPointer(ppv, E_POINTER);
  1472. POSITION pos = m_pUnks.GetHeadPosition();
  1473. while(pos)
  1474. {
  1475. IUnknown* pUnk = m_pUnks.GetNext(pos);
  1476. HRESULT hr;
  1477. if(SUCCEEDED(hr = pUnk->QueryInterface(iid, ppv)))
  1478. return hr;
  1479. }
  1481. return E_NOINTERFACE;
  1482. }
  1484. //
  1485. // CGraphBuilderFile
  1486. //
  1488. CGraphBuilderFile::CGraphBuilderFile(IGraphBuilder* pGB, HWND hWnd)
  1489. : CGraphBuilder(pGB, hWnd)
  1490. {
  1491. CList<GUID> guids;
  1493. if(AfxGetAppSettings().fEnableAudioSwitcher)
  1494. {
  1495. guids.AddTail(MEDIATYPE_Audio);
  1496. guids.AddTail(MEDIASUBTYPE_NULL);
  1497. AddFilter(new CGraphCustomFilter(__uuidof(CAudioSwitcherFilter), guids, L"Audio Switcher", m_ARMerit + 0x100));
  1498. guids.RemoveAll();
  1500. CLSID CLSID_MorganStreamSwitcher = GUIDFromCString(_T("{D3CD7858-971A-4838-ACEC-40CA5D529DC8}"));
  1501. AddFilter(new CGraphRegFilter(CLSID_MorganStreamSwitcher, LMERIT_DO_NOT_USE));
  1502. }
  1503. }
  1505. //
  1506. // CGraphBuilderDVD
  1507. //
  1509. CGraphBuilderDVD::CGraphBuilderDVD(IGraphBuilder* pGB, HWND hWnd)
  1510. : CGraphBuilderFile(pGB, hWnd)
  1511. {
  1512. CList<GUID> guids;
  1513. /*
  1514. // there wasn't much use of this and the users were just 
  1515. // confused by "decss" being in the report after a failed 
  1516. // dvd nav pin rendering
  1518. guids.AddTail(MEDIATYPE_DVD_ENCRYPTED_PACK);
  1519. guids.AddTail(MEDIASUBTYPE_NULL);
  1520. AddFilter(new CGraphCustomFilter(__uuidof(CDeCSSFilter), guids, L"DeCSS", LMERIT_UNLIKELY));
  1521. guids.RemoveAll();
  1522. */
  1523. DWORD ver = ::GetVersion();
  1524. bool m_fXp = (int)ver >= 0 && (((ver<<8)&0xff00)|((ver>>8)&0xff)) >= 0x0501;
  1526. AppSettings& s = AfxGetAppSettings();
  1527. if(!m_fXp && s.iDSVideoRendererType != VIDRNDT_DS_OVERLAYMIXER 
  1528. || s.iDSVideoRendererType == VIDRNDT_DS_OLDRENDERER)
  1529.         AddFilter(new CGraphRendererFilter(CLSID_OverlayMixer, m_hWnd, L"Overlay Mixer", m_VRMerit-1));
  1531. // this filter just simply sucks for dvd playback (atm)
  1532. CLSID CLSID_ElecardMpeg2 = GUIDFromCString(_T("{F50B3F13-19C4-11CF-AA9A-02608C9BABA2}"));
  1533. AddFilter(new CGraphRegFilter(CLSID_ElecardMpeg2, LMERIT_DO_NOT_USE));
  1534. }
  1536. #include "....decssVobFile.h"
  1538. class CResetDVD : public CDVDSession
  1539. {
  1540. public:
  1541. CResetDVD(LPCTSTR path)
  1542. {
  1543. if(Open(path))
  1544. {
  1545. if(BeginSession())
  1546. {
  1547. Authenticate();
  1548. // GetDiscKey();
  1549. EndSession();
  1550. }
  1552. Close();
  1553. }
  1554. }
  1555. };
  1557. [uuid("482d10b6-376e-4411-8a17-833800A065DB")]
  1558. class ratDVDNavigator {};
  1560. HRESULT CGraphBuilderDVD::Render(CString fn, CString& path)
  1561. {
  1562. if(!m_pGB) return E_INVALIDARG;
  1564. HRESULT hr;
  1566. GUID clsid = CLSID_DVDNavigator;
  1567. if(fn.MakeLower().Find(_T(".ratdvd")) >= 0)
  1568. clsid = __uuidof(ratDVDNavigator);
  1570. CComPtr<IBaseFilter> pBF;
  1571. if(FAILED(hr = pBF.CoCreateInstance(clsid)))
  1572.   return E_FAIL;
  1574. if(FAILED(hr = m_pGB->AddFilter(pBF, L"DVD Navigator")))
  1575. return VFW_E_CANNOT_LOAD_SOURCE_FILTER;
  1577. CComQIPtr<IDvdControl2> pDVDC;
  1578. CComQIPtr<IDvdInfo2> pDVDI;
  1580. if(!((pDVDC = pBF) && (pDVDI = pBF)))
  1581. return E_NOINTERFACE;
  1583. WCHAR buff[MAX_PATH];
  1584. ULONG len;
  1585. if((!fn.IsEmpty()
  1586. && FAILED(hr = pDVDC->SetDVDDirectory(CStringW(fn)))
  1587. && FAILED(hr = pDVDC->SetDVDDirectory(CStringW(fn + _T("VIDEO_TS"))))
  1588. && FAILED(hr = pDVDC->SetDVDDirectory(CStringW(fn + _T("\VIDEO_TS")))))
  1589. || FAILED(hr = pDVDI->GetDVDDirectory(buff, MAX_PATH, &len)) || len == 0)
  1590. return VFW_E_CANNOT_LOAD_SOURCE_FILTER;
  1592. path = buff;
  1594. pDVDC->SetOption(DVD_ResetOnStop, FALSE);
  1595. pDVDC->SetOption(DVD_HMSF_TimeCodeEvents, TRUE);
  1597. m_pUnks.AddTail(pDVDC);
  1598. m_pUnks.AddTail(pDVDI);
  1600. if(clsid == CLSID_DVDNavigator)
  1601. CResetDVD tmp(path);
  1603. return __super::Render(pBF);
  1604. }
  1606. //
  1607. // CGraphBuilderCapture
  1608. //
  1610. CGraphBuilderCapture::CGraphBuilderCapture(IGraphBuilder* pGB, HWND hWnd)
  1611. : CGraphBuilderFile(pGB, hWnd)
  1612. {
  1613. CList<GUID> guids;
  1615. // if(AfxGetAppSettings().fEnableDeinterlacer)
  1616. {
  1617. guids.AddTail(MEDIATYPE_Video);
  1618. guids.AddTail(MEDIASUBTYPE_NULL);
  1619. AddFilter(new CGraphCustomFilter(__uuidof(CDeinterlacerFilter), guids, L"Deinterlacer", m_VRMerit + 0x100));
  1620. guids.RemoveAll();
  1621. }
  1622. /**/
  1623. CLSID CLSID_MorganStreamSwitcher = GUIDFromCString(_T("{D3CD7858-971A-4838-ACEC-40CA5D529DC8}"));
  1624. AddFilter(new CGraphRegFilter(CLSID_MorganStreamSwitcher, LMERIT_DO_NOT_USE));
  1625. }
  1627. //
  1628. // CGraphFilter
  1629. //
  1631. CGraphFilter::CGraphFilter(CStringW name, ULONGLONG merit)
  1632. : m_name(name), m_clsid(GUID_NULL)
  1633. {
  1634. m_merit.val = merit;
  1635. }
  1637. bool CGraphFilter::IsExactMatch(CArray<GUID>& guids)
  1638. {
  1639. POSITION pos = m_guids.GetHeadPosition();
  1640. while(pos)
  1641. {
  1642. GUID& major = m_guids.GetNext(pos);
  1643. if(!pos) {ASSERT(0); break;}
  1644. GUID& sub = m_guids.GetNext(pos);
  1646. for(int i = 0; i < (guids.GetCount()&~1); i += 2)
  1647. {
  1648. if(major == guids[i] && major != GUID_NULL
  1649. && sub == guids[i+1] && sub != GUID_NULL)
  1650.              return(true);
  1651. }
  1652. }
  1654. return(false);
  1655. }
  1657. bool CGraphFilter::IsCompatible(CArray<GUID>& guids)
  1658. {
  1659. POSITION pos = m_guids.GetHeadPosition();
  1660. while(pos)
  1661. {
  1662. GUID& major = m_guids.GetNext(pos);
  1663. if(!pos) {ASSERT(0); break;}
  1664. GUID& sub = m_guids.GetNext(pos);
  1666. for(int i = 0; i < (guids.GetCount()&~1); i += 2)
  1667. {
  1668. if((major == GUID_NULL || guids[i] == GUID_NULL || major == guids[i])
  1669. && (sub == GUID_NULL || guids[i+1] == GUID_NULL || sub == guids[i+1]))
  1670.              return(true);
  1671. }
  1672. }
  1674. return(false);
  1675. }
  1677. //
  1678. // CGraphRegFilter
  1679. //
  1681. CGraphRegFilter::CGraphRegFilter(IMoniker* pMoniker, ULONGLONG merit) 
  1682. : CGraphFilter(L"", merit), m_pMoniker(pMoniker)
  1683. {
  1684. if(!m_pMoniker) return;
  1686. LPOLESTR str = NULL;
  1687. if(FAILED(m_pMoniker->GetDisplayName(0, 0, &str))) return;
  1688. m_dispname = m_name = str;
  1689. CoTaskMemFree(str), str = NULL;
  1691. CComPtr<IPropertyBag> pPB;
  1692. if(SUCCEEDED(m_pMoniker->BindToStorage(0, 0, IID_IPropertyBag, (void**)&pPB)))
  1693. {
  1694. CComVariant var;
  1695. if(SUCCEEDED(pPB->Read(CComBSTR(_T("FriendlyName")), &var, NULL)))
  1696. {
  1697. m_name = var.bstrVal;
  1698. var.Clear();
  1699. }
  1701. if(SUCCEEDED(pPB->Read(CComBSTR(_T("CLSID")), &var, NULL)))
  1702. {
  1703. CLSIDFromString(var.bstrVal, &m_clsid);
  1704. var.Clear();
  1705. }
  1707. if(SUCCEEDED(pPB->Read(CComBSTR(_T("FilterData")), &var, NULL)))
  1708. {
  1709. BSTR* pstr;
  1710. if(SUCCEEDED(SafeArrayAccessData(var.parray, (void**)&pstr)))
  1711. {
  1712. ExtractFilterData((BYTE*)pstr, var.parray->cbElements*(var.parray->rgsabound[0].cElements));
  1713. SafeArrayUnaccessData(var.parray);
  1714. }
  1715. var.Clear();
  1716. }
  1717. }
  1719. if(merit != LMERIT_DO_USE) m_merit.val = merit;
  1720. }
  1722. CGraphRegFilter::CGraphRegFilter(CStringW m_dispname, ULONGLONG merit) 
  1723. : CGraphFilter(L"", merit), m_dispname(m_dispname)
  1724. {
  1725. if(m_dispname.IsEmpty()) return;
  1727. CComPtr<IBindCtx> pBC;
  1728. CreateBindCtx(0, &pBC);
  1730. ULONG chEaten;
  1731. if(S_OK != MkParseDisplayName(pBC, CComBSTR(m_dispname), &chEaten, &m_pMoniker))
  1732. return;
  1734. CComPtr<IPropertyBag> pPB;
  1735. if(SUCCEEDED(m_pMoniker->BindToStorage(0, 0, IID_IPropertyBag, (void**)&pPB)))
  1736. {
  1737. CComVariant var;
  1738. if(SUCCEEDED(pPB->Read(CComBSTR(_T("FriendlyName")), &var, NULL)))
  1739. {
  1740. m_name = var.bstrVal;
  1741. var.Clear();
  1742. }
  1744. if(SUCCEEDED(pPB->Read(CComBSTR(_T("CLSID")), &var, NULL)))
  1745. {
  1746. CLSIDFromString(var.bstrVal, &m_clsid);
  1747. var.Clear();
  1748. }
  1750. if(SUCCEEDED(pPB->Read(CComBSTR(_T("FilterData")), &var, NULL)))
  1751. {
  1752. BSTR* pstr;
  1753. if(SUCCEEDED(SafeArrayAccessData(var.parray, (void**)&pstr)))
  1754. {
  1755. ExtractFilterData((BYTE*)pstr, var.parray->cbElements*(var.parray->rgsabound[0].cElements));
  1756. SafeArrayUnaccessData(var.parray);
  1757. }
  1758. var.Clear();
  1759. }
  1760. }
  1762. if(merit != LMERIT_DO_USE) m_merit.val = merit;
  1763. }
  1765. CGraphRegFilter::CGraphRegFilter(const CLSID& clsid, ULONGLONG merit) 
  1766. : CGraphFilter(L"", merit)
  1767. {
  1768. if((m_clsid = clsid) == GUID_NULL) return;
  1770. CString guid = CStringFromGUID(m_clsid);
  1771. CString str = CString(_T("CLSID\{083863F1-70DE-11d0-BD40-00A0C911CE86}\Instance\")) + guid;
  1772. CString str2 = CString(_T("CLSID\")) + guid;
  1774. CRegKey key;
  1776. if(ERROR_SUCCESS == key.Open(HKEY_CLASSES_ROOT, str2, KEY_READ))
  1777. {
  1778. ULONG nChars = 0;
  1779. if(ERROR_SUCCESS == key.QueryStringValue(NULL, NULL, &nChars))
  1780. {
  1781. CString name;
  1782. if(ERROR_SUCCESS == key.QueryStringValue(NULL, name.GetBuffer(nChars), &nChars))
  1783. {
  1784. name.ReleaseBuffer(nChars);
  1785. m_name = name;
  1786. }
  1787. }
  1789. key.Close();
  1790. }
  1792. if(ERROR_SUCCESS == key.Open(HKEY_CLASSES_ROOT, str, KEY_READ))
  1793. {
  1794. ULONG nChars = 0;
  1795. if(ERROR_SUCCESS == key.QueryStringValue(_T("FriendlyName"), NULL, &nChars))
  1796. {
  1797. CString name;
  1798. if(ERROR_SUCCESS == key.QueryStringValue(_T("FriendlyName"), name.GetBuffer(nChars), &nChars))
  1799. {
  1800. name.ReleaseBuffer(nChars);
  1801. m_name = name;
  1802. }
  1803. }
  1805. ULONG nBytes = 0;
  1806. if(ERROR_SUCCESS == key.QueryBinaryValue(_T("FilterData"), NULL, &nBytes))
  1807. {
  1808. CAutoVectorPtr<BYTE> buff;
  1809. if(buff.Allocate(nBytes) && ERROR_SUCCESS == key.QueryBinaryValue(_T("FilterData"), buff, &nBytes))
  1810. {
  1811. ExtractFilterData(buff, nBytes);
  1812. }
  1813. }
  1815. key.Close();
  1816. }
  1818. if(merit != LMERIT_DO_USE) m_merit.val = merit;
  1819. }
  1821. [uuid("97f7c4d4-547b-4a5f-8332-536430ad2e4d")]
  1822. interface IAMFilterData : public IUnknown
  1823. {
  1824. STDMETHOD (ParseFilterData) (BYTE* rgbFilterData, ULONG cb, BYTE** prgbRegFilter2) PURE;
  1825. STDMETHOD (CreateFilterData) (REGFILTER2* prf2, BYTE** prgbFilterData, ULONG* pcb) PURE;
  1826. };
  1828. void CGraphRegFilter::ExtractFilterData(BYTE* p, UINT len)
  1829. {
  1830. CComPtr<IAMFilterData> pFD;
  1831. BYTE* ptr = NULL;
  1833. if(SUCCEEDED(pFD.CoCreateInstance(CLSID_FilterMapper2))
  1834. && SUCCEEDED(pFD->ParseFilterData(p, len, (BYTE**)&ptr)))
  1835. {
  1836. REGFILTER2* prf = (REGFILTER2*)*(DWORD*)ptr; // this is f*cked up
  1838. m_merit.mid = prf->dwMerit;
  1840. if(prf->dwVersion == 1)
  1841. {
  1842. for(UINT i = 0; i < prf->cPins; i++)
  1843. {
  1844. if(prf->rgPins[i].bOutput)
  1845. continue;
  1847. for(UINT j = 0; j < prf->rgPins[i].nMediaTypes; j++)
  1848. {
  1849. if(!prf->rgPins[i].lpMediaType[j].clsMajorType || !prf->rgPins[i].lpMediaType[j].clsMinorType)
  1850. break;
  1851. m_guids.AddTail(*(GUID*)prf->rgPins[i].lpMediaType[j].clsMajorType);
  1852. m_guids.AddTail(*(GUID*)prf->rgPins[i].lpMediaType[j].clsMinorType);
  1853. }
  1854. }
  1855. }
  1856. else if(prf->dwVersion == 2)
  1857. {
  1858. for(UINT i = 0; i < prf->cPins2; i++)
  1859. {
  1860. if(prf->rgPins2[i].dwFlags&REG_PINFLAG_B_OUTPUT)
  1861. continue;
  1863. for(UINT j = 0; j < prf->rgPins2[i].nMediaTypes; j++)
  1864. {
  1865. if(!prf->rgPins2[i].lpMediaType[j].clsMajorType || !prf->rgPins2[i].lpMediaType[j].clsMinorType)
  1866. break;
  1867. m_guids.AddTail(*(GUID*)prf->rgPins2[i].lpMediaType[j].clsMajorType);
  1868. m_guids.AddTail(*(GUID*)prf->rgPins2[i].lpMediaType[j].clsMinorType);
  1869. }
  1870. }
  1871. }
  1873. CoTaskMemFree(prf);
  1874. }
  1875. else
  1876. {
  1877. BYTE* base = p;
  1879. #define ChkLen(size) if(p - base + size > (int)len) return;
  1881. ChkLen(4)
  1882. if(*(DWORD*)p != 0x00000002) return; // only version 2 supported, no samples found for 1
  1883. p += 4;
  1885. ChkLen(4)
  1886. m_merit.mid = *(DWORD*)p; p += 4;
  1888. m_guids.RemoveAll();
  1890. ChkLen(8)
  1891. DWORD nPins = *(DWORD*)p; p += 8;
  1892. while(nPins-- > 0)
  1893. {
  1894. ChkLen(1)
  1895. BYTE n = *p-0x30; p++;
  1896. ChkLen(2)
  1897. WORD pi = *(WORD*)p; p += 2;
  1898. ASSERT(pi == 'ip');
  1899. ChkLen(1)
  1900. BYTE x33 = *p; p++;
  1901. ASSERT(x33 == 0x33);
  1902. ChkLen(8)
  1903. bool fOutput = !!(*p&REG_PINFLAG_B_OUTPUT);
  1904. p += 8;
  1905. ChkLen(12)
  1906. DWORD nTypes = *(DWORD*)p; p += 12;
  1907. while(nTypes-- > 0)
  1908. {
  1909. ChkLen(1)
  1910. BYTE n = *p-0x30; p++;
  1911. ChkLen(2)
  1912. WORD ty = *(WORD*)p; p += 2;
  1913. ASSERT(ty == 'yt');
  1914. ChkLen(5)
  1915. BYTE x33 = *p; p++;
  1916. ASSERT(x33 == 0x33);
  1917. p += 4;
  1919. ChkLen(8)
  1920. if(*(DWORD*)p < (p-base+8) || *(DWORD*)p >= len 
  1921. || *(DWORD*)(p+4) < (p-base+8) || *(DWORD*)(p+4) >= len)
  1922. {
  1923. p += 8;
  1924. continue;
  1925. }
  1927. GUID guid;
  1928. memcpy(&guid, &base[*(DWORD*)p], sizeof(GUID)); p += 4;
  1929. if(!fOutput) m_guids.AddTail(guid); 
  1930. memcpy(&guid, &base[*(DWORD*)p], sizeof(GUID)); p += 4;
  1931. if(!fOutput) m_guids.AddTail(guid); 
  1932. }
  1933. }
  1935. #undef ChkLen
  1937. }
  1938. /*
  1939. if(CLSID_MMSPLITTER == m_clsid && m_merit.val == LMERIT(MERIT_NORMAL-1))
  1940. {
  1941. m_merit.val = LMERIT(MERIT_NORMAL)+1; // take this mpeg2 demux...
  1942. }
  1943. */
  1944. }
  1946. HRESULT CGraphRegFilter::Create(IBaseFilter** ppBF, IUnknown** ppUnk)
  1947. {
  1948. CheckPointer(ppBF, E_POINTER);
  1950. if(ppUnk) *ppUnk = NULL;
  1952. HRESULT hr = E_FAIL;
  1955. if(m_pMoniker)
  1956. {
  1957. if(SUCCEEDED(hr = m_pMoniker->BindToObject(0, 0, IID_IBaseFilter, (void**)ppBF)))
  1958. m_clsid = ::GetCLSID(*ppBF);
  1959. }
  1960. else if(m_clsid != GUID_NULL)
  1961. {
  1962. CComPtr<IBaseFilter> pBF;
  1963. if(FAILED(pBF.CoCreateInstance(m_clsid))) return E_FAIL;
  1964. *ppBF = pBF.Detach();
  1965. hr = S_OK;
  1966. }
  1968. return hr;
  1969. };
  1971. //
  1972. // CGraphCustomFilter
  1973. //
  1975. CGraphCustomFilter::CGraphCustomFilter(const CLSID& clsid, CList<GUID>& guids, CStringW name, ULONGLONG merit) 
  1976. : CGraphFilter(name, merit)
  1977. {
  1978. m_clsid = clsid;
  1979. ASSERT(guids.GetCount() > 0);
  1980. m_guids.AddTail(&guids);
  1981. }
  1983. HRESULT CGraphCustomFilter::Create(IBaseFilter** ppBF, IUnknown** ppUnk)
  1984. {
  1985. CheckPointer(ppBF, E_POINTER);
  1987. if(ppUnk) *ppUnk = NULL;
  1989. HRESULT hr = S_OK;
  1991. *ppBF = 
  1992. m_clsid == __uuidof(CAVI2AC3Filter) ? (IBaseFilter*)new CAVI2AC3Filter(NULL, &hr) : 
  1993. m_clsid == __uuidof(CDeCSSFilter) ? (IBaseFilter*)new CDeCSSFilter(NULL, &hr) : 
  1994. m_clsid == __uuidof(CAudioSwitcherFilter) ? (IBaseFilter*)new CAudioSwitcherFilter(NULL, &hr) :
  1995. m_clsid == __uuidof(CMatroskaSplitterFilter) ? (IBaseFilter*)new CMatroskaSplitterFilter(NULL, &hr) :
  1996. m_clsid == __uuidof(CRealMediaSplitterFilter) ? (IBaseFilter*)new CRealMediaSplitterFilter(NULL, &hr) :
  1997. m_clsid == __uuidof(CRealVideoDecoder) ? (IBaseFilter*)new CRealVideoDecoder(NULL, &hr) :
  1998. m_clsid == __uuidof(CRealAudioDecoder) ? (IBaseFilter*)new CRealAudioDecoder(NULL, &hr) :
  1999. m_clsid == __uuidof(CRoQVideoDecoder) ? (IBaseFilter*)new CRoQVideoDecoder(NULL, &hr) :
  2000. m_clsid == __uuidof(CRoQAudioDecoder) ? (IBaseFilter*)new CRoQAudioDecoder(NULL, &hr) :
  2001. m_clsid == __uuidof(CAviSplitterFilter) ? (IBaseFilter*)new CAviSplitterFilter(NULL, &hr) :
  2002. m_clsid == __uuidof(CRoQSplitterFilter) ? (IBaseFilter*)new CRoQSplitterFilter(NULL, &hr) :
  2003. m_clsid == __uuidof(COggSplitterFilter) ? (IBaseFilter*)new COggSplitterFilter(NULL, &hr) :
  2004. m_clsid == __uuidof(CNutSplitterFilter) ? (IBaseFilter*)new CNutSplitterFilter(NULL, &hr) :
  2005. m_clsid == __uuidof(CMpegSplitterFilter) ? (IBaseFilter*)new CMpegSplitterFilter(NULL, &hr) :
  2006. m_clsid == __uuidof(CMpeg2DecFilter) ? (IBaseFilter*)new CMpeg2DecFilter(NULL, &hr) :
  2007. m_clsid == __uuidof(CDiracSplitterFilter) ? (IBaseFilter*)new CDiracSplitterFilter(NULL, &hr) :
  2008. m_clsid == __uuidof(CDiracVideoDecoder) ? (IBaseFilter*)new CDiracVideoDecoder(NULL, &hr) :
  2009. m_clsid == __uuidof(CMpaSplitterFilter) ? (IBaseFilter*)new CMpaSplitterFilter(NULL, &hr) :
  2010. m_clsid == __uuidof(CMpaDecFilter) ? (IBaseFilter*)new CMpaDecFilter(NULL, &hr) :
  2011. m_clsid == __uuidof(CDSMSplitterFilter) ? (IBaseFilter*)new CDSMSplitterFilter(NULL, &hr) :
  2012. m_clsid == __uuidof(CMP4SplitterFilter) ? (IBaseFilter*)new CMP4SplitterFilter(NULL, &hr) :
  2013. m_clsid == __uuidof(CNullVideoRenderer) ? (IBaseFilter*)new CNullVideoRenderer() :
  2014. m_clsid == __uuidof(CNullAudioRenderer) ? (IBaseFilter*)new CNullAudioRenderer() :
  2015. m_clsid == __uuidof(CNullUVideoRenderer) ? (IBaseFilter*)new CNullUVideoRenderer() :
  2016. m_clsid == __uuidof(CNullUAudioRenderer) ? (IBaseFilter*)new CNullUAudioRenderer() :
  2017. m_clsid == __uuidof(CNullTextRenderer) ? (IBaseFilter*)new CNullTextRenderer(NULL, &hr) :
  2018. m_clsid == __uuidof(CDeinterlacerFilter) ? (IBaseFilter*)new CDeinterlacerFilter(NULL, &hr) :
  2019. NULL;
  2021. __if_exists(CRadGtSplitterFilter)
  2022. {
  2023. if(*ppBF == NULL && m_clsid == __uuidof(CRadGtSplitterFilter))
  2024.  *ppBF = (IBaseFilter*)new CRadGtSplitterFilter(NULL, &hr);
  2025. }
  2027. if(!*ppBF) hr = E_FAIL;
  2028. else (*ppBF)->AddRef();
  2030. if(!*ppBF)
  2031. {
  2032. CComPtr<IBaseFilter> pBF;
  2033. if(SUCCEEDED(hr = pBF.CoCreateInstance(m_clsid)))
  2034. *ppBF = pBF.Detach();
  2035. }
  2037. if(SUCCEEDED(hr) && ppUnk)
  2038. {
  2039. if(m_clsid == __uuidof(CAudioSwitcherFilter))
  2040. {
  2041. *ppUnk = (IUnknown*)CComQIPtr<IAudioSwitcherFilter>(*ppBF).Detach();
  2042. CComQIPtr<IAudioSwitcherFilter> pASF = *ppUnk;
  2044. if(pASF)
  2045. {
  2046. AppSettings& s = AfxGetAppSettings();
  2047. pASF->SetSpeakerConfig(s.fCustomChannelMapping, s.pSpeakerToChannelMap);
  2048. pASF->EnableDownSamplingTo441(s.fDownSampleTo441);
  2049. pASF->SetAudioTimeShift(s.fAudioTimeShift ? 10000i64*s.tAudioTimeShift : 0);
  2050. }
  2051. }
  2052. }
  2054. return hr;
  2055. }
  2057. //
  2058. // CGraphFileFilter
  2059. //
  2061. CGraphFileFilter::CGraphFileFilter(const CLSID& clsid, CList<GUID>& guids, CString path, CStringW name, ULONGLONG merit)
  2062. : CGraphCustomFilter(clsid, guids, name, merit), m_path(path), m_hInst(NULL)
  2063. {
  2064. }
  2066. HRESULT CGraphFileFilter::Create(IBaseFilter** ppBF, IUnknown** ppUnk)
  2067. {
  2068. CheckPointer(ppBF, E_POINTER);
  2070. if(ppUnk) *ppUnk = NULL;
  2072. HRESULT hr = S_OK;
  2074. if(SUCCEEDED(hr = __super::Create(ppBF, ppUnk)))
  2075. return hr;
  2077. return LoadExternalFilter(m_path, m_clsid, ppBF);
  2078. }
  2080. //
  2081. // CGraphRendererFilter
  2082. //
  2084. CGraphRendererFilter::CGraphRendererFilter(const CLSID& clsid, HWND hWnd, CStringW name, ULONGLONG merit) 
  2085. : CGraphFilter(name, merit), m_clsid(clsid), m_hWnd(hWnd)
  2086. {
  2087. m_guids.AddTail(MEDIATYPE_Video);
  2088. m_guids.AddTail(MEDIASUBTYPE_NULL);
  2089. }
  2091. HRESULT CGraphRendererFilter::Create(IBaseFilter** ppBF, IUnknown** ppUnk)
  2092. {
  2093. CheckPointer(ppBF, E_POINTER);
  2095. HRESULT hr = S_OK;
  2097. if(m_clsid == CLSID_OverlayMixer)
  2098. {
  2099. CComPtr<IBaseFilter> pBF;
  2100. if(SUCCEEDED(pBF.CoCreateInstance(CLSID_OverlayMixer)))
  2101. {
  2102. BeginEnumPins(pBF, pEP, pPin)
  2103. {
  2104. if(CComQIPtr<IMixerPinConfig, &IID_IMixerPinConfig> pMPC = pPin)
  2105. {
  2106. if(ppUnk) *ppUnk = pMPC.Detach();
  2107. break;
  2108. }
  2109. }
  2110. EndEnumPins
  2112. *ppBF = pBF.Detach();
  2113. }
  2114. }
  2115. else if(m_clsid == CLSID_VideoMixingRenderer)
  2116. {
  2117. CComPtr<IBaseFilter> pBF;
  2118. if(SUCCEEDED(pBF.CoCreateInstance(CLSID_VideoMixingRenderer)))
  2119. *ppBF = pBF.Detach();
  2120. }
  2121. else if(m_clsid == CLSID_VideoMixingRenderer9)
  2122. {
  2123. CComPtr<IBaseFilter> pBF;
  2124. if(SUCCEEDED(pBF.CoCreateInstance(CLSID_VideoMixingRenderer9)))
  2125. *ppBF = pBF.Detach();
  2126. }
  2127. else if(m_clsid == CLSID_VMR7AllocatorPresenter)
  2128. {
  2129. CComPtr<ISubPicAllocatorPresenter> pCAP;
  2130. CComPtr<IUnknown> pRenderer;
  2131. if(SUCCEEDED(hr = CreateAP7(CLSID_VMR7AllocatorPresenter, m_hWnd, &pCAP))
  2132. && SUCCEEDED(hr = pCAP->CreateRenderer(&pRenderer)))
  2133. {
  2134. *ppBF = CComQIPtr<IBaseFilter>(pRenderer).Detach();
  2135. if(ppUnk) *ppUnk = (IUnknown*)pCAP.Detach();
  2136. }
  2137. }
  2138. else if(m_clsid == CLSID_VMR9AllocatorPresenter)
  2139. {
  2140. CComPtr<ISubPicAllocatorPresenter> pCAP;
  2141. CComPtr<IUnknown> pRenderer;
  2142. if(SUCCEEDED(hr = CreateAP9(CLSID_VMR9AllocatorPresenter, m_hWnd, &pCAP))
  2143. && SUCCEEDED(hr = pCAP->CreateRenderer(&pRenderer)))
  2144. {
  2145. *ppBF = CComQIPtr<IBaseFilter>(pRenderer).Detach();
  2146. if(ppUnk) *ppUnk = (IUnknown*)pCAP.Detach();
  2147. }
  2148. }
  2150. if(!*ppBF) hr = E_FAIL;
  2152. return hr;
  2153. }