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

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

多媒体编程

开发平台：

Visual C++

DirectVobSubFilter.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 <math.h>
  24. #include <time.h>
  25. #include "DirectVobSubFilter.h"
  26. #include "TextInputPin.h"
  27. #include "DirectVobSubPropPage.h"
  28. #include "VSFilter.h"
  29. #include "systray.h"
  30. #include "......DSUtilMediaTypes.h"
  31. #include "......SubPicMemSubPic.h"
  33. #include <initguid.h>
  34. #include "........includemoreuuids.h"
  35. #include "........includeOggOggDS.h"
  37. ///////////////////////////////////////////////////////////////////////////
  39. /*removeme*/
  40. bool g_RegOK = true;//false; // doesn't work with the dvd graph builder
  41. #include "valami.cpp"
  43. ////////////////////////////////////////////////////////////////////////////
  44. //
  45. // Constructor
  46. //
  48. CDirectVobSubFilter::CDirectVobSubFilter(LPUNKNOWN punk, HRESULT* phr, const GUID& clsid)
  49. : CBaseVideoFilter(NAME("CDirectVobSubFilter"), punk, phr, clsid)
  50. , m_nSubtitleId(-1)
  51. , m_fMSMpeg4Fix(false)
  52. , m_fDivxPlusFix(false)
  53. , m_fps(25)
  54. {
  55. AFX_MANAGE_STATE(AfxGetStaticModuleState());
  57. m_hdc = 0;
  58. m_hbm = 0;
  59. m_hfont = 0;
  61. {
  62. LOGFONT lf;
  63. memset(&lf, 0, sizeof(lf));
  64. lf.lfCharSet = DEFAULT_CHARSET;
  65. lf.lfOutPrecision = OUT_CHARACTER_PRECIS;
  66. lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
  67. lf.lfQuality = ANTIALIASED_QUALITY;
  68. HDC hdc = GetDC(NULL);
  69. lf.lfHeight = -MulDiv(10, GetDeviceCaps(hdc, LOGPIXELSY), 72);
  70. ReleaseDC(NULL, hdc);
  71. lf.lfWeight = FW_BOLD;
  72. _tcscpy(lf.lfFaceName, _T("Arial"));
  73. m_hfont = CreateFontIndirect(&lf);
  74. }
  76. theApp.WriteProfileString(ResStr(IDS_R_DEFTEXTPATHES), _T("Hint"), _T("The first three are fixed, but you can add more up to ten entries."));
  77. theApp.WriteProfileString(ResStr(IDS_R_DEFTEXTPATHES), _T("Path0"), _T("."));
  78. theApp.WriteProfileString(ResStr(IDS_R_DEFTEXTPATHES), _T("Path1"), _T("c:\subtitles"));
  79. theApp.WriteProfileString(ResStr(IDS_R_DEFTEXTPATHES), _T("Path2"), _T(".\subtitles"));
  81. m_fLoading = true;
  83. m_hSystrayThread = 0;
  84. m_tbid.hSystrayWnd = NULL;
  85. m_tbid.graph = NULL;
  86. m_tbid.fRunOnce = false;
  87. m_tbid.fShowIcon = (theApp.m_AppName.Find(_T("zplayer"), 0) < 0 || !!theApp.GetProfileInt(ResStr(IDS_R_GENERAL), ResStr(IDS_RG_ENABLEZPICON), 0));
  89. HRESULT hr = S_OK;
  90. m_pTextInput.Add(new CTextInputPin(this, m_pLock, &m_csSubLock, &hr));
  91. ASSERT(SUCCEEDED(hr));
  93. CAMThread::Create();
  94. m_frd.EndThreadEvent.Create(0, FALSE, FALSE, 0);
  95. m_frd.RefreshEvent.Create(0, FALSE, FALSE, 0);
  96. }
  98. CDirectVobSubFilter::~CDirectVobSubFilter()
  99. {
  100. CAutoLock cAutoLock(&m_csQueueLock);
  101. if(m_pSubPicQueue) m_pSubPicQueue->Invalidate();
  102. m_pSubPicQueue = NULL;
  104. if(m_hfont) {DeleteObject(m_hfont); m_hfont = 0;}
  105. if(m_hbm) {DeleteObject(m_hbm); m_hbm = 0;}
  106. if(m_hdc) {DeleteObject(m_hdc); m_hdc = 0;}
  108. for(int i = 0; i < m_pTextInput.GetSize(); i++) 
  109. delete m_pTextInput[i];
  111. m_frd.EndThreadEvent.Set();
  112. CAMThread::Close();
  113. }
  115. STDMETHODIMP CDirectVobSubFilter::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  116. {
  117.     CheckPointer(ppv, E_POINTER);
  119.     return 
  120. QI(IDirectVobSub)
  121. QI(IDirectVobSub2)
  122. QI(IFilterVersion)
  123. QI(ISpecifyPropertyPages)
  124. QI(IAMStreamSelect)
  125. __super::NonDelegatingQueryInterface(riid, ppv);
  126. }
  128. // CBaseVideoFilter
  130. void CDirectVobSubFilter::GetOutputSize(int& w, int& h, int& arx, int& ary)
  131. {
  132. CSize s(w, h), os = s;
  133. AdjustFrameSize(s);
  134. w = s.cx;
  135. h = s.cy;
  137. if(w != os.cx)
  138. {
  139. while(arx < 100) arx *= 10, ary *= 10;
  140. arx = arx * w / os.cx;
  141. }
  143. if(h != os.cy)
  144. {
  145. while(ary < 100) arx *= 10, ary *= 10;
  146. ary = ary * h / os.cy;
  147. }
  148. }
  150. HRESULT CDirectVobSubFilter::Transform(IMediaSample* pIn)
  151. {
  152. HRESULT hr;
  155. REFERENCE_TIME rtStart, rtStop;
  156. if(SUCCEEDED(pIn->GetTime(&rtStart, &rtStop)))
  157. {
  158. double dRate = m_pInput->CurrentRate();
  160. m_tPrev = m_pInput->CurrentStartTime() + dRate*rtStart;
  162. REFERENCE_TIME rtAvgTimePerFrame = rtStop - rtStart;
  163. if(CComQIPtr<ISubClock2> pSC2 = m_pSubClock)
  164. {
  165. REFERENCE_TIME rt;
  166.  if(S_OK == pSC2->GetAvgTimePerFrame(&rt))
  167.  rtAvgTimePerFrame = rt;
  168. }
  170. m_fps = 10000000.0/rtAvgTimePerFrame / dRate;
  171. }
  173. //
  175. {
  176. CAutoLock cAutoLock(&m_csQueueLock);
  178. if(m_pSubPicQueue)
  179. {
  180. m_pSubPicQueue->SetTime(CalcCurrentTime());
  181. m_pSubPicQueue->SetFPS(m_fps);
  182. }
  183. }
  185. //
  187. BYTE* pDataIn = NULL;
  188. if(FAILED(pIn->GetPointer(&pDataIn)) || !pDataIn)
  189. return S_FALSE;
  191. const CMediaType& mt = m_pInput->CurrentMediaType();
  193. BITMAPINFOHEADER bihIn;
  194. ExtractBIH(&mt, &bihIn);
  196. bool fYV12 = (mt.subtype == MEDIASUBTYPE_YV12 || mt.subtype == MEDIASUBTYPE_I420 || mt.subtype == MEDIASUBTYPE_IYUV);
  197. int bpp = fYV12 ? 8 : bihIn.biBitCount;
  198. DWORD black = fYV12 ? 0x10101010 : (bihIn.biCompression == '2YUY') ? 0x80108010 : 0;
  200. CSize sub(m_w, m_h);
  201. CSize in(bihIn.biWidth, bihIn.biHeight);
  203. if(FAILED(Copy((BYTE*)m_pTempPicBuff, pDataIn, sub, in, bpp, mt.subtype, black))) 
  204. return E_FAIL;
  206. if(fYV12)
  207. {
  208. BYTE* pSubV = (BYTE*)m_pTempPicBuff + (sub.cx*bpp>>3)*sub.cy;
  209. BYTE* pInV = pDataIn + (in.cx*bpp>>3)*in.cy;
  210. sub.cx >>= 1; sub.cy >>= 1; in.cx >>= 1; in.cy >>= 1;
  211. BYTE* pSubU = pSubV + (sub.cx*bpp>>3)*sub.cy;
  212. BYTE* pInU = pInV + (in.cx*bpp>>3)*in.cy;
  213. if(FAILED(Copy(pSubV, pInV, sub, in, bpp, mt.subtype, 0x80808080)))
  214. return E_FAIL;
  215. if(FAILED(Copy(pSubU, pInU, sub, in, bpp, mt.subtype, 0x80808080)))
  216. return E_FAIL;
  217. }
  219. //
  221. SubPicDesc spd = m_spd;
  223. CComPtr<IMediaSample> pOut;
  224. BYTE* pDataOut = NULL;
  225. if(FAILED(hr = GetDeliveryBuffer(spd.w, spd.h, &pOut))
  226. || FAILED(hr = pOut->GetPointer(&pDataOut)))
  227. return hr;
  229. pOut->SetTime(&rtStart, &rtStop);
  230. pOut->SetMediaTime(NULL, NULL);
  232. // 
  234. BITMAPINFOHEADER bihOut;
  235. ExtractBIH(&m_pOutput->CurrentMediaType(), &bihOut);
  237. bool fInputFlipped = bihIn.biHeight >= 0 && bihIn.biCompression <= 3;
  238. bool fOutputFlipped = bihOut.biHeight >= 0 && bihOut.biCompression <= 3;
  240. bool fFlip = fInputFlipped != fOutputFlipped;
  241. if(m_fFlipPicture) fFlip = !fFlip;
  242. if(m_fMSMpeg4Fix) fFlip = !fFlip;
  243. // if(m_fDivxPlusFix) fFlip = !fFlip;
  245. bool fFlipSub = fOutputFlipped;
  246. if(m_fFlipSubtitles) fFlipSub = !fFlipSub;
  247. // if(m_fDivxPlusFix) fFlipSub = !fFlipSub;
  249. //
  251. {
  252. CAutoLock cAutoLock(&m_csQueueLock);
  254. if(m_pSubPicQueue)
  255. {
  256. CComPtr<ISubPic> pSubPic;
  257. if(SUCCEEDED(m_pSubPicQueue->LookupSubPic(CalcCurrentTime(), &pSubPic)) && pSubPic)
  258. {
  259. CRect r;
  260. pSubPic->GetDirtyRect(r);
  262. if(fFlip ^ fFlipSub)
  263. spd.h = -spd.h;
  265. pSubPic->AlphaBlt(r, r, &spd);
  266. }
  267. }
  268. }
  270. CopyBuffer(pDataOut, (BYTE*)spd.bits, spd.w, abs(spd.h)*(fFlip?-1:1), spd.pitch, mt.subtype);
  272. PrintMessages(pDataOut);
  274. return m_pOutput->Deliver(pOut);
  275. }
  277. // CBaseFilter
  279. CBasePin* CDirectVobSubFilter::GetPin(int n)
  280. {
  281. if(n < __super::GetPinCount())
  282. return __super::GetPin(n);
  284. n -= __super::GetPinCount();
  286. if(n >= 0 && n < m_pTextInput.GetSize())
  287. return m_pTextInput[n]; 
  289. n -= m_pTextInput.GetSize();
  291. return NULL;
  292. }
  294. int CDirectVobSubFilter::GetPinCount()
  295. {
  296. return __super::GetPinCount() + m_pTextInput.GetSize();
  297. }
  299. HRESULT CDirectVobSubFilter::JoinFilterGraph(IFilterGraph* pGraph, LPCWSTR pName)
  300. {
  301. if(pGraph)
  302. {
  303. AFX_MANAGE_STATE(AfxGetStaticModuleState());
  305. if(!theApp.GetProfileInt(ResStr(IDS_R_GENERAL), ResStr(IDS_RG_SEENDIVXWARNING), 0))
  306. {
  307. unsigned __int64 ver = GetFileVersion(_T("divx_c32.ax"));
  308. if(((ver >> 48)&0xffff) == 4 && ((ver >> 32)&0xffff) == 2)
  309. {
  310. DWORD dwVersion = GetVersion();
  311. DWORD dwWindowsMajorVersion = (DWORD)(LOBYTE(LOWORD(dwVersion)));
  312. DWORD dwWindowsMinorVersion = (DWORD)(HIBYTE(LOWORD(dwVersion)));
  314. if(dwVersion < 0x80000000 && dwWindowsMajorVersion >= 5)
  315. {
  316. AfxMessageBox(IDS_DIVX_WARNING);
  317. theApp.WriteProfileInt(ResStr(IDS_R_GENERAL), ResStr(IDS_RG_SEENDIVXWARNING), 1);
  318. }
  319. }
  320. }
  322. /*removeme*/
  323. if(!g_RegOK)
  324. {
  325. DllRegisterServer();
  326. g_RegOK = true;
  327. }
  328. }
  329. else
  330. {
  331. if(m_hSystrayThread)
  332. {
  333. SendMessage(m_tbid.hSystrayWnd, WM_CLOSE, 0, 0);
  335. if(WaitForSingleObject(m_hSystrayThread, 10000) != WAIT_OBJECT_0)
  336. {
  337. DbgLog((LOG_TRACE, 0, _T("CALL THE AMBULANCE!!!")));
  338. TerminateThread(m_hSystrayThread, (DWORD)-1);
  339. }
  341. m_hSystrayThread = 0;
  342. }
  343. }
  345. return __super::JoinFilterGraph(pGraph, pName);
  346. }
  348. STDMETHODIMP CDirectVobSubFilter::QueryFilterInfo(FILTER_INFO* pInfo)
  349. {
  350.     CheckPointer(pInfo, E_POINTER);
  351.     ValidateReadWritePtr(pInfo, sizeof(FILTER_INFO));
  353. if(!get_Forced())
  354. return __super::QueryFilterInfo(pInfo);
  356. wcscpy(pInfo->achName, L"DirectVobSub (forced auto-loading version)");
  357. if(pInfo->pGraph = m_pGraph) m_pGraph->AddRef();
  359. return S_OK;
  360. }
  362. // CTransformFilter
  364. HRESULT CDirectVobSubFilter::SetMediaType(PIN_DIRECTION dir, const CMediaType* pmt)
  365. {
  366. HRESULT hr = __super::SetMediaType(dir, pmt);
  367. if(FAILED(hr)) return hr;
  369. if(dir == PINDIR_INPUT)
  370. {
  371. CAutoLock cAutoLock(&m_csReceive);
  373. REFERENCE_TIME atpf = 
  374. pmt->formattype == FORMAT_VideoInfo ? ((VIDEOINFOHEADER*)pmt->Format())->AvgTimePerFrame :
  375. pmt->formattype == FORMAT_VideoInfo2 ? ((VIDEOINFOHEADER2*)pmt->Format())->AvgTimePerFrame :
  376. 0;
  378. m_fps = atpf ? 10000000.0 / atpf : 25;
  380.         InitSubPicQueue();
  381. }
  382. else if(dir == PINDIR_OUTPUT)
  383. {
  385. }
  387. return hr;
  388. }
  390. HRESULT CDirectVobSubFilter::CheckConnect(PIN_DIRECTION dir, IPin* pPin)
  391. {
  392. if(dir == PINDIR_INPUT)
  393. {
  394. }
  395. else if(dir == PINDIR_OUTPUT)
  396. {
  397. /*removeme*/
  398. if(HmGyanusVagyTeNekem(pPin)) return(E_FAIL);
  399. }
  401. return __super::CheckConnect(dir, pPin);
  402. }
  404. HRESULT CDirectVobSubFilter::CompleteConnect(PIN_DIRECTION dir, IPin* pReceivePin)
  405. {
  406. if(dir == PINDIR_INPUT)
  407. {
  408. CComPtr<IBaseFilter> pFilter;
  410. // needed when we have a decoder with a version number of 3.x
  411. if(SUCCEEDED(m_pGraph->FindFilterByName(L"DivX MPEG-4 DVD Video Decompressor ", &pFilter))
  412. && (GetFileVersion(_T("divx_c32.ax")) >> 48) <= 4
  413. || SUCCEEDED(m_pGraph->FindFilterByName(L"Microcrap MPEG-4 Video Decompressor", &pFilter))
  414. || SUCCEEDED(m_pGraph->FindFilterByName(L"Microsoft MPEG-4 Video Decompressor", &pFilter)) 
  415. && (GetFileVersion(_T("mpg4ds32.ax")) >> 48) <= 3)
  416. {
  417. m_fMSMpeg4Fix = true;
  418. }
  419. }
  420. else if(dir == PINDIR_OUTPUT)
  421. {
  422. if(!m_hSystrayThread)
  423. {
  424. m_tbid.graph = m_pGraph;
  425. m_tbid.dvs = static_cast<IDirectVobSub*>(this);
  427. DWORD tid;
  428. m_hSystrayThread = CreateThread(0, 0, SystrayThreadProc, &m_tbid, 0, &tid);
  429. }
  431. // HACK: triggers CBaseVideoFilter::SetMediaType to adjust m_w/m_h/.. and InitSubPicQueue() to realloc buffers
  432. m_pInput->SetMediaType(&m_pInput->CurrentMediaType());
  433. }
  435. return __super::CompleteConnect(dir, pReceivePin);
  436. }
  438. HRESULT CDirectVobSubFilter::BreakConnect(PIN_DIRECTION dir)
  439. {
  440. if(dir == PINDIR_INPUT)
  441. {
  442. if(m_pOutput->IsConnected())
  443. {
  444. m_pOutput->GetConnected()->Disconnect();
  445. m_pOutput->Disconnect();
  446. }
  447. }
  448. else if(dir == PINDIR_OUTPUT)
  449. {
  450. // not really needed, but may free up a little memory
  451. CAutoLock cAutoLock(&m_csQueueLock);
  452. m_pSubPicQueue = NULL;
  453. }
  455. return __super::BreakConnect(dir);
  456. }
  458. HRESULT CDirectVobSubFilter::StartStreaming()
  459. {
  460. m_fLoading = false;
  462. InitSubPicQueue();
  464. m_tbid.fRunOnce = true;
  466. CComPtr<IBaseFilter> pFilter;
  467. m_fDivxPlusFix = SUCCEEDED(m_pGraph->FindFilterByName(L"HPlus YUV Video Renderer", &pFilter));
  469. put_MediaFPS(m_fMediaFPSEnabled, m_MediaFPS);
  471. return __super::StartStreaming();
  472. }
  474. HRESULT CDirectVobSubFilter::StopStreaming()
  475. {
  476. InvalidateSubtitle();
  478. return __super::StopStreaming();
  479. }
  481. HRESULT CDirectVobSubFilter::NewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
  482. {
  483. m_tPrev = tStart;
  484.     return __super::NewSegment(tStart, tStop, dRate);
  485. }
  487. //
  489. REFERENCE_TIME CDirectVobSubFilter::CalcCurrentTime()
  490. {
  491. REFERENCE_TIME rt = m_pSubClock ? m_pSubClock->GetTime() : m_tPrev;
  492. return (rt - 10000i64*m_SubtitleDelay) * m_SubtitleSpeedMul / m_SubtitleSpeedDiv; // no, it won't overflow if we use normal parameters (__int64 is enough for about 2000 hours if we multiply it by the max: 65536 as m_SubtitleSpeedMul)
  493. }
  495. void CDirectVobSubFilter::InitSubPicQueue()
  496. {
  497. CAutoLock cAutoLock(&m_csQueueLock);
  499. m_pSubPicQueue = NULL;
  501. m_pTempPicBuff.Free();
  502. m_pTempPicBuff.Allocate(4*m_w*m_h);
  504. const GUID& subtype = m_pInput->CurrentMediaType().subtype;
  506. BITMAPINFOHEADER bihIn;
  507. ExtractBIH(&m_pInput->CurrentMediaType(), &bihIn);
  509. m_spd.type = -1;
  510. if(subtype == MEDIASUBTYPE_YV12) m_spd.type = MSP_YV12;
  511. else if(subtype == MEDIASUBTYPE_I420 || subtype == MEDIASUBTYPE_IYUV) m_spd.type = MSP_IYUV;
  512. else if(subtype == MEDIASUBTYPE_YUY2) m_spd.type = MSP_YUY2;
  513. else if(subtype == MEDIASUBTYPE_RGB32) m_spd.type = MSP_RGB32;
  514. else if(subtype == MEDIASUBTYPE_RGB24) m_spd.type = MSP_RGB24;
  515. else if(subtype == MEDIASUBTYPE_RGB565) m_spd.type = MSP_RGB16;
  516. else if(subtype == MEDIASUBTYPE_RGB555) m_spd.type = MSP_RGB15;
  517. m_spd.w = m_w;
  518. m_spd.h = m_h;
  519. m_spd.bpp = (m_spd.type == MSP_YV12 || m_spd.type == MSP_IYUV) ? 8 : bihIn.biBitCount;
  520. m_spd.pitch = m_spd.w*m_spd.bpp>>3;
  521. m_spd.bits = (void*)m_pTempPicBuff;
  523. CComPtr<ISubPicAllocator> pSubPicAllocator = new CMemSubPicAllocator(m_spd.type, CSize(m_w, m_h));
  525. CSize video(bihIn.biWidth, bihIn.biHeight);
  526. CSize window(m_w, m_h);
  527. if(AdjustFrameSize(window)) video += video;
  528. pSubPicAllocator->SetCurSize(window);
  529. pSubPicAllocator->SetCurVidRect(CRect(CPoint((window.cx - video.cx)/2, (window.cy - video.cy)/2), video));
  531. HRESULT hr = S_OK;
  532. m_pSubPicQueue = m_fDoPreBuffering 
  533. ? (ISubPicQueue*)new CSubPicQueue(10, pSubPicAllocator, &hr)
  534. : (ISubPicQueue*)new CSubPicQueueNoThread(pSubPicAllocator, &hr);
  536. if(FAILED(hr)) m_pSubPicQueue = NULL;
  538. UpdateSubtitle(false);
  540. if(m_hbm) {DeleteObject(m_hbm); m_hbm = NULL;}
  541. if(m_hdc) {DeleteDC(m_hdc); m_hdc = NULL;}
  543. struct {BITMAPINFOHEADER bih; DWORD mask[3];} b = {{sizeof(BITMAPINFOHEADER), m_w, -(int)m_h, 1, 32, BI_BITFIELDS, 0, 0, 0, 0, 0}, 0xFF0000, 0x00FF00, 0x0000FF};
  544. m_hdc = CreateCompatibleDC(NULL);
  545. m_hbm = CreateDIBSection(m_hdc, (BITMAPINFO*)&b, DIB_RGB_COLORS, NULL, NULL, 0);
  547. BITMAP bm;
  548. GetObject(m_hbm, sizeof(bm), &bm);
  549. memsetd(bm.bmBits, 0xFF000000, bm.bmHeight*bm.bmWidthBytes);
  550. }
  552. bool CDirectVobSubFilter::AdjustFrameSize(CSize& s)
  553. {
  554. int horizontal, vertical, resx2, resx2minw, resx2minh;
  555. get_ExtendPicture(&horizontal, &vertical, &resx2, &resx2minw, &resx2minh);
  557. bool fRet;
  558. if(fRet = (resx2 == 1) || (resx2 == 2 && s.cx*s.cy <= resx2minw*resx2minh))
  559. {
  560. s.cx <<= 1; 
  561. s.cy <<= 1;
  562. }
  564. int h;
  565. switch(vertical&0x7f)
  566. {
  567. case 1:
  568. h = s.cx * 9 / 16;
  569. if(s.cy < h || !!(vertical&0x80)) s.cy = (h + 3) & ~3;
  570. break;
  571. case 2:
  572. h = s.cx * 3 / 4;
  573. if(s.cy < h || !!(vertical&0x80)) s.cy = (h + 3) & ~3;
  574. break;
  575. case 3:
  576. h = 480;
  577. if(s.cy < h || !!(vertical&0x80)) s.cy = (h + 3) & ~3;
  578. break;
  579. case 4:
  580. h = 576;
  581. if(s.cy < h || !!(vertical&0x80)) s.cy = (h + 3) & ~3;
  582. break;
  583. }
  585. if(horizontal == 1)
  586. {
  587. s.cx = (s.cx + 31) & ~31;
  588. s.cy = (s.cy + 1) & ~1;
  589. }
  591. return(fRet);
  592. }
  594. STDMETHODIMP CDirectVobSubFilter::Count(DWORD* pcStreams)
  595. {
  596. if(!pcStreams) return E_POINTER;
  598. *pcStreams = 0;
  600. int nLangs = 0;
  601. if(SUCCEEDED(get_LanguageCount(&nLangs)))
  602. (*pcStreams) += nLangs;
  604. (*pcStreams) += 2; // enable ... disable
  606. (*pcStreams) += 2; // normal flipped
  608. return S_OK;
  609. }
  611. #define MAXPREFLANGS 5
  613. int CDirectVobSubFilter::FindPreferedLanguage(bool fHideToo)
  614. {
  615. AFX_MANAGE_STATE(AfxGetStaticModuleState());
  617. int nLangs;
  618. get_LanguageCount(&nLangs);
  620. if(nLangs <= 0) return(0);
  622. for(int i = 0; i < MAXPREFLANGS; i++)
  623. {
  624. CString tmp;
  625. tmp.Format(IDS_RL_LANG, i);
  627. CString lang = theApp.GetProfileString(ResStr(IDS_R_PREFLANGS), tmp);
  629. if(!lang.IsEmpty())
  630. {
  631. for(int ret = 0; ret < nLangs; ret++)
  632. {
  633. CString l;
  634. WCHAR* pName = NULL;
  635. get_LanguageName(ret, &pName);
  636. l = pName;
  637. CoTaskMemFree(pName);
  639. if(!l.CompareNoCase(lang)) return(ret);
  640. }
  641. }
  642. }
  644. return(0);
  645. }
  647. void CDirectVobSubFilter::UpdatePreferedLanguages(CString l)
  648. {
  649. AFX_MANAGE_STATE(AfxGetStaticModuleState());
  651. CString langs[MAXPREFLANGS+1];
  653. int i = 0, j = 0, k = -1;
  654. for(; i < MAXPREFLANGS; i++)
  655. {
  656. CString tmp;
  657. tmp.Format(IDS_RL_LANG, i);
  659. langs[j] = theApp.GetProfileString(ResStr(IDS_R_PREFLANGS), tmp);
  661. if(!langs[j].IsEmpty()) 
  662. {
  663. if(!langs[j].CompareNoCase(l)) k = j;
  664. j++;
  665. }
  666. }
  668. if(k == -1)
  669. {
  670. langs[k = j] = l;
  671. j++;
  672. }
  674. // move the selected to the top of the list
  676. while(k > 0)
  677. {
  678. CString tmp = langs[k]; langs[k] = langs[k-1]; langs[k-1] = tmp;
  679. k--;
  680. }
  682. // move "Hide subtitles" to the last position if it wasn't our selection
  684. CString hidesubs;
  685. hidesubs.LoadString(IDS_M_HIDESUBTITLES);
  687. for(k = 1; k < j; k++)
  688. {
  689. if(!langs[k].CompareNoCase(hidesubs)) break;
  690. }
  692. while(k < j-1)
  693. {
  694. CString tmp = langs[k]; langs[k] = langs[k+1]; langs[k+1] = tmp;
  695. k++;
  696. }
  698. for(i = 0; i < j; i++)
  699. {
  700. CString tmp;
  701. tmp.Format(IDS_RL_LANG, i);
  703. theApp.WriteProfileString(ResStr(IDS_R_PREFLANGS), tmp, langs[i]);
  704. }
  705. }
  707. STDMETHODIMP CDirectVobSubFilter::Enable(long lIndex, DWORD dwFlags)
  708. {
  709. if(!(dwFlags & AMSTREAMSELECTENABLE_ENABLE))
  710. return E_NOTIMPL;
  712. int nLangs = 0;
  713. get_LanguageCount(&nLangs);
  715. if(!(lIndex >= 0 && lIndex < nLangs+2+2)) 
  716. return E_INVALIDARG;
  718. int i = lIndex-1;
  720. if(i == -1 && !m_fLoading) // we need this because when loading something stupid media player pushes the first stream it founds, which is "enable" in our case
  721. {
  722. put_HideSubtitles(false);
  723. }
  724. else if(i >= 0 && i < nLangs)
  725. {
  726. put_HideSubtitles(false);
  727. put_SelectedLanguage(i);
  729. WCHAR* pName = NULL;
  730. if(SUCCEEDED(get_LanguageName(i, &pName)))
  731. {
  732. UpdatePreferedLanguages(CString(pName));
  733. if(pName) CoTaskMemFree(pName);
  734. }
  735. }
  736. else if(i == nLangs && !m_fLoading)
  737. {
  738. put_HideSubtitles(true);
  739. }
  740. else if((i == nLangs+1 || i == nLangs+2) && !m_fLoading)
  741. {
  742. put_Flip(i == nLangs+2, m_fFlipSubtitles);
  743. }
  745. return S_OK;
  746. }
  748. STDMETHODIMP CDirectVobSubFilter::Info(long lIndex, AM_MEDIA_TYPE** ppmt, DWORD* pdwFlags, LCID* plcid, DWORD* pdwGroup, WCHAR** ppszName, IUnknown** ppObject, IUnknown** ppUnk)
  749. {
  750. AFX_MANAGE_STATE(AfxGetStaticModuleState());
  752. int nLangs = 0;
  753. get_LanguageCount(&nLangs);
  755. if(!(lIndex >= 0 && lIndex < nLangs+2+2)) 
  756. return E_INVALIDARG;
  758. int i = lIndex-1;
  760. if(ppmt) *ppmt = CreateMediaType(&m_pInput->CurrentMediaType());
  762. if(pdwFlags)
  763. {
  764. *pdwFlags = 0;
  766. if(i == -1 && !m_fHideSubtitles
  767. || i >= 0 && i < nLangs && i == m_iSelectedLanguage
  768. || i == nLangs && m_fHideSubtitles
  769. || i == nLangs+1 && !m_fFlipPicture
  770. || i == nLangs+2 && m_fFlipPicture)
  771. {
  772. *pdwFlags |= AMSTREAMSELECTINFO_ENABLED;
  773. }
  774. }
  776. if(plcid) *plcid = 0;
  778. if(pdwGroup) *pdwGroup = 0x648E51;
  780. if(ppszName)
  781. {
  782. *ppszName = NULL;
  784. CStringW str;
  785. if(i == -1) str = ResStr(IDS_M_SHOWSUBTITLES);
  786. else if(i >= 0 && i < nLangs) get_LanguageName(i, ppszName);
  787. else if(i == nLangs) str = ResStr(IDS_M_HIDESUBTITLES);
  788. else if(i == nLangs+1) {str = ResStr(IDS_M_ORIGINALPICTURE); if(pdwGroup) (*pdwGroup)++;}
  789. else if(i == nLangs+2) {str = ResStr(IDS_M_FLIPPEDPICTURE); if(pdwGroup) (*pdwGroup)++;}
  791. if(!str.IsEmpty())
  792. {
  793. *ppszName = (WCHAR*)CoTaskMemAlloc((str.GetLength()+1)*sizeof(WCHAR));
  794. if(*ppszName == NULL) return S_FALSE;
  795. wcscpy(*ppszName, str);
  796. }
  797. }
  799. if(ppObject) *ppObject = NULL;
  801. if(ppUnk) *ppUnk = NULL;
  803. return S_OK;
  804. }
  806. STDMETHODIMP CDirectVobSubFilter::GetClassID(CLSID* pClsid)
  807. {
  808.     if(pClsid == NULL) return E_POINTER;
  809. *pClsid = m_clsid;
  810.     return NOERROR;
  811. }
  813. STDMETHODIMP CDirectVobSubFilter::GetPages(CAUUID* pPages)
  814. {
  815.     CheckPointer(pPages, E_POINTER);
  817. pPages->cElems = 7;
  818.     pPages->pElems = (GUID*)CoTaskMemAlloc(sizeof(GUID)*pPages->cElems);
  820. if(pPages->pElems == NULL) return E_OUTOFMEMORY;
  822. int i = 0;
  823.     pPages->pElems[i++] = __uuidof(CDVSMainPPage);
  824.     pPages->pElems[i++] = __uuidof(CDVSGeneralPPage);
  825.     pPages->pElems[i++] = __uuidof(CDVSMiscPPage);
  826.     pPages->pElems[i++] = __uuidof(CDVSTimingPPage);
  827.     pPages->pElems[i++] = __uuidof(CDVSColorPPage);
  828.     pPages->pElems[i++] = __uuidof(CDVSPathsPPage);
  829.     pPages->pElems[i++] = __uuidof(CDVSAboutPPage);
  831.     return NOERROR;
  832. }
  834. // IDirectVobSub
  836. STDMETHODIMP CDirectVobSubFilter::put_FileName(WCHAR* fn)
  837. {
  838. HRESULT hr = CDirectVobSub::put_FileName(fn);
  840. if(hr == S_OK && !Open()) 
  841. {
  842. m_FileName.Empty();
  843. hr = E_FAIL;
  844. }
  846. return hr;
  847. }
  849. STDMETHODIMP CDirectVobSubFilter::get_LanguageCount(int* nLangs)
  850. {
  851. HRESULT hr = CDirectVobSub::get_LanguageCount(nLangs);
  853. if(hr == NOERROR && nLangs)
  854. {
  855.         CAutoLock cAutolock(&m_csQueueLock);
  857. *nLangs = 0;
  858. POSITION pos = m_pSubStreams.GetHeadPosition();
  859. while(pos) (*nLangs) += m_pSubStreams.GetNext(pos)->GetStreamCount();
  860. }
  862. return hr;
  863. }
  865. STDMETHODIMP CDirectVobSubFilter::get_LanguageName(int iLanguage, WCHAR** ppName)
  866. {
  867. HRESULT hr = CDirectVobSub::get_LanguageName(iLanguage, ppName);
  869. if(!ppName) return E_POINTER;
  871. if(hr == NOERROR)
  872. {
  873.         CAutoLock cAutolock(&m_csQueueLock);
  875. hr = E_INVALIDARG;
  877. int i = iLanguage;
  879. POSITION pos = m_pSubStreams.GetHeadPosition();
  880. while(i >= 0 && pos)
  881. {
  882. CComPtr<ISubStream> pSubStream = m_pSubStreams.GetNext(pos);
  884. if(i < pSubStream->GetStreamCount())
  885. {
  886. pSubStream->GetStreamInfo(i, ppName, NULL);
  887. hr = NOERROR;
  888. break;
  889. }
  891. i -= pSubStream->GetStreamCount();
  892. }
  893. }
  895. return hr;
  896. }
  898. STDMETHODIMP CDirectVobSubFilter::put_SelectedLanguage(int iSelected)
  899. {
  900. HRESULT hr = CDirectVobSub::put_SelectedLanguage(iSelected);
  902. if(hr == NOERROR)
  903. {
  904. UpdateSubtitle(false);
  905. }
  907. return hr;
  908. }
  910. STDMETHODIMP CDirectVobSubFilter::put_HideSubtitles(bool fHideSubtitles)
  911. {
  912. HRESULT hr = CDirectVobSub::put_HideSubtitles(fHideSubtitles);
  914. if(hr == NOERROR)
  915. {
  916. UpdateSubtitle(false);
  917. }
  919. return hr;
  920. }
  922. STDMETHODIMP CDirectVobSubFilter::put_PreBuffering(bool fDoPreBuffering)
  923. {
  924. HRESULT hr = CDirectVobSub::put_PreBuffering(fDoPreBuffering);
  926. if(hr == NOERROR)
  927. {
  928. InitSubPicQueue();
  929. }
  931. return hr;
  932. }
  934. STDMETHODIMP CDirectVobSubFilter::put_Placement(bool fOverridePlacement, int xperc, int yperc)
  935. {
  936. HRESULT hr = CDirectVobSub::put_Placement(fOverridePlacement, xperc, yperc);
  938. if(hr == NOERROR)
  939. {
  940. UpdateSubtitle(true);
  941. }
  943. return hr;
  944. }
  946. STDMETHODIMP CDirectVobSubFilter::put_VobSubSettings(bool fBuffer, bool fOnlyShowForcedSubs, bool fReserved)
  947. {
  948. HRESULT hr = CDirectVobSub::put_VobSubSettings(fBuffer, fOnlyShowForcedSubs, fReserved);
  950. if(hr == NOERROR)
  951. {
  952. // UpdateSubtitle(false);
  953. InvalidateSubtitle();
  954. }
  956. return hr;
  957. }
  959. STDMETHODIMP CDirectVobSubFilter::put_TextSettings(void* lf, int lflen, COLORREF color, bool fShadow, bool fOutline, bool fAdvancedRenderer)
  960. {
  961. HRESULT hr = CDirectVobSub::put_TextSettings(lf, lflen, color, fShadow, fOutline, fAdvancedRenderer);
  963. if(hr == NOERROR)
  964. {
  965. // UpdateSubtitle(true);
  966. InvalidateSubtitle();
  967. }
  969. return hr;
  970. }
  972. STDMETHODIMP CDirectVobSubFilter::put_SubtitleTiming(int delay, int speedmul, int speeddiv)
  973. {
  974. HRESULT hr = CDirectVobSub::put_SubtitleTiming(delay, speedmul, speeddiv);
  976. if(hr == NOERROR)
  977. {
  978. InvalidateSubtitle();
  979. }
  981. return hr;
  982. }
  984. STDMETHODIMP CDirectVobSubFilter::get_MediaFPS(bool* fEnabled, double* fps)
  985. {
  986. HRESULT hr = CDirectVobSub::get_MediaFPS(fEnabled, fps);
  988. CComQIPtr<IMediaSeeking> pMS = m_pGraph;
  989. double rate;
  990. if(pMS && SUCCEEDED(pMS->GetRate(&rate)))
  991. {
  992. m_MediaFPS = rate * m_fps;
  993. if(fps) *fps = m_MediaFPS;
  994. }
  996. return hr;
  997. }
  999. STDMETHODIMP CDirectVobSubFilter::put_MediaFPS(bool fEnabled, double fps)
  1000. {
  1001. HRESULT hr = CDirectVobSub::put_MediaFPS(fEnabled, fps);
  1003. CComQIPtr<IMediaSeeking> pMS = m_pGraph;
  1004. if(pMS)
  1005. {
  1006. if(hr == NOERROR)
  1007. {
  1008. hr = pMS->SetRate(m_fMediaFPSEnabled ? m_MediaFPS / m_fps : 1.0);
  1009. }
  1011. double dRate;
  1012. if(SUCCEEDED(pMS->GetRate(&dRate)))
  1013. m_MediaFPS = dRate * m_fps;
  1014. }
  1016. return hr;
  1017. }
  1019. STDMETHODIMP CDirectVobSubFilter::get_ZoomRect(NORMALIZEDRECT* rect)
  1020. {
  1021. return E_NOTIMPL;
  1022. }
  1024. STDMETHODIMP CDirectVobSubFilter::put_ZoomRect(NORMALIZEDRECT* rect)
  1025. {
  1026. return E_NOTIMPL;
  1027. }
  1029. // IDirectVobSub2
  1031. STDMETHODIMP CDirectVobSubFilter::put_TextSettings(STSStyle* pDefStyle)
  1032. {
  1033. HRESULT hr = CDirectVobSub::put_TextSettings(pDefStyle);
  1035. if(hr == NOERROR)
  1036. {
  1037. UpdateSubtitle(true);
  1038. }
  1040. return hr;
  1041. }
  1043. // IDirectVobSubFilterColor
  1045. STDMETHODIMP CDirectVobSubFilter::HasConfigDialog(int iSelected)
  1046. {
  1047. int nLangs;
  1048. if(FAILED(get_LanguageCount(&nLangs))) return E_FAIL;
  1049. return E_FAIL;
  1050. // TODO: temporally disabled since we don't have a new textsub/vobsub editor dlg for dvs yet
  1051. // return(nLangs >= 0 && iSelected < nLangs ? S_OK : E_FAIL);
  1052. }
  1054. STDMETHODIMP CDirectVobSubFilter::ShowConfigDialog(int iSelected, HWND hWndParent)
  1055. {
  1056. // TODO: temporally disabled since we don't have a new textsub/vobsub editor dlg for dvs yet
  1057. return(E_FAIL);
  1058. }
  1060. ///////////////////////////////////////////////////////////////////////////
  1062. CDirectVobSubFilter2::CDirectVobSubFilter2(LPUNKNOWN punk, HRESULT* phr, const GUID& clsid) :
  1063. CDirectVobSubFilter(punk, phr, clsid)
  1064. {
  1065. }
  1067. HRESULT CDirectVobSubFilter2::CheckConnect(PIN_DIRECTION dir, IPin* pPin)
  1068. {
  1069. CPinInfo pi;
  1070. if(FAILED(pPin->QueryPinInfo(&pi))) return E_FAIL;
  1072. if(CComQIPtr<IDirectVobSub>(pi.pFilter)) return E_FAIL;
  1074. if(dir == PINDIR_INPUT)
  1075. {
  1076. CFilterInfo fi;
  1077. if(SUCCEEDED(pi.pFilter->QueryFilterInfo(&fi))
  1078. && !wcsnicmp(fi.achName, L"Overlay Mixer", 13))
  1079. return(E_FAIL);
  1080. }
  1081. else
  1082. {
  1083. }
  1085. return __super::CheckConnect(dir, pPin);
  1086. }
  1088. HRESULT CDirectVobSubFilter2::JoinFilterGraph(IFilterGraph* pGraph, LPCWSTR pName)
  1089. {
  1090. if(pGraph)
  1091. {
  1092. BeginEnumFilters(pGraph, pEF, pBF)
  1093. {
  1094. if(pBF != (IBaseFilter*)this && CComQIPtr<IDirectVobSub>(pBF))
  1095. return E_FAIL;
  1096. }
  1097. EndEnumFilters
  1099. // don't look... we will do some serious graph hacking again...
  1100. //
  1101. // we will add dvs2 to the filter graph cache
  1102. // - if the main app has already added some kind of renderer or overlay mixer (anything which accepts video on its input)
  1103. // and 
  1104. // - if we have a reason to auto-load (we don't want to make any trouble when there is no need :)
  1105. //
  1106. // This whole workaround is needed because the video stream will always be connected 
  1107. // to the pre-added filters first, no matter how high merit we have.
  1109. if(!get_Forced())
  1110. {
  1111. BeginEnumFilters(pGraph, pEF, pBF)
  1112. {
  1113. if(CComQIPtr<IDirectVobSub>(pBF))
  1114. continue;
  1116. CComPtr<IPin> pInPin = GetFirstPin(pBF, PINDIR_INPUT);
  1117. CComPtr<IPin> pOutPin = GetFirstPin(pBF, PINDIR_OUTPUT);
  1119. if(!pInPin)
  1120. continue;
  1122. CComPtr<IPin> pPin;
  1123. if(pInPin && SUCCEEDED(pInPin->ConnectedTo(&pPin))
  1124. || pOutPin && SUCCEEDED(pOutPin->ConnectedTo(&pPin)))
  1125. continue;
  1127. if(pOutPin && GetFilterName(pBF) == _T("Overlay Mixer")) 
  1128. continue;
  1130. bool fVideoInputPin = false;
  1132. do
  1133. {
  1134. BITMAPINFOHEADER bih = {sizeof(BITMAPINFOHEADER), 384, 288, 1, 16, '2YUY', 384*288*2, 0, 0, 0, 0};
  1136. CMediaType cmt;
  1137. cmt.majortype = MEDIATYPE_Video;
  1138. cmt.subtype = MEDIASUBTYPE_YUY2;
  1139. cmt.formattype = FORMAT_VideoInfo;
  1140. cmt.pUnk = NULL;
  1141. cmt.bFixedSizeSamples = TRUE;
  1142. cmt.bTemporalCompression = TRUE;
  1143. cmt.lSampleSize = 384*288*2;
  1144. VIDEOINFOHEADER* vih = (VIDEOINFOHEADER*)cmt.AllocFormatBuffer(sizeof(VIDEOINFOHEADER));
  1145. memset(vih, 0, sizeof(VIDEOINFOHEADER));
  1146. memcpy(&vih->bmiHeader, &bih, sizeof(bih));
  1147. vih->AvgTimePerFrame = 400000;
  1149. if(SUCCEEDED(pInPin->QueryAccept(&cmt))) 
  1150. {
  1151. fVideoInputPin = true;
  1152. break;
  1153. }
  1155. VIDEOINFOHEADER2* vih2 = (VIDEOINFOHEADER2*)cmt.AllocFormatBuffer(sizeof(VIDEOINFOHEADER2));
  1156. memset(vih2, 0, sizeof(VIDEOINFOHEADER2));
  1157. memcpy(&vih2->bmiHeader, &bih, sizeof(bih));
  1158. vih2->AvgTimePerFrame = 400000;
  1159. vih2->dwPictAspectRatioX = 384;
  1160. vih2->dwPictAspectRatioY = 288;
  1162. if(SUCCEEDED(pInPin->QueryAccept(&cmt)))
  1163. {
  1164. fVideoInputPin = true;
  1165. break;
  1166. }
  1167. }
  1168. while(false);
  1170. if(fVideoInputPin)
  1171. {
  1172. CComPtr<IBaseFilter> pDVS;
  1173. if(ShouldWeAutoload(pGraph) && SUCCEEDED(pDVS.CoCreateInstance(__uuidof(CDirectVobSubFilter2))))
  1174. {
  1175. CComQIPtr<IDirectVobSub2>(pDVS)->put_Forced(true);
  1176. CComQIPtr<IGraphConfig>(pGraph)->AddFilterToCache(pDVS);
  1177. }
  1179. break;
  1180. }
  1181. }
  1182. EndEnumFilters
  1183. }
  1184. }
  1185. else
  1186. {
  1187. }
  1189. return __super::JoinFilterGraph(pGraph, pName);
  1190. }
  1192. HRESULT CDirectVobSubFilter2::CheckInputType(const CMediaType* mtIn)
  1193. {
  1194.     HRESULT hr = __super::CheckInputType(mtIn);
  1196. if(FAILED(hr) || m_pInput->IsConnected()) return hr;
  1198. if(!ShouldWeAutoload(m_pGraph)) return VFW_E_TYPE_NOT_ACCEPTED;
  1200. GetRidOfInternalScriptRenderer();
  1202. return NOERROR;
  1203. }
  1205. bool CDirectVobSubFilter2::ShouldWeAutoload(IFilterGraph* pGraph)
  1206. {
  1207. TCHAR blacklistedapps[][32] = 
  1208. {
  1209. _T("WM8EUTIL."), // wmp8 encoder's dummy renderer releases the outputted media sample after calling Receive on its input pin (yes, even when dvobsub isn't registered at all)
  1210. _T("explorer."), // as some users reported thumbnail preview loads dvobsub, I've never experienced this yet...
  1211. _T("producer."), // this is real's producer
  1212. };
  1214. for(int i = 0; i < countof(blacklistedapps); i++)
  1215. {
  1216. if(theApp.m_AppName.Find(blacklistedapps[i]) >= 0) 
  1217. return(false);
  1218. }
  1220. int level;
  1221. bool m_fExternalLoad, m_fWebLoad, m_fEmbeddedLoad;
  1222. get_LoadSettings(&level, &m_fExternalLoad, &m_fWebLoad, &m_fEmbeddedLoad);
  1224. if(level < 0 || level >= 2) return(false);
  1226. bool fRet = false;
  1228. if(level == 1)
  1229. fRet = m_fExternalLoad = m_fWebLoad = m_fEmbeddedLoad = true;
  1231. // find text stream on known splitters
  1233. if(!fRet && m_fEmbeddedLoad)
  1234. {
  1235. CComPtr<IBaseFilter> pBF;
  1236. if((pBF = FindFilter(CLSID_OggSplitter, pGraph)) || (pBF = FindFilter(CLSID_AviSplitter, pGraph))
  1237. || (pBF = FindFilter(L"{34293064-02F2-41D5-9D75-CC5967ACA1AB}", pGraph)) // matroska demux
  1238. || (pBF = FindFilter(L"{0A68C3B5-9164-4a54-AFAF-995B2FF0E0D4}", pGraph)) // matroska source
  1239. || (pBF = FindFilter(L"{149D2E01-C32E-4939-80F6-C07B81015A7A}", pGraph)) // matroska splitter
  1240. || (pBF = FindFilter(L"{9AB95E90-1F37-427e-9B3D-257FB0CB25F7}", pGraph)) // Haali's matroska splitter (?)
  1241. || (pBF = FindFilter(L"{55DA30FC-F16B-49fc-BAA5-AE59FC65F82D}", pGraph)) // Haali's matroska splitter
  1242. || (pBF = FindFilter(L"{52B63861-DC93-11CE-A099-00AA00479A58}", pGraph)) // 3ivx splitter
  1243. || (pBF = FindFilter(L"{6D3688CE-3E9D-42F4-92CA-8A11119D25CD}", pGraph)) // our ogg source
  1244. || (pBF = FindFilter(L"{9FF48807-E133-40AA-826F-9B2959E5232D}", pGraph)) // our ogg splitter
  1245. || (pBF = FindFilter(L"{803E8280-F3CE-4201-982C-8CD8FB512004}", pGraph)) // dsm source
  1246. || (pBF = FindFilter(L"{0912B4DD-A30A-4568-B590-7179EBB420EC}", pGraph))) // dsm splitter
  1247. {
  1248. BeginEnumPins(pBF, pEP, pPin)
  1249. {
  1250. BeginEnumMediaTypes(pPin, pEM, pmt)
  1251. {
  1252. if(pmt->majortype == MEDIATYPE_Text || pmt->majortype == MEDIATYPE_Subtitle)
  1253. {
  1254. fRet = true;
  1255. break;
  1256. }
  1257. }
  1258. EndEnumMediaTypes(pmt)
  1259. if(fRet) break;
  1260. }
  1261. EndEnumFilters
  1262. }
  1263. }
  1265. // find file name
  1267. CStringW fn;
  1269. BeginEnumFilters(pGraph, pEF, pBF)
  1270. {
  1271. if(CComQIPtr<IFileSourceFilter> pFSF = pBF)
  1272. {
  1273. LPOLESTR fnw = NULL;
  1274. if(!pFSF || FAILED(pFSF->GetCurFile(&fnw, NULL)) || !fnw)
  1275. continue;
  1276. fn = CString(fnw);
  1277. CoTaskMemFree(fnw);
  1278. break;
  1279. }
  1280. }
  1281. EndEnumFilters
  1283. if((m_fExternalLoad || m_fWebLoad) && (m_fWebLoad || !(wcsstr(fn, L"http://") || wcsstr(fn, L"mms://"))))
  1284. {
  1285. bool fTemp = m_fHideSubtitles;
  1286. fRet = !fn.IsEmpty() && SUCCEEDED(put_FileName((LPWSTR)(LPCWSTR)fn))
  1287. || SUCCEEDED(put_FileName(L"c:\tmp.srt")) 
  1288. || fRet;
  1289. if(fTemp) m_fHideSubtitles = true;
  1290. }
  1292. return(fRet);
  1293. }
  1295. void CDirectVobSubFilter2::GetRidOfInternalScriptRenderer()
  1296. {
  1297. while(CComPtr<IBaseFilter> pBF = FindFilter(L"{48025243-2D39-11CE-875D-00608CB78066}", m_pGraph))
  1298. {
  1299. BeginEnumPins(pBF, pEP, pPin)
  1300. {
  1301. PIN_DIRECTION dir;
  1302. CComPtr<IPin> pPinTo;
  1304. if(SUCCEEDED(pPin->QueryDirection(&dir)) && dir == PINDIR_INPUT 
  1305. && SUCCEEDED(pPin->ConnectedTo(&pPinTo)))
  1306. {
  1307. m_pGraph->Disconnect(pPinTo);
  1308. m_pGraph->Disconnect(pPin);
  1309. m_pGraph->ConnectDirect(pPinTo, GetPin(2 + m_pTextInput.GetSize()-1), NULL);
  1310. }
  1311. }
  1312. EndEnumPins
  1314. if(FAILED(m_pGraph->RemoveFilter(pBF)))
  1315. break;
  1316. }
  1317. }
  1319. ///////////////////////////////////////////////////////////////////////////////
  1321. bool CDirectVobSubFilter::Open()
  1322. {
  1323. AFX_MANAGE_STATE(AfxGetStaticModuleState());
  1325. CAutoLock cAutolock(&m_csQueueLock);
  1327. m_pSubStreams.RemoveAll();
  1329. m_frd.files.RemoveAll();
  1331. CStringArray paths;
  1333. for(int i = 0; i < 10; i++)
  1334. {
  1335. CString tmp;
  1336. tmp.Format(IDS_RP_PATH, i);
  1337. CString path = theApp.GetProfileString(ResStr(IDS_R_DEFTEXTPATHES), tmp);
  1338. if(!path.IsEmpty()) paths.Add(path);
  1339. }
  1341. SubFiles ret;
  1342. GetSubFileNames(m_FileName, paths, ret);
  1344. for(int i = 0; i < ret.GetSize(); i++)
  1345. {
  1346. if(m_frd.files.Find(ret[i].fn))
  1347. continue;
  1349. CComPtr<ISubStream> pSubStream;
  1351. if(!pSubStream)
  1352. {
  1353. CAutoPtr<CVobSubFile> pVSF(new CVobSubFile(&m_csSubLock));
  1354. if(pVSF && pVSF->Open(ret[i].fn) && pVSF->GetStreamCount() > 0)
  1355. {
  1356. pSubStream = pVSF.Detach();
  1357. m_frd.files.AddTail(ret[i].fn.Left(ret[i].fn.GetLength()-4) + _T(".sub"));
  1358. }
  1359. }
  1361. if(!pSubStream)
  1362. {
  1363. CAutoPtr<CRenderedTextSubtitle> pRTS(new CRenderedTextSubtitle(&m_csSubLock));
  1364. if(pRTS && pRTS->Open(ret[i].fn, DEFAULT_CHARSET) && pRTS->GetStreamCount() > 0)
  1365. {
  1366. pSubStream = pRTS.Detach();
  1367. m_frd.files.AddTail(ret[i].fn + _T(".style"));
  1368. }
  1369. }
  1370.     
  1371. if(pSubStream)
  1372. {
  1373. m_pSubStreams.AddTail(pSubStream);
  1374. m_frd.files.AddTail(ret[i].fn);
  1375. }
  1376. }
  1378. for(int i = 0; i < m_pTextInput.GetSize(); i++)
  1379. {
  1380. if(m_pTextInput[i]->IsConnected())
  1381. m_pSubStreams.AddTail(m_pTextInput[i]->GetSubStream());
  1382. }
  1384. if(S_FALSE == put_SelectedLanguage(FindPreferedLanguage()))
  1385.         UpdateSubtitle(false); // make sure pSubPicProvider of our queue gets updated even if the stream number hasn't changed
  1387. m_frd.RefreshEvent.Set();
  1389. return(m_pSubStreams.GetCount() > 0);
  1390. }
  1392. void CDirectVobSubFilter::UpdateSubtitle(bool fApplyDefStyle)
  1393. {
  1394. CAutoLock cAutolock(&m_csQueueLock);
  1396. if(!m_pSubPicQueue) return;
  1398. InvalidateSubtitle();
  1400. CComPtr<ISubStream> pSubStream;
  1402. if(!m_fHideSubtitles)
  1403. {
  1404. int i = m_iSelectedLanguage;
  1406. for(POSITION pos = m_pSubStreams.GetHeadPosition(); i >= 0 && pos; pSubStream = NULL)
  1407. {
  1408. pSubStream = m_pSubStreams.GetNext(pos);
  1410. if(i < pSubStream->GetStreamCount()) 
  1411. {
  1412. CAutoLock cAutoLock(&m_csSubLock);
  1413. pSubStream->SetStream(i);
  1414. break;
  1415. }
  1417. i -= pSubStream->GetStreamCount();
  1418. }
  1419. }
  1421. SetSubtitle(pSubStream, fApplyDefStyle);
  1422. }
  1424. void CDirectVobSubFilter::SetSubtitle(ISubStream* pSubStream, bool fApplyDefStyle)
  1425. {
  1426.     CAutoLock cAutolock(&m_csQueueLock);
  1428. if(pSubStream)
  1429. {
  1430. CAutoLock cAutolock(&m_csSubLock);
  1432. CLSID clsid;
  1433. pSubStream->GetClassID(&clsid);
  1435. if(clsid == __uuidof(CVobSubFile))
  1436. {
  1437. CVobSubSettings* pVSS = (CVobSubFile*)(ISubStream*)pSubStream;
  1439. if(fApplyDefStyle)
  1440. {
  1441. pVSS->SetAlignment(m_fOverridePlacement, m_PlacementXperc, m_PlacementYperc, 1, 1);
  1442. pVSS->m_fOnlyShowForcedSubs = m_fOnlyShowForcedVobSubs;
  1443. }
  1444. }
  1445. else if(clsid == __uuidof(CVobSubStream))
  1446. {
  1447. CVobSubSettings* pVSS = (CVobSubStream*)(ISubStream*)pSubStream;
  1449. if(fApplyDefStyle)
  1450. {
  1451. pVSS->SetAlignment(m_fOverridePlacement, m_PlacementXperc, m_PlacementYperc, 1, 1);
  1452. pVSS->m_fOnlyShowForcedSubs = m_fOnlyShowForcedVobSubs;
  1453. }
  1454. }
  1455. else if(clsid == __uuidof(CRenderedTextSubtitle))
  1456. {
  1457. CRenderedTextSubtitle* pRTS = (CRenderedTextSubtitle*)(ISubStream*)pSubStream;
  1459. if(fApplyDefStyle || pRTS->m_fUsingAutoGeneratedDefaultStyle)
  1460. {
  1461. STSStyle s = m_defStyle;
  1463. if(m_fOverridePlacement)
  1464. {
  1465. s.scrAlignment = 2;
  1466. int w = pRTS->m_dstScreenSize.cx;
  1467. int h = pRTS->m_dstScreenSize.cy;
  1468. int mw = w - s.marginRect.left - s.marginRect.right;
  1469. s.marginRect.bottom = h - MulDiv(h, m_PlacementYperc, 100);
  1470. s.marginRect.left = MulDiv(w, m_PlacementXperc, 100) - mw/2;
  1471. s.marginRect.right = w - (s.marginRect.left + mw);
  1472. }
  1474. pRTS->SetDefaultStyle(s);
  1475. }
  1477. pRTS->Deinit();
  1478. }
  1479. }
  1481. if(!fApplyDefStyle)
  1482. {
  1483. int i = 0;
  1485. POSITION pos = m_pSubStreams.GetHeadPosition();
  1486. while(pos)
  1487. {
  1488. CComPtr<ISubStream> pSubStream2 = m_pSubStreams.GetNext(pos);
  1490. if(pSubStream == pSubStream2)
  1491. {
  1492. m_iSelectedLanguage = i + pSubStream2->GetStream();
  1493. break;
  1494. }
  1496. i += pSubStream2->GetStreamCount();
  1497. }
  1498. }
  1500. m_nSubtitleId = (DWORD_PTR)pSubStream;
  1502. if(m_pSubPicQueue)
  1503. m_pSubPicQueue->SetSubPicProvider(CComQIPtr<ISubPicProvider>(pSubStream));
  1504. }
  1506. void CDirectVobSubFilter::InvalidateSubtitle(REFERENCE_TIME rtInvalidate, DWORD_PTR nSubtitleId)
  1507. {
  1508.     CAutoLock cAutolock(&m_csQueueLock);
  1510. if(m_pSubPicQueue)
  1511. {
  1512. if(nSubtitleId == -1 || nSubtitleId == m_nSubtitleId)
  1513. m_pSubPicQueue->Invalidate(rtInvalidate);
  1514. }
  1515. }
  1517. //////////////////////////////////////////////////////////////////////////////////////////
  1519. void CDirectVobSubFilter::AddSubStream(ISubStream* pSubStream)
  1520. {
  1521. CAutoLock cAutoLock(&m_csQueueLock);
  1523. POSITION pos = m_pSubStreams.Find(pSubStream);
  1524. if(!pos) m_pSubStreams.AddTail(pSubStream);
  1526. int len = m_pTextInput.GetSize();
  1527. for(int i = 0; i < m_pTextInput.GetSize(); i++)
  1528. if(m_pTextInput[i]->IsConnected()) len--;
  1530. if(len == 0)
  1531. {
  1532. HRESULT hr = S_OK;
  1533. m_pTextInput.Add(new CTextInputPin(this, m_pLock, &m_csSubLock, &hr));
  1534. }
  1535. }
  1537. void CDirectVobSubFilter::RemoveSubStream(ISubStream* pSubStream)
  1538. {
  1539. CAutoLock cAutoLock(&m_csQueueLock);
  1541. POSITION pos = m_pSubStreams.Find(pSubStream);
  1542. if(pos) m_pSubStreams.RemoveAt(pos);
  1543. }
  1545. void CDirectVobSubFilter::Post_EC_OLE_EVENT(CString str, DWORD_PTR nSubtitleId)
  1546. {
  1547. if(nSubtitleId != -1 && nSubtitleId != m_nSubtitleId)
  1548. return;
  1550. CComQIPtr<IMediaEventSink> pMES = m_pGraph;
  1551. if(!pMES) return;
  1553. CComBSTR bstr1("Text"), bstr2(" ");
  1555. str.Trim();
  1556. if(!str.IsEmpty()) bstr2 = CStringA(str);
  1558. pMES->Notify(EC_OLE_EVENT, (LONG_PTR)bstr1.Detach(), (LONG_PTR)bstr2.Detach());
  1559. }
  1561. ////////////////////////////////////////////////////////////////
  1563. void CDirectVobSubFilter::SetupFRD(CStringArray& paths, CArray<HANDLE>& handles)
  1564. {
  1565.     CAutoLock cAutolock(&m_csSubLock);
  1567. for(int i = 2; i < handles.GetSize(); i++)
  1568. {
  1569. FindCloseChangeNotification(handles[i]);
  1570. }
  1572. paths.RemoveAll();
  1573. handles.RemoveAll();
  1575. handles.Add(m_frd.EndThreadEvent);
  1576. handles.Add(m_frd.RefreshEvent);
  1578. m_frd.mtime.SetSize(m_frd.files.GetSize());
  1580. POSITION pos = m_frd.files.GetHeadPosition();
  1581. for(int i = 0; pos; i++)
  1582. {
  1583. CString fn = m_frd.files.GetNext(pos);
  1585. CFileStatus status;
  1586. if(CFileGetStatus(fn, status)) 
  1587. m_frd.mtime[i] = status.m_mtime;
  1589. fn.Replace('\', '/');
  1590. fn = fn.Left(fn.ReverseFind('/')+1);
  1592. bool fFound = false;
  1594. for(int j = 0; !fFound && j < paths.GetSize(); j++)
  1595. {
  1596. if(paths[j] == fn) fFound = true;
  1597. }
  1599. if(!fFound)
  1600. {
  1601. paths.Add(fn);
  1603. HANDLE h = FindFirstChangeNotification(fn, FALSE, FILE_NOTIFY_CHANGE_LAST_WRITE); 
  1604. if(h != INVALID_HANDLE_VALUE) handles.Add(h);
  1605. }
  1606. }
  1607. }
  1609. DWORD CDirectVobSubFilter::ThreadProc()
  1610. {
  1611. SetThreadPriority(m_hThread, THREAD_PRIORITY_LOWEST/*THREAD_PRIORITY_BELOW_NORMAL*/);
  1613. CStringArray paths;
  1614. CArray<HANDLE> handles;
  1616. SetupFRD(paths, handles);
  1618. while(1)
  1619. { 
  1620. DWORD idx = WaitForMultipleObjects(handles.GetSize(), handles.GetData(), FALSE, INFINITE);
  1622. if(idx == (WAIT_OBJECT_0 + 0)) // m_frd.hEndThreadEvent
  1623. {
  1624. break;
  1625. }
  1626. if(idx == (WAIT_OBJECT_0 + 1)) // m_frd.hRefreshEvent
  1627. {
  1628. SetupFRD(paths, handles);
  1629. }
  1630. else if(idx >= (WAIT_OBJECT_0 + 2) && idx < (WAIT_OBJECT_0 + handles.GetSize()))
  1631. {
  1632. bool fLocked = true;
  1633. IsSubtitleReloaderLocked(&fLocked);
  1634. if(fLocked) continue;
  1636. if(FindNextChangeNotification(handles[idx - WAIT_OBJECT_0]) == FALSE) 
  1637. break;
  1639. int j = 0;
  1641. POSITION pos = m_frd.files.GetHeadPosition();
  1642. for(int i = 0; pos && j == 0; i++)
  1643. {
  1644. CString fn = m_frd.files.GetNext(pos);
  1646. CFileStatus status;
  1647. if(CFileGetStatus(fn, status) && m_frd.mtime[i] != status.m_mtime) 
  1648. {
  1649. for(j = 0; j < 10; j++)
  1650. {
  1651. if(FILE* f = _tfopen(fn, _T("rb+"))) 
  1652. {
  1653. fclose(f);
  1654. j = 0;
  1655. break;
  1656. }
  1657. else
  1658. {
  1659. Sleep(100);
  1660. j++;
  1661. }
  1662. }
  1663. }
  1664. }
  1666. if(j > 0)
  1667. {
  1668. SetupFRD(paths, handles);
  1669. }
  1670. else
  1671. {
  1672. Sleep(500);
  1674. POSITION pos = m_frd.files.GetHeadPosition();
  1675. for(int i = 0; pos; i++)
  1676. {
  1677. CFileStatus status;
  1678. if(CFileGetStatus(m_frd.files.GetNext(pos), status) 
  1679. && m_frd.mtime[i] != status.m_mtime) 
  1680. {
  1681. Open();
  1682. SetupFRD(paths, handles);
  1683. break;
  1684. }
  1685. }
  1686. }
  1687. }
  1688. else 
  1689. {
  1690. break;
  1691. }
  1692. }
  1694. for(int i = 2; i < handles.GetSize(); i++)
  1695. {
  1696. FindCloseChangeNotification(handles[i]);
  1697. }
  1699. return 0;
  1700. }