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

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

多媒体编程

开发平台：

Visual C++

RealMediaSplitter.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 <Shlwapi.h>
  24. #include <atlpath.h>
  25. #include <mmreg.h>
  26. #include <ks.h>
  27. #include <ksmedia.h>
  28. #include "......DSUtilDSUtil.h"
  29. #include "......DSUtilMediaTypes.h"
  30. #include "RealMediaSplitter.h"
  31. #include "......subtitlesSubtitleInputPin.h"
  33. //
  35. #include <initguid.h>
  36. #include "........includemoreuuids.h"
  38. template<typename T>
  39. static void bswap(T& var)
  40. {
  41. BYTE* s = (BYTE*)&var;
  42. for(BYTE* d = s + sizeof(var)-1; s < d; s++, d--)
  43. *s ^= *d, *d ^= *s, *s ^= *d;
  44. }
  46. void rvinfo::bswap()
  47. {
  48. ::bswap(dwSize);
  49. ::bswap(w); ::bswap(h); ::bswap(bpp);
  50. ::bswap(unk1); ::bswap(fps); 
  51. ::bswap(type1); ::bswap(type2);
  52. }
  54. void rainfo::bswap()
  55. {
  56. ::bswap(version1);
  57. ::bswap(version2);
  58. ::bswap(header_size);
  59. ::bswap(flavor);
  60. ::bswap(coded_frame_size);
  61. ::bswap(sub_packet_h);
  62. ::bswap(frame_size);
  63. ::bswap(sub_packet_size);
  64. }
  66. void rainfo4::bswap()
  67. {
  68. __super::bswap();
  69. ::bswap(sample_rate);
  70. ::bswap(sample_size);
  71. ::bswap(channels);
  72. }
  74. void rainfo5::bswap()
  75. {
  76. __super::bswap();
  77. ::bswap(sample_rate);
  78. ::bswap(sample_size);
  79. ::bswap(channels);
  80. }
  82. using namespace RMFF;
  84. #ifdef REGISTER_FILTER
  86. const AMOVIESETUP_MEDIATYPE sudPinTypesIn[] =
  87. {
  88. {&MEDIATYPE_Stream, &MEDIASUBTYPE_NULL},
  89. };
  91. const AMOVIESETUP_PIN sudpPins[] =
  92. {
  93.     {L"Input", FALSE, FALSE, FALSE, FALSE, &CLSID_NULL, NULL, countof(sudPinTypesIn), sudPinTypesIn},
  94.     {L"Output", FALSE, TRUE, FALSE, FALSE, &CLSID_NULL, NULL, 0, NULL}
  95. };
  97. const AMOVIESETUP_MEDIATYPE sudPinTypesIn2[] =
  98. {
  99. {&MEDIATYPE_Video, &MEDIASUBTYPE_RV20},
  100. {&MEDIATYPE_Video, &MEDIASUBTYPE_RV30},
  101. {&MEDIATYPE_Video, &MEDIASUBTYPE_RV40},
  102. {&MEDIATYPE_Video, &MEDIASUBTYPE_RV41},
  103. };
  105. const AMOVIESETUP_MEDIATYPE sudPinTypesOut2[] =
  106. {
  107. {&MEDIATYPE_Video, &MEDIASUBTYPE_NULL},
  108. };
  110. const AMOVIESETUP_PIN sudpPins2[] =
  111. {
  112.     {L"Input", FALSE, FALSE, FALSE, FALSE, &CLSID_NULL, NULL, countof(sudPinTypesIn2), sudPinTypesIn2},
  113.     {L"Output", FALSE, TRUE, FALSE, FALSE, &CLSID_NULL, NULL, countof(sudPinTypesOut2), sudPinTypesOut2}
  114. };
  116. const AMOVIESETUP_MEDIATYPE sudPinTypesIn3[] =
  117. {
  118. {&MEDIATYPE_Audio, &MEDIASUBTYPE_14_4},
  119. {&MEDIATYPE_Audio, &MEDIASUBTYPE_28_8},
  120. {&MEDIATYPE_Audio, &MEDIASUBTYPE_ATRC},
  121. {&MEDIATYPE_Audio, &MEDIASUBTYPE_COOK},
  122. {&MEDIATYPE_Audio, &MEDIASUBTYPE_DNET},
  123. {&MEDIATYPE_Audio, &MEDIASUBTYPE_SIPR},
  124. {&MEDIATYPE_Audio, &MEDIASUBTYPE_AAC},
  125. {&MEDIATYPE_Audio, &MEDIASUBTYPE_RAAC},
  126. {&MEDIATYPE_Audio, &MEDIASUBTYPE_RACP},
  127. };
  129. const AMOVIESETUP_MEDIATYPE sudPinTypesOut3[] =
  130. {
  131. {&MEDIATYPE_Audio, &MEDIASUBTYPE_PCM},
  132. };
  134. const AMOVIESETUP_PIN sudpPins3[] =
  135. {
  136.     {L"Input", FALSE, FALSE, FALSE, FALSE, &CLSID_NULL, NULL, countof(sudPinTypesIn3), sudPinTypesIn3},
  137.     {L"Output", FALSE, TRUE, FALSE, FALSE, &CLSID_NULL, NULL, countof(sudPinTypesOut3), sudPinTypesOut3}
  138. };
  140. const AMOVIESETUP_FILTER sudFilter[] =
  141. {
  142. {&__uuidof(CRealMediaSplitterFilter), L"RealMedia Splitter", MERIT_NORMAL, countof(sudpPins), sudpPins},
  143. {&__uuidof(CRealMediaSourceFilter), L"RealMedia Source", MERIT_NORMAL, 0, NULL},
  144. {&__uuidof(CRealVideoDecoder), L"RealVideo Decoder", MERIT_UNLIKELY, countof(sudpPins2), sudpPins2},
  145. {&__uuidof(CRealAudioDecoder), L"RealAudio Decoder", MERIT_UNLIKELY, countof(sudpPins3), sudpPins3},
  146. };
  148. CFactoryTemplate g_Templates[] =
  149. {
  150. {sudFilter[0].strName, sudFilter[0].clsID, CreateInstance<CRealMediaSplitterFilter>, NULL, &sudFilter[0]},
  151. {sudFilter[1].strName, sudFilter[1].clsID, CreateInstance<CRealMediaSourceFilter>, NULL, &sudFilter[1]},
  152.     {sudFilter[2].strName, sudFilter[2].clsID, CreateInstance<CRealVideoDecoder>, NULL, &sudFilter[2]},
  153.     {sudFilter[3].strName, sudFilter[3].clsID, CreateInstance<CRealAudioDecoder>, NULL, &sudFilter[3]},
  154. };
  156. int g_cTemplates = countof(g_Templates);
  158. STDAPI DllRegisterServer()
  159. {
  160. RegisterSourceFilter(
  161. CLSID_AsyncReader, 
  162. MEDIASUBTYPE_RealMedia, 
  163. _T("0,4,,2E524D46"), 
  164. _T(".rm"), _T(".rmvb"), _T(".ram"), NULL);
  166. return AMovieDllRegisterServer2(TRUE);
  167. }
  169. STDAPI DllUnregisterServer()
  170. {
  171. UnRegisterSourceFilter(MEDIASUBTYPE_RealMedia);
  173. return AMovieDllRegisterServer2(FALSE);
  174. }
  176. extern "C" BOOL WINAPI DllEntryPoint(HINSTANCE, ULONG, LPVOID);
  178. BOOL APIENTRY DllMain(HANDLE hModule, DWORD dwReason, LPVOID lpReserved)
  179. {
  180.     return DllEntryPoint((HINSTANCE)hModule, dwReason, 0); // "DllMain" of the dshow baseclasses;
  181. }
  183. #endif
  185. //
  186. // CRealMediaSplitterFilter
  187. //
  189. CRealMediaSplitterFilter::CRealMediaSplitterFilter(LPUNKNOWN pUnk, HRESULT* phr)
  190. : CBaseSplitterFilter(NAME("CRealMediaSplitterFilter"), pUnk, phr, __uuidof(this))
  191. {
  192. }
  194. CRealMediaSplitterFilter::~CRealMediaSplitterFilter()
  195. {
  196. }
  198. HRESULT CRealMediaSplitterFilter::CreateOutputs(IAsyncReader* pAsyncReader)
  199. {
  200. CheckPointer(pAsyncReader, E_POINTER);
  202. {
  203. DWORD dw;
  204. if(FAILED(pAsyncReader->SyncRead(0, 4, (BYTE*)&dw)) || dw != 'FMR.')
  205. return E_FAIL;
  206. }
  208. HRESULT hr = E_FAIL;
  210. m_pFile.Free();
  212. m_pFile.Attach(new CRMFile(pAsyncReader, hr));
  213. if(!m_pFile) return E_OUTOFMEMORY;
  214. if(FAILED(hr)) {m_pFile.Free(); return hr;}
  216. m_rtNewStart = m_rtCurrent = 0;
  217. m_rtNewStop = m_rtStop = 0;
  219. m_rtStop = 10000i64*m_pFile->m_p.tDuration;
  221. POSITION pos = m_pFile->m_mps.GetHeadPosition();
  222. while(pos)
  223. {
  224. MediaProperies* pmp = m_pFile->m_mps.GetNext(pos);
  226. CStringW name;
  227. name.Format(L"Output %02d", pmp->stream);
  228. if(!pmp->name.IsEmpty()) name += L" (" + CStringW(pmp->name) + L")";
  230. CArray<CMediaType> mts;
  232. CMediaType mt;
  233. mt.SetSampleSize(max(pmp->maxPacketSize*16/**/, 1));
  235. if(pmp->mime == "video/x-pn-realvideo")
  236. {
  237. mt.majortype = MEDIATYPE_Video;
  238. mt.formattype = FORMAT_VideoInfo;
  240. VIDEOINFOHEADER* pvih = (VIDEOINFOHEADER*)mt.AllocFormatBuffer(sizeof(VIDEOINFOHEADER) + pmp->typeSpecData.GetCount());
  241. memset(mt.Format(), 0, mt.FormatLength());
  242. memcpy(pvih + 1, pmp->typeSpecData.GetData(), pmp->typeSpecData.GetCount());
  244. rvinfo rvi = *(rvinfo*)pmp->typeSpecData.GetData();
  245. rvi.bswap();
  247. ASSERT(rvi.dwSize >= FIELD_OFFSET(rvinfo, morewh));
  248. ASSERT(rvi.fcc1 == 'ODIV');
  250. mt.subtype = FOURCCMap(rvi.fcc2);
  251. if(rvi.fps > 0x10000) pvih->AvgTimePerFrame = REFERENCE_TIME(10000000i64 / ((float)rvi.fps/0x10000)); 
  252. pvih->dwBitRate = pmp->avgBitRate; 
  253. pvih->bmiHeader.biSize = sizeof(pvih->bmiHeader);
  254. pvih->bmiHeader.biWidth = rvi.w;
  255. pvih->bmiHeader.biHeight = rvi.h;
  256. pvih->bmiHeader.biPlanes = 3;
  257. pvih->bmiHeader.biBitCount = rvi.bpp;
  258. pvih->bmiHeader.biCompression = rvi.fcc2;
  259. pvih->bmiHeader.biSizeImage = rvi.w*rvi.h*3/2;
  261. mts.Add(mt);
  263. if(pmp->width > 0 && pmp->height > 0)
  264. {
  265. BITMAPINFOHEADER bmi = pvih->bmiHeader;
  266. mt.formattype = FORMAT_VideoInfo2;
  267. VIDEOINFOHEADER2* pvih2 = (VIDEOINFOHEADER2*)mt.ReallocFormatBuffer(sizeof(VIDEOINFOHEADER2) + pmp->typeSpecData.GetCount());
  268. memset(mt.Format() + FIELD_OFFSET(VIDEOINFOHEADER2, dwInterlaceFlags), 0, mt.FormatLength() - FIELD_OFFSET(VIDEOINFOHEADER2, dwInterlaceFlags));
  269. memcpy(pvih2 + 1, pmp->typeSpecData.GetData(), pmp->typeSpecData.GetCount());
  270. pvih2->bmiHeader = bmi;
  271. pvih2->bmiHeader.biWidth = (DWORD)pmp->width;
  272. pvih2->bmiHeader.biHeight = (DWORD)pmp->height;
  273. pvih2->dwPictAspectRatioX = rvi.w;
  274. pvih2->dwPictAspectRatioY = rvi.h;
  276. mts.InsertAt(0, mt);
  277. }
  278. }
  279. else if(pmp->mime == "audio/x-pn-realaudio")
  280. {
  281. mt.majortype = MEDIATYPE_Audio;
  282. mt.formattype = FORMAT_WaveFormatEx;
  283. mt.bTemporalCompression = 1;
  285. WAVEFORMATEX* pwfe = (WAVEFORMATEX*)mt.AllocFormatBuffer(sizeof(WAVEFORMATEX) + pmp->typeSpecData.GetCount());
  286. memset(mt.Format(), 0, mt.FormatLength());
  287. memcpy(pwfe + 1, pmp->typeSpecData.GetData(), pmp->typeSpecData.GetCount());
  289. union {
  290. DWORD fcc;
  291. char fccstr[5];
  292. };
  294. fcc = 0;
  295. fccstr[4] = 0;
  297. BYTE* fmt = pmp->typeSpecData.GetData();
  298. for(int i = 0; i < pmp->typeSpecData.GetSize()-4; i++, fmt++)
  299. {
  300. if(fmt[0] == '.' || fmt[1] == 'r' || fmt[2] == 'a')
  301. break;
  302. }
  304. rainfo rai = *(rainfo*)fmt;
  305. rai.bswap();
  307. BYTE* extra = NULL;
  309. if(rai.version2 == 4)
  310. {
  311. rainfo4 rai4 = *(rainfo4*)fmt;
  312. rai4.bswap();
  313. pwfe->nChannels = rai4.channels;
  314. pwfe->wBitsPerSample = rai4.sample_size;
  315. pwfe->nSamplesPerSec = rai4.sample_rate;
  316. pwfe->nBlockAlign = rai4.frame_size;
  317. BYTE* p = (BYTE*)((rainfo4*)fmt+1);
  318. int len = *p++; p += len; len = *p++; ASSERT(len == 4);
  319. if(len == 4)
  320. fcc = MAKEFOURCC(p[0],p[1],p[2],p[3]);
  321. extra = p + len + 3;
  322. }
  323. else if(rai.version2 == 5)
  324. {
  325. rainfo5 rai5 = *(rainfo5*)fmt;
  326. rai5.bswap();
  327. pwfe->nChannels = rai5.channels;
  328. pwfe->wBitsPerSample = rai5.sample_size;
  329. pwfe->nSamplesPerSec = rai5.sample_rate;
  330. pwfe->nBlockAlign = rai5.frame_size;
  331. fcc = rai5.fourcc3;
  332. extra = fmt + sizeof(rainfo5) + 4;
  333. }
  334. else
  335. {
  336. continue;
  337. }
  339. _strupr(fccstr);
  341. mt.subtype = FOURCCMap(fcc);
  343. bswap(fcc);
  345. switch(fcc)
  346. {
  347. case '14_4': pwfe->wFormatTag = WAVE_FORMAT_14_4; break;
  348. case '28_8': pwfe->wFormatTag = WAVE_FORMAT_28_8; break;
  349. case 'ATRC': pwfe->wFormatTag = WAVE_FORMAT_ATRC; break;
  350. case 'COOK': pwfe->wFormatTag = WAVE_FORMAT_COOK; break;
  351. case 'DNET': pwfe->wFormatTag = WAVE_FORMAT_DNET; break;
  352. case 'SIPR': pwfe->wFormatTag = WAVE_FORMAT_SIPR; break;
  353. case 'RAAC': pwfe->wFormatTag = WAVE_FORMAT_RAAC; break;
  354. case 'RACP': pwfe->wFormatTag = WAVE_FORMAT_RACP; break;
  355. }
  357. if(pwfe->wFormatTag)
  358. {
  359. mts.Add(mt);
  361. if(fcc == 'DNET')
  362. {
  363. mt.subtype = FOURCCMap(pwfe->wFormatTag = WAVE_FORMAT_DOLBY_AC3); 
  364. mts.InsertAt(0, mt);
  365. }
  366. else if(fcc == 'RAAC' || fcc == 'RACP')
  367. {
  368. mt.subtype = FOURCCMap(pwfe->wFormatTag = WAVE_FORMAT_AAC); 
  369. int extralen = *(DWORD*)extra; extra += 4;
  370. ::bswap(extralen);
  371. ASSERT(*extra == 2); // always 2? why? what does it mean?
  372. if(*extra == 2)
  373. {
  374. extra++; extralen--;
  375. WAVEFORMATEX* pwfe = (WAVEFORMATEX*)mt.ReallocFormatBuffer(sizeof(WAVEFORMATEX) + extralen);
  376. pwfe->cbSize = extralen;
  377. memcpy(pwfe + 1, extra, extralen);
  378. }
  379. else
  380. {
  381. WAVEFORMATEX* pwfe = (WAVEFORMATEX*)mt.ReallocFormatBuffer(sizeof(WAVEFORMATEX) + 5);
  382. pwfe->cbSize = MakeAACInitData((BYTE*)(pwfe+1), 0, pwfe->nSamplesPerSec, pwfe->nChannels);
  383. }
  384. mts.InsertAt(0, mt);
  385. }
  386. }
  387. }
  388. else if(pmp->mime == "logical-fileinfo")
  389. {
  390. CMap<CStringA,LPCSTR,CStringA,LPCSTR> lfi;
  391. CStringA key, value;
  393. BYTE* p = pmp->typeSpecData.GetData();
  394. BYTE* end = p + pmp->typeSpecData.GetCount();
  395. p += 8;
  397. DWORD cnt = p <= end-4 ? *(DWORD*)p : 0; bswap(cnt); p += 4;
  399. if(cnt > 0xffff) // different format?
  400. {
  401. p += 2;
  402. cnt = p <= end-4 ? *(DWORD*)p : 0; bswap(cnt); p += 4;
  403. }
  405. while(p < end-4 && cnt-- > 0)
  406. {
  407. BYTE* base = p;
  408. DWORD len = *(DWORD*)p; bswap(len); p += 4;
  409. if(base + len > end) break;
  411. p++;
  412. WORD keylen = *(WORD*)p; bswap(keylen); p += 2;
  413. memcpy(key.GetBufferSetLength(keylen), p, keylen);
  414. p += keylen;
  416. p+=4;
  417. WORD valuelen = *(WORD*)p; bswap(valuelen); p += 2;
  418. memcpy(value.GetBufferSetLength(valuelen), p, valuelen);
  419. p += valuelen;
  421. ASSERT(p == base + len);
  422. p = base + len;
  424. lfi[key] = value;
  425. }
  427. POSITION pos = lfi.GetStartPosition();
  428. while(pos)
  429. {
  430. lfi.GetNextAssoc(pos, key, value);
  432. int n;
  433. if(key.Find("CHAPTER") == 0 && key.Find("TIME") == key.GetLength()-4
  434. && (n = strtol(key.Mid(7), NULL, 10)) > 0)
  435. {
  436. int h, m, s, ms;
  437. char c;
  438. if(7 != sscanf(value, "%d%c%d%c%d%c%d", &h, &c, &m, &c, &s, &c, &ms))
  439. continue;
  441. key.Format("CHAPTER%02dNAME", n);
  442. if(!lfi.Lookup(key, value) || value.IsEmpty())
  443. value.Format("Chapter %d", n);
  445. ChapAppend(
  446. ((((REFERENCE_TIME)h*60+m)*60+s)*1000+ms)*10000, 
  447. CStringW(CString(value)));
  448. }
  449. }
  450. }
  452. if(mts.IsEmpty())
  453. {
  454. TRACE(_T("Unsupported RealMedia stream (%d): %sn"), pmp->stream, CString(pmp->mime));
  455. continue;
  456. }
  458. HRESULT hr;
  460. CAutoPtr<CBaseSplitterOutputPin> pPinOut(new CRealMediaSplitterOutputPin(mts, name, this, this, &hr));
  461. if(SUCCEEDED(AddOutputPin((DWORD)pmp->stream, pPinOut)))
  462. {
  463. if(!m_rtStop)
  464. m_pFile->m_p.tDuration = max(m_pFile->m_p.tDuration, pmp->tDuration);
  465. }
  466. }
  468. pos = m_pFile->m_subs.GetHeadPosition();
  469. for(DWORD stream = 0; pos; stream++)
  470. {
  471. CRMFile::subtitle& s = m_pFile->m_subs.GetNext(pos);
  473. CStringW name;
  474. name.Format(L"Subtitle %02d", stream);
  475. if(!s.name.IsEmpty()) name += L" (" + CStringW(CString(s.name)) + L")";
  477. CMediaType mt;
  478. mt.SetSampleSize(1);
  479. mt.majortype = MEDIATYPE_Text;
  481. CArray<CMediaType> mts;
  482. mts.Add(mt);
  484. HRESULT hr;
  486. CAutoPtr<CBaseSplitterOutputPin> pPinOut(new CRealMediaSplitterOutputPin(mts, name, this, this, &hr));
  487. AddOutputPin((DWORD)~stream, pPinOut);
  488. }
  490. m_rtDuration = m_rtNewStop = m_rtStop = 10000i64*m_pFile->m_p.tDuration;
  492. SetProperty(L"TITL", CStringW(m_pFile->m_cd.title));
  493. SetProperty(L"AUTH", CStringW(m_pFile->m_cd.author));
  494. SetProperty(L"CPYR", CStringW(m_pFile->m_cd.copyright));
  495. SetProperty(L"DESC", CStringW(m_pFile->m_cd.comment));
  497. return m_pOutputs.GetCount() > 0 ? S_OK : E_FAIL;
  498. }
  500. bool CRealMediaSplitterFilter::DemuxInit()
  501. {
  502. if(!m_pFile) return(false);
  504. // reindex if needed
  506. if(m_pFile->m_irs.GetCount() == 0)
  507. {
  508. m_nOpenProgress = 0;
  509. m_rtDuration = 0;
  511. int stream = m_pFile->GetMasterStream();
  513. UINT32 tLastStart = -1;
  514. UINT32 nPacket = 0;
  516. POSITION pos = m_pFile->m_dcs.GetHeadPosition(); 
  517. while(pos && !m_fAbort)
  518. {
  519. DataChunk* pdc = m_pFile->m_dcs.GetNext(pos);
  521. m_pFile->Seek(pdc->pos);
  523. for(UINT32 i = 0; i < pdc->nPackets && !m_fAbort; i++, nPacket++)
  524. {
  525. UINT64 filepos = m_pFile->GetPos();
  527. HRESULT hr;
  529. MediaPacketHeader mph;
  530. if(S_OK != (hr = m_pFile->Read(mph, false)))
  531. break;
  533. if(mph.stream == stream && (mph.flags&MediaPacketHeader::PN_KEYFRAME_FLAG) && tLastStart != mph.tStart)
  534. {
  535. m_rtDuration = max((__int64)(10000i64*mph.tStart), m_rtDuration);
  537. CAutoPtr<IndexRecord> pir(new IndexRecord());
  538. pir->tStart = mph.tStart;
  539. pir->ptrFilePos = (UINT32)filepos;
  540. pir->packet = nPacket;
  541. m_pFile->m_irs.AddTail(pir);
  543. tLastStart = mph.tStart;
  544. }
  546. m_nOpenProgress = m_pFile->GetPos()*100/m_pFile->GetLength();
  548. DWORD cmd;
  549. if(CheckRequest(&cmd))
  550. {
  551. if(cmd == CMD_EXIT) m_fAbort = true;
  552. else Reply(S_OK);
  553. }
  554. }
  555. }
  557. m_nOpenProgress = 100;
  559. if(m_fAbort) m_pFile->m_irs.RemoveAll();
  561. m_fAbort = false;
  562. }
  564. m_seekpos = NULL;
  565. m_seekpacket = 0;
  566. m_seekfilepos = 0;
  568. return(true);
  569. }
  571. void CRealMediaSplitterFilter::DemuxSeek(REFERENCE_TIME rt)
  572. {
  573. if(rt <= 0)
  574. {
  575. m_seekpos = m_pFile->m_dcs.GetHeadPosition(); 
  576. m_seekpacket = 0;
  577. m_seekfilepos = m_pFile->m_dcs.GetHead()->pos;
  578. }
  579. else
  580. {
  581. m_seekpos = NULL; 
  583. POSITION pos = m_pFile->m_irs.GetTailPosition();
  584. while(pos && !m_seekpos)
  585. {
  586. IndexRecord* pir = m_pFile->m_irs.GetPrev(pos);
  587. if(pir->tStart <= rt/10000)
  588. {
  589. m_seekpacket = pir->packet;
  591. pos = m_pFile->m_dcs.GetTailPosition();
  592. while(pos && !m_seekpos)
  593. {
  594. POSITION tmp = pos;
  596. DataChunk* pdc = m_pFile->m_dcs.GetPrev(pos);
  598. if(pdc->pos <= pir->ptrFilePos)
  599. {
  600. m_seekpos = tmp;
  601. m_seekfilepos = pir->ptrFilePos;
  603. POSITION pos = m_pFile->m_dcs.GetHeadPosition();
  604. while(pos != m_seekpos)
  605. {
  606. m_seekpacket -= m_pFile->m_dcs.GetNext(pos)->nPackets;
  607. }
  608. }
  609. }
  611. // search the closest keyframe to the seek time (commented out 'cause rm seems to index all of its keyframes...)
  612. /*
  613. if(m_seekpos)
  614. {
  615. DataChunk* pdc = m_pFile->m_dcs.GetAt(m_seekpos);
  617. m_pFile->Seek(m_seekfilepos);
  619. REFERENCE_TIME seektime = -1;
  620. UINT32 seekstream = -1;
  622. for(UINT32 i = m_seekpacket; i < pdc->nPackets; i++)
  623. {
  624. UINT64 filepos = m_pFile->GetPos();
  626. MediaPacketHeader mph;
  627. if(S_OK != m_pFile->Read(mph, false))
  628. break;
  630. if(seekstream == -1) seekstream = mph.stream;
  631. if(seekstream != mph.stream) continue;
  633. if(seektime == 10000i64*mph.tStart) continue;
  634. if(rt < 10000i64*mph.tStart) break;
  636. if((mph.flags&MediaPacketHeader::PN_KEYFRAME_FLAG))
  637. {
  638. m_seekpacket = i;
  639. m_seekfilepos = filepos;
  640. seektime = 10000i64*mph.tStart;
  641. }
  642. }
  643. }
  644. */
  645. }
  646. }
  648. if(!m_seekpos)
  649. {
  650. m_seekpos = m_pFile->m_dcs.GetHeadPosition(); 
  651. m_seekpacket = 0;
  652. m_seekfilepos = m_pFile->m_dcs.GetAt(m_seekpos)->pos;
  653. }
  654. }
  655. }
  657. bool CRealMediaSplitterFilter::DemuxLoop()
  658. {
  659. HRESULT hr = S_OK;
  660. POSITION pos;
  662. pos = m_pFile->m_subs.GetHeadPosition();
  663. for(DWORD stream = 0; pos && SUCCEEDED(hr) && !CheckRequest(NULL); stream++)
  664. {
  665. CRMFile::subtitle& s = m_pFile->m_subs.GetNext(pos);
  667. CAutoPtr<Packet> p(new Packet);
  669. p->TrackNumber = ~stream;
  670. p->bSyncPoint = TRUE;
  671. p->rtStart = 0;
  672. p->rtStop = 1;
  674. p->pData.SetSize((4+1) + (2+4+(s.name.GetLength()+1)*2) + (2+4+s.data.GetLength()));
  675. BYTE* ptr = p->pData.GetData();
  677. strcpy((char*)ptr, "GAB2"); ptr += 4+1;
  679. *(WORD*)ptr = 2; ptr += 2;
  680. *(DWORD*)ptr = (s.name.GetLength()+1)*2; ptr += 4;
  681. wcscpy((WCHAR*)ptr, CStringW(s.name)); ptr += (s.name.GetLength()+1)*2;
  683. *(WORD*)ptr = 4; ptr += 2;
  684. *(DWORD*)ptr = s.data.GetLength(); ptr += 4;
  685. memcpy((char*)ptr, s.data, s.data.GetLength()); ptr += s.name.GetLength();
  687. hr = DeliverPacket(p);
  688. }
  690. pos = m_seekpos; 
  691. while(pos && SUCCEEDED(hr) && !CheckRequest(NULL))
  692. {
  693. DataChunk* pdc = m_pFile->m_dcs.GetNext(pos);
  695. m_pFile->Seek(m_seekfilepos > 0 ? m_seekfilepos : pdc->pos);
  697. for(UINT32 i = m_seekpacket; i < pdc->nPackets && SUCCEEDED(hr) && !CheckRequest(NULL); i++)
  698. {
  699. MediaPacketHeader mph;
  700. if(S_OK != (hr = m_pFile->Read(mph)))
  701. break;
  703. CAutoPtr<Packet> p(new Packet);
  704. p->TrackNumber = mph.stream;
  705. p->bSyncPoint = !!(mph.flags&MediaPacketHeader::PN_KEYFRAME_FLAG);
  706. p->rtStart = 10000i64*(mph.tStart);
  707. p->rtStop = p->rtStart+1;
  708. p->pData.Copy(mph.pData);
  709. hr = DeliverPacket(p);
  710. }
  712. m_seekpacket = 0;
  713. m_seekfilepos = 0;
  714. }
  716. return(true);
  717. }
  719. // IKeyFrameInfo
  721. STDMETHODIMP CRealMediaSplitterFilter::GetKeyFrameCount(UINT& nKFs)
  722. {
  723. if(!m_pFile) return E_UNEXPECTED;
  724. nKFs = m_pFile->m_irs.GetCount();
  725. return S_OK;
  726. }
  728. STDMETHODIMP CRealMediaSplitterFilter::GetKeyFrames(const GUID* pFormat, REFERENCE_TIME* pKFs, UINT& nKFs)
  729. {
  730. CheckPointer(pFormat, E_POINTER);
  731. CheckPointer(pKFs, E_POINTER);
  733. if(!m_pFile) return E_UNEXPECTED;
  734. if(*pFormat != TIME_FORMAT_MEDIA_TIME) return E_INVALIDARG;
  736. UINT nKFsTmp = 0;
  737. POSITION pos = m_pFile->m_irs.GetHeadPosition();
  738. for(int i = 0; pos && nKFsTmp < nKFs; i++)
  739. pKFs[nKFsTmp++] = 10000i64*m_pFile->m_irs.GetNext(pos)->tStart;
  740. nKFs = nKFsTmp;
  742. return S_OK;
  743. }
  745. //
  746. // CRealMediaSplitterOutputPin
  747. //
  749. CRealMediaSplitterOutputPin::CRealMediaSplitterOutputPin(CArray<CMediaType>& mts, LPCWSTR pName, CBaseFilter* pFilter, CCritSec* pLock, HRESULT* phr)
  750. : CBaseSplitterOutputPin(mts, pName, pFilter, pLock, phr)
  751. {
  752. }
  754. CRealMediaSplitterOutputPin::~CRealMediaSplitterOutputPin()
  755. {
  756. }
  758. HRESULT CRealMediaSplitterOutputPin::DeliverEndFlush()
  759. {
  760. {
  761. CAutoLock cAutoLock(&m_csQueue);
  762. m_segments.Clear();
  763. }
  765. return __super::DeliverEndFlush();
  766. }
  768. HRESULT CRealMediaSplitterOutputPin::DeliverSegments()
  769. {
  770. HRESULT hr;
  772. if(m_segments.GetCount() == 0)
  773. {
  774. m_segments.Clear();
  775. return S_OK;
  776. }
  778. CAutoPtr<Packet> p(new Packet());
  780. p->TrackNumber = -1;
  781. p->bDiscontinuity = m_segments.fDiscontinuity;
  782. p->bSyncPoint = m_segments.fSyncPoint;
  783. p->rtStart = m_segments.rtStart;
  784. p->rtStop = m_segments.rtStart+1;
  786. DWORD len = 0, total = 0;
  787. POSITION pos = m_segments.GetHeadPosition();
  788. while(pos)
  789. {
  790. segment* s = m_segments.GetNext(pos);
  791. len = max(len, s->offset + s->data.GetCount());
  792. total += s->data.GetCount();
  793. }
  794. ASSERT(len == total);
  795. len += 1 + 2*4*(!m_segments.fMerged ? m_segments.GetCount() : 1);
  797. p->pData.SetSize(len);
  799. BYTE* pData = p->pData.GetData();
  801. *pData++ = m_segments.fMerged ? 0 : m_segments.GetCount()-1;
  803. if(m_segments.fMerged)
  804. {
  805. *((DWORD*)pData) = 1; pData += 4;
  806. *((DWORD*)pData) = 0; pData += 4;
  807. }
  808. else
  809. {
  810. pos = m_segments.GetHeadPosition();
  811. while(pos)
  812. {
  813. *((DWORD*)pData) = 1; pData += 4;
  814. *((DWORD*)pData) = m_segments.GetNext(pos)->offset; pData += 4;
  815. }
  816. }
  818. pos = m_segments.GetHeadPosition();
  819. while(pos)
  820. {
  821. segment* s = m_segments.GetNext(pos);
  822. memcpy(pData + s->offset, s->data.GetData(), s->data.GetCount());
  823. }
  825. hr = __super::DeliverPacket(p);
  827. m_segments.Clear();
  829. return hr;
  830. }
  832. HRESULT CRealMediaSplitterOutputPin::DeliverPacket(CAutoPtr<Packet> p)
  833. {
  834. HRESULT hr = S_OK;
  836. ASSERT(p->rtStart < p->rtStop);
  838. if(m_mt.subtype == MEDIASUBTYPE_WAVE_DOLBY_AC3)
  839. {
  840. WORD* s = (WORD*)p->pData.GetData();
  841. WORD* e = s + p->pData.GetSize()/2;
  842. while(s < e) bswap(*s++);
  843. }
  845. if(m_mt.subtype == MEDIASUBTYPE_RV10 || m_mt.subtype == MEDIASUBTYPE_RV20
  846. || m_mt.subtype == MEDIASUBTYPE_RV30 || m_mt.subtype == MEDIASUBTYPE_RV40
  847. || m_mt.subtype == MEDIASUBTYPE_RV41)
  848. {
  849. CAutoLock cAutoLock(&m_csQueue);
  851. int len = p->pData.GetCount();
  852. BYTE* pIn = p->pData.GetData();
  853. BYTE* pInOrg = pIn;
  855. if(m_segments.rtStart != p->rtStart)
  856. {
  857. if(S_OK != (hr = DeliverSegments()))
  858. return hr;
  859. }
  861. if(!m_segments.fDiscontinuity && p->bDiscontinuity)
  862. m_segments.fDiscontinuity = true;
  863. m_segments.fSyncPoint = !!p->bSyncPoint;
  864. m_segments.rtStart = p->rtStart;
  866. while(pIn - pInOrg < len)
  867. {
  868. BYTE hdr = *pIn++, subseq = 0, seqnum = 0;
  869. DWORD packetlen = 0, packetoffset = 0;
  871. if((hdr&0xc0) == 0x40)
  872. {
  873. pIn++;
  874. packetlen = len - (pIn - pInOrg);
  875. }
  876. else
  877. {
  878. if((hdr&0x40) == 0)
  879. subseq = (*pIn++)&0x7f;
  881. #define GetWORD(var) 
  882. var = (var<<8)|(*pIn++); 
  883. var = (var<<8)|(*pIn++); 
  885. GetWORD(packetlen);
  886. if(packetlen&0x8000) m_segments.fMerged = true;
  887. if((packetlen&0x4000) == 0) {GetWORD(packetlen); packetlen &= 0x3fffffff;}
  888. else packetlen &= 0x3fff;
  890. GetWORD(packetoffset);
  891. if((packetoffset&0x4000) == 0) {GetWORD(packetoffset); packetoffset &= 0x3fffffff;}
  892. else packetoffset &= 0x3fff;
  894. #undef GetWORD
  896. if((hdr&0xc0) == 0xc0)
  897. m_segments.rtStart = 10000i64*packetoffset - m_rtStart, packetoffset = 0;
  898. else if((hdr&0xc0) == 0x80)
  899. packetoffset = packetlen - packetoffset;
  901. seqnum = *pIn++;
  902. }
  904.             int len2 = min(len - (pIn - pInOrg), packetlen - packetoffset);
  906. CAutoPtr<segment> s(new segment);
  907. s->offset = packetoffset;
  908. s->data.SetSize(len2);
  909. memcpy(s->data.GetData(), pIn, len2);
  910. m_segments.AddTail(s);
  912. pIn += len2;
  914. if((hdr&0x80) || packetoffset+len2 >= packetlen)
  915. {
  916.     if(S_OK != (hr = DeliverSegments()))
  917. return hr;
  918. }
  919. }
  920. }
  921. else if(m_mt.subtype == MEDIASUBTYPE_RAAC || m_mt.subtype == MEDIASUBTYPE_RACP
  922.  || m_mt.subtype == MEDIASUBTYPE_AAC)
  923. {
  924. BYTE* ptr = p->pData.GetData()+2;
  926. CList<WORD> sizes;
  927. int total = 0;
  928. int remaining = p->pData.GetSize()-2;
  929. int expected = *(ptr-1)>>4;
  931. while(total < remaining)
  932. {
  933. int size = (ptr[0]<<8)|(ptr[1]);
  934. sizes.AddTail(size);
  935. total += size;
  936. ptr += 2;
  937. remaining -= 2;
  938. expected--;
  939. }
  941. ASSERT(total == remaining);
  942. ASSERT(expected == 0);
  944. WAVEFORMATEX* wfe = (WAVEFORMATEX*)m_mt.pbFormat;
  945. REFERENCE_TIME rtDur = 10240000000i64/wfe->nSamplesPerSec * (wfe->cbSize>2?2:1);
  946. REFERENCE_TIME rtStart = p->rtStart;
  947. BOOL bDiscontinuity = p->bDiscontinuity;
  949. POSITION pos = sizes.GetHeadPosition();
  950. while(pos)
  951. {
  952. CAutoPtr<Packet> p(new Packet);
  953. p->bDiscontinuity = bDiscontinuity;
  954. p->bSyncPoint = true;
  955. p->rtStart = rtStart;
  956. p->rtStop = rtStart + rtDur;
  957. p->pData.SetSize(sizes.GetNext(pos));
  958. memcpy(p->pData.GetData(), ptr, p->pData.GetSize());
  959. ptr += p->pData.GetSize();
  960. rtStart = p->rtStop;
  961. bDiscontinuity = false;
  962. if(S_OK != (hr = __super::DeliverPacket(p)))
  963. break;
  964. }
  965. }
  966. else
  967. {
  968. hr = __super::DeliverPacket(p);
  969. }
  971. return hr;
  972. }
  974. //
  975. // CRealMediaSourceFilter
  976. //
  978. CRealMediaSourceFilter::CRealMediaSourceFilter(LPUNKNOWN pUnk, HRESULT* phr)
  979. : CRealMediaSplitterFilter(pUnk, phr)
  980. {
  981. m_clsid = __uuidof(this);
  982. m_pInput.Free();
  983. }
  985. //
  986. // CRMFile
  987. //
  989. CRMFile::CRMFile(IAsyncReader* pAsyncReader, HRESULT& hr)
  990. : CBaseSplitterFile(pAsyncReader, hr)
  991. {
  992. if(FAILED(hr)) return;
  993. hr = Init();
  994. }
  996. template<typename T> 
  997. HRESULT CRMFile::Read(T& var)
  998. {
  999. HRESULT hr = Read((BYTE*)&var, sizeof(var));
  1000. bswap(var);
  1001. return hr;
  1002. }
  1004. HRESULT CRMFile::Read(ChunkHdr& hdr)
  1005. {
  1006. memset(&hdr, 0, sizeof(hdr));
  1007. HRESULT hr;
  1008. if(S_OK != (hr = Read(hdr.object_id))
  1009. || S_OK != (hr = Read(hdr.size))
  1010. || S_OK != (hr = Read(hdr.object_version)))
  1011. return hr;
  1012. return S_OK;
  1013. }
  1015. HRESULT CRMFile::Read(MediaPacketHeader& mph, bool fFull)
  1016. {
  1017. memset(&mph, 0, FIELD_OFFSET(MediaPacketHeader, pData));
  1018. mph.stream = -1;
  1020. HRESULT hr;
  1022. UINT16 object_version;
  1023. if(S_OK != (hr = Read(object_version))) return hr;
  1024. if(object_version != 0 && object_version != 1) return S_OK;
  1026. UINT8 flags;
  1027. if(S_OK != (hr = Read(mph.len))
  1028. || S_OK != (hr = Read(mph.stream))
  1029. || S_OK != (hr = Read(mph.tStart))
  1030. || S_OK != (hr = Read(mph.reserved))
  1031. || S_OK != (hr = Read(flags)))
  1032. return hr;
  1033. mph.flags = (MediaPacketHeader::flag_t)flags;
  1035. LONG len = mph.len;
  1036. len -= sizeof(object_version);
  1037. len -= FIELD_OFFSET(MediaPacketHeader, flags);
  1038. len -= sizeof(flags);
  1039. ASSERT(len >= 0);
  1040. len = max(len, 0);
  1042. if(fFull)
  1043. {
  1044. mph.pData.SetSize(len);
  1045. if(mph.len > 0 && S_OK != (hr = Read(mph.pData.GetData(), len)))
  1046. return hr;
  1047. }
  1048. else
  1049. {
  1050. Seek(GetPos() + len);
  1051. }
  1053. return S_OK;
  1054. }
  1057. HRESULT CRMFile::Init()
  1058. {
  1059. Seek(0);
  1061. bool fFirstChunk = true;
  1063. HRESULT hr;
  1065. ChunkHdr hdr;
  1066. while(GetPos() < GetLength() && S_OK == (hr = Read(hdr)))
  1067. {
  1068. __int64 pos = GetPos() - sizeof(hdr);
  1070. if(fFirstChunk && hdr.object_id != '.RMF')
  1071. return E_FAIL;
  1073. fFirstChunk = false;
  1075. if(pos + hdr.size > GetLength() && hdr.object_id != 'DATA') // truncated?
  1076. break;
  1078. if(hdr.object_id == 0x2E7261FD) // '.ra+0xFD'
  1079. return E_FAIL;
  1081. if(hdr.object_version == 0)
  1082. {
  1083. switch(hdr.object_id)
  1084. {
  1085. case '.RMF':
  1086. if(S_OK != (hr = Read(m_fh.version))) return hr;
  1087. if(hdr.size == 0x10) {WORD w = 0; if(S_OK != (hr = Read(w))) return hr; m_fh.nHeaders = w;}
  1088. else if(S_OK != (hr = Read(m_fh.nHeaders))) return hr;
  1089. break;
  1090. case 'CONT':
  1091. UINT16 slen;
  1092. if(S_OK != (hr = Read(slen))) return hr;
  1093. if(slen > 0 && S_OK != (hr = Read((BYTE*)m_cd.title.GetBufferSetLength(slen), slen))) return hr;
  1094. if(S_OK != (hr = Read(slen))) return hr;
  1095. if(slen > 0 && S_OK != (hr = Read((BYTE*)m_cd.author.GetBufferSetLength(slen), slen))) return hr;
  1096. if(S_OK != (hr = Read(slen))) return hr;
  1097. if(slen > 0 && S_OK != (hr = Read((BYTE*)m_cd.copyright.GetBufferSetLength(slen), slen))) return hr;
  1098. if(S_OK != (hr = Read(slen))) return hr;
  1099. if(slen > 0 && S_OK != (hr = Read((BYTE*)m_cd.comment.GetBufferSetLength(slen), slen))) return hr;
  1100. break;
  1101. case 'PROP':
  1102. if(S_OK != (hr = Read(m_p.maxBitRate))) return hr;
  1103. if(S_OK != (hr = Read(m_p.avgBitRate))) return hr;
  1104. if(S_OK != (hr = Read(m_p.maxPacketSize))) return hr;
  1105. if(S_OK != (hr = Read(m_p.avgPacketSize))) return hr;
  1106. if(S_OK != (hr = Read(m_p.nPackets))) return hr;
  1107. if(S_OK != (hr = Read(m_p.tDuration))) return hr;
  1108. if(S_OK != (hr = Read(m_p.tPreroll))) return hr;
  1109. if(S_OK != (hr = Read(m_p.ptrIndex))) return hr;
  1110. if(S_OK != (hr = Read(m_p.ptrData))) return hr;
  1111. if(S_OK != (hr = Read(m_p.nStreams))) return hr;
  1112. UINT16 flags;
  1113. if(S_OK != (hr = Read(flags))) return hr;
  1114. m_p.flags = (Properies::flags_t)flags;
  1115. break;
  1116. case 'MDPR':
  1117. {
  1118. CAutoPtr<MediaProperies> mp(new MediaProperies);
  1119. if(S_OK != (hr = Read(mp->stream))) return hr;
  1120. if(S_OK != (hr = Read(mp->maxBitRate))) return hr;
  1121. if(S_OK != (hr = Read(mp->avgBitRate))) return hr;
  1122. if(S_OK != (hr = Read(mp->maxPacketSize))) return hr;
  1123. if(S_OK != (hr = Read(mp->avgPacketSize))) return hr;
  1124. if(S_OK != (hr = Read(mp->tStart))) return hr;
  1125. if(S_OK != (hr = Read(mp->tPreroll))) return hr;
  1126. if(S_OK != (hr = Read(mp->tDuration))) return hr;
  1127. UINT8 slen;
  1128. if(S_OK != (hr = Read(slen))) return hr;
  1129. if(slen > 0 && S_OK != (hr = Read((BYTE*)mp->name.GetBufferSetLength(slen), slen))) return hr;
  1130. if(S_OK != (hr = Read(slen))) return hr;
  1131. if(slen > 0 && S_OK != (hr = Read((BYTE*)mp->mime.GetBufferSetLength(slen), slen))) return hr;
  1132. UINT32 tsdlen;
  1133. if(S_OK != (hr = Read(tsdlen))) return hr;
  1134. mp->typeSpecData.SetSize(tsdlen);
  1135. if(tsdlen > 0 && S_OK != (hr = Read(mp->typeSpecData.GetData(), tsdlen))) return hr;
  1136. mp->width = mp->height = 0;
  1137. mp->interlaced = mp->top_field_first = false;
  1138. m_mps.AddTail(mp);
  1139. break;
  1140. }
  1141. case 'DATA':
  1142. {
  1143. CAutoPtr<DataChunk> dc(new DataChunk);
  1144. if(S_OK != (hr = Read(dc->nPackets))) return hr;
  1145. if(S_OK != (hr = Read(dc->ptrNext))) return hr;
  1146. dc->pos = GetPos();
  1147. m_dcs.AddTail(dc);
  1148.                 GetDimensions();
  1149. break;
  1150. }
  1151. case 'INDX':
  1152. {
  1153. IndexChunkHeader ich;
  1154. if(S_OK != (hr = Read(ich.nIndices))) return hr;
  1155. if(S_OK != (hr = Read(ich.stream))) return hr;
  1156. if(S_OK != (hr = Read(ich.ptrNext))) return hr;
  1157. int stream = GetMasterStream();
  1158. while(ich.nIndices-- > 0)
  1159. {
  1160. UINT16 object_version;
  1161. if(S_OK != (hr = Read(object_version))) return hr;
  1162. if(object_version == 0)
  1163. {
  1164. CAutoPtr<IndexRecord> ir(new IndexRecord);
  1165. if(S_OK != (hr = Read(ir->tStart))) return hr;
  1166. if(S_OK != (hr = Read(ir->ptrFilePos))) return hr;
  1167. if(S_OK != (hr = Read(ir->packet))) return hr;
  1168. if(ich.stream == stream) m_irs.AddTail(ir);
  1169. }
  1170. }
  1171. break;
  1172. }
  1173. case '.SUB':
  1174. if(hdr.size > sizeof(hdr))
  1175. {
  1176. int size = hdr.size - sizeof(hdr);
  1177. CAutoVectorPtr<char> buff;
  1178. if(!buff.Allocate(size)) return E_OUTOFMEMORY;
  1179. char* p = buff;
  1180. if(S_OK != (hr = Read((BYTE*)p, size))) return hr;
  1181. for(char* end = p + size; p < end; )
  1182. {
  1183. subtitle s;
  1184. s.name = p; p += s.name.GetLength()+1;
  1185. CStringA len(p); p += len.GetLength()+1;
  1186. s.data = CStringA(p, strtol(len, NULL, 10)); p += s.data.GetLength();
  1187. m_subs.AddTail(s);
  1188. }
  1189. }
  1190. break;
  1191. }
  1192. }
  1194. ASSERT(hdr.object_id == 'DATA' 
  1195. || GetPos() == pos + hdr.size 
  1196. || GetPos() == pos + sizeof(hdr));
  1198. pos += hdr.size;
  1199. if(pos > GetPos()) 
  1200. Seek(pos);
  1201. }
  1203. return S_OK;
  1204. }
  1206. #define GetBits(n) GetBits2(n, p, bit_offset, bit_buffer)
  1208. unsigned int GetBits2(int n, unsigned char*& p, unsigned int& bit_offset, unsigned int& bit_buffer)
  1209. {
  1210. unsigned int ret = ((unsigned int)bit_buffer >> (32-(n)));
  1212. bit_offset += n;
  1213. bit_buffer <<= n;
  1214. if(bit_offset > (32-16))
  1215. {
  1216. p += bit_offset >> 3;
  1217. bit_offset &= 7;
  1218. bit_buffer = (unsigned int)p[0] << 24;
  1219. bit_buffer |= (unsigned int)p[1] << 16;
  1220. bit_buffer |= (unsigned int)p[2] << 8;
  1221. bit_buffer |= (unsigned int)p[3];
  1222. bit_buffer <<= bit_offset;
  1223. }
  1225.     return ret;
  1226. }
  1228. void GetDimensions(unsigned char* p, unsigned int* wi, unsigned int* hi)
  1229. {
  1230. unsigned int w, h, c;
  1232. const unsigned int cw[8] = {160, 176, 240, 320, 352, 640, 704, 0};
  1233. const unsigned int ch1[8] = {120, 132, 144, 240, 288, 480, 0, 0};
  1234. const unsigned int ch2[4] = {180, 360, 576, 0};
  1236. unsigned int bit_offset = 0;
  1237. unsigned int bit_buffer = *(unsigned int*)p;
  1238. bswap(bit_buffer);
  1240.     GetBits(13);
  1242. GetBits(13);
  1244. w = cw[GetBits(3)];
  1245. if(w == 0)
  1246. {
  1247. do
  1248. {
  1249. c = GetBits(8);
  1250. w += (c << 2);
  1251. }
  1252. while(c == 255);
  1253. }
  1255. c = GetBits(3);
  1257. h = ch1[c];
  1258. if(h == 0)
  1259. {
  1260. c = ((c << 1) | GetBits(1)) & 3;
  1262. h = ch2[c];
  1263. if(h == 0)
  1264. {
  1265. do
  1266. {
  1267. c = GetBits(8);
  1268. h += (c << 2);
  1269. }
  1270. while(c == 255);
  1271. }
  1272. }
  1274. *wi = w;
  1275. *hi = h;    
  1276. }
  1278. void GetDimensions_X10(unsigned char* p, unsigned int* wi, unsigned int* hi, 
  1279.    bool *interlaced, bool *top_field_first, bool *repeat_field)
  1280. {
  1281. unsigned int w, h, c;
  1283. const unsigned int cw[8] = {160, 176, 240, 320, 352, 640, 704, 0};
  1284. const unsigned int ch1[8] = {120, 132, 144, 240, 288, 480, 0, 0};
  1285. const unsigned int ch2[4] = {180, 360, 576, 0};
  1287. unsigned int bit_offset = 0;
  1288. unsigned int bit_buffer = *(unsigned int*)p;
  1289. bswap(bit_buffer);
  1291.     GetBits(9);
  1293. *interlaced = false;
  1294. *top_field_first = false;
  1295. *repeat_field = false;
  1296. c = GetBits(1);
  1297. if (c)
  1298. {
  1299. c = GetBits(1);
  1300. if (c)
  1301. *interlaced = true;
  1302. c = GetBits(1);
  1303. if (c)
  1304. *top_field_first = true;
  1305. c = GetBits(1); 
  1306. if (c)
  1307. *repeat_field = true; 
  1309. c = GetBits(1);
  1310. c = GetBits(1);
  1311. if (c)
  1312. GetBits(2);
  1313. }
  1315. GetBits(16);
  1317. w = cw[GetBits(3)];
  1318. if(w == 0)
  1319. {
  1320. do
  1321. {
  1322. c = GetBits(8);
  1323. w += (c << 2);
  1324. }
  1325. while(c == 255);
  1326. }
  1328. c = GetBits(3);
  1330. h = ch1[c];
  1331. if(h == 0)
  1332. {
  1333. c = ((c << 1) | GetBits(1)) & 3;
  1335. h = ch2[c];
  1336. if(h == 0)
  1337. {
  1338. do
  1339. {
  1340. c = GetBits(8);
  1341. h += (c << 2);
  1342. }
  1343. while(c == 255);
  1344. }
  1345. }
  1347. *wi = w;
  1348. *hi = h;    
  1349. }
  1351. void CRMFile::GetDimensions()
  1352. {
  1353. POSITION pos = m_mps.GetHeadPosition();
  1354. while(pos)
  1355. {
  1356. UINT64 filepos = GetPos();
  1358. MediaProperies* pmp = m_mps.GetNext(pos);
  1359. if(pmp->mime == "video/x-pn-realvideo")
  1360. {
  1361. pmp->width = pmp->height = 0;
  1363. rvinfo rvi = *(rvinfo*)pmp->typeSpecData.GetData();
  1364. rvi.bswap();
  1366. if(rvi.fcc2 != '04VR' && rvi.fcc2 != '14VR')
  1367. continue;
  1369. MediaPacketHeader mph;
  1370. while(S_OK == Read(mph))
  1371. {
  1372. if(mph.stream != pmp->stream || mph.len == 0
  1373. || !(mph.flags&MediaPacketHeader::PN_KEYFRAME_FLAG))
  1374. continue;
  1376. BYTE* p = mph.pData.GetData();
  1377. BYTE* p0 = p;
  1378. int len = mph.pData.GetCount();
  1380. BYTE hdr = *p++;
  1381. DWORD packetlen = 0, packetoffset = 0;
  1383. if((hdr&0xc0) == 0x40)
  1384. {
  1385. packetlen = len - (++p - p0);
  1386. }
  1387. else
  1388. {
  1389. if((hdr&0x40) == 0) p++;
  1391. #define GetWORD(var) 
  1392. var = (var<<8)|(*p++); 
  1393. var = (var<<8)|(*p++); 
  1395. GetWORD(packetlen);
  1396. if((packetlen&0x4000) == 0) {GetWORD(packetlen); packetlen &= 0x3fffffff;}
  1397. else packetlen &= 0x3fff;
  1399. GetWORD(packetoffset);
  1400. if((packetoffset&0x4000) == 0) {GetWORD(packetoffset); packetoffset &= 0x3fffffff;}
  1401. else packetoffset &= 0x3fff;
  1403. #undef GetWORD
  1405. if((hdr&0xc0) == 0xc0) packetoffset = 0;
  1406. else if((hdr&0xc0) == 0x80) packetoffset = packetlen - packetoffset;
  1408. p++;
  1409. }
  1411. len = min(len - (p - p0), packetlen - packetoffset);
  1413. if(len > 0)
  1414. {
  1415. bool repeat_field;
  1416. if(rvi.fcc2 == '14VR') ::GetDimensions_X10(p, &pmp->width, &pmp->height, &pmp->interlaced, &pmp->top_field_first, &repeat_field);
  1417. else ::GetDimensions(p, &pmp->width, &pmp->height);
  1419. if(rvi.w == pmp->width && rvi.h == pmp->height)
  1420. pmp->width = pmp->height = 0;
  1422. break;
  1423. }
  1424. }
  1425. }
  1427. Seek(filepos);
  1428. }
  1429. }
  1431. int CRMFile::GetMasterStream()
  1432. {
  1433. int s1 = -1, s2 = -1;
  1435. POSITION pos = m_mps.GetHeadPosition();
  1436. while(pos)
  1437. {
  1438. MediaProperies* pmp = m_mps.GetNext(pos);
  1439. if(pmp->mime == "video/x-pn-realvideo") {s1 = pmp->stream; break;}
  1440. else if(pmp->mime == "audio/x-pn-realaudio" && s2 == -1) s2 = pmp->stream;
  1441. }
  1443. if(s1 == -1)
  1444. s1 = s2;
  1446. return s1;
  1447. }
  1450. ////////////////////////////
  1452. //
  1453. // CRealVideoDecoder
  1454. //
  1456. CRealVideoDecoder::CRealVideoDecoder(LPUNKNOWN lpunk, HRESULT* phr)
  1457. : CBaseVideoFilter(NAME("CRealVideoDecoder"), lpunk, phr, __uuidof(this))
  1458. , m_hDrvDll(NULL)
  1459. , m_dwCookie(0)
  1460. {
  1461. }
  1463. CRealVideoDecoder::~CRealVideoDecoder()
  1464. {
  1465. if(m_hDrvDll) FreeLibrary(m_hDrvDll);
  1466. }
  1468. HRESULT CRealVideoDecoder::InitRV(const CMediaType* pmt)
  1469. {
  1470. FreeRV();
  1472. HRESULT hr = VFW_E_TYPE_NOT_ACCEPTED;
  1474. rvinfo rvi = *(rvinfo*)(pmt->Format() + (pmt->formattype == FORMAT_VideoInfo ? sizeof(VIDEOINFOHEADER) : sizeof(VIDEOINFOHEADER2)));
  1475. rvi.bswap();
  1477. #pragma pack(push, 1)
  1478. struct {WORD unk1, w, h, unk3; DWORD unk2, subformat, unk5, format;} i =
  1479. {11, rvi.w, rvi.h, 0, 0, rvi.type1, 1, rvi.type2};
  1480. #pragma pack(pop)
  1482. if(FAILED(hr = RVInit(&i, &m_dwCookie)))
  1483. return hr;
  1485. if(rvi.fcc2 <= '03VR' && rvi.type2 >= 0x20200002)
  1486. {
  1487. int nWidthHeight = (1+((rvi.type1>>16)&7));
  1488. UINT32* pWH = new UINT32[nWidthHeight*2];
  1489. pWH[0] = rvi.w; pWH[1] = rvi.h;
  1490. for(int i = 2; i < nWidthHeight*2; i++)
  1491. pWH[i] = rvi.morewh[i-2]*4;
  1492. #pragma pack(push, 1)
  1493. struct {UINT32 data1; UINT32 data2; UINT32* dimensions;} cmsg_data = 
  1494. {0x24, nWidthHeight, pWH};
  1495. #pragma pack(pop)
  1496. hr = RVCustomMessage(&cmsg_data, m_dwCookie);
  1497. delete [] pWH;
  1498. }
  1500. return hr;
  1501. }
  1503. void CRealVideoDecoder::FreeRV()
  1504. {
  1505. if(m_dwCookie)
  1506. {
  1507. RVFree(m_dwCookie);
  1508. m_dwCookie = 0;
  1509. }
  1510. }
  1512. HRESULT CRealVideoDecoder::Transform(IMediaSample* pIn)
  1513. {
  1514. CAutoLock cAutoLock(&m_csReceive);
  1516. HRESULT hr;
  1518. BYTE* pDataIn = NULL;
  1519. if(FAILED(hr = pIn->GetPointer(&pDataIn)))
  1520. return hr;
  1522. long len = pIn->GetActualDataLength();
  1523. if(len <= 0) return S_OK; // nothing to do
  1525. REFERENCE_TIME rtStart, rtStop;
  1526. pIn->GetTime(&rtStart, &rtStop);
  1528. rtStart += m_tStart;
  1530. int offset = 1+((*pDataIn)+1)*8;
  1532. #pragma pack(push, 1)
  1533. struct {DWORD len, unk1, chunks; DWORD* extra; DWORD unk2, timestamp;} transform_in = 
  1534. {len - offset, 0, *pDataIn, (DWORD*)(pDataIn+1), 0, (DWORD)(rtStart/10000)};
  1535. struct {DWORD unk1, unk2, timestamp, w, h;} transform_out = 
  1536. {0,0,0,0,0};
  1537. #pragma pack(pop)
  1539. pDataIn += offset;
  1541. if(m_fDropFrames && m_timestamp+1 == transform_in.timestamp)
  1542. {
  1543. m_timestamp = transform_in.timestamp;
  1544. return S_OK;
  1545. }
  1547. hr = RVTransform(pDataIn, (BYTE*)m_pI420, &transform_in, &transform_out, m_dwCookie);
  1549. unsigned int tmp1, tmp2;
  1550. bool interlaced = false, tmp3, tmp4;
  1551. ::GetDimensions_X10(pDataIn, &tmp1, &tmp2, &interlaced, &tmp3, &tmp4);
  1553. m_timestamp = transform_in.timestamp;
  1555. if(FAILED(hr))
  1556. {
  1557. TRACE(_T("RV returned an error code!!!n"));
  1558. ASSERT(!(transform_out.unk1&1)); // error allowed when the "render" flag is not set
  1559. // return hr;
  1560. }
  1562. if(pIn->IsPreroll() == S_OK || rtStart < 0 || !(transform_out.unk1&1))
  1563. return S_OK;
  1565. CComPtr<IMediaSample> pOut;
  1566. BYTE* pDataOut = NULL;
  1567. if(/*FAILED(hr = GetDeliveryBuffer(transform_out.w, transform_out.h, &pOut)) // TODO
  1568. && */ FAILED(hr = GetDeliveryBuffer(m_w, m_h, &pOut))
  1569. || FAILED(hr = pOut->GetPointer(&pDataOut)))
  1570. return hr;
  1572. BYTE* pI420[3] = {m_pI420, m_pI420Tmp, NULL};
  1574. if(interlaced)
  1575. {
  1576. int size = m_w*m_h;
  1577. DeinterlaceBlend(pI420[1], pI420[0], m_w, m_h, m_w, m_w);
  1578. DeinterlaceBlend(pI420[1]+size, pI420[0]+size, m_w/2, m_h/2, m_w/2, m_w/2);
  1579. DeinterlaceBlend(pI420[1]+size*5/4, pI420[0]+size*5/4, m_w/2, m_h/2, m_w/2, m_w/2);
  1580. pI420[2] = pI420[1], pI420[1] = pI420[0], pI420[0] = pI420[2];
  1581. }
  1583. if(transform_out.w != m_w || transform_out.h != m_h)
  1584. {
  1585. Resize(pI420[0], transform_out.w, transform_out.h, pI420[1], m_w, m_h);
  1586. // only one of these can be true, and when it happens the result image must be in the tmp buffer
  1587. if(transform_out.w == m_w || transform_out.h == m_h)
  1588. pI420[2] = pI420[1], pI420[1] = pI420[0], pI420[0] = pI420[2];
  1589. }
  1591. rtStart = 10000i64*transform_out.timestamp - m_tStart;
  1592. rtStop = rtStart + 1;
  1593. pOut->SetTime(&rtStart, /*NULL*/&rtStop);
  1595. pOut->SetDiscontinuity(pIn->IsDiscontinuity() == S_OK);
  1597. CopyBuffer(pDataOut, pI420[0], m_w, m_h, m_w, MEDIASUBTYPE_I420);
  1599. DbgLog((LOG_TRACE, 0, _T("V: rtStart=%I64d, rtStop=%I64d, disc=%d, sync=%d"), 
  1600.    rtStart, rtStop, pOut->IsDiscontinuity() == S_OK, pOut->IsSyncPoint() == S_OK));
  1602. return m_pOutput->Deliver(pOut);
  1603. }
  1605. void CRealVideoDecoder::Resize(BYTE* pIn, DWORD wi, DWORD hi, BYTE* pOut, DWORD wo, DWORD ho)
  1606. {
  1607. int si = wi*hi, so = wo*ho;
  1608. ASSERT(((si*so)&3) == 0);
  1610. if(wi < wo)
  1611. {
  1612. ResizeWidth(pIn, wi, hi, pOut, wo, ho);
  1613. ResizeWidth(pIn + si, wi/2, hi/2, pOut + so, wo/2, ho/2);
  1614. ResizeWidth(pIn + si + si/4, wi/2, hi/2, pOut + so + so/4, wo/2, ho/2);
  1615. if(hi == ho) return; 
  1616. ResizeHeight(pOut, wo, hi, pIn, wo, ho);
  1617. ResizeHeight(pOut + so, wo/2, hi/2, pIn + so, wo/2, ho/2);
  1618. ResizeHeight(pOut + so + so/4, wo/2, hi/2, pIn + so + so/4, wo/2, ho/2);
  1619. }
  1620. else if(hi < ho)
  1621. {
  1622. ResizeHeight(pIn, wi, hi, pOut, wo, ho);
  1623. ResizeHeight(pIn + si, wi/2, hi/2, pOut + so, wo/2, ho/2);
  1624. ResizeHeight(pIn + si + si/4, wi/2, hi/2, pOut + so + so/4, wo/2, ho/2);
  1625. if(wi == wo) return;
  1626. ASSERT(0); // this is uncreachable code, but anyway... looks nice being so symmetric
  1627. ResizeWidth(pOut, wi, ho, pIn, wo, ho);
  1628. ResizeWidth(pOut + so, wi/2, ho/2, pIn + so, wo/2, ho/2);
  1629. ResizeWidth(pOut + so + so/4, wi/2, ho/2, pIn + so + so/4, wo/2, ho/2);
  1630. }
  1631. }
  1633. void CRealVideoDecoder::ResizeWidth(BYTE* pIn, DWORD wi, DWORD hi, BYTE* pOut, DWORD wo, DWORD ho)
  1634. {
  1635. for(DWORD y = 0; y < hi; y++, pIn += wi, pOut += wo)
  1636. {
  1637. if(wi == wo) memcpy_accel(pOut, pIn, wo);
  1638. else ResizeRow(pIn, wi, 1, pOut, wo, 1);
  1639. }
  1640. }
  1642. void CRealVideoDecoder::ResizeHeight(BYTE* pIn, DWORD wi, DWORD hi, BYTE* pOut, DWORD wo, DWORD ho)
  1643. {
  1644. if(hi == ho) 
  1645. {
  1646. memcpy_accel(pOut, pIn, wo*ho);
  1647. }
  1648. else
  1649. {
  1650. for(DWORD x = 0; x < wo; x++, pIn++, pOut++)
  1651. ResizeRow(pIn, hi, wo, pOut, ho, wo);
  1652. }
  1653. }
  1655. void CRealVideoDecoder::ResizeRow(BYTE* pIn, DWORD wi, DWORD dpi, BYTE* pOut, DWORD wo, DWORD dpo)
  1656. {
  1657. ASSERT(wi < wo);
  1659.     if(dpo == 1)
  1660. {
  1661. for(DWORD i = 0, j = 0, dj = (wi<<16)/wo; i < wo-1; i++, pOut++, j += dj)
  1662. // pOut[i] = pIn[j>>16];
  1663. {
  1664. BYTE* p = &pIn[j>>16];
  1665. DWORD jf = j&0xffff;
  1666. *pOut = ((p[0]*(0xffff-jf) + p[1]*jf) + 0x7fff) >> 16;
  1667. }
  1669. *pOut = pIn[wi-1];
  1670. }
  1671. else
  1672. {
  1673. for(DWORD i = 0, j = 0, dj = (wi<<16)/wo; i < wo-1; i++, pOut += dpo, j += dj)
  1674. // *pOut = pIn[dpi*(j>>16)];
  1675. {
  1676. BYTE* p = &pIn[dpi*(j>>16)];
  1677. DWORD jf = j&0xffff;
  1678. *pOut = ((p[0]*(0xffff-jf) + p[dpi]*jf) + 0x7fff) >> 16;
  1679. }
  1681. *pOut = pIn[dpi*(wi-1)];
  1682. }
  1683. }
  1685. HRESULT CRealVideoDecoder::CheckInputType(const CMediaType* mtIn)
  1686. {
  1687. if(mtIn->majortype != MEDIATYPE_Video 
  1688. || mtIn->subtype != MEDIASUBTYPE_RV20
  1689. && mtIn->subtype != MEDIASUBTYPE_RV30 
  1690. && mtIn->subtype != MEDIASUBTYPE_RV40
  1691. && mtIn->subtype != MEDIASUBTYPE_RV41)
  1692. return VFW_E_TYPE_NOT_ACCEPTED;
  1694. if(mtIn->formattype == FORMAT_VideoInfo2)
  1695. {
  1696. VIDEOINFOHEADER2* vih2 = (VIDEOINFOHEADER2*)mtIn->Format();
  1697. if(vih2->dwPictAspectRatioX < vih2->bmiHeader.biWidth
  1698. || vih2->dwPictAspectRatioY < vih2->bmiHeader.biHeight)
  1699. return VFW_E_TYPE_NOT_ACCEPTED;
  1700. }
  1702. if(!m_pInput->IsConnected())
  1703. {
  1704. if(m_hDrvDll) {FreeLibrary(m_hDrvDll); m_hDrvDll = NULL;}
  1706. CList<CString> paths;
  1707. CString olddll, newdll, oldpath, newpath;
  1709. olddll.Format(_T("drv%c3260.dll"), (TCHAR)((mtIn->subtype.Data1>>16)&0xff));
  1710. newdll = 
  1711. mtIn->subtype == FOURCCMap('14VR') ? _T("drvi.dll") :
  1712. mtIn->subtype == FOURCCMap('02VR') ? _T("drv2.dll") :
  1713. _T("drvc.dll");
  1715. CRegKey key;
  1716. TCHAR buff[MAX_PATH];
  1717. ULONG len = sizeof(buff);
  1718. if(ERROR_SUCCESS == key.Open(HKEY_CLASSES_ROOT, _T("Software\RealNetworks\Preferences\DT_Codecs"), KEY_READ)
  1719. && ERROR_SUCCESS == key.QueryStringValue(NULL, buff, &len) && _tcslen(buff) > 0)
  1720. {
  1721. oldpath = buff;
  1722. TCHAR c = oldpath[oldpath.GetLength()-1];
  1723. if(c != '\' && c != '/') oldpath += '\';
  1724. key.Close();
  1725. }
  1726. len = sizeof(buff);
  1727. if(ERROR_SUCCESS == key.Open(HKEY_CLASSES_ROOT, _T("Helix\HelixSDK\10.0\Preferences\DT_Codecs"), KEY_READ)
  1728. && ERROR_SUCCESS == key.QueryStringValue(NULL, buff, &len) && _tcslen(buff) > 0)
  1729. {
  1730. newpath = buff;
  1731. TCHAR c = newpath[newpath.GetLength()-1];
  1732. if(c != '\' && c != '/') newpath += '\';
  1733. key.Close();
  1734. }
  1736. if(!newpath.IsEmpty()) paths.AddTail(newpath + newdll);
  1737. if(!oldpath.IsEmpty()) paths.AddTail(oldpath + newdll);
  1738. paths.AddTail(newdll); // default dll paths
  1739. if(!newpath.IsEmpty()) paths.AddTail(newpath + olddll);
  1740. if(!oldpath.IsEmpty()) paths.AddTail(oldpath + olddll);
  1741. paths.AddTail(olddll); // default dll paths
  1743. POSITION pos = paths.GetHeadPosition();
  1744. while(pos && !(m_hDrvDll = LoadLibrary(paths.GetNext(pos))));
  1746. if(m_hDrvDll)
  1747. {
  1748. RVCustomMessage = (PRVCustomMessage)GetProcAddress(m_hDrvDll, "RV20toYUV420CustomMessage");
  1749. RVFree = (PRVFree)GetProcAddress(m_hDrvDll, "RV20toYUV420Free");
  1750. RVHiveMessage = (PRVHiveMessage)GetProcAddress(m_hDrvDll, "RV20toYUV420HiveMessage");
  1751. RVInit = (PRVInit)GetProcAddress(m_hDrvDll, "RV20toYUV420Init");
  1752. RVTransform = (PRVTransform)GetProcAddress(m_hDrvDll, "RV20toYUV420Transform");
  1754. if(!RVCustomMessage) RVCustomMessage = (PRVCustomMessage)GetProcAddress(m_hDrvDll, "RV40toYUV420CustomMessage");
  1755. if(!RVFree) RVFree = (PRVFree)GetProcAddress(m_hDrvDll, "RV40toYUV420Free");
  1756. if(!RVHiveMessage) RVHiveMessage = (PRVHiveMessage)GetProcAddress(m_hDrvDll, "RV40toYUV420HiveMessage");
  1757. if(!RVInit) RVInit = (PRVInit)GetProcAddress(m_hDrvDll, "RV40toYUV420Init");
  1758. if(!RVTransform) RVTransform = (PRVTransform)GetProcAddress(m_hDrvDll, "RV40toYUV420Transform");
  1759. }
  1761. if(!m_hDrvDll || !RVCustomMessage 
  1762. || !RVFree || !RVHiveMessage
  1763. || !RVInit || !RVTransform)
  1764. return VFW_E_TYPE_NOT_ACCEPTED;
  1766. if(FAILED(InitRV(mtIn)))
  1767. return VFW_E_TYPE_NOT_ACCEPTED;
  1768. }
  1770. return S_OK;
  1771. }
  1773. HRESULT CRealVideoDecoder::CheckTransform(const CMediaType* mtIn, const CMediaType* mtOut)
  1774. {
  1775. if(m_pOutput && m_pOutput->IsConnected())
  1776. {
  1777. BITMAPINFOHEADER bih1, bih2;
  1778. if(ExtractBIH(mtOut, &bih1) && ExtractBIH(&m_pOutput->CurrentMediaType(), &bih2)
  1779. && abs(bih1.biHeight) != abs(bih2.biHeight))
  1780. return VFW_E_TYPE_NOT_ACCEPTED;
  1781. }
  1783. return __super::CheckTransform(mtIn, mtOut);
  1784. }
  1786. HRESULT CRealVideoDecoder::StartStreaming()
  1787. {
  1788. const CMediaType& mt = m_pInput->CurrentMediaType();
  1789. if(FAILED(InitRV(&mt)))
  1790. return E_FAIL;
  1792. int size = m_w*m_h;
  1793. m_pI420.Allocate(size*3/2);
  1794. memset(m_pI420, 0, size);
  1795. memset(m_pI420 + size, 0x80, size/2);
  1796. m_pI420Tmp.Allocate(size*3/2);
  1797. memset(m_pI420Tmp, 0, size);
  1798. memset(m_pI420Tmp + size, 0x80, size/2);
  1800. return __super::StartStreaming();
  1801. }
  1803. HRESULT CRealVideoDecoder::StopStreaming()
  1804. {
  1805. m_pI420.Free();
  1806. m_pI420Tmp.Free();
  1808. FreeRV();
  1810. return __super::StopStreaming();
  1811. }
  1813. HRESULT CRealVideoDecoder::NewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
  1814. {
  1815. CAutoLock cAutoLock(&m_csReceive);
  1817. m_timestamp = ~0;
  1818. m_fDropFrames = false;
  1820. DWORD tmp[2] = {20, 0};
  1821. RVHiveMessage(tmp, m_dwCookie);
  1823. m_tStart = tStart;
  1824. return __super::NewSegment(tStart, tStop, dRate);
  1825. }
  1827. HRESULT CRealVideoDecoder::AlterQuality(Quality q)
  1828. {
  1829. if(q.Late > 500*10000i64) m_fDropFrames = true;
  1830. if(q.Late <= 0) m_fDropFrames = false;
  1831. // TRACE(_T("CRealVideoDecoder::AlterQuality: Type=%d, Proportion=%d, Late=%I64d, TimeStamp=%I64dn"), q.Type, q.Proportion, q.Late, q.TimeStamp);
  1832. return E_NOTIMPL;
  1833. }
  1835. /////////////////////////
  1837. //
  1838. // CRealAudioDecoder
  1839. //
  1841. CRealAudioDecoder::CRealAudioDecoder(LPUNKNOWN lpunk, HRESULT* phr)
  1842. : CTransformFilter(NAME("CRealAudioDecoder"), lpunk, __uuidof(this))
  1843. , m_hDrvDll(NULL)
  1844. , m_dwCookie(0)
  1845. {
  1846. if(phr) *phr = S_OK;
  1847. }
  1849. CRealAudioDecoder::~CRealAudioDecoder()
  1850. {
  1851. // FreeRA();
  1852. if(m_hDrvDll) FreeLibrary(m_hDrvDll);
  1853. }
  1855. HRESULT CRealAudioDecoder::InitRA(const CMediaType* pmt)
  1856. {
  1857. FreeRA();
  1859. HRESULT hr = VFW_E_TYPE_NOT_ACCEPTED;
  1861. if(RAOpenCodec2 && FAILED(hr = RAOpenCodec2(&m_dwCookie, m_dllpath))
  1862. || RAOpenCodec && FAILED(hr = RAOpenCodec(&m_dwCookie)))
  1863. return hr;
  1865. WAVEFORMATEX* pwfe = (WAVEFORMATEX*)pmt->Format();
  1867. // someone might be doing cbSize = sizeof(WAVEFORMATEX), chances of 
  1868. // cbSize being really sizeof(WAVEFORMATEX) is less than this, 
  1869. // especially with our rm splitter ;)
  1870. DWORD cbSize = pwfe->cbSize;
  1871. if(cbSize == sizeof(WAVEFORMATEX)) {ASSERT(0); cbSize = 0;}
  1873. WORD wBitsPerSample = pwfe->wBitsPerSample;
  1874. if(!wBitsPerSample) wBitsPerSample = 16;
  1876. #pragma pack(push, 1)
  1877. struct {DWORD freq; WORD bpsample, channels, quality; DWORD bpframe, packetsize, extralen; void* extra;} initdata =
  1878. {pwfe->nSamplesPerSec, wBitsPerSample, pwfe->nChannels, 100, 
  1879. 0, 0, 0, NULL};
  1880. #pragma pack(pop)
  1882. CAutoVectorPtr<BYTE> pBuff;
  1884. if(pmt->subtype == MEDIASUBTYPE_AAC)
  1885. {
  1886. pBuff.Allocate(cbSize+1);
  1887. pBuff[0] = 0x02;
  1888. memcpy(pBuff+1, pwfe+1, cbSize);
  1889. initdata.extralen = cbSize+1;
  1890. initdata.extra = pBuff;
  1891. }
  1892. else
  1893. {
  1894. if(pmt->FormatLength() <= sizeof(WAVEFORMATEX) + cbSize) // must have type_specific_data appended
  1895. return hr;
  1897. BYTE* fmt = pmt->Format() + sizeof(WAVEFORMATEX) + cbSize;
  1899. for(int i = 0, len = pmt->FormatLength() - (sizeof(WAVEFORMATEX) + cbSize); i < len-4; i++, fmt++)
  1900. {
  1901. if(fmt[0] == '.' || fmt[1] == 'r' || fmt[2] == 'a')
  1902. break;
  1903. }
  1905. m_rai = *(rainfo*)fmt;
  1906. m_rai.bswap();
  1908. BYTE* p;
  1910. if(m_rai.version2 == 4)
  1911. {
  1912. p = (BYTE*)((rainfo4*)fmt+1);
  1913. int len = *p++; p += len; len = *p++; p += len; 
  1914. ASSERT(len == 4);
  1915. }
  1916. else if(m_rai.version2 == 5)
  1917. {
  1918. p = (BYTE*)((rainfo5*)fmt+1);
  1919. }
  1920. else
  1921. {
  1922. return hr;
  1923. }
  1925. p += 3;
  1926. if(m_rai.version2 == 5) p++;
  1928. initdata.bpframe = m_rai.sub_packet_size;
  1929. initdata.packetsize = m_rai.coded_frame_size;
  1930. initdata.extralen = *(DWORD*)p;
  1931. initdata.extra = p + 4;
  1932. }
  1934. if(FAILED(hr = RAInitDecoder(m_dwCookie, &initdata)))
  1935. return hr;
  1937. if(RASetPwd)
  1938. RASetPwd(m_dwCookie, "Ardubancel Quazanga");
  1940. if(RASetFlavor && FAILED(hr = RASetFlavor(m_dwCookie, m_rai.flavor)))
  1941. return hr;
  1943. return hr;
  1944. }
  1946. void CRealAudioDecoder::FreeRA()
  1947. {
  1948. if(m_dwCookie)
  1949. {
  1950. RAFreeDecoder(m_dwCookie);
  1951. RACloseCodec(m_dwCookie);
  1952. m_dwCookie = 0;
  1953. }
  1954. }
  1956. HRESULT CRealAudioDecoder::Receive(IMediaSample* pIn)
  1957. {
  1958. CAutoLock cAutoLock(&m_csReceive);
  1960. HRESULT hr;
  1962.     AM_SAMPLE2_PROPERTIES* const pProps = m_pInput->SampleProps();
  1963.     if(pProps->dwStreamId != AM_STREAM_MEDIA)
  1964. return m_pOutput->Deliver(pIn);
  1966. BYTE* pDataIn = NULL;
  1967. if(FAILED(hr = pIn->GetPointer(&pDataIn))) return hr;
  1968. BYTE* pDataInOrg = pDataIn;
  1970. long len = pIn->GetActualDataLength();
  1971. if(len <= 0) return S_OK;
  1973. REFERENCE_TIME rtStart, rtStop;
  1974. pIn->GetTime(&rtStart, &rtStop);
  1975. /*
  1976. if(pIn->IsPreroll() == S_OK || rtStart < 0)
  1977. return S_OK;
  1978. */
  1979. //
  1981. if(S_OK == pIn->IsSyncPoint())
  1982. {
  1983. m_bufflen = 0;
  1984. m_rtBuffStart = rtStart;
  1985. m_fBuffDiscontinuity = pIn->IsDiscontinuity() == S_OK;
  1986. }
  1988. BYTE* src = NULL;
  1989. BYTE* dst = NULL;
  1991. int w = m_rai.coded_frame_size;
  1992. int h = m_rai.sub_packet_h;
  1993. int sps = m_rai.sub_packet_size;
  1995. if(m_pInput->CurrentMediaType().subtype == MEDIASUBTYPE_RAAC
  1996. || m_pInput->CurrentMediaType().subtype == MEDIASUBTYPE_RACP
  1997. || m_pInput->CurrentMediaType().subtype == MEDIASUBTYPE_AAC)
  1998. {
  1999. src = pDataIn;
  2000. dst = pDataIn + len;
  2001. w = len;
  2002. }
  2003. else
  2004. {
  2005. memcpy(&m_buff[m_bufflen], pDataIn, len);
  2006. m_bufflen += len;
  2008. len = w*h;
  2010. if(m_bufflen >= len)
  2011. {
  2012. ASSERT(m_bufflen == len);
  2014. src = m_buff;
  2015. dst = m_buff + len;
  2017. if(sps > 0
  2018. && (m_pInput->CurrentMediaType().subtype == MEDIASUBTYPE_COOK
  2019. || m_pInput->CurrentMediaType().subtype == MEDIASUBTYPE_ATRC))
  2020. {
  2021. for(int y = 0; y < h; y++)
  2022. {
  2023. for(int x = 0, w2 = w / sps; x < w2; x++)
  2024. {
  2025. // TRACE(_T("--- %d, %dn"), (h*x+((h+1)/2)*(y&1)+(y>>1)), sps*(h*x+((h+1)/2)*(y&1)+(y>>1)));
  2026. memcpy(dst + sps*(h*x+((h+1)/2)*(y&1)+(y>>1)), src, sps);
  2027. src += sps;
  2028. }
  2029. }
  2031. src = m_buff + len;
  2032. dst = m_buff + len*2;
  2033. }
  2034. else if(m_pInput->CurrentMediaType().subtype == MEDIASUBTYPE_SIPR)
  2035. {
  2036. // http://mplayerhq.hu/pipermail/mplayer-dev-eng/2002-August/010569.html
  2038. static BYTE sipr_swaps[38][2]={
  2039. {0,63},{1,22},{2,44},{3,90},{5,81},{7,31},{8,86},{9,58},{10,36},{12,68},
  2040. {13,39},{14,73},{15,53},{16,69},{17,57},{19,88},{20,34},{21,71},{24,46},
  2041. {25,94},{26,54},{28,75},{29,50},{32,70},{33,92},{35,74},{38,85},{40,56},
  2042. {42,87},{43,65},{45,59},{48,79},{49,93},{51,89},{55,95},{61,76},{67,83},
  2043. {77,80} };
  2045. int bs=h*w*2/96; // nibbles per subpacket
  2046. for(int n=0;n<38;n++){
  2047. int i=bs*sipr_swaps[n][0];
  2048. int o=bs*sipr_swaps[n][1];
  2049. // swap nibbles of block 'i' with 'o'      TODO: optimize
  2050. for(int j=0;j<bs;j++){
  2051. int x=(i&1) ? (src[(i>>1)]>>4) : (src[(i>>1)]&15);
  2052. int y=(o&1) ? (src[(o>>1)]>>4) : (src[(o>>1)]&15);
  2053. if(o&1) src[(o>>1)]=(src[(o>>1)]&0x0F)|(x<<4);
  2054. else  src[(o>>1)]=(src[(o>>1)]&0xF0)|x;
  2055. if(i&1) src[(i>>1)]=(src[(i>>1)]&0x0F)|(y<<4);
  2056. else  src[(i>>1)]=(src[(i>>1)]&0xF0)|y;
  2057. ++i;++o;
  2058. }
  2059. }
  2060. }
  2062. m_bufflen = 0;
  2063. }
  2064. }
  2066. rtStart = m_rtBuffStart;
  2068. for(; src < dst; src += w)
  2069. {
  2070. CComPtr<IMediaSample> pOut;
  2071. BYTE* pDataOut = NULL;
  2072. if(FAILED(hr = m_pOutput->GetDeliveryBuffer(&pOut, NULL, NULL, 0))
  2073. || FAILED(hr = pOut->GetPointer(&pDataOut)))
  2074. return hr;
  2076. AM_MEDIA_TYPE* pmt;
  2077. if(SUCCEEDED(pOut->GetMediaType(&pmt)) && pmt)
  2078. {
  2079. CMediaType mt(*pmt);
  2080. m_pOutput->SetMediaType(&mt);
  2081. DeleteMediaType(pmt);
  2082. }
  2084. hr = RADecode(m_dwCookie, src, w, pDataOut, &len, -1);
  2086. if(FAILED(hr))
  2087. {
  2088. TRACE(_T("RA returned an error code!!!n"));
  2089. continue;
  2090. // return hr;
  2091. }
  2093. WAVEFORMATEX* pwfe = (WAVEFORMATEX*)m_pOutput->CurrentMediaType().Format();
  2095. rtStop = rtStart + 1000i64*len/pwfe->nAvgBytesPerSec*10000;
  2096. pOut->SetTime(&rtStart, &rtStop);
  2097. pOut->SetMediaTime(NULL, NULL);
  2099. pOut->SetDiscontinuity(m_fBuffDiscontinuity); m_fBuffDiscontinuity = false;
  2100. pOut->SetSyncPoint(TRUE);
  2102. pOut->SetActualDataLength(len);
  2104. DbgLog((LOG_TRACE, 0, _T("A: rtStart=%I64d, rtStop=%I64d, disc=%d, sync=%d"), 
  2105. rtStart, rtStop, pOut->IsDiscontinuity() == S_OK, pOut->IsSyncPoint() == S_OK));
  2107. if(rtStart >= 0 && S_OK != (hr = m_pOutput->Deliver(pOut)))
  2108. return hr;
  2110. rtStart = rtStop;
  2111. }
  2113. m_rtBuffStart = rtStart;
  2115. return S_OK;
  2116. }
  2118. HRESULT CRealAudioDecoder::CheckInputType(const CMediaType* mtIn)
  2119. {
  2120. if(mtIn->majortype != MEDIATYPE_Audio 
  2121. || mtIn->subtype != MEDIASUBTYPE_14_4
  2122. && mtIn->subtype != MEDIASUBTYPE_28_8
  2123. && mtIn->subtype != MEDIASUBTYPE_ATRC
  2124. && mtIn->subtype != MEDIASUBTYPE_COOK
  2125. && mtIn->subtype != MEDIASUBTYPE_DNET
  2126. && mtIn->subtype != MEDIASUBTYPE_SIPR
  2127. && mtIn->subtype != MEDIASUBTYPE_RAAC
  2128. && mtIn->subtype != MEDIASUBTYPE_RACP
  2129. && mtIn->subtype != MEDIASUBTYPE_AAC)
  2130. return VFW_E_TYPE_NOT_ACCEPTED;
  2132. if(!m_pInput->IsConnected())
  2133. {
  2134. if(m_hDrvDll) {FreeLibrary(m_hDrvDll); m_hDrvDll = NULL;}
  2136. CList<CString> paths;
  2137. CString olddll, newdll, oldpath, newpath;
  2139. TCHAR fourcc[5] = 
  2140. {
  2141. (TCHAR)((mtIn->subtype.Data1>>0)&0xff),
  2142. (TCHAR)((mtIn->subtype.Data1>>8)&0xff),
  2143. (TCHAR)((mtIn->subtype.Data1>>16)&0xff),
  2144. (TCHAR)((mtIn->subtype.Data1>>24)&0xff),
  2145. 0
  2146. };
  2148. if(!_tcscmp(_T("RACP"), fourcc) || !_tcscmp(_T("xff"), fourcc))
  2149. _tcscpy(fourcc, _T("RAAC"));
  2151. olddll.Format(_T("%s3260.dll"), fourcc);
  2152. newdll.Format(_T("%s.dll"), fourcc);
  2154. CRegKey key;
  2155. TCHAR buff[MAX_PATH];
  2156. ULONG len = sizeof(buff);
  2157. if(ERROR_SUCCESS == key.Open(HKEY_CLASSES_ROOT, _T("Software\RealNetworks\Preferences\DT_Codecs"), KEY_READ)
  2158. && ERROR_SUCCESS == key.QueryStringValue(NULL, buff, &len) && _tcslen(buff) > 0)
  2159. {
  2160. oldpath = buff;
  2161. TCHAR c = oldpath[oldpath.GetLength()-1];
  2162. if(c != '\' && c != '/') oldpath += '\';
  2163. key.Close();
  2164. }
  2165. len = sizeof(buff);
  2166. if(ERROR_SUCCESS == key.Open(HKEY_CLASSES_ROOT, _T("Helix\HelixSDK\10.0\Preferences\DT_Codecs"), KEY_READ)
  2167. && ERROR_SUCCESS == key.QueryStringValue(NULL, buff, &len) && _tcslen(buff) > 0)
  2168. {
  2169. newpath = buff;
  2170. TCHAR c = newpath[newpath.GetLength()-1];
  2171. if(c != '\' && c != '/') newpath += '\';
  2172. key.Close();
  2173. }
  2175. if(!newpath.IsEmpty()) paths.AddTail(newpath + newdll);
  2176. if(!oldpath.IsEmpty()) paths.AddTail(oldpath + newdll);
  2177. paths.AddTail(newdll); // default dll paths
  2178. if(!newpath.IsEmpty()) paths.AddTail(newpath + olddll);
  2179. if(!oldpath.IsEmpty()) paths.AddTail(oldpath + olddll);
  2180. paths.AddTail(olddll); // default dll paths
  2182. POSITION pos = paths.GetHeadPosition();
  2183. while(pos && !(m_hDrvDll = LoadLibrary(paths.GetNext(pos))));
  2185. if(m_hDrvDll)
  2186. {
  2187. RACloseCodec = (PCloseCodec)GetProcAddress(m_hDrvDll, "RACloseCodec");
  2188. RADecode = (PDecode)GetProcAddress(m_hDrvDll, "RADecode");
  2189. RAFlush = (PFlush)GetProcAddress(m_hDrvDll, "RAFlush");
  2190. RAFreeDecoder = (PFreeDecoder)GetProcAddress(m_hDrvDll, "RAFreeDecoder");
  2191. RAGetFlavorProperty = (PGetFlavorProperty)GetProcAddress(m_hDrvDll, "RAGetFlavorProperty");
  2192. RAInitDecoder = (PInitDecoder)GetProcAddress(m_hDrvDll, "RAInitDecoder");
  2193. RAOpenCodec = (POpenCodec)GetProcAddress(m_hDrvDll, "RAOpenCodec");
  2194. RAOpenCodec2 = (POpenCodec2)GetProcAddress(m_hDrvDll, "RAOpenCodec2");
  2195. RASetFlavor = (PSetFlavor)GetProcAddress(m_hDrvDll, "RASetFlavor");
  2196. RASetDLLAccessPath = (PSetDLLAccessPath)GetProcAddress(m_hDrvDll, "RASetDLLAccessPath");
  2197. RASetPwd = (PSetPwd)GetProcAddress(m_hDrvDll, "RASetPwd");
  2198. }
  2200. if(!m_hDrvDll || !RACloseCodec || !RADecode /*|| !RAFlush*/
  2201. || !RAFreeDecoder || !RAGetFlavorProperty || !RAInitDecoder 
  2202. || !(RAOpenCodec || RAOpenCodec2) /*|| !RASetFlavor*/)
  2203. return VFW_E_TYPE_NOT_ACCEPTED;
  2205. if(m_hDrvDll)
  2206. {
  2207. char buff[MAX_PATH];
  2208. GetModuleFileNameA(m_hDrvDll, buff, MAX_PATH);
  2209. CPathA p(buff);
  2210. p.RemoveFileSpec();
  2211. p.AddBackslash();
  2212. m_dllpath = p.m_strPath;
  2213. if(RASetDLLAccessPath)
  2214. RASetDLLAccessPath("DT_Codecs=" + m_dllpath);
  2215. }
  2217. if(FAILED(InitRA(mtIn)))
  2218. return VFW_E_TYPE_NOT_ACCEPTED;
  2219. }
  2221. return S_OK;
  2222. }
  2224. HRESULT CRealAudioDecoder::CheckTransform(const CMediaType* mtIn, const CMediaType* mtOut)
  2225. {
  2226. return mtIn->majortype == MEDIATYPE_Audio && (mtIn->subtype == MEDIASUBTYPE_14_4
  2227. || mtIn->subtype == MEDIASUBTYPE_28_8
  2228. || mtIn->subtype == MEDIASUBTYPE_ATRC
  2229. || mtIn->subtype == MEDIASUBTYPE_COOK
  2230. || mtIn->subtype == MEDIASUBTYPE_DNET
  2231. || mtIn->subtype == MEDIASUBTYPE_SIPR
  2232. || mtIn->subtype == MEDIASUBTYPE_RAAC
  2233. || mtIn->subtype == MEDIASUBTYPE_RACP
  2234. || mtIn->subtype == MEDIASUBTYPE_AAC)
  2235. && mtOut->majortype == MEDIATYPE_Audio && mtOut->subtype == MEDIASUBTYPE_PCM
  2236. ? S_OK
  2237. : VFW_E_TYPE_NOT_ACCEPTED;
  2238. }
  2240. HRESULT CRealAudioDecoder::DecideBufferSize(IMemAllocator* pAllocator, ALLOCATOR_PROPERTIES* pProperties)
  2241. {
  2242. if(m_pInput->IsConnected() == FALSE) return E_UNEXPECTED;
  2244. CComPtr<IMemAllocator> pAllocatorIn;
  2245. m_pInput->GetAllocator(&pAllocatorIn);
  2246. if(!pAllocatorIn) return E_UNEXPECTED;
  2248. WAVEFORMATEX* pwfe = (WAVEFORMATEX*)m_pOutput->CurrentMediaType().Format();
  2250. WORD wBitsPerSample = pwfe->wBitsPerSample;
  2251. if(!wBitsPerSample) wBitsPerSample = 16;
  2253. // ok, maybe this is too much...
  2254. pProperties->cBuffers = 8;
  2255. pProperties->cbBuffer = pwfe->nChannels*pwfe->nSamplesPerSec*wBitsPerSample>>3; // nAvgBytesPerSec;
  2256. pProperties->cbAlign = 1;
  2257. pProperties->cbPrefix = 0;
  2259. HRESULT hr;
  2260. ALLOCATOR_PROPERTIES Actual;
  2261.     if(FAILED(hr = pAllocator->SetProperties(pProperties, &Actual))) 
  2262. return hr;
  2264.     return(pProperties->cBuffers > Actual.cBuffers || pProperties->cbBuffer > Actual.cbBuffer
  2265. ? E_FAIL
  2266. : NOERROR);
  2267. }
  2269. HRESULT CRealAudioDecoder::GetMediaType(int iPosition, CMediaType* pmt)
  2270. {
  2271.     if(m_pInput->IsConnected() == FALSE) return E_UNEXPECTED;
  2273. *pmt = m_pInput->CurrentMediaType();
  2274. pmt->subtype = MEDIASUBTYPE_PCM;
  2275. WAVEFORMATEX* pwfe = (WAVEFORMATEX*)pmt->ReallocFormatBuffer(sizeof(WAVEFORMATEX));
  2277. if(iPosition < 0) return E_INVALIDARG;
  2278. if(iPosition > (pwfe->nChannels > 2 && pwfe->nChannels <= 6 ? 1 : 0)) return VFW_S_NO_MORE_ITEMS;
  2280. if(!pwfe->wBitsPerSample) pwfe->wBitsPerSample = 16;
  2282. pwfe->cbSize = 0;
  2283. pwfe->wFormatTag = WAVE_FORMAT_PCM;
  2284. pwfe->nBlockAlign = pwfe->nChannels*pwfe->wBitsPerSample>>3;
  2285. pwfe->nAvgBytesPerSec = pwfe->nSamplesPerSec*pwfe->nBlockAlign;
  2287. if(iPosition == 0 && pwfe->nChannels > 2 && pwfe->nChannels <= 6)
  2288. {
  2289. static DWORD chmask[] = 
  2290. {
  2291. KSAUDIO_SPEAKER_DIRECTOUT,
  2292. KSAUDIO_SPEAKER_MONO,
  2293. KSAUDIO_SPEAKER_STEREO,
  2294. KSAUDIO_SPEAKER_STEREO|SPEAKER_FRONT_CENTER,
  2295. KSAUDIO_SPEAKER_QUAD,
  2296. KSAUDIO_SPEAKER_QUAD|SPEAKER_FRONT_CENTER,
  2297. KSAUDIO_SPEAKER_5POINT1
  2298. };
  2300. WAVEFORMATEXTENSIBLE* pwfex = (WAVEFORMATEXTENSIBLE*)pmt->ReallocFormatBuffer(sizeof(WAVEFORMATEXTENSIBLE));
  2301. pwfex->Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX);
  2302. pwfex->Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
  2303. pwfex->dwChannelMask = chmask[pwfex->Format.nChannels];
  2304. pwfex->Samples.wValidBitsPerSample = pwfex->Format.wBitsPerSample;
  2305. pwfex->SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
  2306. }
  2308. return S_OK;
  2309. }
  2311. HRESULT CRealAudioDecoder::StartStreaming()
  2312. {
  2313. int w = m_rai.coded_frame_size;
  2314. int h = m_rai.sub_packet_h;
  2315. int sps = m_rai.sub_packet_size;
  2317. int len = w*h;
  2319. m_buff.Allocate(len*2);
  2320. m_bufflen = 0;
  2321. m_rtBuffStart = 0;
  2323. return __super::StartStreaming();
  2324. }
  2326. HRESULT CRealAudioDecoder::StopStreaming()
  2327. {
  2328. m_buff.Free();
  2329. m_bufflen = 0;
  2331. return __super::StopStreaming();
  2332. }
  2334. HRESULT CRealAudioDecoder::EndOfStream()
  2335. {
  2336. return __super::EndOfStream();
  2337. }
  2339. HRESULT CRealAudioDecoder::BeginFlush()
  2340. {
  2341. return __super::BeginFlush();
  2342. }
  2344. HRESULT CRealAudioDecoder::EndFlush()
  2345. {
  2346. return __super::EndFlush();
  2347. }
  2349. HRESULT CRealAudioDecoder::NewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
  2350. {
  2351. CAutoLock cAutoLock(&m_csReceive);
  2352. m_tStart = tStart;
  2353. m_bufflen = 0;
  2354. m_rtBuffStart = 0;
  2355. return __super::NewSegment(tStart, tStop, dRate);
  2356. }