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

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

多媒体编程

开发平台：

Visual C++

OggSplitter.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 "OggSplitter.h"
  24. #include "......DSUtilDSUtil.h"
  26. #include <initguid.h>
  27. #include "........includeoggOggDS.h"
  28. #include "........includemoreuuids.h"
  30. #ifdef REGISTER_FILTER
  32. const AMOVIESETUP_MEDIATYPE sudPinTypesIn[] =
  33. {
  34. {&MEDIATYPE_Stream, &MEDIASUBTYPE_NULL},
  35. };
  37. const AMOVIESETUP_PIN sudpPins[] =
  38. {
  39.     {L"Input", FALSE, FALSE, FALSE, FALSE, &CLSID_NULL, NULL, countof(sudPinTypesIn), sudPinTypesIn},
  40.     {L"Output", FALSE, TRUE, FALSE, FALSE, &CLSID_NULL, NULL, 0, NULL}
  41. };
  43. const AMOVIESETUP_FILTER sudFilter[] =
  44. {
  45. {&__uuidof(COggSplitterFilter), L"Ogg Splitter", MERIT_NORMAL+1, countof(sudpPins), sudpPins},
  46. {&__uuidof(COggSourceFilter), L"Ogg Source", MERIT_NORMAL+1, 0, NULL},
  47. };
  49. CFactoryTemplate g_Templates[] =
  50. {
  51. {sudFilter[0].strName, sudFilter[0].clsID, CreateInstance<COggSplitterFilter>, NULL, &sudFilter[0]},
  52. {sudFilter[1].strName, sudFilter[1].clsID, CreateInstance<COggSourceFilter>, NULL, &sudFilter[1]},
  53. };
  55. int g_cTemplates = countof(g_Templates);
  57. STDAPI DllRegisterServer()
  58. {
  59. RegisterSourceFilter(
  60. CLSID_AsyncReader, 
  61. MEDIASUBTYPE_Ogg, 
  62. _T("0,4,,4F676753"), // OggS
  63. _T(".ogg"), _T(".ogm"), NULL);
  65. return AMovieDllRegisterServer2(TRUE);
  66. }
  68. STDAPI DllUnregisterServer()
  69. {
  70. UnRegisterSourceFilter(MEDIASUBTYPE_Ogg);
  72. return AMovieDllRegisterServer2(FALSE);
  73. }
  75. extern "C" BOOL WINAPI DllEntryPoint(HINSTANCE, ULONG, LPVOID);
  77. BOOL APIENTRY DllMain(HANDLE hModule, DWORD dwReason, LPVOID lpReserved)
  78. {
  79.     return DllEntryPoint((HINSTANCE)hModule, dwReason, 0); // "DllMain" of the dshow baseclasses;
  80. }
  82. #endif
  84. //
  85. // bitstream
  86. //
  88. class bitstream
  89. {
  90. BYTE* m_p;
  91. int m_len, m_pos;
  92. public:
  93. bitstream(BYTE* p, int len, bool rev = false) : m_p(p), m_len(len*8) {m_pos = !rev ? 0 : len*8;}
  94. bool hasbits(int cnt)
  95. {
  96. int pos = m_pos+cnt;
  97. return(pos >= 0 && pos < m_len);
  98. }
  99. unsigned int showbits(int cnt) // a bit unclean, but works and can read backwards too! :P
  100. {
  101. if(!hasbits(cnt)) {ASSERT(0); return 0;}
  102. unsigned int ret = 0, off = 0;
  103. BYTE* p = m_p;
  104. if(cnt < 0)
  105. {
  106. p += (m_pos+cnt)>>3;
  107. off = (m_pos+cnt)&7;
  108. cnt = abs(cnt);
  109. ret = (*p++&(~0<<off))>>off; off = 8 - off; cnt -= off;
  110. }
  111. else
  112. {
  113. p += m_pos>>3;
  114. off = m_pos&7;
  115. ret = (*p++>>off)&((1<<min(cnt,8))-1); off = 0; cnt -= 8 - off;
  116. }
  117. while(cnt > 0) {ret |= (*p++&((1<<min(cnt,8))-1)) << off; off += 8; cnt -= 8;}
  118. return ret;
  119. }
  120. unsigned int getbits(int cnt)
  121. {
  122. unsigned int ret = showbits(cnt);
  123. m_pos += cnt;
  124. return ret;
  125. }
  126. };
  128. //
  129. // COggSplitterFilter
  130. //
  132. COggSplitterFilter::COggSplitterFilter(LPUNKNOWN pUnk, HRESULT* phr)
  133. : CBaseSplitterFilter(NAME("COggSplitterFilter"), pUnk, phr, __uuidof(this))
  134. {
  135. }
  137. COggSplitterFilter::~COggSplitterFilter()
  138. {
  139. }
  141. HRESULT COggSplitterFilter::CreateOutputs(IAsyncReader* pAsyncReader)
  142. {
  143. CheckPointer(pAsyncReader, E_POINTER);
  145. HRESULT hr = E_FAIL;
  147. m_pFile.Free();
  149. m_pFile.Attach(new COggFile(pAsyncReader, hr));
  150. if(!m_pFile) return E_OUTOFMEMORY;
  151. if(FAILED(hr)) {m_pFile.Free(); return hr;}
  153. m_rtNewStart = m_rtCurrent = 0;
  154. m_rtNewStop = m_rtStop = 0;
  156. m_rtDuration = 0;
  158. m_pFile->Seek(0);
  159. OggPage page;
  160. for(int i = 0, nWaitForMore = 0; m_pFile->Read(page); i++)
  161. {
  162. BYTE* p = page.GetData();
  164. if(!(page.m_hdr.header_type_flag & OggPageHeader::continued))
  165. {
  166. BYTE type = *p++;
  167. if(!(type&1) && nWaitForMore == 0)
  168. break;
  170. CStringW name;
  171. name.Format(L"Stream %d", i);
  173. HRESULT hr;
  175. if(type == 1 && (page.m_hdr.header_type_flag & OggPageHeader::first))
  176. {
  177. CAutoPtr<CBaseSplitterOutputPin> pPinOut;
  179. if(!memcmp(p, "vorbis", 6))
  180. {
  181. name.Format(L"Vorbis %d", i);
  182. pPinOut.Attach(new COggVorbisOutputPin((OggVorbisIdHeader*)(p+6), name, this, this, &hr));
  183. nWaitForMore++;
  184. }
  185. else if(!memcmp(p, "video", 5))
  186. {
  187. name.Format(L"Video %d", i);
  188. pPinOut.Attach(new COggVideoOutputPin((OggStreamHeader*)p, name, this, this, &hr));
  189. }
  190. else if(!memcmp(p, "audio", 5))
  191. {
  192. name.Format(L"Audio %d", i);
  193. pPinOut.Attach(new COggAudioOutputPin((OggStreamHeader*)p, name, this, this, &hr));
  194. }
  195. else if(!memcmp(p, "text", 4))
  196. {
  197. name.Format(L"Text %d", i);
  198. pPinOut.Attach(new COggTextOutputPin((OggStreamHeader*)p, name, this, this, &hr));
  199. }
  200. else if(!memcmp(p, "Direct Show Samples embedded in Ogg", 35))
  201. {
  202. name.Format(L"DirectShow %d", i);
  203. pPinOut.Attach(new COggDirectShowOutputPin((AM_MEDIA_TYPE*)(p+35+sizeof(GUID)), name, this, this, &hr));
  204. }
  206. AddOutputPin(page.m_hdr.bitstream_serial_number, pPinOut);
  207. }
  209. if(type == 3 && !memcmp(p, "vorbis", 6))
  210. {
  211. if(COggSplitterOutputPin* pOggPin = 
  212. dynamic_cast<COggSplitterOutputPin*>(GetOutputPin(page.m_hdr.bitstream_serial_number)))
  213. {
  214. pOggPin->AddComment(p+6, page.GetSize()-6-1);
  215. }
  216. }
  217. }
  219. if(COggVorbisOutputPin* pOggVorbisPin = 
  220. dynamic_cast<COggVorbisOutputPin*>(GetOutputPin(page.m_hdr.bitstream_serial_number)))
  221. {
  222. pOggVorbisPin->UnpackInitPage(page);
  223. if(pOggVorbisPin->IsInitialized()) nWaitForMore--;
  224. }
  225. }
  227. if(m_pOutputs.IsEmpty())
  228. return E_FAIL;
  230. m_pFile->Seek(max(m_pFile->GetLength()-65536, 0));
  231. while(m_pFile->Read(page))
  232. {
  233. COggSplitterOutputPin* pOggPin = dynamic_cast<COggSplitterOutputPin*>(GetOutputPin(page.m_hdr.bitstream_serial_number));
  234. if(!pOggPin) {ASSERT(0); continue;}
  235. if(page.m_hdr.granule_position == -1) continue;
  236. REFERENCE_TIME rt = pOggPin->GetRefTime(page.m_hdr.granule_position);
  237. m_rtDuration = max(rt, m_rtDuration);
  238. }
  240. m_rtNewStart = m_rtCurrent = 0;
  241. m_rtNewStop = m_rtStop = m_rtDuration;
  243. // comments
  245. {
  246. CAtlMap<CStringW, CStringW, CStringElementTraits<CStringW> > tagmap;
  247. tagmap[L"TITLE"] = L"TITL";
  248. tagmap[L"ARTIST"] = L"AUTH"; // not quite
  249. tagmap[L"COPYRIGHT"] = L"CPYR";
  250. tagmap[L"DESCRIPTION"] = L"DESC";
  252. POSITION pos2 = tagmap.GetStartPosition();
  253. while(pos2)
  254. {
  255. CStringW oggtag, dsmtag;
  256. tagmap.GetNextAssoc(pos2, oggtag, dsmtag);
  258. POSITION pos = m_pOutputs.GetHeadPosition();
  259. while(pos)
  260. {
  261. COggSplitterOutputPin* pOggPin = dynamic_cast<COggSplitterOutputPin*>((CBaseOutputPin*)m_pOutputs.GetNext(pos));
  262. if(!pOggPin) continue;
  264. CStringW value = pOggPin->GetComment(oggtag);
  265. if(!value.IsEmpty())
  266. {
  267. SetProperty(dsmtag, value);
  268. break;
  269. }
  270. }
  271. }
  273. POSITION pos = m_pOutputs.GetHeadPosition();
  274. while(pos && !ChapGetCount())
  275. {
  276. COggSplitterOutputPin* pOggPin = dynamic_cast<COggSplitterOutputPin*>((CBaseOutputPin*)m_pOutputs.GetNext(pos));
  277. if(!pOggPin) continue;
  279. for(int i = 1; pOggPin; i++)
  280. {
  281. CStringW key; 
  282. key.Format(L"CHAPTER%02d", i);
  283. CStringW time = pOggPin->GetComment(key);
  284. if(time.IsEmpty()) break;
  285. key.Format(L"CHAPTER%02dNAME", i);
  286. CStringW name = pOggPin->GetComment(key);
  287. if(name.IsEmpty()) name.Format(L"Chapter %d", i);
  288. int h, m, s, ms;
  289. WCHAR c;
  290. if(7 != swscanf(time, L"%d%c%d%c%d%c%d", &h, &c, &m, &c, &s, &c, &ms)) break;
  291. REFERENCE_TIME rt = ((((REFERENCE_TIME)h*60+m)*60+s)*1000+ms)*10000;
  292. ChapAppend(rt, name);
  293. }
  294. }
  295. }
  297. return m_pOutputs.GetCount() > 0 ? S_OK : E_FAIL;
  298. }
  300. bool COggSplitterFilter::DemuxInit()
  301. {
  302. if(!m_pFile) return(false);
  304. return(true);
  305. }
  307. void COggSplitterFilter::DemuxSeek(REFERENCE_TIME rt)
  308. {
  309. if(rt <= 0)
  310. {
  311. m_pFile->Seek(0);
  312. }
  313. else if(m_rtDuration > 0)
  314. {
  315. // oh, the horror...
  316. clock_t t1 = clock();
  317. __int64 len = m_pFile->GetLength();
  318. __int64 startpos = len * rt/m_rtDuration;
  319. __int64 diff = 0;
  321. REFERENCE_TIME rtMinDiff = _I64_MAX;
  323. while(1)
  324. {
  325. __int64 endpos = startpos;
  326. REFERENCE_TIME rtPos = -1;
  328. OggPage page;
  329. m_pFile->Seek(startpos);
  330. while(m_pFile->Read(page, false))
  331. {
  332. if(page.m_hdr.granule_position == -1) continue;
  334. COggSplitterOutputPin* pOggPin = dynamic_cast<COggSplitterOutputPin*>(GetOutputPin(page.m_hdr.bitstream_serial_number));
  335. if(!pOggPin) {ASSERT(0); continue;}
  337. rtPos = pOggPin->GetRefTime(page.m_hdr.granule_position);
  338. endpos = m_pFile->GetPos();
  340. break;
  341. }
  343. __int64 rtDiff = rtPos - rt;
  345. if(rtDiff < 0)
  346. {
  347. rtDiff = -rtDiff;
  349. if(rtDiff < 1000000 || rtDiff >= rtMinDiff)
  350. {
  351. m_pFile->Seek(startpos);
  352. break;
  353. }
  355. rtMinDiff = rtDiff;
  356. }
  358. __int64 newpos = startpos;
  360. if(rtPos < rt && rtPos < m_rtDuration)
  361. {
  362. newpos = startpos + (__int64)((1.0*(rt - rtPos)/(m_rtDuration - rtPos)) * (len - startpos)) + 1024;
  363.             if(newpos < endpos) newpos = endpos + 1024;
  364. }
  365. else if(rtPos > rt && rtPos > 0)
  366. {
  367. newpos = startpos - (__int64)((1.0*(rtPos - rt)/(rtPos - 0)) * (startpos - 0)) - 1024;
  368.             if(newpos >= startpos) newpos = startpos - 1024;
  369. }
  370. else if(rtPos == rt)
  371. {
  372. m_pFile->Seek(startpos);
  373. break;
  374. }
  375. else
  376. {
  377. ASSERT(0);
  378. m_pFile->Seek(0);
  379. break;
  380. }
  382. diff = newpos - startpos;
  384. startpos = max(min(newpos, len), 0);
  385. }
  387. TRACE(_T("****** t1: %dn"), clock() - t1);
  388. t1 = clock();
  389. m_pFile->Seek(startpos);
  391. POSITION pos = m_pOutputs.GetHeadPosition();
  392. while(pos)
  393. {
  394. CBaseSplitterOutputPin* pPin = m_pOutputs.GetNext(pos);
  395. COggVideoOutputPin* pOggVideoPin = dynamic_cast<COggVideoOutputPin*>(pPin);
  396. if(!pOggVideoPin) continue;
  398. bool fKeyFrameFound = false, fSkipKeyFrame = true;
  399. __int64 endpos = _I64_MAX;
  401. while(!(fKeyFrameFound && !fSkipKeyFrame) && startpos > 0)
  402. {
  403. OggPage page;
  404. while(!(fKeyFrameFound && !fSkipKeyFrame) && m_pFile->GetPos() < endpos && m_pFile->Read(page))
  405. {
  406. if(page.m_hdr.granule_position == -1) continue;
  408. COggSplitterOutputPin* pOggPin = dynamic_cast<COggSplitterOutputPin*>(GetOutputPin(page.m_hdr.bitstream_serial_number));
  409. if(pOggPin != pOggVideoPin) continue;
  411. REFERENCE_TIME rtPos = pOggPin->GetRefTime(page.m_hdr.granule_position);
  413. if(rtPos > rt)
  414. break;
  416. if(!fKeyFrameFound)
  417. {
  418. pOggPin->UnpackPage(page);
  420. CAutoPtr<OggPacket> p;
  421. while(p = pOggPin->GetPacket())
  422. {
  423. if(p->bSyncPoint)
  424. {
  425. fKeyFrameFound = true;
  426. fSkipKeyFrame = p->fSkip;
  427. }
  428. }
  430. if(fKeyFrameFound) break;
  431. }
  432. else
  433. {
  434. pOggPin->UnpackPage(page);
  436. CAutoPtr<OggPacket> p;
  437. while(p = pOggPin->GetPacket())
  438. {
  439. if(!p->fSkip)
  440. {
  441. fSkipKeyFrame = false;
  442. break;
  443. }
  444. }
  445. }
  446. }
  448. if(!(fKeyFrameFound && !fSkipKeyFrame)) {endpos = startpos; startpos = max(startpos - 10*65536, 0);}
  450. m_pFile->Seek(startpos);
  451. }
  452. TRACE(_T("****** t2: %dn"), clock() - t1);
  453. t1 = clock();
  455. #ifdef DEBUG
  456. // verify kf
  458. {
  459. fKeyFrameFound = false;
  461. OggPage page;
  462. while(!fKeyFrameFound && m_pFile->Read(page))
  463. {
  464. if(page.m_hdr.granule_position == -1) continue;
  466. COggSplitterOutputPin* pOggPin = dynamic_cast<COggSplitterOutputPin*>(GetOutputPin(page.m_hdr.bitstream_serial_number));
  467. if(pOggPin != pOggVideoPin) continue;
  469. REFERENCE_TIME rtPos = pOggPin->GetRefTime(page.m_hdr.granule_position);
  470. if(rtPos > rt)
  471. break;
  473. pOggPin->UnpackPage(page);
  475. CAutoPtr<OggPacket> p;
  476. while(p = pOggPin->GetPacket())
  477. {
  478. if(p->bSyncPoint)
  479. {
  480. fKeyFrameFound = true;
  481. break;
  482. }
  483. }
  484. }
  486. ASSERT(fKeyFrameFound);
  488. m_pFile->Seek(startpos);
  489. }
  490. TRACE(_T("****** t3: %dn"), clock() - t1);
  491. t1 = clock();
  492. #endif
  493. break;
  494. }
  495. }
  496. }
  498. bool COggSplitterFilter::DemuxLoop()
  499. {
  500. HRESULT hr = S_OK;
  502. OggPage page;
  503. while(SUCCEEDED(hr) && !CheckRequest(NULL) && m_pFile->Read(page, true, GetRequestHandle()))
  504. {
  505. COggSplitterOutputPin* pOggPin = dynamic_cast<COggSplitterOutputPin*>(GetOutputPin(page.m_hdr.bitstream_serial_number));
  506. if(!pOggPin) {ASSERT(0); continue;}
  507. if(!pOggPin->IsConnected()) continue;
  508. if(FAILED(hr = pOggPin->UnpackPage(page))) {ASSERT(0); break;}
  509. CAutoPtr<OggPacket> p;
  510. while(!CheckRequest(NULL) && SUCCEEDED(hr) && (p = pOggPin->GetPacket()))
  511. {
  512. if(!p->fSkip)
  513. hr = DeliverPacket(p);
  514. }
  515. }
  517. return(true);
  518. }
  520. //
  521. // COggSourceFilter
  522. //
  524. COggSourceFilter::COggSourceFilter(LPUNKNOWN pUnk, HRESULT* phr)
  525. : COggSplitterFilter(pUnk, phr)
  526. {
  527. m_clsid = __uuidof(this);
  528. m_pInput.Free();
  529. }
  531. //
  532. // COggSplitterOutputPin
  533. //
  535. COggSplitterOutputPin::COggSplitterOutputPin(LPCWSTR pName, CBaseFilter* pFilter, CCritSec* pLock, HRESULT* phr)
  536. : CBaseSplitterOutputPin(pName, pFilter, pLock, phr)
  537. {
  538. ResetState(-1);
  539. }
  541. void COggSplitterOutputPin::AddComment(BYTE* p, int len)
  542. {
  543. bitstream bs(p, len);
  544. bs.getbits(bs.getbits(32)*8);
  545. for(int n = bs.getbits(32); n-- > 0; )
  546. {
  547. CStringA str;
  548. for(int len = bs.getbits(32); len-- > 0; )
  549. str += (CHAR)bs.getbits(8);
  551. CList<CStringA> sl;
  552. Explode(str, sl, '=', 2);
  553. if(sl.GetCount() == 2)
  554. {
  555. CAutoPtr<CComment> p(new CComment(UTF8To16(sl.GetHead()), UTF8To16(sl.GetTail())));
  557. if(p->m_key == L"LANGUAGE")
  558. {
  559. CString lang = ISO6392ToLanguage(sl.GetTail()), iso6392 = LanguageToISO6392(CString(p->m_value));
  561. if(p->m_value.GetLength() == 3 && !lang.IsEmpty())
  562. {
  563. SetName(CStringW(lang));
  564. SetProperty(L"LANG", p->m_value);
  565. }
  566. else if(!iso6392.IsEmpty())
  567. {
  568. SetName(p->m_value);
  569. SetProperty(L"LANG", CStringW(iso6392));
  570. }
  571. else
  572. {
  573. SetName(p->m_value);
  574. SetProperty(L"NAME", p->m_value);
  575. }
  576. }
  578. m_pComments.AddTail(p);
  579. }
  580. }
  581. ASSERT(bs.getbits(1) == 1);
  582. }
  584. CStringW COggSplitterOutputPin::GetComment(CStringW key)
  585. {
  586. key.MakeUpper();
  587. CList<CStringW> sl;
  588. POSITION pos = m_pComments.GetHeadPosition();
  589. while(pos)
  590. {
  591. CComment* p = m_pComments.GetNext(pos);
  592. if(key == p->m_key) sl.AddTail(p->m_value);
  593. }
  594. return Implode(sl, ';');
  595. }
  597. void COggSplitterOutputPin::ResetState(DWORD seqnum)
  598. {
  599. CAutoLock csAutoLock(&m_csPackets);
  600. m_packets.RemoveAll();
  601. m_lastpacket.Free();
  602. m_lastseqnum = seqnum;
  603. m_rtLast = 0;
  604. m_fSkip = true;
  605. }
  607. HRESULT COggSplitterOutputPin::UnpackPage(OggPage& page)
  608. {
  609. if(m_lastseqnum != page.m_hdr.page_sequence_number-1)
  610. {
  611. ResetState(page.m_hdr.page_sequence_number);
  612. }
  613. else
  614. {
  615. m_lastseqnum = page.m_hdr.page_sequence_number;
  616. }
  618. POSITION first = page.m_lens.GetHeadPosition();
  619. while(first && page.m_lens.GetAt(first) == 255) page.m_lens.GetNext(first);
  620. if(!first) first = page.m_lens.GetTailPosition();
  622. POSITION last = page.m_lens.GetTailPosition();
  623. while(last && page.m_lens.GetAt(last) == 255) page.m_lens.GetPrev(last);
  624. if(!last) last = page.m_lens.GetTailPosition();
  626. BYTE* pData = page.GetData();
  628. int i = 0, j = 0, len = 0;
  630.     for(POSITION pos = page.m_lens.GetHeadPosition(); pos; page.m_lens.GetNext(pos))
  631. {
  632. len = page.m_lens.GetAt(pos);
  633. j += len;
  635. if(len < 255 || pos == page.m_lens.GetTailPosition())
  636. {
  637. if(first == pos && (page.m_hdr.header_type_flag & OggPageHeader::continued))
  638. {
  639. // ASSERT(m_lastpacket);
  641. if(m_lastpacket)
  642. {
  643. int size = m_lastpacket->pData.GetSize();
  644. m_lastpacket->pData.SetSize(size + j-i);
  645. memcpy(m_lastpacket->pData.GetData() + size, pData + i, j-i);
  647. CAutoLock csAutoLock(&m_csPackets);
  649. if(len < 255) m_packets.AddTail(m_lastpacket);
  650. }
  651. }
  652. else
  653. {
  654. CAutoPtr<OggPacket> p(new OggPacket());
  656. if(last == pos && page.m_hdr.granule_position != -1)
  657. {
  658. p->bDiscontinuity = m_fSkip;
  659. REFERENCE_TIME rtLast = m_rtLast;
  660. m_rtLast = GetRefTime(page.m_hdr.granule_position);
  661. // some bad encodings have a +/-1 frame difference from the normal timeline, 
  662. // but these seem to cancel eachother out nicely so we can just ignore them 
  663. // to make it play a bit more smooth.
  664. if(abs(rtLast - m_rtLast) == GetRefTime(1)) m_rtLast = rtLast; // FIXME
  665. m_fSkip = false;
  666. }
  668. p->TrackNumber = page.m_hdr.bitstream_serial_number;
  670. if(S_OK == UnpackPacket(p, pData + i, j-i))
  671. {
  673. if(p->TrackNumber == 0)
  674. TRACE(_T("[%d]: %d, %I64d -> %I64d (skip=%d, disc=%d, sync=%d)n"), 
  675. (int)p->TrackNumber, p->pData.GetSize(), p->rtStart, p->rtStop,
  676. (int)m_fSkip, (int)p->bDiscontinuity, (int)p->bSyncPoint);
  678. CAutoLock csAutoLock(&m_csPackets);
  680. m_rtLast = p->rtStop;
  681. p->fSkip = m_fSkip;
  683. if(len < 255) m_packets.AddTail(p);
  684. else m_lastpacket = p;
  685. }
  686. }
  688. i = j;
  689. }
  690. }
  692. return S_OK;
  693. }
  695. CAutoPtr<OggPacket> COggSplitterOutputPin::GetPacket()
  696. {
  697. CAutoPtr<OggPacket> p;
  698. CAutoLock csAutoLock(&m_csPackets);
  699. if(m_packets.GetCount()) p = m_packets.RemoveHead();
  700. return p;
  701. }
  703. HRESULT COggSplitterOutputPin::DeliverEndFlush()
  704. {
  705. ResetState();
  706. return __super::DeliverEndFlush();
  707. }
  709. HRESULT COggSplitterOutputPin::DeliverNewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
  710. {
  711. ResetState();
  712. return __super::DeliverNewSegment(tStart, tStop, dRate);
  713. }
  715. //
  716. // COggVorbisOutputPin
  717. //
  719. COggVorbisOutputPin::COggVorbisOutputPin(OggVorbisIdHeader* h, LPCWSTR pName, CBaseFilter* pFilter, CCritSec* pLock, HRESULT* phr)
  720. : COggSplitterOutputPin(pName, pFilter, pLock, phr)
  721. {
  722. m_audio_sample_rate = h->audio_sample_rate;
  723. m_blocksize[0] = 1<<h->blocksize_0;
  724. m_blocksize[1] = 1<<h->blocksize_1;
  725. m_lastblocksize = 0;
  727. CMediaType mt;
  729. mt.InitMediaType();
  730. mt.majortype = MEDIATYPE_Audio;
  731. mt.subtype = MEDIASUBTYPE_Vorbis;
  732. mt.formattype = FORMAT_VorbisFormat;
  733. VORBISFORMAT* vf = (VORBISFORMAT*)mt.AllocFormatBuffer(sizeof(VORBISFORMAT));
  734. memset(mt.Format(), 0, mt.FormatLength());
  735. vf->nChannels = h->audio_channels;
  736. vf->nSamplesPerSec = h->audio_sample_rate;
  737. vf->nAvgBitsPerSec = h->bitrate_nominal;
  738. vf->nMinBitsPerSec = h->bitrate_minimum;
  739. vf->nMaxBitsPerSec = h->bitrate_maximum;
  740. vf->fQuality = -1;
  741. mt.SetSampleSize(8192);
  742. m_mts.Add(mt);
  744. mt.InitMediaType();
  745. mt.majortype = MEDIATYPE_Audio;
  746. mt.subtype = MEDIASUBTYPE_Vorbis2;
  747. mt.formattype = FORMAT_VorbisFormat2;
  748. VORBISFORMAT2* vf2 = (VORBISFORMAT2*)mt.AllocFormatBuffer(sizeof(VORBISFORMAT2));
  749. memset(mt.Format(), 0, mt.FormatLength());
  750. vf2->Channels = h->audio_channels;
  751. vf2->SamplesPerSec = h->audio_sample_rate;
  752. mt.SetSampleSize(8192);
  753. m_mts.InsertAt(0, mt);
  754. }
  756. REFERENCE_TIME COggVorbisOutputPin::GetRefTime(__int64 granule_position)
  757. {
  758. REFERENCE_TIME rt = granule_position * 10000000 / m_audio_sample_rate;
  759. return rt;
  760. }
  762. HRESULT COggVorbisOutputPin::UnpackInitPage(OggPage& page)
  763. {
  764. HRESULT hr = __super::UnpackPage(page);
  766. while(m_packets.GetCount())
  767. {
  768. Packet* p = m_packets.GetHead();
  770. if(p->pData.GetCount() >= 6 && p->pData.GetData()[0] == 0x05)
  771. {
  772. // yeah, right, we are going to be parsing this backwards! :P
  773. bitstream bs(p->pData.GetData(), p->pData.GetCount(), true);
  774. while(bs.hasbits(-1) && bs.getbits(-1) != 1);
  775. for(int cnt = 0; bs.hasbits(-8-16-16-1-6); cnt++)
  776. {
  777. unsigned int modes = bs.showbits(-6)+1;
  779. unsigned int mapping = bs.getbits(-8);
  780. unsigned int transformtype = bs.getbits(-16);
  781. unsigned int windowtype = bs.getbits(-16);
  782. unsigned int blockflag = bs.getbits(-1);
  784. if(transformtype != 0 || windowtype != 0)
  785. {
  786. ASSERT(modes == cnt);
  787. break;
  788. }
  790. m_blockflags.InsertAt(0, !!blockflag);
  791. }
  792. }
  794. int cnt = m_initpackets.GetCount();
  795. if(cnt <= 3)
  796. {
  797. ASSERT(p->pData.GetCount() >= 6 && p->pData.GetData()[0] == 1+cnt*2);
  798. VORBISFORMAT2* vf2 = (VORBISFORMAT2*)m_mts[0].Format();
  799. vf2->HeaderSize[cnt] = p->pData.GetSize();
  800. int len = m_mts[0].FormatLength();
  801. memcpy(
  802. m_mts[0].ReallocFormatBuffer(len + p->pData.GetSize()) + len, 
  803. p->pData.GetData(), p->pData.GetSize());
  804. }
  806. m_initpackets.AddTail(m_packets.RemoveHead());
  807. }
  809. return hr;
  810. }
  812. HRESULT COggVorbisOutputPin::UnpackPacket(CAutoPtr<OggPacket>& p, BYTE* pData, int len)
  813. {
  814. if(len > 0 && m_blockflags.GetCount())
  815. {
  816. bitstream bs(pData, len);
  817. if(bs.getbits(1) == 0)
  818. {
  819. int x = m_blockflags.GetCount()-1, n = 0;
  820. while(x) {n++; x >>= 1;}
  821. DWORD blocksize = m_blocksize[m_blockflags[bs.getbits(n)]?1:0];
  822. if(m_lastblocksize) m_rtLast += GetRefTime((m_lastblocksize + blocksize) >> 2);
  823. m_lastblocksize = blocksize;
  824. }
  825. }
  827. p->bSyncPoint = TRUE;
  828. p->rtStart = m_rtLast;
  829. p->rtStop = m_rtLast+1;
  830. p->pData.SetSize(len);
  831. memcpy(p->pData.GetData(), pData, len);
  833. return S_OK;
  834. }
  836. HRESULT COggVorbisOutputPin::DeliverPacket(CAutoPtr<OggPacket> p)
  837. {
  838. if(p->pData.GetSize() > 0 && (p->pData.GetData()[0]&1))
  839. return S_OK;
  841. return __super::DeliverPacket(p);
  842. }
  844. HRESULT COggVorbisOutputPin::DeliverNewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
  845. {
  846. HRESULT hr = __super::DeliverNewSegment(tStart, tStop, dRate);
  848. m_lastblocksize = 0;
  850. if(m_mt.subtype == MEDIASUBTYPE_Vorbis)
  851. {
  852. POSITION pos = m_initpackets.GetHeadPosition();
  853. while(pos)
  854. {
  855. Packet* pi = m_initpackets.GetNext(pos);
  856. CAutoPtr<OggPacket> p(new OggPacket());
  857. p->TrackNumber = pi->TrackNumber;
  858. p->bDiscontinuity = p->bSyncPoint = TRUE;
  859. p->rtStart = p->rtStop = 0;
  860. p->pData.Copy(pi->pData);
  861. __super::DeliverPacket(p);
  862. }
  863. }
  865. return hr;
  866. }
  868. //
  869. // COggDirectShowOutputPin
  870. //
  872. COggDirectShowOutputPin::COggDirectShowOutputPin(AM_MEDIA_TYPE* pmt, LPCWSTR pName, CBaseFilter* pFilter, CCritSec* pLock, HRESULT* phr)
  873. : COggSplitterOutputPin(pName, pFilter, pLock, phr)
  874. {
  875. CMediaType mt;
  876. memcpy((AM_MEDIA_TYPE*)&mt, pmt, FIELD_OFFSET(AM_MEDIA_TYPE, pUnk));
  877. mt.SetFormat((BYTE*)(pmt+1), pmt->cbFormat);
  878. mt.SetSampleSize(1);
  879. if(mt.majortype == MEDIATYPE_Video) // TODO: find samples for audio and find out what to return in GetRefTime...
  880. m_mts.Add(mt);
  881. }
  883. REFERENCE_TIME COggDirectShowOutputPin::GetRefTime(__int64 granule_position)
  884. {
  885. REFERENCE_TIME rt = 0;
  887. if(m_mt.majortype == MEDIATYPE_Video)
  888. {
  889. rt = granule_position * ((VIDEOINFOHEADER*)m_mt.Format())->AvgTimePerFrame;
  890. }
  891. else if(m_mt.majortype == MEDIATYPE_Audio)
  892. {
  893. rt = granule_position; // ((WAVEFORMATEX*)m_mt.Format())-> // TODO
  894. }
  896. return rt;
  897. }
  899. HRESULT COggDirectShowOutputPin::UnpackPacket(CAutoPtr<OggPacket>& p, BYTE* pData, int len)
  900. {
  901. int i = 0;
  903. BYTE hdr = pData[i++];
  905. if(!(hdr&1))
  906. {
  907. // TODO: verify if this was still present in the old format (haven't found one sample yet)
  908. BYTE nLenBytes = (hdr>>6)|((hdr&2)<<1);
  909. __int64 Length = 0;
  910. for(int j = 0; j < nLenBytes; j++)
  911. Length |= (__int64)pData[i++] << (j << 3);
  913. // TODO: if(len < i) {ASSERT(0); return E_FAIL;}
  915. p->bSyncPoint = !!(hdr&8);
  916. p->rtStart = m_rtLast;
  917. p->rtStop = m_rtLast + (nLenBytes ? GetRefTime(Length) : GetRefTime(1));
  918. p->pData.SetSize(len - i);
  919. memcpy(p->pData.GetData(), &pData[i], len - i);
  921. return S_OK;
  922. }
  924. return S_FALSE;
  925. }
  927. //
  928. // COggStreamOutputPin
  929. //
  931. COggStreamOutputPin::COggStreamOutputPin(OggStreamHeader* h, LPCWSTR pName, CBaseFilter* pFilter, CCritSec* pLock, HRESULT* phr)
  932. : COggSplitterOutputPin(pName, pFilter, pLock, phr)
  933. {
  934. m_time_unit = h->time_unit;
  935. m_samples_per_unit = h->samples_per_unit;
  936. m_default_len = h->default_len;
  937. }
  939. REFERENCE_TIME COggStreamOutputPin::GetRefTime(__int64 granule_position)
  940. {
  941. return granule_position * m_time_unit / m_samples_per_unit;
  942. }
  944. HRESULT COggStreamOutputPin::UnpackPacket(CAutoPtr<OggPacket>& p, BYTE* pData, int len)
  945. {
  946. int i = 0;
  948. BYTE hdr = pData[i++];
  950. if(!(hdr&1))
  951. {
  952. BYTE nLenBytes = (hdr>>6)|((hdr&2)<<1);
  953. __int64 Length = 0;
  954. for(int j = 0; j < nLenBytes; j++)
  955. Length |= (__int64)pData[i++] << (j << 3);
  957. // TODO: if(len < i) {ASSERT(0); return E_FAIL;}
  959. p->bSyncPoint = !!(hdr&8);
  960. p->rtStart = m_rtLast;
  961. p->rtStop = m_rtLast + (nLenBytes ? GetRefTime(Length) : GetRefTime(m_default_len));
  962. p->pData.SetSize(len - i);
  963. memcpy(p->pData.GetData(), &pData[i], len - i);
  965. return S_OK;
  966. }
  968. return S_FALSE;
  969. }
  971. //
  972. // COggVideoOutputPin
  973. //
  975. COggVideoOutputPin::COggVideoOutputPin(OggStreamHeader* h, LPCWSTR pName, CBaseFilter* pFilter, CCritSec* pLock, HRESULT* phr)
  976. : COggStreamOutputPin(h, pName, pFilter, pLock, phr)
  977. {
  978. int extra = (int)h->size - sizeof(OggStreamHeader);
  979. extra = max(extra, 0);
  981. CMediaType mt;
  982. mt.majortype = MEDIATYPE_Video;
  983. mt.subtype = FOURCCMap(MAKEFOURCC(h->subtype[0],h->subtype[1],h->subtype[2],h->subtype[3]));
  984. mt.formattype = FORMAT_VideoInfo;
  985. VIDEOINFOHEADER* pvih = (VIDEOINFOHEADER*)mt.AllocFormatBuffer(sizeof(VIDEOINFOHEADER) + extra);
  986. memset(mt.Format(), 0, mt.FormatLength());
  987. memcpy(mt.Format() + sizeof(VIDEOINFOHEADER), h+1, extra);
  988. pvih->AvgTimePerFrame = h->time_unit / h->samples_per_unit;
  989. pvih->bmiHeader.biWidth = h->v.w;
  990. pvih->bmiHeader.biHeight = h->v.h;
  991. pvih->bmiHeader.biBitCount = (WORD)h->bps;
  992. pvih->bmiHeader.biCompression = mt.subtype.Data1;
  993. switch(pvih->bmiHeader.biCompression)
  994. {
  995. case BI_RGB: case BI_BITFIELDS: mt.subtype = 
  996. pvih->bmiHeader.biBitCount == 1 ? MEDIASUBTYPE_RGB1 :
  997. pvih->bmiHeader.biBitCount == 4 ? MEDIASUBTYPE_RGB4 :
  998. pvih->bmiHeader.biBitCount == 8 ? MEDIASUBTYPE_RGB8 :
  999. pvih->bmiHeader.biBitCount == 16 ? MEDIASUBTYPE_RGB565 :
  1000. pvih->bmiHeader.biBitCount == 24 ? MEDIASUBTYPE_RGB24 :
  1001. pvih->bmiHeader.biBitCount == 32 ? MEDIASUBTYPE_RGB32 :
  1002. MEDIASUBTYPE_NULL;
  1003. break;
  1004. case BI_RLE8: mt.subtype = MEDIASUBTYPE_RGB8; break;
  1005. case BI_RLE4: mt.subtype = MEDIASUBTYPE_RGB4; break;
  1006. }
  1007. mt.SetSampleSize(max(h->buffersize, 1));
  1008. m_mts.Add(mt);
  1009. }
  1011. //
  1012. // COggAudioOutputPin
  1013. //
  1015. COggAudioOutputPin::COggAudioOutputPin(OggStreamHeader* h, LPCWSTR pName, CBaseFilter* pFilter, CCritSec* pLock, HRESULT* phr)
  1016. : COggStreamOutputPin(h, pName, pFilter, pLock, phr)
  1017. {
  1018. int extra = (int)h->size - sizeof(OggStreamHeader);
  1019. extra = max(extra, 0);
  1021. CMediaType mt;
  1022. mt.majortype = MEDIATYPE_Audio;
  1023. mt.subtype = FOURCCMap(strtol(CStringA(h->subtype, 4), NULL, 16));
  1024. mt.formattype = FORMAT_WaveFormatEx;
  1025. WAVEFORMATEX* wfe = (WAVEFORMATEX*)mt.AllocFormatBuffer(sizeof(WAVEFORMATEX) + extra);
  1026. memset(mt.Format(), 0, mt.FormatLength());
  1027. memcpy(mt.Format() + sizeof(WAVEFORMATEX), h+1, extra);
  1028. wfe->cbSize = extra;
  1029. wfe->wFormatTag = (WORD)mt.subtype.Data1;
  1030. wfe->nChannels = h->a.nChannels;
  1031. wfe->nSamplesPerSec = (DWORD)(10000000i64 * h->samples_per_unit / h->time_unit);
  1032. wfe->wBitsPerSample = (WORD)h->bps;
  1033. wfe->nAvgBytesPerSec = h->a.nAvgBytesPerSec; // TODO: verify for PCM
  1034. wfe->nBlockAlign = h->a.nBlockAlign; // TODO: verify for PCM
  1035. mt.SetSampleSize(max(h->buffersize, 1));
  1036. m_mts.Add(mt);
  1037. }
  1039. //
  1040. // COggTextOutputPin
  1041. //
  1043. COggTextOutputPin::COggTextOutputPin(OggStreamHeader* h, LPCWSTR pName, CBaseFilter* pFilter, CCritSec* pLock, HRESULT* phr)
  1044. : COggStreamOutputPin(h, pName, pFilter, pLock, phr)
  1045. {
  1046. CMediaType mt;
  1047. mt.majortype = MEDIATYPE_Text;
  1048. mt.subtype = MEDIASUBTYPE_NULL;
  1049. mt.formattype = FORMAT_None;
  1050. mt.SetSampleSize(1);
  1051. m_mts.Add(mt);
  1052. }