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

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

多媒体编程

开发平台：

Visual C++

MpaDecFilter.cpp：源码内容
  1. /* 
  2.  * Copyright (C) 2003-2005 Gabest
  3.  * http://www.gabest.org
  4.  *
  5.  *  This Program is free software; you can redistribute it and/or modify
  6.  *  it under the terms of the GNU General Public License as published by
  7.  *  the Free Software Foundation; either version 2, or (at your option)
  8.  *  any later version.
  9.  *   
  10.  *  This Program is distributed in the hope that it will be useful,
  11.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13.  *  GNU General Public License for more details.
  14.  *   
  15.  *  You should have received a copy of the GNU General Public License
  16.  *  along with GNU Make; see the file COPYING.  If not, write to
  17.  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 
  18.  *  http://www.gnu.org/copyleft/gpl.html
  19.  *
  20.  */
  22. #include "stdafx.h"
  23. #include <math.h>
  24. #include <atlbase.h>
  25. #include <mmreg.h>
  26. #include "MpaDecFilter.h"
  28. #include "......DSUtilDSUtil.h"
  30. #include <initguid.h>
  31. #include "........includemoreuuids.h"
  33. #include "faad2includeneaacdec.h"
  35. const AMOVIESETUP_MEDIATYPE sudPinTypesIn[] =
  36. {
  37. {&MEDIATYPE_Audio, &MEDIASUBTYPE_MP3},
  38. {&MEDIATYPE_Audio, &MEDIASUBTYPE_MPEG1AudioPayload},
  39. {&MEDIATYPE_Audio, &MEDIASUBTYPE_MPEG1Payload},
  40. {&MEDIATYPE_Audio, &MEDIASUBTYPE_MPEG1Packet},
  41. {&MEDIATYPE_DVD_ENCRYPTED_PACK, &MEDIASUBTYPE_MPEG2_AUDIO},
  42. {&MEDIATYPE_MPEG2_PACK, &MEDIASUBTYPE_MPEG2_AUDIO},
  43. {&MEDIATYPE_MPEG2_PES, &MEDIASUBTYPE_MPEG2_AUDIO},
  44. {&MEDIATYPE_Audio, &MEDIASUBTYPE_MPEG2_AUDIO},
  45. {&MEDIATYPE_DVD_ENCRYPTED_PACK, &MEDIASUBTYPE_DOLBY_AC3},
  46. {&MEDIATYPE_MPEG2_PACK, &MEDIASUBTYPE_DOLBY_AC3},
  47. {&MEDIATYPE_MPEG2_PES, &MEDIASUBTYPE_DOLBY_AC3},
  48. {&MEDIATYPE_Audio, &MEDIASUBTYPE_DOLBY_AC3},
  49. {&MEDIATYPE_Audio, &MEDIASUBTYPE_WAVE_DOLBY_AC3},
  50. {&MEDIATYPE_DVD_ENCRYPTED_PACK, &MEDIASUBTYPE_DTS},
  51. {&MEDIATYPE_MPEG2_PACK, &MEDIASUBTYPE_DTS},
  52. {&MEDIATYPE_MPEG2_PES, &MEDIASUBTYPE_DTS},
  53. {&MEDIATYPE_Audio, &MEDIASUBTYPE_DTS},
  54. {&MEDIATYPE_Audio, &MEDIASUBTYPE_WAVE_DTS},
  55. {&MEDIATYPE_DVD_ENCRYPTED_PACK, &MEDIASUBTYPE_DVD_LPCM_AUDIO},
  56. {&MEDIATYPE_MPEG2_PACK, &MEDIASUBTYPE_DVD_LPCM_AUDIO},
  57. {&MEDIATYPE_MPEG2_PES, &MEDIASUBTYPE_DVD_LPCM_AUDIO},
  58. {&MEDIATYPE_Audio, &MEDIASUBTYPE_DVD_LPCM_AUDIO},
  59. {&MEDIATYPE_DVD_ENCRYPTED_PACK, &MEDIASUBTYPE_AAC},
  60. {&MEDIATYPE_MPEG2_PACK, &MEDIASUBTYPE_AAC},
  61. {&MEDIATYPE_MPEG2_PES, &MEDIASUBTYPE_AAC},
  62. {&MEDIATYPE_Audio, &MEDIASUBTYPE_AAC},
  63. {&MEDIATYPE_DVD_ENCRYPTED_PACK, &MEDIASUBTYPE_MP4A},
  64. {&MEDIATYPE_MPEG2_PACK, &MEDIASUBTYPE_MP4A},
  65. {&MEDIATYPE_MPEG2_PES, &MEDIASUBTYPE_MP4A},
  66. {&MEDIATYPE_Audio, &MEDIASUBTYPE_MP4A},
  67. {&MEDIATYPE_DVD_ENCRYPTED_PACK, &MEDIASUBTYPE_PS2_PCM},
  68. {&MEDIATYPE_MPEG2_PACK, &MEDIASUBTYPE_PS2_PCM},
  69. {&MEDIATYPE_MPEG2_PES, &MEDIASUBTYPE_PS2_PCM},
  70. {&MEDIATYPE_Audio, &MEDIASUBTYPE_PS2_PCM},
  71. {&MEDIATYPE_DVD_ENCRYPTED_PACK, &MEDIASUBTYPE_PS2_ADPCM},
  72. {&MEDIATYPE_MPEG2_PACK, &MEDIASUBTYPE_PS2_ADPCM},
  73. {&MEDIATYPE_MPEG2_PES, &MEDIASUBTYPE_PS2_ADPCM},
  74. {&MEDIATYPE_Audio, &MEDIASUBTYPE_PS2_ADPCM},
  75. };
  77. #ifdef REGISTER_FILTER
  79. const AMOVIESETUP_MEDIATYPE sudPinTypesOut[] =
  80. {
  81. {&MEDIATYPE_Audio, &MEDIASUBTYPE_PCM},
  82. };
  84. const AMOVIESETUP_PIN sudpPins[] =
  85. {
  86.     {L"Input", FALSE, FALSE, FALSE, FALSE, &CLSID_NULL, NULL, countof(sudPinTypesIn), sudPinTypesIn},
  87.     {L"Output", FALSE, TRUE, FALSE, FALSE, &CLSID_NULL, NULL, countof(sudPinTypesOut), sudPinTypesOut}
  88. };
  90. const AMOVIESETUP_FILTER sudFilter[] =
  91. {
  92. {&__uuidof(CMpaDecFilter), L"MPEG/AC3/DTS/LPCM Audio Decoder", MERIT_DO_NOT_USE/*0x40000001*/, countof(sudpPins), sudpPins},
  93. };
  95. CFactoryTemplate g_Templates[] =
  96. {
  97.     {L"MPEG/AC3/DTS/LPCM Audio Decoder", &__uuidof(CMpaDecFilter), CreateInstance<CMpaDecFilter>, NULL, &sudFilter[0]},
  98. };
  100. int g_cTemplates = countof(g_Templates);
  102. STDAPI DllRegisterServer()
  103. {
  104. return AMovieDllRegisterServer2(TRUE);
  105. }
  107. STDAPI DllUnregisterServer()
  108. {
  109. return AMovieDllRegisterServer2(FALSE);
  110. }
  112. //
  114. extern "C" BOOL WINAPI DllEntryPoint(HINSTANCE, ULONG, LPVOID);
  116. BOOL APIENTRY DllMain(HANDLE hModule, DWORD dwReason, LPVOID lpReserved)
  117. {
  118. return DllEntryPoint((HINSTANCE)hModule, dwReason, 0); // "DllMain" of the dshow baseclasses;
  119. }
  121. #endif
  123. // dshow: left, right, center, LFE, left surround, right surround
  124. // ac3: LFE, left, center, right, left surround, right surround
  125. // dts: center, left, right, left surround, right surround, LFE
  127. // lets see how we can map these things to dshow (oh the joy!)
  129. static struct scmap_t
  130. {
  131. WORD nChannels;
  132. BYTE ch[6];
  133. DWORD dwChannelMask;
  134. }
  135. s_scmap_ac3[2*11] = 
  136. {
  137. {2, {0, 1,-1,-1,-1,-1}, 0}, // A52_CHANNEL
  138. {1, {0,-1,-1,-1,-1,-1}, 0}, // A52_MONO
  139. {2, {0, 1,-1,-1,-1,-1}, 0}, // A52_STEREO
  140. {3, {0, 2, 1,-1,-1,-1}, SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER}, // A52_3F
  141. {3, {0, 1, 2,-1,-1,-1}, SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_BACK_CENTER}, // A52_2F1R
  142. {4, {0, 2, 1, 3,-1,-1}, SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_BACK_CENTER}, // A52_3F1R
  143. {4, {0, 1, 2, 3,-1,-1}, SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT}, // A52_2F2R
  144. {5, {0, 2, 1, 3, 4,-1}, SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT}, // A52_3F2R
  145. {1, {0,-1,-1,-1,-1,-1}, 0}, // A52_CHANNEL1
  146. {1, {0,-1,-1,-1,-1,-1}, 0}, // A52_CHANNEL2
  147. {2, {0, 1,-1,-1,-1,-1}, 0}, // A52_DOLBY
  149. {3, {1, 2, 0,-1,-1,-1}, SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_LOW_FREQUENCY}, // A52_CHANNEL|A52_LFE
  150. {2, {1, 0,-1,-1,-1,-1}, SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY}, // A52_MONO|A52_LFE
  151. {3, {1, 2, 0,-1,-1,-1}, SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_LOW_FREQUENCY}, // A52_STEREO|A52_LFE
  152. {4, {1, 3, 2, 0,-1,-1}, SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY}, // A52_3F|A52_LFE
  153. {4, {1, 2, 0, 3,-1,-1}, SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_CENTER}, // A52_2F1R|A52_LFE
  154. {5, {1, 3, 2, 0, 4,-1}, SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_CENTER}, // A52_3F1R|A52_LFE
  155. {5, {1, 2, 0, 3, 4,-1}, SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT}, // A52_2F2R|A52_LFE
  156. {6, {1, 3, 2, 0, 4, 5}, SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT}, // A52_3F2R|A52_LFE
  157. {2, {1, 0,-1,-1,-1,-1}, SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY}, // A52_CHANNEL1|A52_LFE
  158. {2, {1, 0,-1,-1,-1,-1}, SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY}, // A52_CHANNEL2|A52_LFE
  159. {3, {1, 2, 0,-1,-1,-1}, SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_LOW_FREQUENCY}, // A52_DOLBY|A52_LFE
  160. },
  161. s_scmap_dts[2*10] = 
  162. {
  163. {1, {0,-1,-1,-1,-1,-1}, 0}, // DTS_MONO
  164. {2, {0, 1,-1,-1,-1,-1}, 0}, // DTS_CHANNEL
  165. {2, {0, 1,-1,-1,-1,-1}, 0}, // DTS_STEREO
  166. {2, {0, 1,-1,-1,-1,-1}, 0}, // DTS_STEREO_SUMDIFF
  167. {2, {0, 1,-1,-1,-1,-1}, 0}, // DTS_STEREO_TOTAL
  168. {3, {1, 2, 0,-1,-1,-1}, SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER}, // DTS_3F
  169. {3, {0, 1, 2,-1,-1,-1}, SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_BACK_CENTER}, // DTS_2F1R
  170. {4, {1, 2, 0, 3,-1,-1}, SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_BACK_CENTER}, // DTS_3F1R
  171. {4, {0, 1, 2, 3,-1,-1}, SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT}, // DTS_2F2R
  172. {5, {1, 2, 0, 3, 4,-1}, SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT}, // DTS_3F2R
  174. {2, {0, 1,-1,-1,-1,-1}, SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY}, // DTS_MONO|DTS_LFE
  175. {3, {0, 1, 2,-1,-1,-1}, SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_LOW_FREQUENCY}, // DTS_CHANNEL|DTS_LFE
  176. {3, {0, 1, 2,-1,-1,-1}, SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_LOW_FREQUENCY}, // DTS_STEREO|DTS_LFE
  177. {3, {0, 1, 2,-1,-1,-1}, SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_LOW_FREQUENCY}, // DTS_STEREO_SUMDIFF|DTS_LFE
  178. {3, {0, 1, 2,-1,-1,-1}, SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_LOW_FREQUENCY}, // DTS_STEREO_TOTAL|DTS_LFE
  179. {4, {1, 2, 0, 3,-1,-1}, SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY}, // DTS_3F|DTS_LFE
  180. {4, {0, 1, 3, 2,-1,-1}, SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_CENTER}, // DTS_2F1R|DTS_LFE
  181. {5, {1, 2, 0, 4, 3,-1}, SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_CENTER}, // DTS_3F1R|DTS_LFE
  182. {5, {0, 1, 4, 2, 3,-1}, SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT}, // DTS_2F2R|DTS_LFE
  183. {6, {1, 2, 0, 5, 3, 4}, SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT}, // DTS_3F2R|DTS_LFE
  184. };
  186. CMpaDecFilter::CMpaDecFilter(LPUNKNOWN lpunk, HRESULT* phr) 
  187. : CTransformFilter(NAME("CMpaDecFilter"), lpunk, __uuidof(this))
  188. , m_iSampleFormat(SF_PCM16)
  189. , m_fNormalize(false)
  190. , m_boost(1)
  191. {
  192. if(phr) *phr = S_OK;
  194. if(!(m_pInput = new CMpaDecInputPin(this, phr, L"In"))) *phr = E_OUTOFMEMORY;
  195. if(FAILED(*phr)) return;
  197. if(!(m_pOutput = new CTransformOutputPin(NAME("CTransformOutputPin"), this, phr, L"Out"))) *phr = E_OUTOFMEMORY;
  198. if(FAILED(*phr))  {delete m_pInput, m_pInput = NULL; return;}
  200. m_iSpeakerConfig[ac3] = A52_STEREO;
  201. m_iSpeakerConfig[dts] = DTS_STEREO;
  202. m_iSpeakerConfig[aac] = AAC_STEREO;
  203. m_fDynamicRangeControl[ac3] = false;
  204. m_fDynamicRangeControl[dts] = false;
  205. m_fDynamicRangeControl[aac] = false;
  206. }
  208. CMpaDecFilter::~CMpaDecFilter()
  209. {
  210. }
  212. STDMETHODIMP CMpaDecFilter::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  213. {
  214. return
  215. QI(IMpaDecFilter)
  216.  __super::NonDelegatingQueryInterface(riid, ppv);
  217. }
  219. HRESULT CMpaDecFilter::EndOfStream()
  220. {
  221. CAutoLock cAutoLock(&m_csReceive);
  222. return __super::EndOfStream();
  223. }
  225. HRESULT CMpaDecFilter::BeginFlush()
  226. {
  227. return __super::BeginFlush();
  228. }
  230. HRESULT CMpaDecFilter::EndFlush()
  231. {
  232. CAutoLock cAutoLock(&m_csReceive);
  233. m_buff.RemoveAll();
  234. m_sample_max = 0.1f;
  235. return __super::EndFlush();
  236. }
  238. HRESULT CMpaDecFilter::NewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
  239. {
  240. CAutoLock cAutoLock(&m_csReceive);
  241. m_buff.RemoveAll();
  242. m_sample_max = 0.1f;
  243. m_ps2_state.sync = false;
  244. return __super::NewSegment(tStart, tStop, dRate);
  245. }
  247. HRESULT CMpaDecFilter::Receive(IMediaSample* pIn)
  248. {
  249. CAutoLock cAutoLock(&m_csReceive);
  251. HRESULT hr;
  253.     AM_SAMPLE2_PROPERTIES* const pProps = m_pInput->SampleProps();
  254.     if(pProps->dwStreamId != AM_STREAM_MEDIA)
  255. return m_pOutput->Deliver(pIn);
  257. AM_MEDIA_TYPE* pmt;
  258. if(SUCCEEDED(pIn->GetMediaType(&pmt)) && pmt)
  259. {
  260. CMediaType mt(*pmt);
  261. m_pInput->SetMediaType(&mt);
  262. DeleteMediaType(pmt);
  263. pmt = NULL;
  264. m_sample_max = 0.1f;
  265. m_aac_state.init(mt);
  266. }
  268. BYTE* pDataIn = NULL;
  269. if(FAILED(hr = pIn->GetPointer(&pDataIn))) return hr;
  271. long len = pIn->GetActualDataLength();
  273. ((CDeCSSInputPin*)m_pInput)->StripPacket(pDataIn, len);
  275. REFERENCE_TIME rtStart = _I64_MIN, rtStop = _I64_MIN;
  276. hr = pIn->GetTime(&rtStart, &rtStop);
  278. if(pIn->IsDiscontinuity() == S_OK)
  279. {
  280. m_fDiscontinuity = true;
  281. m_buff.RemoveAll();
  282. m_sample_max = 0.1f;
  283. // ASSERT(SUCCEEDED(hr)); // what to do if not?
  284. if(FAILED(hr)) {TRACE(_T("mpa: disc. w/o timestampn")); return S_OK;} // lets wait then...
  285. m_rtStart = rtStart;
  286. }
  288. if(SUCCEEDED(hr) && abs((int)(m_rtStart - rtStart)) > 1000000) // +-100ms jitter is allowed for now
  289. {
  290. m_buff.RemoveAll();
  291. m_rtStart = rtStart;
  292. }
  294. int tmp = m_buff.GetSize();
  295. m_buff.SetSize(m_buff.GetSize() + len);
  296. memcpy(m_buff.GetData() + tmp, pDataIn, len);
  297. len += tmp;
  299. const GUID& subtype = m_pInput->CurrentMediaType().subtype;
  301. if(subtype == MEDIASUBTYPE_DVD_LPCM_AUDIO)
  302. hr = ProcessLPCM();
  303. else if(subtype == MEDIASUBTYPE_DOLBY_AC3 || subtype == MEDIASUBTYPE_WAVE_DOLBY_AC3)
  304. hr = ProcessAC3();
  305. else if(subtype == MEDIASUBTYPE_DTS || subtype == MEDIASUBTYPE_WAVE_DTS)
  306. hr = ProcessDTS();
  307. else if(subtype == MEDIASUBTYPE_AAC || subtype == MEDIASUBTYPE_MP4A)
  308. hr = ProcessAAC();
  309. else if(subtype == MEDIASUBTYPE_PS2_PCM)
  310. hr = ProcessPS2PCM();
  311. else if(subtype == MEDIASUBTYPE_PS2_ADPCM)
  312. hr = ProcessPS2ADPCM();
  313. else // if(.. the rest ..)
  314. hr = ProcessMPA();
  316. return hr;
  317. }
  319. HRESULT CMpaDecFilter::ProcessLPCM()
  320. {
  321. WAVEFORMATEX* wfein = (WAVEFORMATEX*)m_pInput->CurrentMediaType().Format();
  323. ASSERT(wfein->nChannels == 2);
  324. ASSERT(wfein->wBitsPerSample == 16);
  326. BYTE* pDataIn = m_buff.GetData();
  327. int len = m_buff.GetSize() & ~(wfein->nChannels*wfein->wBitsPerSample/8-1);
  329. CArray<float> pBuff;
  330. pBuff.SetSize(len*8/wfein->wBitsPerSample);
  332. float* pDataOut = pBuff.GetData();
  333. for(int i = 0; i < len; i += 2, pDataIn += 2, pDataOut++)
  334. *pDataOut = (float)(short)((pDataIn[0]<<8)|pDataIn[1]) / 0x8000; // FIXME: care about 20/24 bps too
  336. memmove(m_buff.GetData(), pDataIn, m_buff.GetSize() - len);
  337. m_buff.SetSize(m_buff.GetSize() - len);
  339. return Deliver(pBuff, wfein->nSamplesPerSec, wfein->nChannels);
  340. }
  342. HRESULT CMpaDecFilter::ProcessAC3()
  343. {
  344. BYTE* p = m_buff.GetData();
  345. BYTE* base = p;
  346. BYTE* end = p + m_buff.GetSize();
  348. while(end - p >= 7)
  349. {
  350. int size = 0, flags, sample_rate, bit_rate;
  352. if((size = a52_syncinfo(p, &flags, &sample_rate, &bit_rate)) > 0)
  353. {
  354. // TRACE(_T("ac3: size=%d, flags=%08x, sample_rate=%d, bit_rate=%dn"), size, flags, sample_rate, bit_rate);
  356. bool fEnoughData = p + size <= end;
  358. if(fEnoughData)
  359. {
  360. int iSpeakerConfig = GetSpeakerConfig(ac3);
  362. if(iSpeakerConfig < 0)
  363. {
  364. HRESULT hr;
  365. if(S_OK != (hr = Deliver(p, size, bit_rate, 0x0001)))
  366. return hr;
  367. }
  368. else
  369. {
  370. flags = iSpeakerConfig&(A52_CHANNEL_MASK|A52_LFE);
  371. flags |= A52_ADJUST_LEVEL;
  373. sample_t level = 1, gain = 1, bias = 0;
  374. level *= gain;
  376. if(a52_frame(m_a52_state, p, &flags, &level, bias) == 0)
  377. {
  378. if(GetDynamicRangeControl(ac3))
  379. a52_dynrng(m_a52_state, NULL, NULL);
  381. int scmapidx = min(flags&A52_CHANNEL_MASK, countof(s_scmap_ac3)/2);
  382.                         scmap_t& scmap = s_scmap_ac3[scmapidx + ((flags&A52_LFE)?(countof(s_scmap_ac3)/2):0)];
  384. CArray<float> pBuff;
  385. pBuff.SetSize(6*256*scmap.nChannels);
  386. float* p = pBuff.GetData();
  388. int i = 0;
  390. for(; i < 6 && a52_block(m_a52_state) == 0; i++)
  391. {
  392. sample_t* samples = a52_samples(m_a52_state);
  394. for(int j = 0; j < 256; j++, samples++)
  395. {
  396. for(int ch = 0; ch < scmap.nChannels; ch++)
  397. {
  398. ASSERT(scmap.ch[ch] != -1);
  399. *p++ = (float)(*(samples + 256*scmap.ch[ch]) / level);
  400. }
  401. }
  402. }
  404. if(i == 6)
  405. {
  406. HRESULT hr;
  407. if(S_OK != (hr = Deliver(pBuff, sample_rate, scmap.nChannels, scmap.dwChannelMask)))
  408. return hr;
  409. }
  410. }
  411. }
  413. p += size;
  414. }
  416. memmove(base, p, end - p);
  417. end = base + (end - p);
  418. p = base;
  420. if(!fEnoughData)
  421. break;
  422. }
  423. else
  424. {
  425. p++;
  426. }
  427. }
  429. m_buff.SetSize(end - p);
  431. return S_OK;
  432. }
  434. HRESULT CMpaDecFilter::ProcessDTS()
  435. {
  436. BYTE* p = m_buff.GetData();
  437. BYTE* base = p;
  438. BYTE* end = p + m_buff.GetSize();
  440. while(end - p >= 14)
  441. {
  442. int size = 0, flags, sample_rate, bit_rate, frame_length;
  444. if((size = dts_syncinfo(m_dts_state, p, &flags, &sample_rate, &bit_rate, &frame_length)) > 0)
  445. {
  446. // TRACE(_T("dts: size=%d, flags=%08x, sample_rate=%d, bit_rate=%d, frame_length=%dn"), size, flags, sample_rate, bit_rate, frame_length);
  448. bool fEnoughData = p + size <= end;
  450. if(fEnoughData)
  451. {
  452. int iSpeakerConfig = GetSpeakerConfig(dts);
  454. if(iSpeakerConfig < 0)
  455. {
  456. HRESULT hr;
  457. if(S_OK != (hr = Deliver(p, size, bit_rate, 0x000b)))
  458. return hr;
  459. }
  460. else
  461. {
  462. flags = iSpeakerConfig&(DTS_CHANNEL_MASK|DTS_LFE);
  463. flags |= DTS_ADJUST_LEVEL;
  465. sample_t level = 1, gain = 1, bias = 0;
  466. level *= gain;
  468. if(dts_frame(m_dts_state, p, &flags, &level, bias) == 0)
  469. {
  470. if(GetDynamicRangeControl(dts))
  471. dts_dynrng(m_dts_state, NULL, NULL);
  473. int scmapidx = min(flags&DTS_CHANNEL_MASK, countof(s_scmap_dts)/2);
  474.                         scmap_t& scmap = s_scmap_dts[scmapidx + ((flags&DTS_LFE)?(countof(s_scmap_dts)/2):0)];
  476. int blocks = dts_blocks_num(m_dts_state);
  478. CArray<float> pBuff;
  479. pBuff.SetSize(blocks*256*scmap.nChannels);
  480. float* p = pBuff.GetData();
  482. int i = 0;
  484. for(; i < blocks && dts_block(m_dts_state) == 0; i++)
  485. {
  486. sample_t* samples = dts_samples(m_dts_state);
  488. for(int j = 0; j < 256; j++, samples++)
  489. {
  490. for(int ch = 0; ch < scmap.nChannels; ch++)
  491. {
  492. ASSERT(scmap.ch[ch] != -1);
  493. *p++ = (float)(*(samples + 256*scmap.ch[ch]) / level);
  494. }
  495. }
  496. }
  498. if(i == blocks)
  499. {
  500. HRESULT hr;
  501. if(S_OK != (hr = Deliver(pBuff, sample_rate, scmap.nChannels, scmap.dwChannelMask)))
  502. return hr;
  503. }
  504. }
  505. }
  507. p += size;
  508. }
  510. memmove(base, p, end - p);
  511. end = base + (end - p);
  512. p = base;
  514. if(!fEnoughData)
  515. break;
  516. }
  517. else
  518. {
  519. p++;
  520. }
  521. }
  523. m_buff.SetSize(end - p);
  525. return S_OK;
  526. }
  528. HRESULT CMpaDecFilter::ProcessAAC()
  529. {
  530. int iSpeakerConfig = GetSpeakerConfig(aac);
  532. NeAACDecConfigurationPtr c = NeAACDecGetCurrentConfiguration(m_aac_state.h);
  533. c->downMatrix = iSpeakerConfig;
  534. NeAACDecSetConfiguration(m_aac_state.h, c);
  536. NeAACDecFrameInfo info;
  537. float* src = (float*)NeAACDecDecode(m_aac_state.h, &info, m_buff.GetData(), m_buff.GetSize());
  538. m_buff.SetSize(0);
  539. //if(!src) return E_FAIL;
  540. if(info.error)  m_aac_state.init(m_pInput->CurrentMediaType());
  541. if(!src || info.samples == 0) return S_OK;
  543. // HACK: bug in faad2 with mono sources?
  544. if(info.channels == 2 && info.channel_position[1] == UNKNOWN_CHANNEL)
  545. {
  546. info.channel_position[0] = FRONT_CHANNEL_LEFT;
  547. info.channel_position[1] = FRONT_CHANNEL_RIGHT;
  548. }
  550. CArray<float> pBuff;
  551. pBuff.SetSize(info.samples);
  552. float* dst = pBuff.GetData();
  554. CMap<int,int,int,int> chmask;
  555. chmask[FRONT_CHANNEL_CENTER] = SPEAKER_FRONT_CENTER;
  556. chmask[FRONT_CHANNEL_LEFT] = SPEAKER_FRONT_LEFT;
  557. chmask[FRONT_CHANNEL_RIGHT] = SPEAKER_FRONT_RIGHT;
  558. chmask[SIDE_CHANNEL_LEFT] = SPEAKER_SIDE_LEFT;
  559. chmask[SIDE_CHANNEL_RIGHT] = SPEAKER_SIDE_RIGHT;
  560. chmask[BACK_CHANNEL_LEFT] = SPEAKER_BACK_LEFT;
  561. chmask[BACK_CHANNEL_RIGHT] = SPEAKER_BACK_RIGHT;
  562. chmask[BACK_CHANNEL_CENTER] = SPEAKER_BACK_CENTER;
  563. chmask[LFE_CHANNEL] = SPEAKER_LOW_FREQUENCY;
  565. DWORD dwChannelMask = 0;
  566. for(int i = 0; i < info.channels; i++)
  567. {
  568. if(info.channel_position[i] == UNKNOWN_CHANNEL) {ASSERT(0); return E_FAIL;}
  569. dwChannelMask |= chmask[info.channel_position[i]];
  570. }
  572. int chmap[countof(info.channel_position)];
  573. memset(chmap, 0, sizeof(chmap));
  575. for(int i = 0; i < info.channels; i++)
  576. {
  577. unsigned int ch = 0, mask = chmask[info.channel_position[i]];
  579. for(int j = 0; j < 32; j++)
  580. {
  581. if(dwChannelMask & (1 << j))
  582. {
  583. if((1 << j) == mask) {chmap[i] = ch; break;}
  584. ch++;
  585. }
  586. }
  587. }
  589. if(info.channels <= 2) dwChannelMask = 0;
  591. for(int j = 0; j < info.samples; j += info.channels, dst += info.channels)
  592. for(int i = 0; i < info.channels; i++)
  593. dst[chmap[i]] = *src++;
  595. HRESULT hr;
  596. if(S_OK != (hr = Deliver(pBuff, info.samplerate, info.channels, dwChannelMask)))
  597. return hr;
  599. return S_OK;
  600. }
  602. HRESULT CMpaDecFilter::ProcessPS2PCM()
  603. {
  604. BYTE* p = m_buff.GetData();
  605. BYTE* base = p;
  606. BYTE* end = p + m_buff.GetSize();
  608. WAVEFORMATEXPS2* wfe = (WAVEFORMATEXPS2*)m_pInput->CurrentMediaType().Format();
  609. int size = wfe->dwInterleave*wfe->nChannels;
  610. int samples = wfe->dwInterleave/(wfe->wBitsPerSample>>3);
  611. int channels = wfe->nChannels;
  613. CArray<float> pBuff;
  614. pBuff.SetSize(samples*channels);
  615. float* f = pBuff.GetData();
  617. while(end - p >= size)
  618. {
  619. DWORD* dw = (DWORD*)p;
  621. if(dw[0] == 'dhSS')
  622. {
  623. p += dw[1] + 8;
  624. }
  625. else if(dw[0] == 'dbSS')
  626. {
  627. p += 8;
  628. m_ps2_state.sync = true;
  629. }
  630. else
  631. {
  632. if(m_ps2_state.sync)
  633. {
  634. short* s = (short*)p;
  636. for(int i = 0; i < samples; i++)
  637. for(int j = 0; j < channels; j++)
  638. f[i*channels+j] = (float)s[j*samples+i] / 32768;
  639. }
  640. else
  641. {
  642. for(int i = 0, j = samples*channels; i < j; i++)
  643. f[i] = 0;
  644. }
  646. HRESULT hr;
  647. if(S_OK != (hr = Deliver(pBuff, wfe->nSamplesPerSec, wfe->nChannels)))
  648. return hr;
  650. p += size;
  652. memmove(base, p, end - p);
  653. end = base + (end - p);
  654. p = base;
  655. }
  656. }
  658. m_buff.SetSize(end - p);
  660. return S_OK;
  661. }
  663. static void decodeps2adpcm(ps2_state_t& s, int channel, BYTE* pin, double* pout)
  664. {
  665. int tbl_index = pin[0]>>4;
  666. int shift = pin[0]&0xf;
  667.     int unk = pin[1]; // ?
  669. if(tbl_index >= 10) {ASSERT(0); return;}
  670. // if(unk == 7) {ASSERT(0); return;} // ???
  672. static double s_tbl[] = 
  673. {
  674. 0.0, 0.0, 0.9375, 0.0, 1.796875, -0.8125, 1.53125, -0.859375, 1.90625, -0.9375, 
  675. 0.0, 0.0, -0.9375, 0.0, -1.796875, 0.8125, -1.53125, 0.859375 -1.90625, 0.9375
  676. };
  678. double* tbl = &s_tbl[tbl_index*2];
  679. double& a = s.a[channel];
  680. double& b = s.b[channel];
  682. for(int i = 0; i < 28; i++)
  683. {
  684. short input = (short)(((pin[2+i/2] >> ((i&1) << 2)) & 0xf) << 12) >> shift;
  685. double output = a * tbl[1] + b * tbl[0] + input;
  687. a = b;
  688. b = output;
  690. *pout++ = output / SHRT_MAX;
  691. }
  692. }
  694. HRESULT CMpaDecFilter::ProcessPS2ADPCM()
  695. {
  696. BYTE* p = m_buff.GetData();
  697. BYTE* base = p;
  698. BYTE* end = p + m_buff.GetSize();
  700. WAVEFORMATEXPS2* wfe = (WAVEFORMATEXPS2*)m_pInput->CurrentMediaType().Format();
  701. int size = wfe->dwInterleave*wfe->nChannels;
  702. int samples = wfe->dwInterleave * 14 / 16 * 2;
  703. int channels = wfe->nChannels;
  705. CArray<float> pBuff;
  706. pBuff.SetSize(samples*channels);
  707. float* f = pBuff.GetData();
  709. while(end - p >= size)
  710. {
  711. DWORD* dw = (DWORD*)p;
  713. if(dw[0] == 'dhSS')
  714. {
  715. p += dw[1] + 8;
  716. }
  717. else if(dw[0] == 'dbSS')
  718. {
  719. p += 8;
  720. m_ps2_state.sync = true;
  721. }
  722. else
  723. {
  724. if(m_ps2_state.sync)
  725. {
  726. double* tmp = new double[samples*channels];
  728. for(int channel = 0, j = 0, k = 0; channel < channels; channel++, j += wfe->dwInterleave)
  729. for(int i = 0; i < wfe->dwInterleave; i += 16, k += 28)
  730. decodeps2adpcm(m_ps2_state, channel, p + i + j, tmp + k);
  732. for(int i = 0, k = 0; i < samples; i++)
  733. for(int j = 0; j < channels; j++, k++)
  734. f[k] = (float)tmp[j*samples+i];
  736. delete [] tmp;
  737. }
  738. else
  739. {
  740. for(int i = 0, j = samples*channels; i < j; i++)
  741. f[i] = 0;
  742. }
  744. HRESULT hr;
  745. if(S_OK != (hr = Deliver(pBuff, wfe->nSamplesPerSec, wfe->nChannels)))
  746. return hr;
  748. p += size;
  749. }
  750. }
  752. memmove(base, p, end - p);
  753. end = base + (end - p);
  754. p = base;
  756. m_buff.SetSize(end - p);
  758. return S_OK;
  759. }
  761. static inline float fscale(mad_fixed_t sample)
  762. {
  763. if(sample >= MAD_F_ONE) sample = MAD_F_ONE - 1;
  764. else if(sample < -MAD_F_ONE) sample = -MAD_F_ONE;
  766. return (float)sample / (1 << MAD_F_FRACBITS);
  767. }
  769. HRESULT CMpaDecFilter::ProcessMPA()
  770. {
  771. mad_stream_buffer(&m_stream, m_buff.GetData(), m_buff.GetSize());
  773. while(1)
  774. {
  775. if(mad_frame_decode(&m_frame, &m_stream) == -1)
  776. {
  777. if(m_stream.error == MAD_ERROR_BUFLEN)
  778. {
  779. memmove(m_buff.GetData(), m_stream.this_frame, m_stream.bufend - m_stream.this_frame);
  780. m_buff.SetSize(m_stream.bufend - m_stream.this_frame);
  781. break;
  782. }
  784. if(!MAD_RECOVERABLE(m_stream.error))
  785. {
  786. TRACE(_T("*m_stream.error == %dn"), m_stream.error);
  787. return E_FAIL;
  788. }
  790. // FIXME: the renderer doesn't like this
  791. // m_fDiscontinuity = true;
  793. continue;
  794. }
  795. /*
  796. // TODO: needs to be tested... (has anybody got an external mpeg audio decoder?)
  797. HRESULT hr;
  798. if(S_OK != (hr = Deliver(
  799.    (BYTE*)m_stream.this_frame, 
  800.    m_stream.next_frame - m_stream.this_frame, 
  801.    m_frame.header.bitrate, 
  802.    m_frame.header.layer == 1 ? 0x0004 : 0x0005)))
  803. return hr;
  804. continue;
  805. */
  806. mad_synth_frame(&m_synth, &m_frame);
  808. WAVEFORMATEX* wfein = (WAVEFORMATEX*)m_pInput->CurrentMediaType().Format();
  809. if(wfein->nChannels != m_synth.pcm.channels || wfein->nSamplesPerSec != m_synth.pcm.samplerate)
  810. continue;
  812. const mad_fixed_t* left_ch   = m_synth.pcm.samples[0];
  813. const mad_fixed_t* right_ch  = m_synth.pcm.samples[1];
  815. CArray<float> pBuff;
  816. pBuff.SetSize(m_synth.pcm.length*m_synth.pcm.channels);
  818. float* pDataOut = pBuff.GetData();
  819. for(unsigned short i = 0; i < m_synth.pcm.length; i++)
  820. {
  821. *pDataOut++ = fscale(*left_ch++);
  822. if(m_synth.pcm.channels == 2) *pDataOut++ = fscale(*right_ch++);
  823. }
  825. HRESULT hr;
  826. if(S_OK != (hr = Deliver(pBuff, m_synth.pcm.samplerate, m_synth.pcm.channels)))
  827. return hr;
  828. }
  830. return S_OK;
  831. }
  833. HRESULT CMpaDecFilter::GetDeliveryBuffer(IMediaSample** pSample, BYTE** pData)
  834. {
  835. HRESULT hr;
  837. *pData = NULL;
  838. if(FAILED(hr = m_pOutput->GetDeliveryBuffer(pSample, NULL, NULL, 0))
  839. || FAILED(hr = (*pSample)->GetPointer(pData)))
  840. return hr;
  842. AM_MEDIA_TYPE* pmt = NULL;
  843. if(SUCCEEDED((*pSample)->GetMediaType(&pmt)) && pmt)
  844. {
  845. CMediaType mt = *pmt;
  846. m_pOutput->SetMediaType(&mt);
  847. DeleteMediaType(pmt);
  848. pmt = NULL;
  849. }
  851. return S_OK;
  852. }
  854. HRESULT CMpaDecFilter::Deliver(CArray<float>& pBuff, DWORD nSamplesPerSec, WORD nChannels, DWORD dwChannelMask)
  855. {
  856. HRESULT hr;
  858. SampleFormat sf = GetSampleFormat();
  860. CMediaType mt = CreateMediaType(sf, nSamplesPerSec, nChannels, dwChannelMask);
  861. WAVEFORMATEX* wfe = (WAVEFORMATEX*)mt.Format();
  863. int nSamples = pBuff.GetSize()/wfe->nChannels;
  865. if(FAILED(hr = ReconnectOutput(nSamples, mt)))
  866. return hr;
  868. CComPtr<IMediaSample> pOut;
  869. BYTE* pDataOut = NULL;
  870. if(FAILED(GetDeliveryBuffer(&pOut, &pDataOut)))
  871. return E_FAIL;
  873. REFERENCE_TIME rtDur = 10000000i64*nSamples/wfe->nSamplesPerSec;
  874. REFERENCE_TIME rtStart = m_rtStart, rtStop = m_rtStart + rtDur;
  875. m_rtStart += rtDur;
  876. //TRACE(_T("CMpaDecFilter: %I64d - %I64dn"), rtStart/10000, rtStop/10000);
  877. if(rtStart < 0 /*200000*/ /* < 0, FIXME: 0 makes strange noises */)
  878. return S_OK;
  880. if(hr == S_OK)
  881. {
  882. m_pOutput->SetMediaType(&mt);
  883. pOut->SetMediaType(&mt);
  884. }
  886. pOut->SetTime(&rtStart, &rtStop);
  887. pOut->SetMediaTime(NULL, NULL);
  889. pOut->SetPreroll(FALSE);
  890. pOut->SetDiscontinuity(m_fDiscontinuity); m_fDiscontinuity = false;
  891. pOut->SetSyncPoint(TRUE);
  893. pOut->SetActualDataLength(pBuff.GetSize()*wfe->wBitsPerSample/8);
  895. WAVEFORMATEX* wfeout = (WAVEFORMATEX*)m_pOutput->CurrentMediaType().Format();
  896. ASSERT(wfeout->nChannels == wfe->nChannels);
  897. ASSERT(wfeout->nSamplesPerSec == wfe->nSamplesPerSec);
  899. float* pDataIn = pBuff.GetData();
  901. // TODO: move this into the audio switcher
  902. float sample_mul = 1;
  903. if(m_fNormalize)
  904. {
  905. for(int i = 0, len = pBuff.GetSize(); i < len; i++)
  906. {
  907. float f = *pDataIn++;
  908. if(f < 0) f = -f;
  909. if(m_sample_max < f) m_sample_max = f;
  910. }
  911. sample_mul = 1.0f / m_sample_max;
  912. pDataIn = pBuff.GetData();
  913. }
  915. bool fBoost = m_boost > 1;
  916. double boost = 1+log10(m_boost);
  918. for(int i = 0, len = pBuff.GetSize(); i < len; i++)
  919. {
  920. float f = *pDataIn++;
  922. // TODO: move this into the audio switcher
  924. if(m_fNormalize) 
  925. f *= sample_mul;
  927. if(fBoost)
  928. f *= boost;
  930. if(f < -1) f = -1;
  931. else if(f > 1) f = 1;
  933. #define round(x) ((x) > 0 ? (x) + 0.5 : (x) - 0.5)
  935. switch(sf)
  936. {
  937. default:
  938. case SF_PCM16:
  939. *(short*)pDataOut = (short)round(f * SHRT_MAX);
  940. pDataOut += sizeof(short);
  941. break;
  942. case SF_PCM24:
  943. {DWORD i24 = (DWORD)(int)round(f * ((1<<23)-1));
  944. *pDataOut++ = (BYTE)(i24);
  945. *pDataOut++ = (BYTE)(i24>>8);
  946. *pDataOut++ = (BYTE)(i24>>16);}
  947. break;
  948. case SF_PCM32:
  949. *(int*)pDataOut = (int)round(f * INT_MAX);
  950. pDataOut += sizeof(int);
  951. break;
  952. case SF_FLOAT32:
  953. *(float*)pDataOut = f;
  954. pDataOut += sizeof(float);
  955. break;
  956. }
  957. }
  959. return m_pOutput->Deliver(pOut);
  960. }
  962. HRESULT CMpaDecFilter::Deliver(BYTE* pBuff, int size, int bit_rate, BYTE type)
  963. {
  964. HRESULT hr;
  966. CMediaType mt = CreateMediaTypeSPDIF();
  967. WAVEFORMATEX* wfe = (WAVEFORMATEX*)mt.Format();
  969. int length = 0;
  970. while(length < size+sizeof(WORD)*4) length += 0x800;
  971. int size2 = 1i64 * wfe->nBlockAlign * wfe->nSamplesPerSec * size*8 / bit_rate;
  972. while(length < size2) length += 0x800;
  974. if(FAILED(hr = ReconnectOutput(length / wfe->nBlockAlign, mt)))
  975. return hr;
  977. CComPtr<IMediaSample> pOut;
  978. BYTE* pDataOut = NULL;
  979. if(FAILED(GetDeliveryBuffer(&pOut, &pDataOut)))
  980. return E_FAIL;
  982. REFERENCE_TIME rtDur = 10000000i64 * size*8 / bit_rate;
  983. REFERENCE_TIME rtStart = m_rtStart, rtStop = m_rtStart + rtDur;
  984. m_rtStart += rtDur;
  986. if(rtStart < 0)
  987. return S_OK;
  989. if(hr == S_OK)
  990. {
  991. m_pOutput->SetMediaType(&mt);
  992. pOut->SetMediaType(&mt);
  993. }
  995. pOut->SetTime(&rtStart, &rtStop);
  996. pOut->SetMediaTime(NULL, NULL);
  998. pOut->SetPreroll(FALSE);
  999. pOut->SetDiscontinuity(m_fDiscontinuity); m_fDiscontinuity = false;
  1000. pOut->SetSyncPoint(TRUE);
  1002. pOut->SetActualDataLength(length);
  1004. WORD* pDataOutW = (WORD*)pDataOut;
  1005. pDataOutW[0] = 0xf872;
  1006. pDataOutW[1] = 0x4e1f;
  1007. pDataOutW[2] = type;
  1008. pDataOutW[3] = size*8;
  1009. _swab((char*)pBuff, (char*)&pDataOutW[4], size);
  1011. return m_pOutput->Deliver(pOut);
  1012. }
  1014. HRESULT CMpaDecFilter::ReconnectOutput(int nSamples, CMediaType& mt)
  1015. {
  1016. HRESULT hr;
  1018. CComQIPtr<IMemInputPin> pPin = m_pOutput->GetConnected();
  1019. if(!pPin) return E_NOINTERFACE;
  1021. CComPtr<IMemAllocator> pAllocator;
  1022. if(FAILED(hr = pPin->GetAllocator(&pAllocator)) || !pAllocator) 
  1023. return hr;
  1025. ALLOCATOR_PROPERTIES props, actual;
  1026. if(FAILED(hr = pAllocator->GetProperties(&props)))
  1027. return hr;
  1029. WAVEFORMATEX* wfe = (WAVEFORMATEX*)mt.Format();
  1030. long cbBuffer = nSamples * wfe->nBlockAlign;
  1032. if(mt != m_pOutput->CurrentMediaType() || cbBuffer > props.cbBuffer)
  1033. {
  1034. if(cbBuffer > props.cbBuffer)
  1035. {
  1036. props.cBuffers = 4;
  1037. props.cbBuffer = cbBuffer*3/2;
  1039. if(FAILED(hr = m_pOutput->DeliverBeginFlush())
  1040. || FAILED(hr = m_pOutput->DeliverEndFlush())
  1041. || FAILED(hr = pAllocator->Decommit())
  1042. || FAILED(hr = pAllocator->SetProperties(&props, &actual))
  1043. || FAILED(hr = pAllocator->Commit()))
  1044. return hr;
  1046. if(props.cBuffers > actual.cBuffers || props.cbBuffer > actual.cbBuffer)
  1047. {
  1048. NotifyEvent(EC_ERRORABORT, hr, 0);
  1049. return E_FAIL;
  1050. }
  1051. }
  1053. return S_OK;
  1054. }
  1056. return S_FALSE;
  1057. }
  1059. CMediaType CMpaDecFilter::CreateMediaType(SampleFormat sf, DWORD nSamplesPerSec, WORD nChannels, DWORD dwChannelMask)
  1060. {
  1061. CMediaType mt;
  1063. mt.majortype = MEDIATYPE_Audio;
  1064. mt.subtype = sf == SF_FLOAT32 ? MEDIASUBTYPE_IEEE_FLOAT : MEDIASUBTYPE_PCM;
  1065. mt.formattype = FORMAT_WaveFormatEx;
  1067. WAVEFORMATEXTENSIBLE wfex;
  1068. memset(&wfex, 0, sizeof(wfex));
  1069. WAVEFORMATEX* wfe = &wfex.Format;
  1070. wfe->wFormatTag = (WORD)mt.subtype.Data1;
  1071. wfe->nChannels = nChannels;
  1072. wfe->nSamplesPerSec = nSamplesPerSec;
  1073. switch(sf)
  1074. {
  1075. default:
  1076. case SF_PCM16: wfe->wBitsPerSample = 16; break;
  1077. case SF_PCM24: wfe->wBitsPerSample = 24; break;
  1078. case SF_PCM32: case SF_FLOAT32: wfe->wBitsPerSample = 32; break;
  1079. }
  1080. wfe->nBlockAlign = wfe->nChannels*wfe->wBitsPerSample/8;
  1081. wfe->nAvgBytesPerSec = wfe->nSamplesPerSec*wfe->nBlockAlign;
  1083. // FIXME: 24/32 bit only seems to work with WAVE_FORMAT_EXTENSIBLE
  1084. if(dwChannelMask == 0 && (sf == SF_PCM24 || sf == SF_PCM32))
  1085. dwChannelMask = nChannels == 2 ? (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT) : SPEAKER_FRONT_CENTER;
  1087. if(dwChannelMask)
  1088. {
  1089. wfex.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
  1090. wfex.Format.cbSize = sizeof(wfex) - sizeof(wfex.Format);
  1091. wfex.dwChannelMask = dwChannelMask;
  1092. wfex.Samples.wValidBitsPerSample = wfex.Format.wBitsPerSample;
  1093. wfex.SubFormat = mt.subtype;
  1094. }
  1096. mt.SetFormat((BYTE*)&wfex, sizeof(wfex.Format) + wfex.Format.cbSize);
  1098. return mt;
  1099. }
  1101. CMediaType CMpaDecFilter::CreateMediaTypeSPDIF()
  1102. {
  1103. CMediaType mt = CreateMediaType(SF_PCM16, 48000, 2);
  1104. ((WAVEFORMATEX*)mt.pbFormat)->wFormatTag = WAVE_FORMAT_DOLBY_AC3_SPDIF;
  1105. return mt;
  1106. }
  1108. HRESULT CMpaDecFilter::CheckInputType(const CMediaType* mtIn)
  1109. {
  1110. if(mtIn->subtype == MEDIASUBTYPE_DVD_LPCM_AUDIO)
  1111. {
  1112. WAVEFORMATEX* wfe = (WAVEFORMATEX*)mtIn->Format();
  1113. if(wfe->nChannels != 2 || wfe->wBitsPerSample != 16) // TODO: remove this limitation
  1114. return VFW_E_TYPE_NOT_ACCEPTED;
  1115. }
  1116. else if(mtIn->subtype == MEDIASUBTYPE_PS2_ADPCM)
  1117. {
  1118. WAVEFORMATEXPS2* wfe = (WAVEFORMATEXPS2*)mtIn->Format();
  1119. if(wfe->dwInterleave & 0xf) // has to be a multiple of the block size (16 bytes)
  1120. return VFW_E_TYPE_NOT_ACCEPTED;
  1121. }
  1123. for(int i = 0; i < countof(sudPinTypesIn); i++)
  1124. {
  1125. if(*sudPinTypesIn[i].clsMajorType == mtIn->majortype
  1126. && *sudPinTypesIn[i].clsMinorType == mtIn->subtype)
  1127. return S_OK;
  1128. }
  1130. return VFW_E_TYPE_NOT_ACCEPTED;
  1131. }
  1133. HRESULT CMpaDecFilter::CheckTransform(const CMediaType* mtIn, const CMediaType* mtOut)
  1134. {
  1135. return SUCCEEDED(CheckInputType(mtIn))
  1136. && mtOut->majortype == MEDIATYPE_Audio && mtOut->subtype == MEDIASUBTYPE_PCM
  1137. || mtOut->majortype == MEDIATYPE_Audio && mtOut->subtype == MEDIASUBTYPE_IEEE_FLOAT
  1138. ? S_OK
  1139. : VFW_E_TYPE_NOT_ACCEPTED;
  1140. }
  1142. HRESULT CMpaDecFilter::DecideBufferSize(IMemAllocator* pAllocator, ALLOCATOR_PROPERTIES* pProperties)
  1143. {
  1144. if(m_pInput->IsConnected() == FALSE) return E_UNEXPECTED;
  1146. CMediaType& mt = m_pInput->CurrentMediaType();
  1147. WAVEFORMATEX* wfe = (WAVEFORMATEX*)mt.Format();
  1149. pProperties->cBuffers = 4;
  1150. // pProperties->cbBuffer = 1;
  1151. pProperties->cbBuffer = 48000*6*(32/8)/10; // 48KHz 6ch 32bps 100ms
  1152. pProperties->cbAlign = 1;
  1153. pProperties->cbPrefix = 0;
  1155. HRESULT hr;
  1156. ALLOCATOR_PROPERTIES Actual;
  1157.     if(FAILED(hr = pAllocator->SetProperties(pProperties, &Actual))) 
  1158. return hr;
  1160.     return pProperties->cBuffers > Actual.cBuffers || pProperties->cbBuffer > Actual.cbBuffer
  1161. ? E_FAIL
  1162. : NOERROR;
  1163. }
  1165. HRESULT CMpaDecFilter::GetMediaType(int iPosition, CMediaType* pmt)
  1166. {
  1167.     if(m_pInput->IsConnected() == FALSE) return E_UNEXPECTED;
  1169. if(iPosition < 0) return E_INVALIDARG;
  1170. if(iPosition > 0) return VFW_S_NO_MORE_ITEMS;
  1172. CMediaType mt = m_pInput->CurrentMediaType();
  1173. const GUID& subtype = mt.subtype;
  1174. WAVEFORMATEX* wfe = (WAVEFORMATEX*)mt.Format();
  1176. if(GetSpeakerConfig(ac3) < 0 && (subtype == MEDIASUBTYPE_DOLBY_AC3 || subtype == MEDIASUBTYPE_WAVE_DOLBY_AC3)
  1177. || GetSpeakerConfig(dts) < 0 && (subtype == MEDIASUBTYPE_DTS || subtype == MEDIASUBTYPE_WAVE_DTS))
  1178. {
  1179. *pmt = CreateMediaTypeSPDIF();
  1180. }
  1181. else
  1182. {
  1183. *pmt = CreateMediaType(GetSampleFormat(), wfe->nSamplesPerSec, min(2, wfe->nChannels));
  1184. }
  1186. return S_OK;
  1187. }
  1189. HRESULT CMpaDecFilter::StartStreaming()
  1190. {
  1191. HRESULT hr = __super::StartStreaming();
  1192. if(FAILED(hr)) return hr;
  1194. m_a52_state = a52_init(0);
  1196. m_dts_state = dts_init(0);
  1198. m_aac_state.init(m_pInput->CurrentMediaType());
  1200. mad_stream_init(&m_stream);
  1201. mad_frame_init(&m_frame);
  1202. mad_synth_init(&m_synth);
  1203. mad_stream_options(&m_stream, 0/*options*/);
  1205. m_ps2_state.reset();
  1207. m_fDiscontinuity = false;
  1209. m_sample_max = 0.1f;
  1211. return S_OK;
  1212. }
  1214. HRESULT CMpaDecFilter::StopStreaming()
  1215. {
  1216. a52_free(m_a52_state);
  1218. dts_free(m_dts_state);
  1220. mad_synth_finish(&m_synth);
  1221. mad_frame_finish(&m_frame);
  1222. mad_stream_finish(&m_stream);
  1224. return __super::StopStreaming();
  1225. }
  1227. // IMpaDecFilter
  1229. STDMETHODIMP CMpaDecFilter::SetSampleFormat(SampleFormat sf)
  1230. {
  1231. CAutoLock cAutoLock(&m_csProps);
  1232. m_iSampleFormat = sf;
  1233. return S_OK;
  1234. }
  1236. STDMETHODIMP_(SampleFormat) CMpaDecFilter::GetSampleFormat()
  1237. {
  1238. CAutoLock cAutoLock(&m_csProps);
  1239. return m_iSampleFormat;
  1240. }
  1242. STDMETHODIMP CMpaDecFilter::SetNormalize(bool fNormalize)
  1243. {
  1244. CAutoLock cAutoLock(&m_csProps);
  1245. if(m_fNormalize != fNormalize) m_sample_max = 0.1f;
  1246. m_fNormalize = fNormalize;
  1247. return S_OK;
  1248. }
  1250. STDMETHODIMP_(bool) CMpaDecFilter::GetNormalize()
  1251. {
  1252. CAutoLock cAutoLock(&m_csProps);
  1253. return m_fNormalize;
  1254. }
  1256. STDMETHODIMP CMpaDecFilter::SetSpeakerConfig(enctype et, int sc)
  1257. {
  1258. CAutoLock cAutoLock(&m_csProps);
  1259. if(et >= 0 && et < etlast) m_iSpeakerConfig[et] = sc;
  1260. return S_OK;
  1261. }
  1263. STDMETHODIMP_(int) CMpaDecFilter::GetSpeakerConfig(enctype et)
  1264. {
  1265. CAutoLock cAutoLock(&m_csProps);
  1266. if(et >= 0 && et < etlast) return m_iSpeakerConfig[et];
  1267. return -1;
  1268. }
  1270. STDMETHODIMP CMpaDecFilter::SetDynamicRangeControl(enctype et, bool fDRC)
  1271. {
  1272. CAutoLock cAutoLock(&m_csProps);
  1273. if(et >= 0 && et < etlast) m_fDynamicRangeControl[et] = fDRC;
  1274. else return E_INVALIDARG;
  1275. return S_OK;
  1276. }
  1278. STDMETHODIMP_(bool) CMpaDecFilter::GetDynamicRangeControl(enctype et)
  1279. {
  1280. CAutoLock cAutoLock(&m_csProps);
  1281. if(et >= 0 && et < etlast) return m_fDynamicRangeControl[et];
  1282. return false;
  1283. }
  1285. STDMETHODIMP CMpaDecFilter::SetBoost(float boost)
  1286. {
  1287. CAutoLock cAutoLock(&m_csProps);
  1288. m_boost = max(boost, 1);
  1289. return S_OK;
  1290. }
  1292. STDMETHODIMP_(float) CMpaDecFilter::GetBoost()
  1293. {
  1294. CAutoLock cAutoLock(&m_csProps);
  1295. return m_boost;
  1296. }
  1298. //
  1299. // CMpaDecInputPin
  1300. //
  1302. CMpaDecInputPin::CMpaDecInputPin(CTransformFilter* pFilter, HRESULT* phr, LPWSTR pName)
  1303. : CDeCSSInputPin(NAME("CMpaDecInputPin"), pFilter, phr, pName)
  1304. {
  1305. }
  1307. //
  1308. // aac_state_t
  1309. //
  1311. aac_state_t::aac_state_t() : h(NULL), freq(0), channels(0) {open();}
  1312. aac_state_t::~aac_state_t() {close();}
  1314. bool aac_state_t::open()
  1315. {
  1316. close();
  1317. if(!(h = NeAACDecOpen())) return false;
  1318. NeAACDecConfigurationPtr c = NeAACDecGetCurrentConfiguration(h);
  1319. c->outputFormat = FAAD_FMT_FLOAT;
  1320. NeAACDecSetConfiguration(h, c);
  1321. return true;
  1322. }
  1324. void aac_state_t::close()
  1325. {
  1326. if(h) NeAACDecClose(h);
  1327. h = NULL;
  1328. }
  1330. bool aac_state_t::init(CMediaType& mt)
  1331. {
  1332. if(mt.subtype != MEDIASUBTYPE_AAC && mt.subtype != MEDIASUBTYPE_MP4A) return(true); // nothing to do
  1333. open();
  1334. WAVEFORMATEX* wfe = (WAVEFORMATEX*)mt.Format();
  1335. return !NeAACDecInit2(h, (BYTE*)(wfe+1), wfe->cbSize, &freq, &channels);
  1336. }