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

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

多媒体编程

开发平台：

Visual C++

SubtitleSource.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 "subtitlesource.h"
  24. #include "......DSUtilDSUtil.h"
  26. #include <initguid.h>
  27. #include "........includematroskamatroska.h"
  29. static int _WIDTH = 640;
  30. static int _HEIGHT = 480;
  31. static int _ATPF = 400000;
  33. #ifdef REGISTER_FILTER
  35. const AMOVIESETUP_MEDIATYPE sudPinTypesOut[] =
  36. {
  37. {&MEDIATYPE_Subtitle, &MEDIASUBTYPE_NULL},
  38. {&MEDIATYPE_Text, &MEDIASUBTYPE_NULL},
  39. {&MEDIATYPE_Video, &MEDIASUBTYPE_RGB32},
  40. };
  42. const AMOVIESETUP_PIN sudOpPin[] =
  43. {
  44. {L"Output", FALSE, TRUE, FALSE, FALSE, &CLSID_NULL, NULL, countof(sudPinTypesOut), sudPinTypesOut},
  45. };
  47. const AMOVIESETUP_FILTER sudFilter[] =
  48. {
  49. {&__uuidof(CSubtitleSourceASCII), L"SubtitleSource (S_TEXT/ASCII)", MERIT_UNLIKELY, countof(sudOpPin), sudOpPin},
  50. {&__uuidof(CSubtitleSourceUTF8), L"SubtitleSource (S_TEXT/UTF8)", MERIT_UNLIKELY, countof(sudOpPin), sudOpPin},
  51. {&__uuidof(CSubtitleSourceSSA), L"SubtitleSource (S_TEXT/SSA)", MERIT_UNLIKELY, countof(sudOpPin), sudOpPin},
  52. {&__uuidof(CSubtitleSourceASS), L"SubtitleSource (S_TEXT/ASS)", MERIT_UNLIKELY, countof(sudOpPin), sudOpPin},
  53. {&__uuidof(CSubtitleSourceUSF), L"SubtitleSource (S_TEXT/USF)", MERIT_UNLIKELY, countof(sudOpPin), sudOpPin},
  54. {&__uuidof(CSubtitleSourcePreview), L"SubtitleSource (Preview)", MERIT_UNLIKELY, countof(sudOpPin), sudOpPin},
  55. {&__uuidof(CSubtitleSourceARGB), L"SubtitleSource (ARGB)", MERIT_UNLIKELY, countof(sudOpPin), sudOpPin},
  56. };
  58. CFactoryTemplate g_Templates[] =
  59. {
  60. {sudFilter[0].strName, sudFilter[0].clsID, CreateInstance<CSubtitleSourceASCII>, NULL, &sudFilter[0]},
  61. {sudFilter[1].strName, sudFilter[1].clsID, CreateInstance<CSubtitleSourceUTF8>, NULL, &sudFilter[1]},
  62. {sudFilter[2].strName, sudFilter[2].clsID, CreateInstance<CSubtitleSourceSSA>, NULL, &sudFilter[2]},
  63. {sudFilter[3].strName, sudFilter[3].clsID, CreateInstance<CSubtitleSourceASS>, NULL, &sudFilter[3]},
  64. // {sudFilter[4].strName, sudFilter[4].clsID, CreateInstance<CSubtitleSourceUSF>, NULL, &sudFilter[4]},
  65. {sudFilter[5].strName, sudFilter[5].clsID, CreateInstance<CSubtitleSourcePreview>, NULL, &sudFilter[5]},
  66. {sudFilter[6].strName, sudFilter[6].clsID, CreateInstance<CSubtitleSourceARGB>, NULL, &sudFilter[6]},
  67. };
  69. int g_cTemplates = countof(g_Templates);
  71. //#include "registry.cpp"
  73. STDAPI DllRegisterServer()
  74. {
  75. /*
  76. CString clsid = CStringFromGUID(__uuidof(CSubtitleSourcePreview));
  78. SetRegKeyValue(
  79. _T("Media Type\Extensions"), _T(".sub"), 
  80. _T("Source Filter"), clsid);
  82. SetRegKeyValue(
  83. _T("Media Type\Extensions"), _T(".srt"), 
  84. _T("Source Filter"), clsid);
  86. SetRegKeyValue(
  87. _T("Media Type\Extensions"), _T(".smi"), 
  88. _T("Source Filter"), clsid);
  90. SetRegKeyValue(
  91. _T("Media Type\Extensions"), _T(".ssa"), 
  92. _T("Source Filter"), clsid);
  94. SetRegKeyValue(
  95. _T("Media Type\Extensions"), _T(".ass"), 
  96. _T("Source Filter"), clsid);
  98. SetRegKeyValue(
  99. _T("Media Type\Extensions"), _T(".xss"), 
  100. _T("Source Filter"), clsid);
  102. SetRegKeyValue(
  103. _T("Media Type\Extensions"), _T(".usf"), 
  104. _T("Source Filter"), clsid);
  105. */
  106. return AMovieDllRegisterServer2(TRUE);
  107. }
  109. STDAPI DllUnregisterServer()
  110. {
  111. DeleteRegKey(_T("Media Type\Extensions"), _T(".sub"));
  112. DeleteRegKey(_T("Media Type\Extensions"), _T(".srt"));
  113. DeleteRegKey(_T("Media Type\Extensions"), _T(".smi"));
  114. DeleteRegKey(_T("Media Type\Extensions"), _T(".ssa"));
  115. DeleteRegKey(_T("Media Type\Extensions"), _T(".ass"));
  116. DeleteRegKey(_T("Media Type\Extensions"), _T(".xss"));
  117. DeleteRegKey(_T("Media Type\Extensions"), _T(".usf"));
  118. /**/
  119. return AMovieDllRegisterServer2(FALSE);
  120. }
  122. extern "C" BOOL WINAPI DllEntryPoint(HINSTANCE, ULONG, LPVOID);
  124. BOOL APIENTRY DllMain(HANDLE hModule, DWORD dwReason, LPVOID lpReserved)
  125. {
  126. if(dwReason == DLL_PROCESS_ATTACH)
  127. {
  128. _WIDTH = GetProfileInt(_T("SubtitleSource"), _T("w"), 640);
  129. _HEIGHT = GetProfileInt(_T("SubtitleSource"), _T("h"), 480);
  130. _ATPF = GetProfileInt(_T("SubtitleSource"), _T("atpf"), 400000);
  131. if(_ATPF <= 0) _ATPF = 400000;
  132. CString str; 
  133. str.Format(_T("%d"), _WIDTH);
  134. WriteProfileString(_T("SubtitleSource"), _T("w"), str);
  135. str.Format(_T("%d"), _HEIGHT);
  136. WriteProfileString(_T("SubtitleSource"), _T("h"), str);
  137. str.Format(_T("%d"), _ATPF);
  138. WriteProfileString(_T("SubtitleSource"), _T("atpf"), str);
  139. }
  141.     return DllEntryPoint((HINSTANCE)hModule, dwReason, 0); // "DllMain" of the dshow baseclasses;
  142. }
  144. #endif
  146. //
  147. // CSubtitleSource
  148. //
  150. CSubtitleSource::CSubtitleSource(LPUNKNOWN lpunk, HRESULT* phr, const CLSID& clsid)
  151. : CSource(NAME("CSubtitleSource"), lpunk, clsid)
  152. {
  153. }
  155. CSubtitleSource::~CSubtitleSource()
  156. {
  157. }
  159. STDMETHODIMP CSubtitleSource::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  160. {
  161.     CheckPointer(ppv, E_POINTER);
  163. return 
  164. QI(IFileSourceFilter)
  165. QI(IAMFilterMiscFlags)
  166. __super::NonDelegatingQueryInterface(riid, ppv);
  167. }
  169. // IFileSourceFilter
  171. STDMETHODIMP CSubtitleSource::Load(LPCOLESTR pszFileName, const AM_MEDIA_TYPE* pmt) 
  172. {
  173. if(GetPinCount() > 0)
  174. return VFW_E_ALREADY_CONNECTED;
  176. HRESULT hr = S_OK;
  177. if(!(new CSubtitleStream(pszFileName, this, &hr)))
  178. return E_OUTOFMEMORY;
  180. if(FAILED(hr))
  181. return hr;
  183. m_fn = pszFileName;
  185. return S_OK;
  186. }
  188. STDMETHODIMP CSubtitleSource::GetCurFile(LPOLESTR* ppszFileName, AM_MEDIA_TYPE* pmt)
  189. {
  190. if(!ppszFileName) return E_POINTER;
  192. if(!(*ppszFileName = (LPOLESTR)CoTaskMemAlloc((m_fn.GetLength()+1)*sizeof(WCHAR))))
  193. return E_OUTOFMEMORY;
  195. wcscpy(*ppszFileName, m_fn);
  197. return S_OK;
  198. }
  200. // IAMFilterMiscFlags
  202. ULONG CSubtitleSource::GetMiscFlags()
  203. {
  204. return AM_FILTER_MISC_FLAGS_IS_SOURCE;
  205. }
  207. //
  208. // CSubtitleStream
  209. //
  211. CSubtitleStream::CSubtitleStream(const WCHAR* wfn, CSubtitleSource* pParent, HRESULT* phr) 
  212. : CSourceStream(NAME("SubtitleStream"), phr, pParent, L"Output")
  213. , CSourceSeeking(NAME("SubtitleStream"), (IPin*)this, phr, &m_cSharedState)
  214. , m_bDiscontinuity(FALSE), m_bFlushing(FALSE)
  215. , m_nPosition(0)
  216. , m_rts(NULL)
  217. {
  218. CAutoLock cAutoLock(&m_cSharedState);
  220. CString fn(wfn);
  222. if(!m_rts.Open(fn, DEFAULT_CHARSET))
  223. {
  224. if(phr) *phr = E_FAIL;
  225. return;
  226. }
  228. m_rts.CreateDefaultStyle(DEFAULT_CHARSET);
  229. m_rts.ConvertToTimeBased(25);
  230. m_rts.Sort();
  232. m_rtDuration = 0;
  233. for(int i = 0, cnt = m_rts.GetCount(); i < cnt; i++)
  234. m_rtDuration = max(m_rtDuration, 10000i64*m_rts[i].end);
  236. m_rtStop = m_rtDuration;
  238. if(phr) *phr = m_rtDuration > 0 ? S_OK : E_FAIL;
  239. }
  241. CSubtitleStream::~CSubtitleStream()
  242. {
  243. CAutoLock cAutoLock(&m_cSharedState);
  244. }
  246. STDMETHODIMP CSubtitleStream::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  247. {
  248.     CheckPointer(ppv, E_POINTER);
  250. return (riid == IID_IMediaSeeking) ? CSourceSeeking::NonDelegatingQueryInterface(riid, ppv) //GetInterface((IMediaSeeking*)this, ppv)
  251. : CSourceStream::NonDelegatingQueryInterface(riid, ppv);
  252. }
  254. void CSubtitleStream::UpdateFromSeek()
  255. {
  256. if(ThreadExists())
  257. {
  258. // next time around the loop, the worker thread will
  259. // pick up the position change.
  260. // We need to flush all the existing data - we must do that here
  261. // as our thread will probably be blocked in GetBuffer otherwise
  262.     
  263. m_bFlushing = TRUE;
  265. DeliverBeginFlush();
  266. // make sure we have stopped pushing
  267. Stop();
  268. // complete the flush
  269. DeliverEndFlush();
  271.         m_bFlushing = FALSE;
  273. // restart
  274. Run();
  275. }
  276. }
  278. HRESULT CSubtitleStream::SetRate(double dRate)
  279. {
  280. if(dRate <= 0)
  281. return E_INVALIDARG;
  283. {
  284. CAutoLock lock(CSourceSeeking::m_pLock);
  285. m_dRateSeeking = dRate;
  286. }
  288. UpdateFromSeek();
  290. return S_OK;
  291. }
  293. HRESULT CSubtitleStream::OnThreadStartPlay()
  294. {
  295.     m_bDiscontinuity = TRUE;
  296.     return DeliverNewSegment(m_rtStart, m_rtStop, m_dRateSeeking);
  297. }
  299. HRESULT CSubtitleStream::ChangeStart()
  300. {
  301.     {
  302.         CAutoLock lock(CSourceSeeking::m_pLock);
  304. OnThreadCreate();
  305. /*
  306. if(m_mt.majortype == MEDIATYPE_Video && m_mt.subtype == MEDIASUBTYPE_ARGB32)
  307. {
  308. m_nPosition = (int)(m_rtStart/10000)*1/1000;
  309. }
  310. else if(m_mt.majortype == MEDIATYPE_Video && m_mt.subtype == MEDIASUBTYPE_RGB32)
  311. {
  312. int m_nSegments = 0;
  313. if(!m_rts.SearchSubs((int)(m_rtStart/10000), 25, &m_nPosition, &m_nSegments))
  314. m_nPosition = m_nSegments;
  315. }
  316. else
  317. {
  318. m_nPosition = m_rts.SearchSub((int)(m_rtStart/10000), 25);
  319. if(m_nPosition < 0) m_nPosition = 0;
  320. else if(m_rts[m_nPosition].end <= (int)(m_rtStart/10000)) m_nPosition++;
  321. }
  322. */    }
  324.     UpdateFromSeek();
  326.     return S_OK;
  327. }
  329. HRESULT CSubtitleStream::ChangeStop()
  330. {
  331. /*
  332.     {
  333.         CAutoLock lock(CSourceSeeking::m_pLock);
  334.         if(m_rtPosition < m_rtStop)
  335. return S_OK;
  336.     }
  337. */
  338.     // We're already past the new stop time -- better flush the graph.
  339.     UpdateFromSeek();
  341.     return S_OK;
  342. }
  344. HRESULT CSubtitleStream::OnThreadCreate()
  345. {
  346.     CAutoLock cAutoLockShared(&m_cSharedState);
  348. if(m_mt.majortype == MEDIATYPE_Video && m_mt.subtype == MEDIASUBTYPE_ARGB32)
  349. {
  350. m_nPosition = m_rtStart/_ATPF;
  351. }
  352. else if(m_mt.majortype == MEDIATYPE_Video && m_mt.subtype == MEDIASUBTYPE_RGB32)
  353. {
  354. int m_nSegments = 0;
  355. if(!m_rts.SearchSubs((int)(m_rtStart/10000), 10000000/_ATPF, &m_nPosition, &m_nSegments))
  356. m_nPosition = m_nSegments;
  357. }
  358. else
  359. {
  360. m_nPosition = m_rts.SearchSub((int)(m_rtStart/10000), 25);
  361. if(m_nPosition < 0) m_nPosition = 0;
  362. else if(m_rts[m_nPosition].end <= (int)(m_rtStart/10000)) m_nPosition++;
  363. }
  365.     return CSourceStream::OnThreadCreate();
  366. }
  368. HRESULT CSubtitleStream::DecideBufferSize(IMemAllocator* pAlloc, ALLOCATOR_PROPERTIES* pProperties)
  369. {
  370. //    CAutoLock cAutoLock(m_pFilter->pStateLock());
  372.     ASSERT(pAlloc);
  373.     ASSERT(pProperties);
  375.     HRESULT hr = NOERROR;
  377. if(m_mt.majortype == MEDIATYPE_Video)
  378. {
  379. pProperties->cBuffers = 2;
  380. pProperties->cbBuffer = ((VIDEOINFOHEADER*)m_mt.pbFormat)->bmiHeader.biSizeImage;
  381. }
  382. else
  383. {
  384. pProperties->cBuffers = 1;
  385. pProperties->cbBuffer = 0x10000;
  386. }
  388.     ALLOCATOR_PROPERTIES Actual;
  389.     if(FAILED(hr = pAlloc->SetProperties(pProperties, &Actual))) return hr;
  391.     if(Actual.cbBuffer < pProperties->cbBuffer) return E_FAIL;
  392.     ASSERT(Actual.cBuffers == pProperties->cBuffers);
  394.     return NOERROR;
  395. }
  397. HRESULT CSubtitleStream::FillBuffer(IMediaSample* pSample)
  398. {
  399. HRESULT hr;
  401. {
  402. CAutoLock cAutoLockShared(&m_cSharedState);
  404. BYTE* pData = NULL;
  405. if(FAILED(hr = pSample->GetPointer(&pData)) || !pData)
  406. return S_FALSE;
  408. AM_MEDIA_TYPE* pmt;
  409. if(SUCCEEDED(pSample->GetMediaType(&pmt)) && pmt)
  410. {
  411. CMediaType mt(*pmt);
  412. SetMediaType(&mt);
  413. DeleteMediaType(pmt);
  414. }
  416. int len = 0;
  417. REFERENCE_TIME rtStart, rtStop;
  419. if(m_mt.majortype == MEDIATYPE_Video && m_mt.subtype == MEDIASUBTYPE_ARGB32)
  420. {
  421. rtStart = (REFERENCE_TIME)((m_nPosition*_ATPF - m_rtStart) / m_dRateSeeking);
  422. rtStop = (REFERENCE_TIME)(((m_nPosition+1)*_ATPF - m_rtStart) / m_dRateSeeking);
  423. if(m_rtStart+rtStart >= m_rtDuration)
  424. return S_FALSE;
  426. BITMAPINFOHEADER& bmi = ((VIDEOINFOHEADER*)m_mt.pbFormat)->bmiHeader;
  428. SubPicDesc spd;
  429. spd.w = _WIDTH;
  430. spd.h = _HEIGHT;
  431. spd.bpp = 32;
  432. spd.pitch = bmi.biWidth*4;
  433. spd.bits = pData;
  435. len = spd.h*spd.pitch;
  437. for(int y = 0; y < spd.h; y++)
  438. memsetd((DWORD*)(pData + spd.pitch*y), 0xff000000, spd.w*4);
  440. RECT bbox;
  441. m_rts.Render(spd, m_nPosition*_ATPF, 10000000.0/_ATPF, bbox);
  443. for(int y = 0; y < spd.h; y++)
  444. {
  445. DWORD* p = (DWORD*)(pData + spd.pitch*y);
  446. for(int x = 0; x < spd.w; x++, p++)
  447. *p = (0xff000000-(*p&0xff000000))|(*p&0xffffff);
  448. }
  449. }
  450. else if(m_mt.majortype == MEDIATYPE_Video && m_mt.subtype == MEDIASUBTYPE_RGB32)
  451. {
  452. const STSSegment* stss = m_rts.GetSegment(m_nPosition);
  453. if(!stss) return S_FALSE;
  455. BITMAPINFOHEADER& bmi = ((VIDEOINFOHEADER*)m_mt.pbFormat)->bmiHeader;
  457. SubPicDesc spd;
  458. spd.w = _WIDTH;
  459. spd.h = _HEIGHT;
  460. spd.bpp = 32;
  461. spd.pitch = bmi.biWidth*4;
  462. spd.bits = pData;
  464. len = spd.h*spd.pitch;
  466. for(int y = 0; y < spd.h; y++)
  467. {
  468. DWORD c1 = 0xff606060, c2 = 0xffa0a0a0;
  469. if(y&32) c1 ^= c2, c2 ^= c1, c1 ^= c2;
  470. DWORD* p = (DWORD*)(pData + spd.pitch*y);
  471. for(int x = 0; x < spd.w; x+=32, p+=32)
  472. memsetd(p, (x&32) ? c1 : c2, min(spd.w-x,32)*4);
  473. }
  475. RECT bbox;
  476. m_rts.Render(spd, 10000i64*(stss->start+stss->end)/2, 10000000.0/_ATPF, bbox);
  478. rtStart = (REFERENCE_TIME)((10000i64*stss->start - m_rtStart) / m_dRateSeeking);
  479. rtStop = (REFERENCE_TIME)((10000i64*stss->end - m_rtStart) / m_dRateSeeking);
  480. }
  481. else
  482. {
  483. if(m_nPosition >= m_rts.GetCount())
  484. return S_FALSE;
  486. STSEntry& stse = m_rts[m_nPosition];
  488. if(stse.start >= m_rtStop/10000)
  489. return S_FALSE;
  491. if(m_mt.majortype == MEDIATYPE_Subtitle && m_mt.subtype == MEDIASUBTYPE_UTF8)
  492. {
  493. CStringA str = UTF16To8(m_rts.GetStrW(m_nPosition, false));
  494. memcpy((char*)pData, str, len = str.GetLength());
  495. }
  496. else if(m_mt.majortype == MEDIATYPE_Subtitle && (m_mt.subtype == MEDIASUBTYPE_SSA || m_mt.subtype == MEDIASUBTYPE_ASS))
  497. {
  498. CStringW line;
  499. line.Format(L"%d,%d,%s,%s,%d,%d,%d,%s,%s", 
  500. stse.readorder, stse.layer, CStringW(stse.style), CStringW(stse.actor), 
  501. stse.marginRect.left, stse.marginRect.right, (stse.marginRect.top+stse.marginRect.bottom)/2,
  502. CStringW(stse.effect), m_rts.GetStrW(m_nPosition, true));
  504. CStringA str = UTF16To8(line);
  505. memcpy((char*)pData, str, len = str.GetLength());
  506. }
  507. else if(m_mt.majortype == MEDIATYPE_Text && m_mt.subtype == MEDIASUBTYPE_NULL)
  508. {
  509. CStringA str = m_rts.GetStrA(m_nPosition, false);
  510. memcpy((char*)pData, str, len = str.GetLength());
  511. }
  512. else
  513. {
  514. return S_FALSE;
  515. }
  517. rtStart = (REFERENCE_TIME)((10000i64*stse.start - m_rtStart) / m_dRateSeeking);
  518. rtStop = (REFERENCE_TIME)((10000i64*stse.end - m_rtStart) / m_dRateSeeking);
  519. }
  521. pSample->SetTime(&rtStart, &rtStop);
  522. pSample->SetActualDataLength(len);
  524. m_nPosition++;
  525. }
  527. pSample->SetSyncPoint(TRUE);
  529. if(m_bDiscontinuity) 
  530.     {
  531. pSample->SetDiscontinuity(TRUE);
  532. m_bDiscontinuity = FALSE;
  533. }
  535. return S_OK;
  536. }
  538. HRESULT CSubtitleStream::GetMediaType(CMediaType* pmt)
  539. {
  540. return ((CSubtitleSource*)m_pFilter)->GetMediaType(pmt);
  541. }
  543. HRESULT CSubtitleStream::CheckMediaType(const CMediaType* pmt)
  544. {
  545.     CAutoLock lock(m_pFilter->pStateLock());
  547.     CMediaType mt;
  548.     GetMediaType(&mt);
  550. if(mt.majortype == pmt->majortype && mt.subtype == pmt->subtype)
  551. {
  552.         return NOERROR;
  553.     }
  555.     return E_FAIL;
  556. }
  558. STDMETHODIMP CSubtitleStream::Notify(IBaseFilter* pSender, Quality q)
  559. {
  560. return E_NOTIMPL;
  561. }
  563. //
  564. // CSubtitleSourceASCII
  565. //
  567. CSubtitleSourceASCII::CSubtitleSourceASCII(LPUNKNOWN lpunk, HRESULT* phr)
  568. : CSubtitleSource(lpunk, phr, __uuidof(this))
  569. {
  570. }
  572. HRESULT CSubtitleSourceASCII::GetMediaType(CMediaType* pmt)
  573. {
  574.     CAutoLock cAutoLock(pStateLock());
  576. pmt->InitMediaType();
  577. pmt->SetType(&MEDIATYPE_Text);
  578. pmt->SetSubtype(&MEDIASUBTYPE_NULL);
  579. pmt->SetFormatType(&FORMAT_None);
  580. pmt->ResetFormatBuffer();
  582.     return NOERROR;
  583. }
  585. //
  586. // CSubtitleSourceUTF8
  587. //
  589. CSubtitleSourceUTF8::CSubtitleSourceUTF8(LPUNKNOWN lpunk, HRESULT* phr)
  590. : CSubtitleSource(lpunk, phr, __uuidof(this))
  591. {
  592. }
  594. HRESULT CSubtitleSourceUTF8::GetMediaType(CMediaType* pmt)
  595. {
  596.     CAutoLock cAutoLock(pStateLock());
  598. pmt->InitMediaType();
  599. pmt->SetType(&MEDIATYPE_Subtitle);
  600. pmt->SetSubtype(&MEDIASUBTYPE_UTF8);
  601. pmt->SetFormatType(&FORMAT_SubtitleInfo);
  602. SUBTITLEINFO* psi = (SUBTITLEINFO*)pmt->AllocFormatBuffer(sizeof(SUBTITLEINFO));
  603. memset(psi, 0, pmt->FormatLength());
  604. strcpy(psi->IsoLang, "eng");
  606.     return NOERROR;
  607. }
  609. //
  610. // CSubtitleSourceSSA
  611. //
  613. CSubtitleSourceSSA::CSubtitleSourceSSA(LPUNKNOWN lpunk, HRESULT* phr)
  614. : CSubtitleSource(lpunk, phr, __uuidof(this))
  615. {
  616. }
  618. HRESULT CSubtitleSourceSSA::GetMediaType(CMediaType* pmt)
  619. {
  620.     CAutoLock cAutoLock(pStateLock());
  622. pmt->InitMediaType();
  623. pmt->SetType(&MEDIATYPE_Subtitle);
  624. pmt->SetSubtype(&MEDIASUBTYPE_SSA);
  625. pmt->SetFormatType(&FORMAT_SubtitleInfo);
  627. CSimpleTextSubtitle sts;
  628. sts.Open(CString(m_fn), DEFAULT_CHARSET);
  629. sts.RemoveAll();
  631. CFile f;
  632. TCHAR path[MAX_PATH], fn[MAX_PATH];
  633. if(!GetTempPath(MAX_PATH, path) || !GetTempFileName(path, _T("mpc_sts"), 0, fn))
  634. return E_FAIL;
  636. _tcscat(fn, _T(".ssa"));
  638. if(!sts.SaveAs(fn, EXTSSA, -1, CTextFile::UTF8) || !f.Open(fn, CFile::modeRead))
  639. return E_FAIL;
  641. int len = (int)f.GetLength()-3;
  642. f.Seek(3, CFile::begin);
  644. SUBTITLEINFO* psi = (SUBTITLEINFO*)pmt->AllocFormatBuffer(sizeof(SUBTITLEINFO) + len);
  645. memset(psi, 0, pmt->FormatLength());
  646. psi->dwOffset = sizeof(SUBTITLEINFO);
  647. strcpy(psi->IsoLang, "eng");
  648. f.Read(pmt->pbFormat + psi->dwOffset, len);
  649. f.Close();
  651. _tremove(fn);
  653.     return NOERROR;
  654. }
  656. //
  657. // CSubtitleSourceASS
  658. //
  660. CSubtitleSourceASS::CSubtitleSourceASS(LPUNKNOWN lpunk, HRESULT* phr)
  661. : CSubtitleSource(lpunk, phr, __uuidof(this))
  662. {
  663. }
  665. HRESULT CSubtitleSourceASS::GetMediaType(CMediaType* pmt)
  666. {
  667.     CAutoLock cAutoLock(pStateLock());
  669. pmt->InitMediaType();
  670. pmt->SetType(&MEDIATYPE_Subtitle);
  671. pmt->SetSubtype(&MEDIASUBTYPE_ASS);
  672. pmt->SetFormatType(&FORMAT_SubtitleInfo);
  674. CSimpleTextSubtitle sts;
  675. sts.Open(CString(m_fn), DEFAULT_CHARSET);
  676. sts.RemoveAll();
  678. CFile f;
  679. TCHAR path[MAX_PATH], fn[MAX_PATH];
  680. if(!GetTempPath(MAX_PATH, path) || !GetTempFileName(path, _T("mpc_sts"), 0, fn))
  681. return E_FAIL;
  683. _tcscat(fn, _T(".ass"));
  685. if(!sts.SaveAs(fn, EXTASS, -1, CTextFile::UTF8) || !f.Open(fn, CFile::modeRead))
  686. return E_FAIL;
  688. int len = (int)f.GetLength();
  690. SUBTITLEINFO* psi = (SUBTITLEINFO*)pmt->AllocFormatBuffer(sizeof(SUBTITLEINFO) + len);
  691. memset(psi, 0, pmt->FormatLength());
  692. psi->dwOffset = sizeof(SUBTITLEINFO);
  693. strcpy(psi->IsoLang, "eng");
  694. f.Read(pmt->pbFormat + psi->dwOffset, len);
  695. f.Close();
  697. _tremove(fn);
  699.     return NOERROR;
  700. }
  702. //
  703. // CSubtitleSourceUSF
  704. //
  706. CSubtitleSourceUSF::CSubtitleSourceUSF(LPUNKNOWN lpunk, HRESULT* phr)
  707. : CSubtitleSource(lpunk, phr, __uuidof(this))
  708. {
  709. }
  711. HRESULT CSubtitleSourceUSF::GetMediaType(CMediaType* pmt)
  712. {
  713.     CAutoLock cAutoLock(pStateLock());
  715. pmt->InitMediaType();
  716. pmt->SetType(&MEDIATYPE_Subtitle);
  717. pmt->SetSubtype(&MEDIASUBTYPE_USF);
  718. pmt->SetFormatType(&FORMAT_SubtitleInfo);
  719. SUBTITLEINFO* psi = (SUBTITLEINFO*)pmt->AllocFormatBuffer(sizeof(SUBTITLEINFO));
  720. memset(psi, 0, pmt->FormatLength());
  721. strcpy(psi->IsoLang, "eng");
  722. // TODO: ...
  724.     return NOERROR;
  725. }
  727. //
  728. // CSubtitleSourcePreview
  729. //
  731. CSubtitleSourcePreview::CSubtitleSourcePreview(LPUNKNOWN lpunk, HRESULT* phr)
  732. : CSubtitleSource(lpunk, phr, __uuidof(this))
  733. {
  734. }
  736. HRESULT CSubtitleSourcePreview::GetMediaType(CMediaType* pmt)
  737. {
  738.     CAutoLock cAutoLock(pStateLock());
  740. pmt->InitMediaType();
  741. pmt->SetType(&MEDIATYPE_Video);
  742. pmt->SetSubtype(&MEDIASUBTYPE_RGB32);
  743. pmt->SetFormatType(&FORMAT_VideoInfo);
  744. VIDEOINFOHEADER* pvih = (VIDEOINFOHEADER*)pmt->AllocFormatBuffer(sizeof(VIDEOINFOHEADER));
  745. memset(pvih, 0, pmt->FormatLength());
  746. pvih->bmiHeader.biSize = sizeof(pvih->bmiHeader);
  747. pvih->bmiHeader.biWidth = _WIDTH;
  748. pvih->bmiHeader.biHeight = _HEIGHT;
  749. pvih->bmiHeader.biBitCount = 32;
  750. pvih->bmiHeader.biCompression = BI_RGB;
  751. pvih->bmiHeader.biPlanes = 1;
  752. pvih->bmiHeader.biSizeImage = pvih->bmiHeader.biWidth*abs(pvih->bmiHeader.biHeight)*pvih->bmiHeader.biBitCount>>3;
  754.     return NOERROR;
  755. }
  757. //
  758. // CSubtitleSourceARGB
  759. //
  761. CSubtitleSourceARGB::CSubtitleSourceARGB(LPUNKNOWN lpunk, HRESULT* phr)
  762. : CSubtitleSource(lpunk, phr, __uuidof(this))
  763. {
  764. }
  766. HRESULT CSubtitleSourceARGB::GetMediaType(CMediaType* pmt)
  767. {
  768.     CAutoLock cAutoLock(pStateLock());
  770. pmt->InitMediaType();
  771. pmt->SetType(&MEDIATYPE_Video);
  772. pmt->SetSubtype(&MEDIASUBTYPE_ARGB32);
  773. pmt->SetFormatType(&FORMAT_VideoInfo);
  774. VIDEOINFOHEADER* pvih = (VIDEOINFOHEADER*)pmt->AllocFormatBuffer(sizeof(VIDEOINFOHEADER));
  775. memset(pvih, 0, pmt->FormatLength());
  776. pvih->bmiHeader.biSize = sizeof(pvih->bmiHeader);
  777. // TODO: read w,h,fps from a config file or registry
  778. pvih->bmiHeader.biWidth = _WIDTH;
  779. pvih->bmiHeader.biHeight = _HEIGHT;
  780. pvih->bmiHeader.biBitCount = 32;
  781. pvih->bmiHeader.biCompression = BI_RGB;
  782. pvih->bmiHeader.biPlanes = 1;
  783. pvih->bmiHeader.biSizeImage = pvih->bmiHeader.biWidth*abs(pvih->bmiHeader.biHeight)*pvih->bmiHeader.biBitCount>>3;
  785.     return NOERROR;
  786. }