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

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

多媒体编程

开发平台：

Visual C++

DSUtil.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 <atlcoll.h>
  24. #include <afxtempl.h>
  25. #include <Shlwapi.h>
  26. #include <atlpath.h>
  27. #include <Vfw.h>
  28. #include "....includewinddkdevioctl.h"
  29. #include "....includewinddkntddcdrm.h"
  30. #include "DSUtil.h"
  31. #include "....includemoreuuids.h"
  33. void DumpStreamConfig(TCHAR* fn, IAMStreamConfig* pAMVSCCap)
  34. {
  35. CString s, ss;
  36. CStdioFile f;
  37. if(!f.Open(fn, CFile::modeCreate|CFile::modeWrite|CFile::typeText))
  38. return;
  40. int cnt = 0, size = 0;
  41. if(FAILED(pAMVSCCap->GetNumberOfCapabilities(&cnt, &size)))
  42. return;
  44. s.Empty();
  45. s.Format(_T("cnt %d, size %dn"), cnt, size);
  46. f.WriteString(s);
  48. if(size == sizeof(VIDEO_STREAM_CONFIG_CAPS))
  49. {
  50. for(int i = 0; i < cnt; i++)
  51. {
  52. AM_MEDIA_TYPE* pmt = NULL;
  54. VIDEO_STREAM_CONFIG_CAPS caps;
  55. memset(&caps, 0, sizeof(caps));
  57. s.Empty();
  58. ss.Format(_T("%dn"), i); s += ss;
  59. f.WriteString(s);
  61. if(FAILED(pAMVSCCap->GetStreamCaps(i, &pmt, (BYTE*)&caps)))
  62. continue;
  64. {
  65. s.Empty();
  66. ss.Format(_T("VIDEO_STREAM_CONFIG_CAPSn")); s += ss;
  67. ss.Format(_T("tVideoStandard 0x%08xn"), caps.VideoStandard); s += ss;
  68. ss.Format(_T("tInputSize %dx%dn"), caps.InputSize); s += ss;
  69. ss.Format(_T("tCroppingSize %dx%d - %dx%dn"), caps.MinCroppingSize, caps.MaxCroppingSize); s += ss;
  70. ss.Format(_T("tCropGranularity %d, %dn"), caps.CropGranularityX, caps.CropGranularityY); s += ss;
  71. ss.Format(_T("tCropAlign %d, %dn"), caps.CropAlignX, caps.CropAlignY); s += ss;
  72. ss.Format(_T("tOutputSize %dx%d - %dx%dn"), caps.MinOutputSize, caps.MaxOutputSize); s += ss;
  73. ss.Format(_T("tOutputGranularity %d, %dn"), caps.OutputGranularityX, caps.OutputGranularityY); s += ss;
  74. ss.Format(_T("tStretchTaps %d, %dn"), caps.StretchTapsX, caps.StretchTapsY); s += ss;
  75. ss.Format(_T("tShrinkTaps %d, %dn"), caps.ShrinkTapsX, caps.ShrinkTapsY); s += ss;
  76. ss.Format(_T("tFrameInterval %I64d, %I64d (%.4f, %.4f)n"), 
  77. caps.MinFrameInterval, caps.MaxFrameInterval,
  78. (float)10000000/caps.MinFrameInterval, (float)10000000/caps.MaxFrameInterval); s += ss;
  79. ss.Format(_T("tBitsPerSecond %d - %dn"), caps.MinBitsPerSecond, caps.MaxBitsPerSecond); s += ss;
  80. f.WriteString(s);
  81. }
  83. BITMAPINFOHEADER* pbh;
  84. if(pmt->formattype == FORMAT_VideoInfo) 
  85. {
  86. VIDEOINFOHEADER* vih = (VIDEOINFOHEADER*)pmt->pbFormat;
  87. pbh = &vih->bmiHeader;
  89. s.Empty();
  90. ss.Format(_T("FORMAT_VideoInfon")); s += ss;
  91. ss.Format(_T("tAvgTimePerFrame %I64d, %.4fn"), vih->AvgTimePerFrame, (float)10000000/vih->AvgTimePerFrame); s += ss;
  92. ss.Format(_T("trcSource %d,%d,%d,%dn"), vih->rcSource); s += ss;
  93. ss.Format(_T("trcTarget %d,%d,%d,%dn"), vih->rcTarget); s += ss;
  94. f.WriteString(s);
  95. }
  96. else if(pmt->formattype == FORMAT_VideoInfo2) 
  97. {
  98. VIDEOINFOHEADER2* vih = (VIDEOINFOHEADER2*)pmt->pbFormat;
  99. pbh = &vih->bmiHeader;
  101. s.Empty();
  102. ss.Format(_T("FORMAT_VideoInfo2n")); s += ss;
  103. ss.Format(_T("tAvgTimePerFrame %I64d, %.4fn"), vih->AvgTimePerFrame, (float)10000000/vih->AvgTimePerFrame); s += ss;
  104. ss.Format(_T("trcSource %d,%d,%d,%dn"), vih->rcSource); s += ss;
  105. ss.Format(_T("trcTarget %d,%d,%d,%dn"), vih->rcTarget); s += ss;
  106. ss.Format(_T("tdwInterlaceFlags 0x%xn"), vih->dwInterlaceFlags); s += ss;
  107. ss.Format(_T("tdwPictAspectRatio %d:%dn"), vih->dwPictAspectRatioX, vih->dwPictAspectRatioY); s += ss;
  108. f.WriteString(s);
  109. }
  110. else
  111. {
  112. DeleteMediaType(pmt);
  113. continue;
  114. }
  116. s.Empty();
  117. ss.Format(_T("BITMAPINFOHEADERn")); s += ss;
  118. ss.Format(_T("tbiCompression %xn"), pbh->biCompression); s += ss;
  119. ss.Format(_T("tbiWidth %dn"), pbh->biWidth); s += ss;
  120. ss.Format(_T("tbiHeight %dn"), pbh->biHeight); s += ss;
  121. ss.Format(_T("tbiBitCount %dn"), pbh->biBitCount); s += ss;
  122. ss.Format(_T("tbiPlanes %dn"), pbh->biPlanes); s += ss;
  123. ss.Format(_T("tbiSizeImage %dn"), pbh->biSizeImage); s += ss;
  124. f.WriteString(s);
  126. DeleteMediaType(pmt);
  127. }
  128. }
  129. else if(size == sizeof(AUDIO_STREAM_CONFIG_CAPS))
  130. {
  131. // TODO
  132. }
  133. }
  135. int CountPins(IBaseFilter* pBF, int& nIn, int& nOut, int& nInC, int& nOutC)
  136. {
  137. nIn = nOut = 0;
  138. nInC = nOutC = 0;
  140. BeginEnumPins(pBF, pEP, pPin)
  141. {
  142. PIN_DIRECTION dir;
  143. if(SUCCEEDED(pPin->QueryDirection(&dir)))
  144. {
  145. CComPtr<IPin> pPinConnectedTo;
  146. pPin->ConnectedTo(&pPinConnectedTo);
  148. if(dir == PINDIR_INPUT) {nIn++; if(pPinConnectedTo) nInC++;}
  149. else if(dir == PINDIR_OUTPUT) {nOut++; if(pPinConnectedTo) nOutC++;}
  150. }
  151. }
  152. EndEnumPins
  154. return(nIn+nOut);
  155. }
  157. bool IsSplitter(IBaseFilter* pBF, bool fCountConnectedOnly)
  158. {
  159. int nIn, nOut, nInC, nOutC;
  160. CountPins(pBF, nIn, nOut, nInC, nOutC);
  161. return(fCountConnectedOnly ? nOutC > 1 : nOut > 1);
  162. }
  164. bool IsMultiplexer(IBaseFilter* pBF, bool fCountConnectedOnly)
  165. {
  166. int nIn, nOut, nInC, nOutC;
  167. CountPins(pBF, nIn, nOut, nInC, nOutC);
  168. return(fCountConnectedOnly ? nInC > 1 : nIn > 1);
  169. }
  171. bool IsStreamStart(IBaseFilter* pBF)
  172. {
  173. CComQIPtr<IAMFilterMiscFlags> pAMMF(pBF);
  174. if(pAMMF && pAMMF->GetMiscFlags()&AM_FILTER_MISC_FLAGS_IS_SOURCE)
  175. return(true);
  177. int nIn, nOut, nInC, nOutC;
  178. CountPins(pBF, nIn, nOut, nInC, nOutC);
  179. AM_MEDIA_TYPE mt;
  180. CComPtr<IPin> pIn = GetFirstPin(pBF);
  181. return((nOut > 1)
  182. || (nOut > 0 && nIn == 1 && pIn && SUCCEEDED(pIn->ConnectionMediaType(&mt)) && mt.majortype == MEDIATYPE_Stream));
  183. }
  185. bool IsStreamEnd(IBaseFilter* pBF)
  186. {
  187. int nIn, nOut, nInC, nOutC;
  188. CountPins(pBF, nIn, nOut, nInC, nOutC);
  189. return(nOut == 0);
  190. }
  192. bool IsVideoRenderer(IBaseFilter* pBF)
  193. {
  194. int nIn, nOut, nInC, nOutC;
  195. CountPins(pBF, nIn, nOut, nInC, nOutC);
  197. if(nInC > 0 && nOut == 0)
  198. {
  199. BeginEnumPins(pBF, pEP, pPin)
  200. {
  201. AM_MEDIA_TYPE mt;
  202. if(S_OK != pPin->ConnectionMediaType(&mt))
  203. continue;
  205. FreeMediaType(mt);
  207. return(!!(mt.majortype == MEDIATYPE_Video));
  208. /*&& (mt.formattype == FORMAT_VideoInfo || mt.formattype == FORMAT_VideoInfo2));*/
  209. }
  210. EndEnumPins
  211. }
  213. CLSID clsid;
  214. memcpy(&clsid, &GUID_NULL, sizeof(clsid));
  215. pBF->GetClassID(&clsid);
  217. return(clsid == CLSID_VideoRenderer || clsid == CLSID_VideoRendererDefault);
  218. }
  220. #include <initguid.h>
  222. DEFINE_GUID(CLSID_ReClock, 
  223. 0x9dc15360, 0x914c, 0x46b8, 0xb9, 0xdf, 0xbf, 0xe6, 0x7f, 0xd3, 0x6c, 0x6a); 
  225. bool IsAudioWaveRenderer(IBaseFilter* pBF)
  226. {
  227. int nIn, nOut, nInC, nOutC;
  228. CountPins(pBF, nIn, nOut, nInC, nOutC);
  230. if(nInC > 0 && nOut == 0 && CComQIPtr<IBasicAudio>(pBF))
  231. {
  232. BeginEnumPins(pBF, pEP, pPin)
  233. {
  234. AM_MEDIA_TYPE mt;
  235. if(S_OK != pPin->ConnectionMediaType(&mt))
  236. continue;
  238. FreeMediaType(mt);
  240. return(!!(mt.majortype == MEDIATYPE_Audio)
  241. /*&& mt.formattype == FORMAT_WaveFormatEx*/);
  242. }
  243. EndEnumPins
  244. }
  246. CLSID clsid;
  247. memcpy(&clsid, &GUID_NULL, sizeof(clsid));
  248. pBF->GetClassID(&clsid);
  250. return(clsid == CLSID_DSoundRender || clsid == CLSID_AudioRender || clsid == CLSID_ReClock
  251. || clsid == __uuidof(CNullAudioRenderer) || clsid == __uuidof(CNullUAudioRenderer));
  252. }
  254. IBaseFilter* GetUpStreamFilter(IBaseFilter* pBF, IPin* pInputPin)
  255. {
  256. BeginEnumPins(pBF, pEP, pPin)
  257. {
  258. if(pInputPin && pInputPin != pPin) continue;
  260. PIN_DIRECTION dir;
  261. CComPtr<IPin> pPinConnectedTo;
  262. if(SUCCEEDED(pPin->QueryDirection(&dir)) && dir == PINDIR_INPUT
  263. && SUCCEEDED(pPin->ConnectedTo(&pPinConnectedTo)))
  264. {
  265. return(GetFilterFromPin(pPinConnectedTo));
  266. }
  267. }
  268. EndEnumPins
  270. return(NULL);
  271. }
  273. IPin* GetUpStreamPin(IBaseFilter* pBF, IPin* pInputPin)
  274. {
  275. BeginEnumPins(pBF, pEP, pPin)
  276. {
  277. if(pInputPin && pInputPin != pPin) continue;
  279. PIN_DIRECTION dir;
  280. CComPtr<IPin> pPinConnectedTo;
  281. if(SUCCEEDED(pPin->QueryDirection(&dir)) && dir == PINDIR_INPUT
  282. && SUCCEEDED(pPin->ConnectedTo(&pPinConnectedTo)))
  283. {
  284. IPin* pRet = pPinConnectedTo.Detach();
  285. pRet->Release();
  286. return(pRet);
  287. }
  288. }
  289. EndEnumPins
  291. return(NULL);
  292. }
  294. IPin* GetFirstPin(IBaseFilter* pBF, PIN_DIRECTION dir)
  295. {
  296. if(!pBF) return(NULL);
  298. BeginEnumPins(pBF, pEP, pPin)
  299. {
  300. PIN_DIRECTION dir2;
  301. pPin->QueryDirection(&dir2);
  302. if(dir == dir2)
  303. {
  304. IPin* pRet = pPin.Detach();
  305. pRet->Release();
  306. return(pRet);
  307. }
  308. }
  309. EndEnumPins
  311. return(NULL);
  312. }
  314. IPin* GetFirstDisconnectedPin(IBaseFilter* pBF, PIN_DIRECTION dir)
  315. {
  316. if(!pBF) return(NULL);
  318. BeginEnumPins(pBF, pEP, pPin)
  319. {
  320. PIN_DIRECTION dir2;
  321. pPin->QueryDirection(&dir2);
  322. CComPtr<IPin> pPinTo;
  323. if(dir == dir2 && (S_OK != pPin->ConnectedTo(&pPinTo)))
  324. {
  325. IPin* pRet = pPin.Detach();
  326. pRet->Release();
  327. return(pRet);
  328. }
  329. }
  330. EndEnumPins
  332. return(NULL);
  333. }
  335. int RenderFilterPins(IBaseFilter* pBF, IGraphBuilder* pGB, bool fAll)
  336. {
  337. int nPinsRendered = 0;
  339. CInterfaceList<IPin> pProcessedPins;
  341. BeginEnumPins(pBF, pEP, pPin)
  342. {
  343. PIN_DIRECTION dir;
  344. CComPtr<IPin> pPinConnectedTo;
  345. if(SUCCEEDED(pPin->QueryDirection(&dir)) && dir == PINDIR_OUTPUT
  346. && FAILED(pPin->ConnectedTo(&pPinConnectedTo))
  347. && !pProcessedPins.Find(pPin))
  348. {
  349. CPinInfo pi;
  350. if(SUCCEEDED(pPin->QueryPinInfo(&pi)))
  351. {
  352. if(pi.achName[0] == '~' && !fAll)
  353. {
  354. pProcessedPins.AddTail(pPin);
  355. continue;
  356. }
  357. }
  359. if(FAILED(pPin->ConnectedTo(&pPinConnectedTo)))
  360. {
  361. if(SUCCEEDED(pGB->Render(pPin)) && SUCCEEDED(pPin->ConnectedTo(&pPinConnectedTo)))
  362. nPinsRendered++;
  363. }
  365. pEP->Reset();
  366. }
  368. pProcessedPins.AddTail(pPin);
  369. }
  370. EndEnumPins
  372. return(nPinsRendered);
  373. }
  375. void NukeDownstream(IBaseFilter* pBF, IFilterGraph* pFG)
  376. {
  377. if(!pBF) return;
  379. BeginEnumPins(pBF, pEP, pPin)
  380. {
  381. CComPtr<IPin> pPinTo;
  382. CPinInfo pi;
  383.         if(SUCCEEDED(pPin->ConnectedTo(&pPinTo)) && pPinTo
  384. && SUCCEEDED(pPinTo->QueryPinInfo(&pi)))
  385. {
  386. if(pi.dir == PINDIR_INPUT)
  387. {
  388. NukeDownstream(pi.pFilter, pFG);
  389. pFG->Disconnect(pPinTo);
  390. pFG->Disconnect(pPin);
  391. pFG->RemoveFilter(pi.pFilter);
  392. }
  393. }
  394. }
  395. EndEnumPins
  396. }
  398. void NukeDownstream(IPin* pPin, IFilterGraph* pFG)
  399. {
  400. CComPtr<IPin> pPinTo;
  401. if(!pPin || FAILED(pPin->ConnectedTo(&pPinTo)) || !pPinTo)
  402. return;
  404. CPinInfo pi;
  405. if(FAILED(pPinTo->QueryPinInfo(&pi)) || pi.dir != PINDIR_INPUT)
  406. return;
  408. NukeDownstream(pi.pFilter, pFG);
  410. pFG->RemoveFilter(pi.pFilter);
  411. }
  413. HRESULT AddFilterToGraph(IFilterGraph* pFG, IBaseFilter* pBF, WCHAR* pName)
  414. {
  415. return GetGraphFromFilter(pBF) ? S_FALSE : pFG->AddFilter(pBF, pName);
  416. }
  418. IBaseFilter* FindFilter(LPCWSTR clsid, IFilterGraph* pFG)
  419. {
  420. CLSID clsid2;
  421. CLSIDFromString(CComBSTR(clsid), &clsid2);
  422. return(FindFilter(clsid2, pFG));
  423. }
  425. IBaseFilter* FindFilter(const CLSID& clsid, IFilterGraph* pFG)
  426. {
  427. BeginEnumFilters(pFG, pEF, pBF)
  428. {
  429. CLSID clsid2;
  430. if(SUCCEEDED(pBF->GetClassID(&clsid2)) && clsid == clsid2)
  431. return(pBF);
  432. }
  433. EndEnumFilters
  435. return NULL;
  436. }
  438. CStringW GetFilterName(IBaseFilter* pBF)
  439. {
  440. CStringW name;
  441. CFilterInfo fi;
  442. if(pBF && SUCCEEDED(pBF->QueryFilterInfo(&fi)))
  443. name = fi.achName;
  444. return(name);
  445. }
  447. CStringW GetPinName(IPin* pPin)
  448. {
  449. CStringW name;
  450. CPinInfo pi;
  451. if(pPin && SUCCEEDED(pPin->QueryPinInfo(&pi))) 
  452. name = pi.achName;
  453. return(name);
  454. }
  456. IFilterGraph* GetGraphFromFilter(IBaseFilter* pBF)
  457. {
  458. if(!pBF) return NULL;
  459. IFilterGraph* pGraph = NULL;
  460. CFilterInfo fi;
  461. if(pBF && SUCCEEDED(pBF->QueryFilterInfo(&fi)))
  462. pGraph = fi.pGraph;
  463. return(pGraph);
  464. }
  466. IBaseFilter* GetFilterFromPin(IPin* pPin)
  467. {
  468. if(!pPin) return NULL;
  469. IBaseFilter* pBF = NULL;
  470. CPinInfo pi;
  471. if(pPin && SUCCEEDED(pPin->QueryPinInfo(&pi)))
  472. pBF = pi.pFilter;
  473. return(pBF);
  474. }
  476. IPin* AppendFilter(IPin* pPin, CString DisplayName, IGraphBuilder* pGB)
  477. {
  478. IPin* pRet = pPin;
  480. CInterfaceList<IBaseFilter> pFilters;
  482. do
  483. {
  484. if(!pPin || DisplayName.IsEmpty() || !pGB)
  485. break;
  487. CComPtr<IPin> pPinTo;
  488. PIN_DIRECTION dir;
  489. if(FAILED(pPin->QueryDirection(&dir)) || dir != PINDIR_OUTPUT || SUCCEEDED(pPin->ConnectedTo(&pPinTo)))
  490. break;
  492. CComPtr<IBindCtx> pBindCtx;
  493. CreateBindCtx(0, &pBindCtx);
  495. CComPtr<IMoniker> pMoniker;
  496. ULONG chEaten;
  497. if(S_OK != MkParseDisplayName(pBindCtx, CComBSTR(DisplayName), &chEaten, &pMoniker))
  498. break;
  500. CComPtr<IBaseFilter> pBF;
  501. if(FAILED(pMoniker->BindToObject(pBindCtx, 0, IID_IBaseFilter, (void**)&pBF)) || !pBF)
  502. break;
  504. CComPtr<IPropertyBag> pPB;
  505. if(FAILED(pMoniker->BindToStorage(pBindCtx, 0, IID_IPropertyBag, (void**)&pPB)))
  506. break;
  508. CComVariant var;
  509. if(FAILED(pPB->Read(CComBSTR(_T("FriendlyName")), &var, NULL)))
  510. break;
  512. pFilters.AddTail(pBF);
  513. BeginEnumFilters(pGB, pEnum, pBF2) 
  514. pFilters.AddTail(pBF2); 
  515. EndEnumFilters
  517. if(FAILED(pGB->AddFilter(pBF, CStringW(var.bstrVal))))
  518. break;
  520. BeginEnumFilters(pGB, pEnum, pBF2) 
  521. if(!pFilters.Find(pBF2) && SUCCEEDED(pGB->RemoveFilter(pBF2))) 
  522. pEnum->Reset();
  523. EndEnumFilters
  525. pPinTo = GetFirstPin(pBF, PINDIR_INPUT);
  526. if(!pPinTo)
  527. {
  528. pGB->RemoveFilter(pBF);
  529. break;
  530. }
  532. HRESULT hr;
  533. if(FAILED(hr = pGB->ConnectDirect(pPin, pPinTo, NULL)))
  534. {
  535. hr = pGB->Connect(pPin, pPinTo);
  536. pGB->RemoveFilter(pBF);
  537. break;
  538. }
  540. BeginEnumFilters(pGB, pEnum, pBF2) 
  541. if(!pFilters.Find(pBF2) && SUCCEEDED(pGB->RemoveFilter(pBF2))) 
  542. pEnum->Reset();
  543. EndEnumFilters
  545. pRet = GetFirstPin(pBF, PINDIR_OUTPUT);
  546. if(!pRet)
  547. {
  548. pRet = pPin;
  549. pGB->RemoveFilter(pBF);
  550. break;
  551. }
  552. }
  553. while(false);
  555. return(pRet);
  556. }
  558. IPin* InsertFilter(IPin* pPin, CString DisplayName, IGraphBuilder* pGB)
  559. {
  560. do
  561. {
  562. if(!pPin || DisplayName.IsEmpty() || !pGB)
  563. break;
  565. PIN_DIRECTION dir;
  566. if(FAILED(pPin->QueryDirection(&dir)))
  567. break;
  569. CComPtr<IPin> pFrom, pTo;
  571. if(dir == PINDIR_INPUT)
  572. {
  573. pPin->ConnectedTo(&pFrom);
  574. pTo = pPin;
  575. }
  576. else if(dir == PINDIR_OUTPUT)
  577. {
  578. pFrom = pPin;
  579. pPin->ConnectedTo(&pTo);
  580. }
  582. if(!pFrom || !pTo)
  583. break;
  585. CComPtr<IBindCtx> pBindCtx;
  586. CreateBindCtx(0, &pBindCtx);
  588. CComPtr<IMoniker> pMoniker;
  589. ULONG chEaten;
  590. if(S_OK != MkParseDisplayName(pBindCtx, CComBSTR(DisplayName), &chEaten, &pMoniker))
  591. break;
  593. CComPtr<IBaseFilter> pBF;
  594. if(FAILED(pMoniker->BindToObject(pBindCtx, 0, IID_IBaseFilter, (void**)&pBF)) || !pBF)
  595. break;
  597. CComPtr<IPropertyBag> pPB;
  598. if(FAILED(pMoniker->BindToStorage(pBindCtx, 0, IID_IPropertyBag, (void**)&pPB)))
  599. break;
  601. CComVariant var;
  602. if(FAILED(pPB->Read(CComBSTR(_T("FriendlyName")), &var, NULL)))
  603. break;
  605. if(FAILED(pGB->AddFilter(pBF, CStringW(var.bstrVal))))
  606. break;
  608. CComPtr<IPin> pFromTo = GetFirstPin(pBF, PINDIR_INPUT);
  609. if(!pFromTo)
  610. {
  611. pGB->RemoveFilter(pBF);
  612. break;
  613. }
  615. if(FAILED(pGB->Disconnect(pFrom)) || FAILED(pGB->Disconnect(pTo)))
  616. {
  617. pGB->RemoveFilter(pBF);
  618. pGB->ConnectDirect(pFrom, pTo, NULL);
  619. break;
  620. }
  622. HRESULT hr;
  623. if(FAILED(hr = pGB->ConnectDirect(pFrom, pFromTo, NULL)))
  624. {
  625. pGB->RemoveFilter(pBF);
  626. pGB->ConnectDirect(pFrom, pTo, NULL);
  627. break;
  628. }
  630. CComPtr<IPin> pToFrom = GetFirstPin(pBF, PINDIR_OUTPUT);
  631. if(!pToFrom)
  632. {
  633. pGB->RemoveFilter(pBF);
  634. pGB->ConnectDirect(pFrom, pTo, NULL);
  635. break;
  636. }
  638. if(FAILED(pGB->ConnectDirect(pToFrom, pTo, NULL)))
  639. {
  640. pGB->RemoveFilter(pBF);
  641. pGB->ConnectDirect(pFrom, pTo, NULL);
  642. break;
  643. }
  645. pPin = pToFrom;
  646. }
  647. while(false);
  649. return(pPin);
  650. }
  652. int Eval_Exception(int n_except)
  653. {
  654.     if(n_except == STATUS_ACCESS_VIOLATION)
  655. {
  656. AfxMessageBox(_T("The property page of this filter has just caused anmemory access violation. The application will gently die now :)"));
  657. }
  658.         
  659. return EXCEPTION_CONTINUE_SEARCH;
  660. }
  662. void MyOleCreatePropertyFrame(HWND hwndOwner, UINT x, UINT y, LPCOLESTR lpszCaption, ULONG cObjects, LPUNKNOWN FAR* lplpUnk, ULONG cPages, LPCLSID lpPageClsID, LCID lcid, DWORD dwReserved, LPVOID lpvReserved)
  663. {
  664. __try
  665. {
  666. OleCreatePropertyFrame(hwndOwner, x, y, lpszCaption, cObjects, lplpUnk, cPages, lpPageClsID, lcid, dwReserved, lpvReserved);
  667. }
  668. __except(Eval_Exception(GetExceptionCode()))
  669. {
  670. // No code; this block never executed.
  671. }
  672. }
  674. void ShowPPage(CString DisplayName, HWND hParentWnd)
  675. {
  676. CComPtr<IBindCtx> pBindCtx;
  677. CreateBindCtx(0, &pBindCtx);
  679. CComPtr<IMoniker> pMoniker;
  680. ULONG chEaten;
  681. if(S_OK != MkParseDisplayName(pBindCtx, CStringW(DisplayName), &chEaten, &pMoniker))
  682. return;
  684. CComPtr<IBaseFilter> pBF;
  685. if(FAILED(pMoniker->BindToObject(pBindCtx, 0, IID_IBaseFilter, (void**)&pBF)) || !pBF)
  686. return;
  688. ShowPPage(pBF, hParentWnd);
  689. }
  691. void ShowPPage(IUnknown* pUnk, HWND hParentWnd)
  692. {
  693. CComQIPtr<ISpecifyPropertyPages> pSPP = pUnk;
  694. if(!pSPP) return;
  696. CString str;
  698. CComQIPtr<IBaseFilter> pBF = pSPP;
  699. CFilterInfo fi;
  700. CComQIPtr<IPin> pPin = pSPP;
  701. CPinInfo pi;
  702. if(pBF && SUCCEEDED(pBF->QueryFilterInfo(&fi)))
  703. str = fi.achName;
  704. else if(pPin && SUCCEEDED(pPin->QueryPinInfo(&pi)))
  705. str = pi.achName;
  707. CAUUID caGUID;
  708. caGUID.pElems = NULL;
  709. if(SUCCEEDED(pSPP->GetPages(&caGUID)))
  710. {
  711. IUnknown* lpUnk = NULL;
  712. pSPP.QueryInterface(&lpUnk);
  713. MyOleCreatePropertyFrame(
  714. hParentWnd, 0, 0, CStringW(str), 
  715. 1, (IUnknown**)&lpUnk, 
  716. caGUID.cElems, caGUID.pElems, 
  717. 0, 0, NULL);
  718. lpUnk->Release();
  720. if(caGUID.pElems) CoTaskMemFree(caGUID.pElems);
  721. }
  722. }
  724. CLSID GetCLSID(IBaseFilter* pBF)
  725. {
  726. CLSID clsid = GUID_NULL;
  727. if(pBF) pBF->GetClassID(&clsid);
  728. return(clsid);
  729. }
  731. CLSID GetCLSID(IPin* pPin)
  732. {
  733. return(GetCLSID(GetFilterFromPin(pPin)));
  734. }
  736. bool IsCLSIDRegistered(LPCTSTR clsid)
  737. {
  738. CString rootkey1(_T("CLSID\"));
  739. CString rootkey2(_T("CLSID\{083863F1-70DE-11d0-BD40-00A0C911CE86}\Instance\"));
  741. return ERROR_SUCCESS == CRegKey().Open(HKEY_CLASSES_ROOT, rootkey1 + clsid, KEY_READ)
  742. || ERROR_SUCCESS == CRegKey().Open(HKEY_CLASSES_ROOT, rootkey2 + clsid, KEY_READ);
  743. }
  745. bool IsCLSIDRegistered(const CLSID& clsid)
  746. {
  747. bool fRet = false;
  749. LPOLESTR pStr = NULL;
  750. if(S_OK == StringFromCLSID(clsid, &pStr) && pStr)
  751. {
  752. fRet = IsCLSIDRegistered(CString(pStr));
  753. CoTaskMemFree(pStr);
  754. }
  756. return(fRet);
  757. }
  759. void StringToBin(CString s, CByteArray& data)
  760. {
  761. s.Trim();
  762. ASSERT((s.GetLength()&1) == 0);
  763. data.SetSize(s.GetLength()/2);
  765. BYTE b = 0;
  767. s.MakeUpper();
  768. for(int i = 0, j = s.GetLength(); i < j; i++)
  769. {
  770. TCHAR c = s[i];
  771. if(c >= '0' && c <= '9') 
  772. {
  773. if(!(i&1)) b = ((char(c-'0')<<4)&0xf0)|(b&0x0f);
  774. else b = (char(c-'0')&0x0f)|(b&0xf0);
  775. }
  776. else if(c >= 'A' && c <= 'F')
  777. {
  778. if(!(i&1)) b = ((char(c-'A'+10)<<4)&0xf0)|(b&0x0f);
  779. else b = (char(c-'A'+10)&0x0f)|(b&0xf0);
  780. }
  781. else break;
  783. if(i&1)
  784. {
  785. data[i>>1] = b;
  786. b = 0;
  787. }
  788. }
  789. }
  791. CString BinToString(BYTE* ptr, int len)
  792. {
  793. CString ret;
  795. while(len-- > 0)
  796. {
  797. TCHAR high, low;
  798. high = (*ptr>>4) >= 10 ? (*ptr>>4)-10 + 'A' : (*ptr>>4) + '0';
  799. low = (*ptr&0xf) >= 10 ? (*ptr&0xf)-10 + 'A' : (*ptr&0xf) + '0';
  801. CString s;
  802. s.Format(_T("%c%c"), high, low);
  803. ret += s;
  805. ptr++;
  806. }
  808. return(ret);
  809. }
  811. static void FindFiles(CString fn, CList<CString>& files)
  812. {
  813. CString path = fn;
  814. path.Replace('/', '\');
  815. path = path.Left(path.ReverseFind('\')+1);
  817. WIN32_FIND_DATA findData;
  818. HANDLE h = FindFirstFile(fn, &findData);
  819. if(h != INVALID_HANDLE_VALUE)
  820. {
  821. do {files.AddTail(path + findData.cFileName);}
  822. while(FindNextFile(h, &findData));
  824. FindClose(h);
  825. }
  826. }
  828. cdrom_t GetCDROMType(TCHAR drive, CList<CString>& files)
  829. {
  830. files.RemoveAll();
  832. CString path;
  833. path.Format(_T("%c:"), drive);
  835. if(GetDriveType(path + _T("\")) == DRIVE_CDROM)
  836. {
  837. // CDROM_VideoCD
  838. FindFiles(path + _T("\mpegav\avseq??.dat"), files);
  839. FindFiles(path + _T("\mpegav\avseq??.mpg"), files);
  840. FindFiles(path + _T("\mpeg2\avseq??.dat"), files);
  841. FindFiles(path + _T("\mpeg2\avseq??.mpg"), files);
  842. FindFiles(path + _T("\mpegav\music??.dat"), files);
  843. FindFiles(path + _T("\mpegav\music??.mpg"), files);
  844. FindFiles(path + _T("\mpeg2\music??.dat"), files);
  845. FindFiles(path + _T("\mpeg2\music??.mpg"), files);
  846. if(files.GetCount() > 0) return CDROM_VideoCD;
  848. // CDROM_DVDVideo
  849. FindFiles(path + _T("\VIDEO_TS\video_ts.ifo"), files);
  850. if(files.GetCount() > 0) return CDROM_DVDVideo;
  852. // CDROM_Audio
  853. if(!(GetVersion()&0x80000000))
  854. {
  855. HANDLE hDrive = CreateFile(CString(_T("\\.\")) + path, GENERIC_READ, FILE_SHARE_READ, NULL, 
  856. OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, (HANDLE)NULL);
  857. if(hDrive != INVALID_HANDLE_VALUE)
  858. {
  859. DWORD BytesReturned;
  860. CDROM_TOC TOC;
  861. if(DeviceIoControl(hDrive, IOCTL_CDROM_READ_TOC, NULL, 0, &TOC, sizeof(TOC), &BytesReturned, 0))
  862. {
  863. for(int i = TOC.FirstTrack; i <= TOC.LastTrack; i++)
  864. {
  865. // MMC-3 Draft Revision 10g: Table 222 ?Q Sub-channel control field
  866. TOC.TrackData[i-1].Control &= 5;
  867. if(TOC.TrackData[i-1].Control == 0 || TOC.TrackData[i-1].Control == 1) 
  868. {
  869. CString fn;
  870. fn.Format(_T("%s\track%02d.cda"), path, i);
  871. files.AddTail(fn);
  872. }
  873. }
  874. }
  876. CloseHandle(hDrive);
  877. }
  878. }
  879. if(files.GetCount() > 0) return CDROM_Audio;
  881. // it is a cdrom but nothing special
  882. return CDROM_Unknown;
  883. }
  885. return CDROM_NotFound;
  886. }
  888. CString GetDriveLabel(TCHAR drive)
  889. {
  890. CString label;
  892. CString path;
  893. path.Format(_T("%c:\"), drive);
  894. TCHAR VolumeNameBuffer[MAX_PATH], FileSystemNameBuffer[MAX_PATH];
  895. DWORD VolumeSerialNumber, MaximumComponentLength, FileSystemFlags;
  896. if(GetVolumeInformation(path, 
  897. VolumeNameBuffer, MAX_PATH, &VolumeSerialNumber, &MaximumComponentLength, 
  898. &FileSystemFlags, FileSystemNameBuffer, MAX_PATH))
  899. {
  900. label = VolumeNameBuffer;
  901. }
  903. return(label);
  904. }
  906. bool GetKeyFrames(CString fn, CUIntArray& kfs)
  907. {
  908. kfs.RemoveAll();
  910. CString fn2 = CString(fn).MakeLower();
  911. if(fn2.Mid(fn2.ReverseFind('.')+1) == _T("avi"))
  912. {
  913. AVIFileInit();
  914.     
  915. PAVIFILE pfile;
  916. if(AVIFileOpen(&pfile, fn, OF_SHARE_DENY_WRITE, 0L) == 0)
  917. {
  918. AVIFILEINFO afi;
  919. memset(&afi, 0, sizeof(afi));
  920. AVIFileInfo(pfile, &afi, sizeof(AVIFILEINFO));
  922. CComPtr<IAVIStream> pavi;
  923. if(AVIFileGetStream(pfile, &pavi, streamtypeVIDEO, 0) == AVIERR_OK)
  924. {
  925. AVISTREAMINFO si;
  926. AVIStreamInfo(pavi, &si, sizeof(si));
  928. if(afi.dwCaps&AVIFILECAPS_ALLKEYFRAMES)
  929. {
  930. kfs.SetSize(si.dwLength);
  931. for(int kf = 0; kf < si.dwLength; kf++) kfs[kf] = kf;
  932. }
  933. else
  934. {
  935. for(int kf = 0; ; kf++)
  936. {
  937. kf = pavi->FindSample(kf, FIND_KEY|FIND_NEXT);
  938. if(kf < 0 || kfs.GetCount() > 0 && kfs[kfs.GetCount()-1] >= kf) break;
  939. kfs.Add(kf);
  940. }
  942. if(kfs.GetCount() > 0 && kfs[kfs.GetCount()-1] < si.dwLength-1)
  943. {
  944. kfs.Add(si.dwLength-1);
  945. }
  946. }
  947. }
  949. AVIFileRelease(pfile);
  950. }
  952. AVIFileExit();
  953. }
  955. return(kfs.GetCount() > 0);
  956. }
  958. DVD_HMSF_TIMECODE RT2HMSF(REFERENCE_TIME rt, double fps)
  959. {
  960. DVD_HMSF_TIMECODE hmsf = 
  961. {
  962. (BYTE)((rt/10000000/60/60)),
  963. (BYTE)((rt/10000000/60)%60),
  964. (BYTE)((rt/10000000)%60),
  965. (BYTE)(1.0*((rt/10000)%1000) * fps / 1000)
  966. };
  968. return hmsf;
  969. }
  971. REFERENCE_TIME HMSF2RT(DVD_HMSF_TIMECODE hmsf, double fps)
  972. {
  973. if(fps == 0) {hmsf.bFrames = 0; fps = 1;}
  974. return (REFERENCE_TIME)((((REFERENCE_TIME)hmsf.bHours*60+hmsf.bMinutes)*60+hmsf.bSeconds)*1000+1.0*hmsf.bFrames*1000/fps)*10000;
  975. }
  977. HRESULT AddToRot(IUnknown* pUnkGraph, DWORD* pdwRegister) 
  978. {
  979.     CComPtr<IRunningObjectTable> pROT;
  980.     if(FAILED(GetRunningObjectTable(0, &pROT)))
  981. return E_FAIL;
  983. WCHAR wsz[256];
  984.     swprintf(wsz, L"FilterGraph %08p pid %08x (MPC)", (DWORD_PTR)pUnkGraph, GetCurrentProcessId());
  986.     HRESULT hr;
  988. CComPtr<IMoniker> pMoniker;
  989.     if(SUCCEEDED(hr = CreateItemMoniker(L"!", wsz, &pMoniker)))
  990.         hr = pROT->Register(ROTFLAGS_REGISTRATIONKEEPSALIVE, pUnkGraph, pMoniker, pdwRegister);
  992. return hr;
  993. }
  995. void RemoveFromRot(DWORD& dwRegister)
  996. {
  997. CComPtr<IRunningObjectTable> pROT;
  998.     if(SUCCEEDED(GetRunningObjectTable(0, &pROT)))
  999.         pROT->Revoke(dwRegister);
  1000. dwRegister = 0;
  1001. }
  1003. void memsetd(void* dst, unsigned int c, int nbytes)
  1004. {
  1005. __asm
  1006. {
  1007. mov eax, c
  1008. mov ecx, nbytes
  1009. shr ecx, 2
  1010. mov edi, dst
  1011. cld
  1012. rep stosd
  1013. }
  1014. }
  1016. bool ExtractBIH(const AM_MEDIA_TYPE* pmt, BITMAPINFOHEADER* bih)
  1017. {
  1018. if(pmt)
  1019. {
  1020. if(pmt->formattype == FORMAT_VideoInfo)
  1021. {
  1022. VIDEOINFOHEADER* vih = (VIDEOINFOHEADER*)pmt->pbFormat;
  1023. memcpy(bih, &vih->bmiHeader, sizeof(BITMAPINFOHEADER));
  1024. }
  1025. else if(pmt->formattype == FORMAT_VideoInfo2)
  1026. {
  1027. VIDEOINFOHEADER2* vih = (VIDEOINFOHEADER2*)pmt->pbFormat;
  1028. memcpy(bih, &vih->bmiHeader, sizeof(BITMAPINFOHEADER));
  1029. }
  1030. else if(pmt->formattype == FORMAT_MPEGVideo)
  1031. {
  1032. VIDEOINFOHEADER* vih = &((MPEG1VIDEOINFO*)pmt->pbFormat)->hdr;
  1033. memcpy(bih, &vih->bmiHeader, sizeof(BITMAPINFOHEADER));
  1034. }
  1035. else if(pmt->formattype == FORMAT_MPEG2_VIDEO)
  1036. {
  1037. VIDEOINFOHEADER2* vih = &((MPEG2VIDEOINFO*)pmt->pbFormat)->hdr;
  1038. memcpy(bih, &vih->bmiHeader, sizeof(BITMAPINFOHEADER));
  1039. }
  1040. else if(pmt->formattype == FORMAT_DiracVideoInfo)
  1041. {
  1042. VIDEOINFOHEADER2* vih = &((DIRACINFOHEADER*)pmt->pbFormat)->hdr;
  1043. memcpy(bih, &vih->bmiHeader, sizeof(BITMAPINFOHEADER));
  1044. }
  1046. return(true);
  1047. }
  1049. return(false);
  1050. }
  1052. bool ExtractBIH(IMediaSample* pMS, BITMAPINFOHEADER* bih)
  1053. {
  1054. AM_MEDIA_TYPE* pmt = NULL;
  1055. pMS->GetMediaType(&pmt);
  1056. if(pmt)
  1057. {
  1058. bool fRet = ExtractBIH(pmt, bih);
  1059. DeleteMediaType(pmt);
  1060. return(fRet);
  1061. }
  1063. return(false);
  1064. }
  1066. bool ExtractDim(const AM_MEDIA_TYPE* pmt, int& w, int& h, int& arx, int& ary)
  1067. {
  1068. w = h = arx = ary = 0;
  1070. if(pmt->formattype == FORMAT_VideoInfo || pmt->formattype == FORMAT_MPEGVideo)
  1071. {
  1072. VIDEOINFOHEADER* vih = (VIDEOINFOHEADER*)pmt->pbFormat;
  1073. w = vih->bmiHeader.biWidth;
  1074. h = abs(vih->bmiHeader.biHeight);
  1075. arx = w * vih->bmiHeader.biYPelsPerMeter;
  1076. ary = h * vih->bmiHeader.biXPelsPerMeter;
  1077. }
  1078. else if(pmt->formattype == FORMAT_VideoInfo2 || pmt->formattype == FORMAT_MPEG2_VIDEO || pmt->formattype == FORMAT_DiracVideoInfo)
  1079. {
  1080. VIDEOINFOHEADER2* vih = (VIDEOINFOHEADER2*)pmt->pbFormat;
  1081. w = vih->bmiHeader.biWidth;
  1082. h = abs(vih->bmiHeader.biHeight);
  1083. arx = vih->dwPictAspectRatioX;
  1084. ary = vih->dwPictAspectRatioY;
  1085. }
  1086. else
  1087. {
  1088. return(false);
  1089. }
  1091. if(!arx || !ary)
  1092. {
  1093. arx = w;
  1094. ary = h;
  1095. }
  1097. BYTE* ptr = NULL;
  1098. DWORD len = 0;
  1100. if(pmt->formattype == FORMAT_MPEGVideo)
  1101. {
  1102. ptr = ((MPEG1VIDEOINFO*)pmt->pbFormat)->bSequenceHeader;
  1103. len = ((MPEG1VIDEOINFO*)pmt->pbFormat)->cbSequenceHeader;
  1105. if(ptr && len >= 8 && *(DWORD*)ptr == 0xb3010000)
  1106. {
  1107. w = (ptr[4]<<4)|(ptr[5]>>4);
  1108. h = ((ptr[5]&0xf)<<8)|ptr[6];
  1109. float ar[] = 
  1110. {
  1111. 1.0000f,1.0000f,0.6735f,0.7031f,
  1112. 0.7615f,0.8055f,0.8437f,0.8935f,
  1113. 0.9157f,0.9815f,1.0255f,1.0695f,
  1114. 1.0950f,1.1575f,1.2015f,1.0000f,
  1115. };
  1116. arx = (int)((float)w / ar[ptr[7]>>4] + 0.5);
  1117. ary = h;
  1118. }
  1119. }
  1120. else if(pmt->formattype == FORMAT_MPEG2_VIDEO)
  1121. {
  1122. ptr = (BYTE*)((MPEG2VIDEOINFO*)pmt->pbFormat)->dwSequenceHeader; 
  1123. len = ((MPEG2VIDEOINFO*)pmt->pbFormat)->cbSequenceHeader;
  1125. if(ptr && len >= 8 && *(DWORD*)ptr == 0xb3010000)
  1126. {
  1127. w = (ptr[4]<<4)|(ptr[5]>>4);
  1128. h = ((ptr[5]&0xf)<<8)|ptr[6];
  1129. struct {int x, y;} ar[] = {{w,h},{4,3},{16,9},{221,100},{w,h}};
  1130. int i = min(max(ptr[7]>>4, 1), 5)-1;
  1131. arx = ar[i].x;
  1132. ary = ar[i].y;
  1133. }
  1134. }
  1136. if(ptr && len >= 8)
  1137. {
  1139. }
  1141. DWORD a = arx, b = ary;
  1142.     while(a) {int tmp = a; a = b % tmp; b = tmp;}
  1143. if(b) arx /= b, ary /= b;
  1145. return(true);
  1146. }
  1148. bool MakeMPEG2MediaType(CMediaType& mt, BYTE* seqhdr, DWORD len, int w, int h)
  1149. {
  1150. if(len < 4 || *(DWORD*)seqhdr != 0xb3010000) return false;
  1152. BYTE* seqhdr_ext = NULL;
  1154. BYTE* seqhdr_end = seqhdr + 11;
  1155. if(seqhdr_end - seqhdr > len) return false;
  1156. if(*seqhdr_end & 0x02) seqhdr_end += 64;
  1157. if(seqhdr_end - seqhdr > len) return false;
  1158. if(*seqhdr_end & 0x01) seqhdr_end += 64;
  1159. if(seqhdr_end - seqhdr > len) return false;
  1160. seqhdr_end++;
  1161. if(seqhdr_end - seqhdr > len) return false;
  1162. if(len - (seqhdr_end - seqhdr) > 4 && *(DWORD*)seqhdr_end == 0xb5010000) {seqhdr_ext = seqhdr_end; seqhdr_end += 10;}
  1163. if(seqhdr_end - seqhdr > len) return false;
  1165. len = seqhdr_end - seqhdr;
  1167. mt = CMediaType();
  1169. mt.majortype = MEDIATYPE_Video;
  1170. mt.subtype = MEDIASUBTYPE_MPEG2_VIDEO;
  1171. mt.formattype = FORMAT_MPEG2Video;
  1173. MPEG2VIDEOINFO* vih = (MPEG2VIDEOINFO*)mt.AllocFormatBuffer(FIELD_OFFSET(MPEG2VIDEOINFO, dwSequenceHeader) + len);
  1174. memset(mt.Format(), 0, mt.FormatLength());
  1175. vih->hdr.bmiHeader.biSize = sizeof(vih->hdr.bmiHeader);
  1176. vih->hdr.bmiHeader.biWidth = w;
  1177. vih->hdr.bmiHeader.biHeight = h;
  1179. BYTE* pSequenceHeader = (BYTE*)vih->dwSequenceHeader;
  1180. memcpy(pSequenceHeader, seqhdr, len);
  1181. vih->cbSequenceHeader = len;
  1183. static char profile[8] = 
  1184. {
  1185. 0, AM_MPEG2Profile_High, AM_MPEG2Profile_SpatiallyScalable, AM_MPEG2Profile_SNRScalable, 
  1186. AM_MPEG2Profile_Main, AM_MPEG2Profile_Simple, 0, 0
  1187. };
  1189. static char level[16] =
  1190. {
  1191. 0, 0, 0, 0, 
  1192. AM_MPEG2Level_High, 0, AM_MPEG2Level_High1440, 0, 
  1193. AM_MPEG2Level_Main, 0, AM_MPEG2Level_Low, 0, 
  1194. 0, 0, 0, 0
  1195. };
  1197. if(seqhdr_ext && (seqhdr_ext[4] & 0xf0) == 0x10)
  1198. {
  1199. vih->dwProfile = profile[seqhdr_ext[4] & 0x07];
  1200. vih->dwLevel = level[seqhdr_ext[5] >> 4];
  1201. }
  1203. return true;
  1204. }
  1206. unsigned __int64 GetFileVersion(LPCTSTR fn)
  1207. {
  1208. unsigned __int64 ret = 0;
  1210. DWORD buff[4];
  1211. VS_FIXEDFILEINFO* pvsf = (VS_FIXEDFILEINFO*)buff;
  1212. DWORD d; // a variable that GetFileVersionInfoSize sets to zero (but why is it needed ?????????????????????????????? :)
  1213. DWORD len = GetFileVersionInfoSize((TCHAR*)fn, &d);
  1215. if(len)
  1216. {
  1217. TCHAR* b1 = new TCHAR[len];
  1218. if(b1)
  1219. {
  1220.             UINT uLen;
  1221.             if(GetFileVersionInfo((TCHAR*)fn, 0, len, b1) && VerQueryValue(b1, _T("\"), (void**)&pvsf, &uLen))
  1222.             {
  1223. ret = ((unsigned __int64)pvsf->dwFileVersionMS<<32) | pvsf->dwFileVersionLS;
  1224.             }
  1226.             delete [] b1;
  1227. }
  1228. }
  1230. return ret;
  1231. }
  1233. bool CreateFilter(CStringW DisplayName, IBaseFilter** ppBF, CStringW& FriendlyName)
  1234. {
  1235. if(!ppBF) return(false);
  1237. *ppBF = NULL;
  1238. FriendlyName.Empty();
  1240. CComPtr<IBindCtx> pBindCtx;
  1241. CreateBindCtx(0, &pBindCtx);
  1243. CComPtr<IMoniker> pMoniker;
  1244. ULONG chEaten;
  1245. if(S_OK != MkParseDisplayName(pBindCtx, CComBSTR(DisplayName), &chEaten, &pMoniker))
  1246. return(false);
  1248. if(FAILED(pMoniker->BindToObject(pBindCtx, 0, IID_IBaseFilter, (void**)ppBF)) || !*ppBF)
  1249. return(false);
  1251. CComPtr<IPropertyBag> pPB;
  1252. CComVariant var;
  1253. if(SUCCEEDED(pMoniker->BindToStorage(pBindCtx, 0, IID_IPropertyBag, (void**)&pPB))
  1254. && SUCCEEDED(pPB->Read(CComBSTR(_T("FriendlyName")), &var, NULL)))
  1255. FriendlyName = var.bstrVal;
  1257. return(true);
  1258. }
  1260. IBaseFilter* AppendFilter(IPin* pPin, IMoniker* pMoniker, IGraphBuilder* pGB)
  1261. {
  1262. do
  1263. {
  1264. if(!pPin || !pMoniker || !pGB)
  1265. break;
  1267. CComPtr<IPin> pPinTo;
  1268. PIN_DIRECTION dir;
  1269. if(FAILED(pPin->QueryDirection(&dir)) || dir != PINDIR_OUTPUT || SUCCEEDED(pPin->ConnectedTo(&pPinTo)))
  1270. break;
  1272. CComPtr<IBindCtx> pBindCtx;
  1273. CreateBindCtx(0, &pBindCtx);
  1275. CComPtr<IPropertyBag> pPB;
  1276. if(FAILED(pMoniker->BindToStorage(pBindCtx, 0, IID_IPropertyBag, (void**)&pPB)))
  1277. break;
  1279. CComVariant var;
  1280. if(FAILED(pPB->Read(CComBSTR(_T("FriendlyName")), &var, NULL)))
  1281. break;
  1283. CComPtr<IBaseFilter> pBF;
  1284. if(FAILED(pMoniker->BindToObject(pBindCtx, 0, IID_IBaseFilter, (void**)&pBF)) || !pBF)
  1285. break;
  1287. if(FAILED(pGB->AddFilter(pBF, CStringW(var.bstrVal))))
  1288. break;
  1290. BeginEnumPins(pBF, pEP, pPinTo)
  1291. {
  1292. PIN_DIRECTION dir;
  1293. if(FAILED(pPinTo->QueryDirection(&dir)) || dir != PINDIR_INPUT)
  1294. continue;
  1296. if(SUCCEEDED(pGB->ConnectDirect(pPin, pPinTo, NULL)))
  1297. return(pBF);
  1298. }
  1299. EndEnumFilters
  1301. pGB->RemoveFilter(pBF);
  1302. }
  1303. while(false);
  1305. return(NULL);
  1306. }
  1308. CStringW GetFriendlyName(CStringW DisplayName)
  1309. {
  1310. CStringW FriendlyName;
  1312. CComPtr<IBindCtx> pBindCtx;
  1313. CreateBindCtx(0, &pBindCtx);
  1315. CComPtr<IMoniker> pMoniker;
  1316. ULONG chEaten;
  1317. if(S_OK != MkParseDisplayName(pBindCtx, CComBSTR(DisplayName), &chEaten, &pMoniker))
  1318. return(false);
  1320. CComPtr<IPropertyBag> pPB;
  1321. CComVariant var;
  1322. if(SUCCEEDED(pMoniker->BindToStorage(pBindCtx, 0, IID_IPropertyBag, (void**)&pPB))
  1323. && SUCCEEDED(pPB->Read(CComBSTR(_T("FriendlyName")), &var, NULL)))
  1324. FriendlyName = var.bstrVal;
  1326. return FriendlyName;
  1327. }
  1329. typedef struct
  1330. {
  1331. CString path;
  1332. HINSTANCE hInst;
  1333. CLSID clsid;
  1334. } ExternalObject;
  1336. static CList<ExternalObject> s_extobjs;
  1338. HRESULT LoadExternalObject(LPCTSTR path, REFCLSID clsid, REFIID iid, void** ppv)
  1339. {
  1340. CheckPointer(ppv, E_POINTER);
  1342. CString fullpath = MakeFullPath(path);
  1344. HINSTANCE hInst = NULL;
  1345. bool fFound = false;
  1347. POSITION pos = s_extobjs.GetHeadPosition();
  1348. while(pos)
  1349. {
  1350. ExternalObject& eo = s_extobjs.GetNext(pos);
  1351. if(!eo.path.CompareNoCase(fullpath))
  1352. {
  1353. hInst = eo.hInst;
  1354. fFound = true;
  1355. break;
  1356. }
  1357. }
  1359. HRESULT hr = E_FAIL;
  1361. if(hInst || (hInst = CoLoadLibrary(CComBSTR(fullpath), TRUE)))
  1362. {
  1363. typedef HRESULT (__stdcall * PDllGetClassObject)(REFCLSID rclsid, REFIID riid, LPVOID* ppv);
  1364. PDllGetClassObject p = (PDllGetClassObject)GetProcAddress(hInst, "DllGetClassObject");
  1366. if(p && FAILED(hr = p(clsid, iid, ppv)))
  1367. {
  1368. CComPtr<IClassFactory> pCF;
  1369. if(SUCCEEDED(hr = p(clsid, __uuidof(IClassFactory), (void**)&pCF)))
  1370. {
  1371. hr = pCF->CreateInstance(NULL, iid, ppv);
  1372. }
  1373. }
  1374. }
  1376. if(FAILED(hr) && hInst && !fFound)
  1377. {
  1378. CoFreeLibrary(hInst);
  1379. return hr;
  1380. }
  1382. if(hInst && !fFound)
  1383. {
  1384. ExternalObject eo;
  1385. eo.path = fullpath;
  1386. eo.hInst = hInst;
  1387. eo.clsid = clsid;
  1388. s_extobjs.AddTail(eo);
  1389. }
  1391. return hr;
  1392. }
  1394. HRESULT LoadExternalFilter(LPCTSTR path, REFCLSID clsid, IBaseFilter** ppBF)
  1395. {
  1396. return LoadExternalObject(path, clsid, __uuidof(IBaseFilter), (void**)ppBF);
  1397. }
  1399. HRESULT LoadExternalPropertyPage(IPersist* pP, REFCLSID clsid, IPropertyPage** ppPP)
  1400. {
  1401. CLSID clsid2 = GUID_NULL;
  1402. if(FAILED(pP->GetClassID(&clsid2))) return E_FAIL;
  1404. POSITION pos = s_extobjs.GetHeadPosition();
  1405. while(pos)
  1406. {
  1407. ExternalObject& eo = s_extobjs.GetNext(pos);
  1408. if(eo.clsid == clsid2)
  1409. {
  1410. return LoadExternalObject(eo.path, clsid, __uuidof(IPropertyPage), (void**)ppPP);
  1411. }
  1412. }
  1414. return E_FAIL;
  1415. }
  1417. void UnloadExternalObjects()
  1418. {
  1419. POSITION pos = s_extobjs.GetHeadPosition();
  1420. while(pos)
  1421. {
  1422. ExternalObject& eo = s_extobjs.GetNext(pos);
  1423. CoFreeLibrary(eo.hInst);
  1424. }
  1425. s_extobjs.RemoveAll();
  1426. }
  1428. CString MakeFullPath(LPCTSTR path)
  1429. {
  1430. CString full(path);
  1431. full.Replace('/', '\');
  1433. CString fn;
  1434. fn.ReleaseBuffer(GetModuleFileName(AfxGetInstanceHandle(), fn.GetBuffer(MAX_PATH), MAX_PATH));
  1435. CPath p(fn);
  1437. if(full.GetLength() >= 2 && full[0] == '\' && full[1] != '\')
  1438. {
  1439. p.StripToRoot();
  1440. full = CString(p) + full.Mid(1); 
  1441. }
  1442. else if(full.Find(_T(":\")) < 0)
  1443. {
  1444. p.RemoveFileSpec();
  1445. p.AddBackslash();
  1446. full = CString(p) + full;
  1447. }
  1449. CPath c(full);
  1450. c.Canonicalize();
  1451. return CString(c);
  1452. }
  1454. //
  1456. CString GetMediaTypeName(const GUID& guid)
  1457. {
  1458. CString ret = guid == GUID_NULL 
  1459. ? _T("Any type") 
  1460. : CString(GuidNames[guid]);
  1462. if(ret == _T("FOURCC GUID"))
  1463. {
  1464. CString str;
  1465. if(guid.Data1 >= 0x10000)
  1466. str.Format(_T("Video: %c%c%c%c"), (guid.Data1>>0)&0xff, (guid.Data1>>8)&0xff, (guid.Data1>>16)&0xff, (guid.Data1>>24)&0xff);
  1467. else
  1468. str.Format(_T("Audio: 0x%08x"), guid.Data1);
  1469. ret = str;
  1470. }
  1471. else if(ret == _T("Unknown GUID Name"))
  1472. {
  1473. WCHAR null[128] = {0}, buff[128];
  1474. StringFromGUID2(GUID_NULL, null, 127);
  1475. ret = CString(CStringW(StringFromGUID2(guid, buff, 127) ? buff : null));
  1476. }
  1478. return ret;
  1479. }
  1481. GUID GUIDFromCString(CString str)
  1482. {
  1483. GUID guid = GUID_NULL;
  1484. CLSIDFromString(CComBSTR(str), &guid);
  1485. return guid;
  1486. }
  1488. CString CStringFromGUID(const GUID& guid)
  1489. {
  1490. WCHAR null[128] = {0}, buff[128];
  1491. StringFromGUID2(GUID_NULL, null, 127);
  1492. return CString(StringFromGUID2(guid, buff, 127) > 0 ? buff : null);
  1493. }
  1495. CStringW UTF8To16(LPCSTR utf8)
  1496. {
  1497. CStringW str;
  1498. int n = MultiByteToWideChar(CP_UTF8, 0, utf8, -1, NULL, 0)-1;
  1499. if(n < 0) return str;
  1500. str.ReleaseBuffer(MultiByteToWideChar(CP_UTF8, 0, utf8, -1, str.GetBuffer(n), n+1)-1);
  1501. return str;
  1502. }
  1504. CStringA UTF16To8(LPCWSTR utf16)
  1505. {
  1506. CStringA str;
  1507. int n = WideCharToMultiByte(CP_UTF8, 0, utf16, -1, NULL, 0, NULL, NULL)-1;
  1508. if(n < 0) return str;
  1509. str.ReleaseBuffer(WideCharToMultiByte(CP_UTF8, 0, utf16, -1, str.GetBuffer(n), n+1, NULL, NULL)-1);
  1510. return str;
  1511. }
  1513. static struct {LPCSTR name, iso6392, iso6391;} s_isolangs[] = 
  1514. {
  1515. {"Abkhazian", "abk", "ab"},
  1516. {"Achinese", "ace", ""},
  1517. {"Acoli", "ach", ""},
  1518. {"Adangme", "ada", ""},
  1519. {"Afar", "aar", "aa"},
  1520. {"Afrihili", "afh", ""},
  1521. {"Afrikaans", "afr", "af"},
  1522. {"Afro-Asiatic (Other)", "afa", ""},
  1523. {"Akan", "aka", "ak"},
  1524. {"Akkadian", "akk", ""},
  1525. {"Albanian", "alb", "sq"},
  1526. {"Albanian", "sqi", "sq"},
  1527. {"Aleut", "ale", ""},
  1528. {"Algonquian languages", "alg", ""},
  1529. {"Altaic (Other)", "tut", ""},
  1530. {"Amharic", "amh", "am"},
  1531. {"Apache languages", "apa", ""},
  1532. {"Arabic", "ara", "ar"},
  1533. {"Aragonese", "arg", "an"},
  1534. {"Aramaic", "arc", ""},
  1535. {"Arapaho", "arp", ""},
  1536. {"Araucanian", "arn", ""},
  1537. {"Arawak", "arw", ""},
  1538. {"Armenian", "arm", "hy"},
  1539. {"Armenian", "hye", "hy"},
  1540. {"Artificial (Other)", "art", ""},
  1541. {"Assamese", "asm", "as"},
  1542. {"Asturian; Bable", "ast", ""},
  1543. {"Athapascan languages", "ath", ""},
  1544. {"Australian languages", "aus", ""},
  1545. {"Austronesian (Other)", "map", ""},
  1546. {"Avaric", "ava", "av"},
  1547. {"Avestan", "ave", "ae"},
  1548. {"Awadhi", "awa", ""},
  1549. {"Aymara", "aym", "ay"},
  1550. {"Azerbaijani", "aze", "az"},
  1551. {"Bable; Asturian", "ast", ""},
  1552. {"Balinese", "ban", ""},
  1553. {"Baltic (Other)", "bat", ""},
  1554. {"Baluchi", "bal", ""},
  1555. {"Bambara", "bam", "bm"},
  1556. {"Bamileke languages", "bai", ""},
  1557. {"Banda", "bad", ""},
  1558. {"Bantu (Other)", "bnt", ""},
  1559. {"Basa", "bas", ""},
  1560. {"Bashkir", "bak", "ba"},
  1561. {"Basque", "baq", "eu"},
  1562. {"Basque", "eus", "eu"},
  1563. {"Batak (Indonesia)", "btk", ""},
  1564. {"Beja", "bej", ""},
  1565. {"Belarusian", "bel", "be"},
  1566. {"Bemba", "bem", ""},
  1567. {"Bengali", "ben", "bn"},
  1568. {"Berber (Other)", "ber", ""},
  1569. {"Bhojpuri", "bho", ""},
  1570. {"Bihari", "bih", "bh"},
  1571. {"Bikol", "bik", ""},
  1572. {"Bini", "bin", ""},
  1573. {"Bislama", "bis", "bi"},
  1574. {"Bokm錶, Norwegian; Norwegian Bokm錶", "nob", "nb"},
  1575. {"Bosnian", "bos", "bs"},
  1576. {"Braj", "bra", ""},
  1577. {"Breton", "bre", "br"},
  1578. {"Buginese", "bug", ""},
  1579. {"Bulgarian", "bul", "bg"},
  1580. {"Buriat", "bua", ""},
  1581. {"Burmese", "bur", "my"},
  1582. {"Burmese", "mya", "my"},
  1583. {"Caddo", "cad", ""},
  1584. {"Carib", "car", ""},
  1585. {"Spanish; Castilian", "spa", "es"},
  1586. {"Catalan", "cat", "ca"},
  1587. {"Caucasian (Other)", "cau", ""},
  1588. {"Cebuano", "ceb", ""},
  1589. {"Celtic (Other)", "cel", ""},
  1590. {"Central American Indian (Other)", "cai", ""},
  1591. {"Chagatai", "chg", ""},
  1592. {"Chamic languages", "cmc", ""},
  1593. {"Chamorro", "cha", "ch"},
  1594. {"Chechen", "che", "ce"},
  1595. {"Cherokee", "chr", ""},
  1596. {"Chewa; Chichewa; Nyanja", "nya", "ny"},
  1597. {"Cheyenne", "chy", ""},
  1598. {"Chibcha", "chb", ""},
  1599. {"Chichewa; Chewa; Nyanja", "nya", "ny"},
  1600. {"Chinese", "chi", "zh"},
  1601. {"Chinese", "zho", "zh"},
  1602. {"Chinook jargon", "chn", ""},
  1603. {"Chipewyan", "chp", ""},
  1604. {"Choctaw", "cho", ""},
  1605. {"Chuang; Zhuang", "zha", "za"},
  1606. {"Church Slavic; Old Church Slavonic", "chu", "cu"},
  1607. {"Old Church Slavonic; Old Slavonic; ", "chu", "cu"},
  1608. {"Church Slavonic; Old Bulgarian; Church Slavic;", "chu", "cu"},
  1609. {"Old Slavonic; Church Slavonic; Old Bulgarian;", "chu", "cu"},
  1610. {"Church Slavic; Old Church Slavonic", "chu", "cu"},
  1611. {"Chuukese", "chk", ""},
  1612. {"Chuvash", "chv", "cv"},
  1613. {"Coptic", "cop", ""},
  1614. {"Cornish", "cor", "kw"},
  1615. {"Corsican", "cos", "co"},
  1616. {"Cree", "cre", "cr"},
  1617. {"Creek", "mus", ""},
  1618. {"Creoles and pidgins (Other)", "crp", ""},
  1619. {"Creoles and pidgins,", "cpe", ""},
  1620. //   {"English-based (Other)", "", ""},
  1621. {"Creoles and pidgins,", "cpf", ""},
  1622. //   {"French-based (Other)", "", ""},
  1623. {"Creoles and pidgins,", "cpp", ""},
  1624. //   {"Portuguese-based (Other)", "", ""},
  1625. {"Croatian", "scr", "hr"},
  1626. {"Croatian", "hrv", "hr"},
  1627. {"Cushitic (Other)", "cus", ""},
  1628. {"Czech", "cze", "cs"},
  1629. {"Czech", "ces", "cs"},
  1630. {"Dakota", "dak", ""},
  1631. {"Danish", "dan", "da"},
  1632. {"Dargwa", "dar", ""},
  1633. {"Dayak", "day", ""},
  1634. {"Delaware", "del", ""},
  1635. {"Dinka", "din", ""},
  1636. {"Divehi", "div", "dv"},
  1637. {"Dogri", "doi", ""},
  1638. {"Dogrib", "dgr", ""},
  1639. {"Dravidian (Other)", "dra", ""},
  1640. {"Duala", "dua", ""},
  1641. {"Dutch; Flemish", "dut", "nl"},
  1642. {"Dutch; Flemish", "nld", "nl"},
  1643. {"Dutch, Middle (ca. 1050-1350)", "dum", ""},
  1644. {"Dyula", "dyu", ""},
  1645. {"Dzongkha", "dzo", "dz"},
  1646. {"Efik", "efi", ""},
  1647. {"Egyptian (Ancient)", "egy", ""},
  1648. {"Ekajuk", "eka", ""},
  1649. {"Elamite", "elx", ""},
  1650. {"English", "eng", "en"},
  1651. {"English, Middle (1100-1500)", "enm", ""},
  1652. {"English, Old (ca.450-1100)", "ang", ""},
  1653. {"Esperanto", "epo", "eo"},
  1654. {"Estonian", "est", "et"},
  1655. {"Ewe", "ewe", "ee"},
  1656. {"Ewondo", "ewo", ""},
  1657. {"Fang", "fan", ""},
  1658. {"Fanti", "fat", ""},
  1659. {"Faroese", "fao", "fo"},
  1660. {"Fijian", "fij", "fj"},
  1661. {"Finnish", "fin", "fi"},
  1662. {"Finno-Ugrian (Other)", "fiu", ""},
  1663. {"Flemish; Dutch", "dut", "nl"},
  1664. {"Flemish; Dutch", "nld", "nl"},
  1665. {"Fon", "fon", ""},
  1666. {"French", "fre", "fr"},
  1667. {"French", "fra*", "fr"},
  1668. {"French, Middle (ca.1400-1600)", "frm", ""},
  1669. {"French, Old (842-ca.1400)", "fro", ""},
  1670. {"Frisian", "fry", "fy"},
  1671. {"Friulian", "fur", ""},
  1672. {"Fulah", "ful", "ff"},
  1673. {"Ga", "gaa", ""},
  1674. {"Gaelic; Scottish Gaelic", "gla", "gd"},
  1675. {"Gallegan", "glg", "gl"},
  1676. {"Ganda", "lug", "lg"},
  1677. {"Gayo", "gay", ""},
  1678. {"Gbaya", "gba", ""},
  1679. {"Geez", "gez", ""},
  1680. {"Georgian", "geo", "ka"},
  1681. {"Georgian", "kat", "ka"},
  1682. {"German", "ger", "de"},
  1683. {"German", "deu", "de"},
  1684. {"German, Low; Saxon, Low; Low German; Low Saxon", "nds", ""},
  1685. {"German, Middle High (ca.1050-1500)", "gmh", ""},
  1686. {"German, Old High (ca.750-1050)", "goh", ""},
  1687. {"Germanic (Other)", "gem", ""},
  1688. {"Gikuyu; Kikuyu", "kik", "ki"},
  1689. {"Gilbertese", "gil", ""},
  1690. {"Gondi", "gon", ""},
  1691. {"Gorontalo", "gor", ""},
  1692. {"Gothic", "got", ""},
  1693. {"Grebo", "grb", ""},
  1694. {"Greek, Ancient (to 1453)", "grc", ""},
  1695. {"Greek, Modern (1453-)", "gre", "el"},
  1696. {"Greek, Modern (1453-)", "ell", "el"},
  1697. {"Greenlandic; Kalaallisut", "kal", "kl"},
  1698. {"Guarani", "grn", "gn"},
  1699. {"Gujarati", "guj", "gu"},
  1700. {"Gwich磇n", "gwi", ""},
  1701. {"Haida", "hai", ""},
  1702. {"Hausa", "hau", "ha"},
  1703. {"Hawaiian", "haw", ""},
  1704. {"Hebrew", "heb", "he"},
  1705. {"Herero", "her", "hz"},
  1706. {"Hiligaynon", "hil", ""},
  1707. {"Himachali", "him", ""},
  1708. {"Hindi", "hin", "hi"},
  1709. {"Hiri Motu", "hmo", "ho"},
  1710. {"Hittite", "hit", ""},
  1711. {"Hmong", "hmn", ""},
  1712. {"Hungarian", "hun", "hu"},
  1713. {"Hupa", "hup", ""},
  1714. {"Iban", "iba", ""},
  1715. {"Icelandic", "ice", "is"},
  1716. {"Icelandic", "isl", "is"},
  1717. {"Ido", "ido", "io"},
  1718. {"Igbo", "ibo", "ig"},
  1719. {"Ijo", "ijo", ""},
  1720. {"Iloko", "ilo", ""},
  1721. {"Inari Sami", "smn", ""},
  1722. {"Indic (Other)", "inc", ""},
  1723. {"Indo-European (Other)", "ine", ""},
  1724. {"Indonesian", "ind", "id"},
  1725. {"Ingush", "inh", ""},
  1726. {"Interlingua (International", "ina", "ia"},
  1727. //   {"Auxiliary Language Association)", "", ""},
  1728. {"Interlingue", "ile", "ie"},
  1729. {"Inuktitut", "iku", "iu"},
  1730. {"Inupiaq", "ipk", "ik"},
  1731. {"Iranian (Other)", "ira", ""},
  1732. {"Irish", "gle", "ga"},
  1733. {"Irish, Middle (900-1200)", "mga", ""},
  1734. {"Irish, Old (to 900)", "sga", ""},
  1735. {"Iroquoian languages", "iro", ""},
  1736. {"Italian", "ita", "it"},
  1737. {"Japanese", "jpn", "ja"},
  1738. {"Javanese", "jav", "jv"},
  1739. {"Judeo-Arabic", "jrb", ""},
  1740. {"Judeo-Persian", "jpr", ""},
  1741. {"Kabardian", "kbd", ""},
  1742. {"Kabyle", "kab", ""},
  1743. {"Kachin", "kac", ""},
  1744. {"Kalaallisut; Greenlandic", "kal", "kl"},
  1745. {"Kamba", "kam", ""},
  1746. {"Kannada", "kan", "kn"},
  1747. {"Kanuri", "kau", "kr"},
  1748. {"Kara-Kalpak", "kaa", ""},
  1749. {"Karen", "kar", ""},
  1750. {"Kashmiri", "kas", "ks"},
  1751. {"Kawi", "kaw", ""},
  1752. {"Kazakh", "kaz", "kk"},
  1753. {"Khasi", "kha", ""},
  1754. {"Khmer", "khm", "km"},
  1755. {"Khoisan (Other)", "khi", ""},
  1756. {"Khotanese", "kho", ""},
  1757. {"Kikuyu; Gikuyu", "kik", "ki"},
  1758. {"Kimbundu", "kmb", ""},
  1759. {"Kinyarwanda", "kin", "rw"},
  1760. {"Kirghiz", "kir", "ky"},
  1761. {"Komi", "kom", "kv"},
  1762. {"Kongo", "kon", "kg"},
  1763. {"Konkani", "kok", ""},
  1764. {"Korean", "kor", "ko"},
  1765. {"Kosraean", "kos", ""},
  1766. {"Kpelle", "kpe", ""},
  1767. {"Kru", "kro", ""},
  1768. {"Kuanyama; Kwanyama", "kua", "kj"},
  1769. {"Kumyk", "kum", ""},
  1770. {"Kurdish", "kur", "ku"},
  1771. {"Kurukh", "kru", ""},
  1772. {"Kutenai", "kut", ""},
  1773. {"Kwanyama, Kuanyama", "kua", "kj"},
  1774. {"Ladino", "lad", ""},
  1775. {"Lahnda", "lah", ""},
  1776. {"Lamba", "lam", ""},
  1777. {"Lao", "lao", "lo"},
  1778. {"Latin", "lat", "la"},
  1779. {"Latvian", "lav", "lv"},
  1780. {"Letzeburgesch; Luxembourgish", "ltz", "lb"},
  1781. {"Lezghian", "lez", ""},
  1782. {"Limburgan; Limburger; Limburgish", "lim", "li"},
  1783. {"Limburger; Limburgan; Limburgish;", "lim", "li"},
  1784. {"Limburgish; Limburger; Limburgan", "lim", "li"},
  1785. {"Lingala", "lin", "ln"},
  1786. {"Lithuanian", "lit", "lt"},
  1787. {"Low German; Low Saxon; German, Low; Saxon, Low", "nds", ""},
  1788. {"Low Saxon; Low German; Saxon, Low; German, Low", "nds", ""},
  1789. {"Lozi", "loz", ""},
  1790. {"Luba-Katanga", "lub", "lu"},
  1791. {"Luba-Lulua", "lua", ""},
  1792. {"Luiseno", "lui", ""},
  1793. {"Lule Sami", "smj", ""},
  1794. {"Lunda", "lun", ""},
  1795. {"Luo (Kenya and Tanzania)", "luo", ""},
  1796. {"Lushai", "lus", ""},
  1797. {"Luxembourgish; Letzeburgesch", "ltz", "lb"},
  1798. {"Macedonian", "mac", "mk"},
  1799. {"Macedonian", "mkd", "mk"},
  1800. {"Madurese", "mad", ""},
  1801. {"Magahi", "mag", ""},
  1802. {"Maithili", "mai", ""},
  1803. {"Makasar", "mak", ""},
  1804. {"Malagasy", "mlg", "mg"},
  1805. {"Malay", "may", "ms"},
  1806. {"Malay", "msa", "ms"},
  1807. {"Malayalam", "mal", "ml"},
  1808. {"Maltese", "mlt", "mt"},
  1809. {"Manchu", "mnc", ""},
  1810. {"Mandar", "mdr", ""},
  1811. {"Mandingo", "man", ""},
  1812. {"Manipuri", "mni", ""},
  1813. {"Manobo languages", "mno", ""},
  1814. {"Manx", "glv", "gv"},
  1815. {"Maori", "mao", "mi"},
  1816. {"Maori", "mri", "mi"},
  1817. {"Marathi", "mar", "mr"},
  1818. {"Mari", "chm", ""},
  1819. {"Marshallese", "mah", "mh"},
  1820. {"Marwari", "mwr", ""},
  1821. {"Masai", "mas", ""},
  1822. {"Mayan languages", "myn", ""},
  1823. {"Mende", "men", ""},
  1824. {"Micmac", "mic", ""},
  1825. {"Minangkabau", "min", ""},
  1826. {"Miscellaneous languages", "mis", ""},
  1827. {"Mohawk", "moh", ""},
  1828. {"Moldavian", "mol", "mo"},
  1829. {"Mon-Khmer (Other)", "mkh", ""},
  1830. {"Mongo", "lol", ""},
  1831. {"Mongolian", "mon", "mn"},
  1832. {"Mossi", "mos", ""},
  1833. {"Multiple languages", "mul", ""},
  1834. {"Munda languages", "mun", ""},
  1835. {"Nahuatl", "nah", ""},
  1836. {"Nauru", "nau", "na"},
  1837. {"Navaho, Navajo", "nav", "nv"},
  1838. {"Navajo; Navaho", "nav", "nv"},
  1839. {"Ndebele, North", "nde", "nd"},
  1840. {"Ndebele, South", "nbl", "nr"},
  1841. {"Ndonga", "ndo", "ng"},
  1842. {"Neapolitan", "nap", ""},
  1843. {"Nepali", "nep", "ne"},
  1844. {"Newari", "new", ""},
  1845. {"Nias", "nia", ""},
  1846. {"Niger-Kordofanian (Other)", "nic", ""},
  1847. {"Nilo-Saharan (Other)", "ssa", ""},
  1848. {"Niuean", "niu", ""},
  1849. {"Norse, Old", "non", ""},
  1850. {"North American Indian (Other)", "nai", ""},
  1851. {"Northern Sami", "sme", "se"},
  1852. {"North Ndebele", "nde", "nd"},
  1853. {"Norwegian", "nor", "no"},
  1854. {"Norwegian Bokm錶; Bokm錶, Norwegian", "nob", "nb"},
  1855. {"Norwegian Nynorsk; Nynorsk, Norwegian", "nno", "nn"},
  1856. {"Nubian languages", "nub", ""},
  1857. {"Nyamwezi", "nym", ""},
  1858. {"Nyanja; Chichewa; Chewa", "nya", "ny"},
  1859. {"Nyankole", "nyn", ""},
  1860. {"Nynorsk, Norwegian; Norwegian Nynorsk", "nno", "nn"},
  1861. {"Nyoro", "nyo", ""},
  1862. {"Nzima", "nzi", ""},
  1863. {"Occitan (post 1500},; Proven鏰l", "oci", "oc"},
  1864. {"Ojibwa", "oji", "oj"},
  1865. {"Old Bulgarian; Old Slavonic; Church Slavonic;", "chu", "cu"},
  1866. {"Oriya", "ori", "or"},
  1867. {"Oromo", "orm", "om"},
  1868. {"Osage", "osa", ""},
  1869. {"Ossetian; Ossetic", "oss", "os"},
  1870. {"Ossetic; Ossetian", "oss", "os"},
  1871. {"Otomian languages", "oto", ""},
  1872. {"Pahlavi", "pal", ""},
  1873. {"Palauan", "pau", ""},
  1874. {"Pali", "pli", "pi"},
  1875. {"Pampanga", "pam", ""},
  1876. {"Pangasinan", "pag", ""},
  1877. {"Panjabi", "pan", "pa"},
  1878. {"Papiamento", "pap", ""},
  1879. {"Papuan (Other)", "paa", ""},
  1880. {"Persian", "per", "fa"},
  1881. {"Persian", "fas", "fa"},
  1882. {"Persian, Old (ca.600-400 B.C.)", "peo", ""},
  1883. {"Philippine (Other)", "phi", ""},
  1884. {"Phoenician", "phn", ""},
  1885. {"Pohnpeian", "pon", ""},
  1886. {"Polish", "pol", "pl"},
  1887. {"Portuguese", "por", "pt"},
  1888. {"Prakrit languages", "pra", ""},
  1889. {"Proven鏰l; Occitan (post 1500)", "oci", "oc"},
  1890. {"Proven鏰l, Old (to 1500)", "pro", ""},
  1891. {"Pushto", "pus", "ps"},
  1892. {"Quechua", "que", "qu"},
  1893. {"Raeto-Romance", "roh", "rm"},
  1894. {"Rajasthani", "raj", ""},
  1895. {"Rapanui", "rap", ""},
  1896. {"Rarotongan", "rar", ""},
  1897. {"Reserved for local use", "qaa-qtz", ""},
  1898. {"Romance (Other)", "roa", ""},
  1899. {"Romanian", "rum", "ro"},
  1900. {"Romanian", "ron", "ro"},
  1901. {"Romany", "rom", ""},
  1902. {"Rundi", "run", "rn"},
  1903. {"Russian", "rus", "ru"},
  1904. {"Salishan languages", "sal", ""},
  1905. {"Samaritan Aramaic", "sam", ""},
  1906. {"Sami languages (Other)", "smi", ""},
  1907. {"Samoan", "smo", "sm"},
  1908. {"Sandawe", "sad", ""},
  1909. {"Sango", "sag", "sg"},
  1910. {"Sanskrit", "san", "sa"},
  1911. {"Santali", "sat", ""},
  1912. {"Sardinian", "srd", "sc"},
  1913. {"Sasak", "sas", ""},
  1914. {"Saxon, Low; German, Low; Low Saxon; Low German", "nds", ""},
  1915. {"Scots", "sco", ""},
  1916. {"Scottish Gaelic; Gaelic", "gla", "gd"},
  1917. {"Selkup", "sel", ""},
  1918. {"Semitic (Other)", "sem", ""},
  1919. {"Serbian", "scc", "sr"},
  1920. {"Serbian", "srp", "sr"},
  1921. {"Serer", "srr", ""},
  1922. {"Shan", "shn", ""},
  1923. {"Shona", "sna", "sn"},
  1924. {"Sichuan Yi", "iii", "ii"},
  1925. {"Sidamo", "sid", ""},
  1926. {"Sign languages", "sgn", ""},
  1927. {"Siksika", "bla", ""},
  1928. {"Sindhi", "snd", "sd"},
  1929. {"Sinhalese", "sin", "si"},
  1930. {"Sino-Tibetan (Other)", "sit", ""},
  1931. {"Siouan languages", "sio", ""},
  1932. {"Skolt Sami", "sms", ""},
  1933. {"Slave (Athapascan)", "den", ""},
  1934. {"Slavic (Other)", "sla", ""},
  1935. {"Slovak", "slo", "sk"},
  1936. {"Slovak", "slk", "sk"},
  1937. {"Slovenian", "slv", "sl"},
  1938. {"Sogdian", "sog", ""},
  1939. {"Somali", "som", "so"},
  1940. {"Songhai", "son", ""},
  1941. {"Soninke", "snk", ""},
  1942. {"Sorbian languages", "wen", ""},
  1943. {"Sotho, Northern", "nso", ""},
  1944. {"Sotho, Southern", "sot", "st"},
  1945. {"South American Indian (Other)", "sai", ""},
  1946. {"Southern Sami", "sma", ""},
  1947. {"South Ndebele", "nbl", "nr"},
  1948. {"Spanish; Castilian", "spa", "es"},
  1949. {"Sukuma", "suk", ""},
  1950. {"Sumerian", "sux", ""},
  1951. {"Sundanese", "sun", "su"},
  1952. {"Susu", "sus", ""},
  1953. {"Swahili", "swa", "sw"},
  1954. {"Swati", "ssw", "ss"},
  1955. {"Swedish", "swe", "sv"},
  1956. {"Syriac", "syr", ""},
  1957. {"Tagalog", "tgl", "tl"},
  1958. {"Tahitian", "tah", "ty"},
  1959. {"Tai (Other)", "tai", ""},
  1960. {"Tajik", "tgk", "tg"},
  1961. {"Tamashek", "tmh", ""},
  1962. {"Tamil", "tam", "ta"},
  1963. {"Tatar", "tat", "tt"},
  1964. {"Telugu", "tel", "te"},
  1965. {"Tereno", "ter", ""},
  1966. {"Tetum", "tet", ""},
  1967. {"Thai", "tha", "th"},
  1968. {"Tibetan", "tib", "bo"},
  1969. {"Tibetan", "bod", "bo"},
  1970. {"Tigre", "tig", ""},
  1971. {"Tigrinya", "tir", "ti"},
  1972. {"Timne", "tem", ""},
  1973. {"Tiv", "tiv", ""},
  1974. {"Tlingit", "tli", ""},
  1975. {"Tok Pisin", "tpi", ""},
  1976. {"Tokelau", "tkl", ""},
  1977. {"Tonga (Nyasa)", "tog", ""},
  1978. {"Tonga (Tonga Islands)", "ton", "to"},
  1979. {"Tsimshian", "tsi", ""},
  1980. {"Tsonga", "tso", "ts"},
  1981. {"Tswana", "tsn", "tn"},
  1982. {"Tumbuka", "tum", ""},
  1983. {"Tupi languages", "tup", ""},
  1984. {"Turkish", "tur", "tr"},
  1985. {"Turkish, Ottoman (1500-1928)", "ota", ""},
  1986. {"Turkmen", "tuk", "tk"},
  1987. {"Tuvalu", "tvl", ""},
  1988. {"Tuvinian", "tyv", ""},
  1989. {"Twi", "twi", "tw"},
  1990. {"Ugaritic", "uga", ""},
  1991. {"Uighur", "uig", "ug"},
  1992. {"Ukrainian", "ukr", "uk"},
  1993. {"Umbundu", "umb", ""},
  1994. {"Undetermined", "und", ""},
  1995. {"Urdu", "urd", "ur"},
  1996. {"Uzbek", "uzb", "uz"},
  1997. {"Vai", "vai", ""},
  1998. {"Venda", "ven", "ve"},
  1999. {"Vietnamese", "vie", "vi"},
  2000. {"Volap黭", "vol", "vo"},
  2001. {"Votic", "vot", ""},
  2002. {"Wakashan languages", "wak", ""},
  2003. {"Walamo", "wal", ""},
  2004. {"Walloon", "wln", "wa"},
  2005. {"Waray", "war", ""},
  2006. {"Washo", "was", ""},
  2007. {"Welsh", "wel", "cy"},
  2008. {"Welsh", "cym", "cy"},
  2009. {"Wolof", "wol", "wo"},
  2010. {"Xhosa", "xho", "xh"},
  2011. {"Yakut", "sah", ""},
  2012. {"Yao", "yao", ""},
  2013. {"Yapese", "yap", ""},
  2014. {"Yiddish", "yid", "yi"},
  2015. {"Yoruba", "yor", "yo"},
  2016. {"Yupik languages", "ypk", ""},
  2017. {"Zande", "znd", ""},
  2018. {"Zapotec", "zap", ""},
  2019. {"Zenaga", "zen", ""},
  2020. {"Zhuang; Chuang", "zha", "za"},
  2021. {"Zulu", "zul", "zu"},
  2022. {"Zuni", "zun", ""},
  2023. {"Classical Newari", "nwc", ""},
  2024. {"Klingon", "tlh", ""},
  2025. {"Blin", "byn", ""},
  2026. {"Lojban", "jbo", ""},
  2027. {"Lower Sorbian", "dsb", ""},
  2028. {"Upper Sorbian", "hsb", ""},
  2029. {"Kashubian", "csb", ""},
  2030. {"Crimean Turkish", "crh", ""},
  2031. {"Erzya", "myv", ""},
  2032. {"Moksha", "mdf", ""},
  2033. {"Karachay-Balkar", "krc", ""},
  2034. {"Adyghe", "ady", ""},
  2035. {"Udmurt", "udm", ""},
  2036. {"Dargwa", "dar", ""},
  2037. {"Ingush", "inh", ""},
  2038. {"Nogai", "nog", ""},
  2039. {"Haitian", "hat", "ht"},
  2040. {"Kalmyk", "xal", ""},
  2041. {"", "", ""},
  2042. };
  2044. CString ISO6391ToLanguage(LPCSTR code)
  2045. {
  2046. CHAR tmp[2+1];
  2047. strncpy(tmp, code, 2);
  2048. tmp[2] = 0;
  2049. _strlwr(tmp);
  2050. for(int i = 0, j = countof(s_isolangs); i < j; i++)
  2051. if(!strcmp(s_isolangs[i].iso6391, tmp))
  2052. {
  2053. CString ret = CString(CStringA(s_isolangs[i].name));
  2054. int i = ret.Find(';');
  2055. if(i > 0) ret = ret.Left(i);
  2056. return ret;
  2057. }
  2058. return(_T(""));
  2059. }
  2061. CString ISO6392ToLanguage(LPCSTR code)
  2062. {
  2063. CHAR tmp[3+1];
  2064. strncpy(tmp, code, 3);
  2065. tmp[3] = 0;
  2066. _strlwr(tmp);
  2067. for(int i = 0, j = countof(s_isolangs); i < j; i++)
  2068. {
  2069. if(!strcmp(s_isolangs[i].iso6392, tmp))
  2070. {
  2071. CString ret = CString(CStringA(s_isolangs[i].name));
  2072. int i = ret.Find(';');
  2073. if(i > 0) ret = ret.Left(i);
  2074. return ret;
  2075. }
  2076. }
  2077. return _T("");
  2078. }
  2080. CString ISO6391To6392(LPCSTR code)
  2081. {
  2082. CHAR tmp[2+1];
  2083. strncpy(tmp, code, 2);
  2084. tmp[2] = 0;
  2085. _strlwr(tmp);
  2086. for(int i = 0, j = countof(s_isolangs); i < j; i++)
  2087. if(!strcmp(s_isolangs[i].iso6391, tmp))
  2088. return CString(CStringA(s_isolangs[i].iso6392));
  2089. return _T("");
  2090. }
  2092. CString LanguageToISO6392(LPCTSTR lang)
  2093. {
  2094. CString str = lang;
  2095. str.MakeLower();
  2096. for(int i = 0, j = countof(s_isolangs); i < j; i++)
  2097. {
  2098. CList<CString> sl;
  2099. Explode(CString(s_isolangs[i].name), sl, ';');
  2100. POSITION pos = sl.GetHeadPosition();
  2101. while(pos)
  2102. {
  2103. if(!str.CompareNoCase(sl.GetNext(pos)))
  2104. return CString(s_isolangs[i].iso6392);
  2105. }
  2106. }
  2107. return _T("");
  2108. }
  2110. int MakeAACInitData(BYTE* pData, int profile, int freq, int channels)
  2111. {
  2112. int srate_idx;
  2114. if(92017 <= freq) srate_idx = 0;
  2115. else if(75132 <= freq) srate_idx = 1;
  2116. else if(55426 <= freq) srate_idx = 2;
  2117. else if(46009 <= freq) srate_idx = 3;
  2118. else if(37566 <= freq) srate_idx = 4;
  2119. else if(27713 <= freq) srate_idx = 5;
  2120. else if(23004 <= freq) srate_idx = 6;
  2121. else if(18783 <= freq) srate_idx = 7;
  2122. else if(13856 <= freq) srate_idx = 8;
  2123. else if(11502 <= freq) srate_idx = 9;
  2124. else if(9391 <= freq) srate_idx = 10;
  2125. else srate_idx = 11;
  2127. pData[0] = ((abs(profile) + 1) << 3) | ((srate_idx & 0xe) >> 1);
  2128. pData[1] = ((srate_idx & 0x1) << 7) | (channels << 3);
  2130. int ret = 2;
  2132. if(profile < 0)
  2133. {
  2134. freq *= 2;
  2136. if(92017 <= freq) srate_idx = 0;
  2137. else if(75132 <= freq) srate_idx = 1;
  2138. else if(55426 <= freq) srate_idx = 2;
  2139. else if(46009 <= freq) srate_idx = 3;
  2140. else if(37566 <= freq) srate_idx = 4;
  2141. else if(27713 <= freq) srate_idx = 5;
  2142. else if(23004 <= freq) srate_idx = 6;
  2143. else if(18783 <= freq) srate_idx = 7;
  2144. else if(13856 <= freq) srate_idx = 8;
  2145. else if(11502 <= freq) srate_idx = 9;
  2146. else if(9391 <= freq) srate_idx = 10;
  2147. else srate_idx = 11;
  2149. pData[2] = 0x2B7>>3;
  2150. pData[3] = (BYTE)((0x2B7<<5) | 5);
  2151. pData[4] = (1<<7) | (srate_idx<<3);
  2153. ret = 5;
  2154. }
  2156. return(ret);
  2157. }
  2159. BOOL CFileGetStatus(LPCTSTR lpszFileName, CFileStatus& status)
  2160. {
  2161. try
  2162. {
  2163. return CFile::GetStatus(lpszFileName, status);
  2164. }
  2165. catch(CException* e)
  2166. {
  2167. // MFCBUG: E_INVALIDARG / "Parameter is incorrect" is thrown for certain cds (vs2003)
  2168. // http://groups.google.co.uk/groups?hl=en&lr=&ie=UTF-8&threadm=OZuXYRzWDHA.536%40TK2MSFTNGP10.phx.gbl&rnum=1&prev=/groups%3Fhl%3Den%26lr%3D%26ie%3DISO-8859-1
  2169. TRACE(_T("CFile::GetStatus has thrown an exceptionn"));
  2170. e->Delete();
  2171. return false;
  2172. }
  2173. }
  2175. // filter registration helpers
  2177. bool DeleteRegKey(LPCTSTR pszKey, LPCTSTR pszSubkey)
  2178. {
  2179. bool bOK = false;
  2181. HKEY hKey;
  2182. LONG ec = ::RegOpenKeyEx(HKEY_CLASSES_ROOT, pszKey, 0, KEY_ALL_ACCESS, &hKey);
  2183. if(ec == ERROR_SUCCESS)
  2184. {
  2185. if(pszSubkey != 0)
  2186. ec = ::RegDeleteKey(hKey, pszSubkey);
  2188. bOK = (ec == ERROR_SUCCESS);
  2190. ::RegCloseKey(hKey);
  2191. }
  2193. return bOK;
  2194. }
  2196. bool SetRegKeyValue(LPCTSTR pszKey, LPCTSTR pszSubkey, LPCTSTR pszValueName, LPCTSTR pszValue)
  2197. {
  2198. bool bOK = false;
  2200. CString szKey(pszKey);
  2201. if(pszSubkey != 0)
  2202. szKey += CString(_T("\")) + pszSubkey;
  2204. HKEY hKey;
  2205. LONG ec = ::RegCreateKeyEx(HKEY_CLASSES_ROOT, szKey, 0, 0, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, 0, &hKey, 0);
  2206. if(ec == ERROR_SUCCESS)
  2207. {
  2208. if(pszValue != 0)
  2209. {
  2210. ec = ::RegSetValueEx(hKey, pszValueName, 0, REG_SZ,
  2211. reinterpret_cast<BYTE*>(const_cast<LPTSTR>(pszValue)),
  2212. (_tcslen(pszValue) + 1) * sizeof(TCHAR));
  2213. }
  2215. bOK = (ec == ERROR_SUCCESS);
  2217. ::RegCloseKey(hKey);
  2218. }
  2220. return bOK;
  2221. }
  2223. bool SetRegKeyValue(LPCTSTR pszKey, LPCTSTR pszSubkey, LPCTSTR pszValue)
  2224. {
  2225. return SetRegKeyValue(pszKey, pszSubkey, 0, pszValue);
  2226. }
  2228. void RegisterSourceFilter(const CLSID& clsid, const GUID& subtype2, LPCTSTR chkbytes, LPCTSTR ext, ...)
  2229. {
  2230. CString null = CStringFromGUID(GUID_NULL);
  2231. CString majortype = CStringFromGUID(MEDIATYPE_Stream);
  2232. CString subtype = CStringFromGUID(subtype2);
  2234. SetRegKeyValue(_T("Media Type\") + majortype, subtype, _T("0"), chkbytes);
  2235. SetRegKeyValue(_T("Media Type\") + majortype, subtype, _T("Source Filter"), CStringFromGUID(clsid));
  2237. DeleteRegKey(_T("Media Type\") + null, subtype);
  2239. va_list marker;
  2240. va_start(marker, ext);
  2241. for(; ext; ext = va_arg(marker, LPCTSTR))
  2242. DeleteRegKey(_T("Media Type\Extensions"), ext);
  2243. va_end(marker);
  2244. }
  2246. void RegisterSourceFilter(const CLSID& clsid, const GUID& subtype2, const CList<CString>& chkbytes, LPCTSTR ext, ...)
  2247. {
  2248. CString null = CStringFromGUID(GUID_NULL);
  2249. CString majortype = CStringFromGUID(MEDIATYPE_Stream);
  2250. CString subtype = CStringFromGUID(subtype2);
  2252. POSITION pos = chkbytes.GetHeadPosition();
  2253. for(int i = 0; pos; i++)
  2254. {
  2255. CString idx;
  2256. idx.Format(_T("%d"), i);
  2257. SetRegKeyValue(_T("Media Type\") + majortype, subtype, idx, chkbytes.GetNext(pos));
  2258. }
  2260. SetRegKeyValue(_T("Media Type\") + majortype, subtype, _T("Source Filter"), CStringFromGUID(clsid));
  2262. DeleteRegKey(_T("Media Type\") + null, subtype);
  2264. va_list marker;
  2265. va_start(marker, ext);
  2266. for(; ext; ext = va_arg(marker, LPCTSTR))
  2267. DeleteRegKey(_T("Media Type\Extensions"), ext);
  2268. va_end(marker);
  2269. }
  2271. void UnRegisterSourceFilter(const GUID& subtype)
  2272. {
  2273. DeleteRegKey(_T("Media Type\") + CStringFromGUID(MEDIATYPE_Stream), CStringFromGUID(subtype));
  2274. }