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

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

多媒体编程

开发平台：

Visual C++

AudioSwitcher.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"
  24. #include "Shlwapi.h"
  25. #include <atlpath.h>
  26. #include <mmreg.h>
  27. #include <ks.h>
  28. #include <ksmedia.h>
  29. #include "AudioSwitcher.h"
  30. #include "Audio.h"
  31. #include "......DSUtilDSUtil.h"
  33. #include <initguid.h>
  34. #include "........includeOggOggDS.h"
  37. #ifdef REGISTER_FILTER
  39. const AMOVIESETUP_MEDIATYPE sudPinTypesIn[] =
  40. {
  41. {&MEDIATYPE_Audio, &MEDIASUBTYPE_NULL}
  42. };
  44. const AMOVIESETUP_MEDIATYPE sudPinTypesOut[] =
  45. {
  46. {&MEDIATYPE_Audio, &MEDIASUBTYPE_NULL}
  47. };
  49. const AMOVIESETUP_PIN sudpPins[] =
  50. {
  51.     {L"Input", FALSE, FALSE, FALSE, FALSE, &CLSID_NULL, NULL, countof(sudPinTypesIn), sudPinTypesIn},
  52.     {L"Output", FALSE, TRUE, FALSE, FALSE, &CLSID_NULL, NULL, countof(sudPinTypesOut), sudPinTypesOut}
  53. };
  55. const AMOVIESETUP_FILTER sudFilter[] =
  56. {
  57. {&__uuidof(CAudioSwitcherFilter), L"AudioSwitcher", MERIT_DO_NOT_USE, countof(sudpPins), sudpPins}
  58. };
  60. CFactoryTemplate g_Templates[] =
  61. {
  62.     {sudFilter[0].strName, sudFilter[0].clsID, CreateInstance<CAudioSwitcherFilter>, NULL, &sudFilter[0]}
  63. };
  65. int g_cTemplates = countof(g_Templates);
  67. STDAPI DllRegisterServer()
  68. {
  69. return AMovieDllRegisterServer2(TRUE);
  70. }
  72. STDAPI DllUnregisterServer()
  73. {
  74. return AMovieDllRegisterServer2(FALSE);
  75. }
  77. extern "C" BOOL WINAPI DllEntryPoint(HINSTANCE, ULONG, LPVOID);
  79. BOOL APIENTRY DllMain(HANDLE hModule, DWORD dwReason, LPVOID lpReserved)
  80. {
  81.     return DllEntryPoint((HINSTANCE)hModule, dwReason, 0); // "DllMain" of the dshow baseclasses;
  82. }
  84. #endif
  86. //
  87. // CAudioSwitcherFilter
  88. //
  90. CAudioSwitcherFilter::CAudioSwitcherFilter(LPUNKNOWN lpunk, HRESULT* phr)
  91. : CStreamSwitcherFilter(lpunk, phr, __uuidof(this))
  92. {
  93. if(phr)
  94. {
  95. if(FAILED(*phr)) return;
  96. else *phr = S_OK;
  97. }
  99. m_fCustomChannelMapping = false;
  100. memset(m_pSpeakerToChannelMap, 0, sizeof(m_pSpeakerToChannelMap));
  101. m_fDownSampleTo441 = false;
  102. m_rtAudioTimeShift = 0;
  103. m_rtNextStart = 0;
  104. m_rtNextStop = 1;
  105. }
  107. STDMETHODIMP CAudioSwitcherFilter::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  108. {
  109. return
  110. QI(IAudioSwitcherFilter)
  111. __super::NonDelegatingQueryInterface(riid, ppv);
  112. }
  114. HRESULT CAudioSwitcherFilter::CheckMediaType(const CMediaType* pmt)
  115. {
  116. if(pmt->formattype == FORMAT_WaveFormatEx
  117. && ((WAVEFORMATEX*)pmt->pbFormat)->nChannels > 2
  118. && ((WAVEFORMATEX*)pmt->pbFormat)->wFormatTag != WAVE_FORMAT_EXTENSIBLE)
  119. return VFW_E_INVALIDMEDIATYPE; // stupid iviaudio tries to fool us
  121. return (pmt->majortype == MEDIATYPE_Audio
  122. && pmt->formattype == FORMAT_WaveFormatEx
  123. && (((WAVEFORMATEX*)pmt->pbFormat)->wBitsPerSample == 8
  124. || ((WAVEFORMATEX*)pmt->pbFormat)->wBitsPerSample == 16
  125. || ((WAVEFORMATEX*)pmt->pbFormat)->wBitsPerSample == 24
  126. || ((WAVEFORMATEX*)pmt->pbFormat)->wBitsPerSample == 32)
  127. && (((WAVEFORMATEX*)pmt->pbFormat)->wFormatTag == WAVE_FORMAT_PCM
  128. || ((WAVEFORMATEX*)pmt->pbFormat)->wFormatTag == WAVE_FORMAT_IEEE_FLOAT
  129. || ((WAVEFORMATEX*)pmt->pbFormat)->wFormatTag == WAVE_FORMAT_DOLBY_AC3_SPDIF
  130. || ((WAVEFORMATEX*)pmt->pbFormat)->wFormatTag == WAVE_FORMAT_EXTENSIBLE))
  131. ? S_OK
  132. : VFW_E_TYPE_NOT_ACCEPTED;
  133. }
  135. #define mixchannels(type, sumtype, mintype, maxtype) 
  136. sumtype sum = 0; 
  137. int num = 0; 
  138. for(int j = 0; j < 18 && j < wfe->nChannels; j++) 
  139. { 
  140. if(Channel&(1<<j)) 
  141. { 
  142. num++; 
  143. sum += *(type*)&pDataIn[bps*(j + wfe->nChannels*k)]; 
  144. } 
  145. } 
  146. sum = min(max(sum, mintype), maxtype); 
  147. *(type*)&pDataOut[bps*(i + wfeout->nChannels*k)] = (type)sum; 
  149. HRESULT CAudioSwitcherFilter::Transform(IMediaSample* pIn, IMediaSample* pOut)
  150. {
  151. CStreamSwitcherInputPin* pInPin = GetInputPin();
  152. CStreamSwitcherOutputPin* pOutPin = GetOutputPin();
  153. if(!pInPin || !pOutPin) 
  154. return __super::Transform(pIn, pOut);
  156. WAVEFORMATEX* wfe = (WAVEFORMATEX*)pInPin->CurrentMediaType().pbFormat;
  157. WAVEFORMATEX* wfeout = (WAVEFORMATEX*)pOutPin->CurrentMediaType().pbFormat;
  158. WAVEFORMATEXTENSIBLE* wfex = (WAVEFORMATEXTENSIBLE*)wfe;
  159. WAVEFORMATEXTENSIBLE* wfexout = (WAVEFORMATEXTENSIBLE*)wfeout;
  161. int bps = wfe->wBitsPerSample>>3;
  163. int len = pIn->GetActualDataLength() / (bps*wfe->nChannels);
  164. int lenout = len * wfeout->nSamplesPerSec / wfe->nSamplesPerSec;
  166. REFERENCE_TIME rtStart, rtStop;
  167. if(SUCCEEDED(pIn->GetTime(&rtStart, &rtStop)))
  168. {
  169. rtStart += m_rtAudioTimeShift;
  170. rtStop += m_rtAudioTimeShift;
  171. pOut->SetTime(&rtStart, &rtStop);
  173. m_rtNextStart = rtStart;
  174. m_rtNextStop = rtStop;
  175. }
  176. else
  177. {
  178. pOut->SetTime(&m_rtNextStart, &m_rtNextStop);
  179. }
  181. m_rtNextStart += 10000000i64*len/wfe->nSamplesPerSec;
  182. m_rtNextStop += 10000000i64*len/wfe->nSamplesPerSec;
  184. bool fPCM = wfe->wFormatTag == WAVE_FORMAT_PCM
  185. || wfe->wFormatTag == WAVE_FORMAT_EXTENSIBLE && wfex->SubFormat == KSDATAFORMAT_SUBTYPE_PCM;
  187. bool fFloat = wfe->wFormatTag == WAVE_FORMAT_IEEE_FLOAT
  188. || wfe->wFormatTag == WAVE_FORMAT_EXTENSIBLE && wfex->SubFormat == KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
  190. if(!fPCM && !fFloat)
  191. return __super::Transform(pIn, pOut);
  193. BYTE* pDataIn = NULL;
  194. BYTE* pDataOut = NULL;
  196. HRESULT hr;
  197. if(FAILED(hr = pIn->GetPointer(&pDataIn))) return hr;
  198. if(FAILED(hr = pOut->GetPointer(&pDataOut))) return hr;
  200. if(!pDataIn || !pDataOut || len <= 0 || lenout <= 0) return S_FALSE;
  202. memset(pDataOut, 0, pOut->GetSize());
  204. if(m_fCustomChannelMapping)
  205. {
  206. if(m_chs[wfe->nChannels-1].GetCount() > 0)
  207. {
  208. for(int i = 0; i < wfeout->nChannels; i++)
  209. {
  210. DWORD Channel = m_chs[wfe->nChannels-1][i].Channel, nChannels = 0;
  212. for(int k = 0; k < len; k++)
  213. {
  214. if(fPCM && wfe->wBitsPerSample == 8)
  215. {
  216. mixchannels(unsigned char, __int64, 0, UCHAR_MAX);
  217. }
  218. else if(fPCM && wfe->wBitsPerSample == 16)
  219. {
  220. mixchannels(short, __int64, SHRT_MIN, SHRT_MAX);
  221. }
  222. else if(fPCM && wfe->wBitsPerSample == 24)
  223. {
  224. // mixchannels(_int24, __int64, _INT24_MIN, _INT24_MAX);
  226. __int64 sum = 0;
  227. int num = 0;
  228. for(int j = 0; j < 18 && j < wfe->nChannels; j++)
  229. {
  230. if(Channel&(1<<j))
  231. {
  232. num++;
  233. int tmp;
  234. memcpy((BYTE*)&tmp+1, &pDataIn[bps*(j + wfe->nChannels*k)], 3);
  235. tmp>>=8;
  236. sum += tmp;
  237. }
  238. }
  239. sum = min(max(sum, -(1<<24)), (1<<24)-1);
  240. memcpy(&pDataOut[bps*(i + wfeout->nChannels*k)], (BYTE*)&sum, 3);
  241. }
  242. else if(fPCM && wfe->wBitsPerSample == 32)
  243. {
  244. mixchannels(int, __int64, INT_MIN, INT_MAX);
  245. }
  246. else if(fFloat && wfe->wBitsPerSample == 32)
  247. {
  248. mixchannels(float, double, -1, 1);
  249. }
  250. else if(fFloat && wfe->wBitsPerSample == 64)
  251. {
  252. mixchannels(double, double, -1, 1);
  253. }
  254. }
  255. }
  256. }
  257. else
  258. {
  259. BYTE* pDataOut = NULL;
  260. HRESULT hr;
  261. if(FAILED(hr = pOut->GetPointer(&pDataOut)) || !pDataOut) return hr;
  262. memset(pDataOut, 0, pOut->GetSize());
  263. }
  264. }
  265. else
  266. {
  267. HRESULT hr;
  268. if(S_OK != (hr = __super::Transform(pIn, pOut)))
  269. return hr;
  270. }
  272. if(m_fDownSampleTo441
  273. && wfe->nSamplesPerSec > 44100 && wfeout->nSamplesPerSec == 44100 
  274. && wfe->wBitsPerSample <= 16 && fPCM)
  275. {
  276. if(BYTE* buff = new BYTE[len*bps])
  277. {
  278. for(int ch = 0; ch < wfeout->nChannels; ch++)
  279. {
  280. memset(buff, 0, len*bps);
  282. for(int i = 0; i < len; i++)
  283. memcpy(buff + i*bps, (char*)pDataOut + (ch + i*wfeout->nChannels)*bps, bps);
  285. m_pResamplers[ch]->Downsample(buff, len, buff, lenout);
  287. for(int i = 0; i < lenout; i++)
  288. memcpy((char*)pDataOut + (ch + i*wfeout->nChannels)*bps, buff + i*bps, bps);
  289. }
  291. delete [] buff;
  292. }
  293. }
  295. pOut->SetActualDataLength(lenout*bps*wfeout->nChannels);
  297. return S_OK;
  298. }
  300. CMediaType CAudioSwitcherFilter::CreateNewOutputMediaType(CMediaType mt, long& cbBuffer)
  301. {
  302. CStreamSwitcherInputPin* pInPin = GetInputPin();
  303. CStreamSwitcherOutputPin* pOutPin = GetOutputPin();
  304. if(!pInPin || !pOutPin || ((WAVEFORMATEX*)mt.pbFormat)->wFormatTag == WAVE_FORMAT_DOLBY_AC3_SPDIF) 
  305. return __super::CreateNewOutputMediaType(mt, cbBuffer);
  307. WAVEFORMATEX* wfe = (WAVEFORMATEX*)pInPin->CurrentMediaType().pbFormat;
  309. if(m_fCustomChannelMapping)
  310. {
  311. m_chs[wfe->nChannels-1].RemoveAll();
  313. DWORD mask = DWORD((__int64(1)<<wfe->nChannels)-1);
  314. for(int i = 0; i < 18; i++)
  315. {
  316. if(m_pSpeakerToChannelMap[wfe->nChannels-1][i]&mask)
  317. {
  318. ChMap cm = {1<<i, m_pSpeakerToChannelMap[wfe->nChannels-1][i]};
  319. m_chs[wfe->nChannels-1].Add(cm);
  320. }
  321. }
  323. if(m_chs[wfe->nChannels-1].GetCount() > 0)
  324. {
  325. mt.ReallocFormatBuffer(sizeof(WAVEFORMATEXTENSIBLE));
  326. WAVEFORMATEXTENSIBLE* wfex = (WAVEFORMATEXTENSIBLE*)mt.pbFormat;
  327. wfex->Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE)-sizeof(WAVEFORMATEX);
  328. wfex->Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
  329. wfex->Samples.wValidBitsPerSample = wfe->wBitsPerSample;
  330. wfex->SubFormat = 
  331. wfe->wFormatTag == WAVE_FORMAT_PCM ? KSDATAFORMAT_SUBTYPE_PCM :
  332. wfe->wFormatTag == WAVE_FORMAT_IEEE_FLOAT ? KSDATAFORMAT_SUBTYPE_IEEE_FLOAT :
  333. wfe->wFormatTag == WAVE_FORMAT_EXTENSIBLE ? ((WAVEFORMATEXTENSIBLE*)wfe)->SubFormat :
  334. KSDATAFORMAT_SUBTYPE_PCM; // can't happen
  336. wfex->dwChannelMask = 0;
  337. for(int i = 0; i < m_chs[wfe->nChannels-1].GetCount(); i++)
  338. wfex->dwChannelMask |= m_chs[wfe->nChannels-1][i].Speaker;
  340. wfex->Format.nChannels = (WORD)m_chs[wfe->nChannels-1].GetCount();
  341. wfex->Format.nBlockAlign = wfex->Format.nChannels*wfex->Format.wBitsPerSample>>3;
  342. wfex->Format.nAvgBytesPerSec = wfex->Format.nBlockAlign*wfex->Format.nSamplesPerSec;
  343. }
  344. }
  346. WAVEFORMATEX* wfeout = (WAVEFORMATEX*)mt.pbFormat;
  348. if(m_fDownSampleTo441)
  349. {
  350. if(wfeout->nSamplesPerSec > 44100 && wfeout->wBitsPerSample <= 16)
  351. {
  352. wfeout->nSamplesPerSec = 44100;
  353. wfeout->nAvgBytesPerSec = wfeout->nBlockAlign*wfeout->nSamplesPerSec;
  354. }
  355. }
  357. int bps = wfe->wBitsPerSample>>3;
  358. int len = cbBuffer / (bps*wfe->nChannels);
  359. int lenout = len * wfeout->nSamplesPerSec / wfe->nSamplesPerSec;
  360. cbBuffer = lenout*bps*wfeout->nChannels;
  362. // mt.lSampleSize = (ULONG)max(mt.lSampleSize, wfe->nAvgBytesPerSec * rtLen / 10000000i64);
  363. // mt.lSampleSize = (mt.lSampleSize + (wfe->nBlockAlign-1)) & ~(wfe->nBlockAlign-1);
  365. return mt;
  366. }
  368. void CAudioSwitcherFilter::OnNewOutputMediaType(const CMediaType& mtIn, const CMediaType& mtOut)
  369. {
  370. const WAVEFORMATEX* wfe = (WAVEFORMATEX*)mtIn.pbFormat;
  371. const WAVEFORMATEX* wfeout = (WAVEFORMATEX*)mtOut.pbFormat;
  373. m_pResamplers.RemoveAll();
  374. for(int i = 0; i < wfeout->nChannels; i++)
  375. {
  376. CAutoPtr<AudioStreamResampler> pResampler;
  377. pResampler.Attach(new AudioStreamResampler(wfeout->wBitsPerSample>>3, wfe->nSamplesPerSec, wfeout->nSamplesPerSec, true));
  378. m_pResamplers.Add(pResampler);
  379. }
  380. }
  382. // IAudioSwitcherFilter
  384. STDMETHODIMP CAudioSwitcherFilter::GetInputSpeakerConfig(DWORD* pdwChannelMask)
  385. {
  386. if(!pdwChannelMask) 
  387. return E_POINTER;
  389. *pdwChannelMask = 0;
  391. CStreamSwitcherInputPin* pInPin = GetInputPin();
  392. if(!pInPin || !pInPin->IsConnected())
  393. return E_UNEXPECTED;
  395. WAVEFORMATEX* wfe = (WAVEFORMATEX*)pInPin->CurrentMediaType().pbFormat;
  397. if(wfe->wFormatTag == WAVE_FORMAT_EXTENSIBLE)
  398. {
  399. WAVEFORMATEXTENSIBLE* wfex = (WAVEFORMATEXTENSIBLE*)wfe;
  400. *pdwChannelMask = wfex->dwChannelMask;
  401. }
  402. else
  403. {
  404. *pdwChannelMask = 0/*wfe->nChannels == 1 ? 4 : wfe->nChannels == 2 ? 3 : 0*/;
  405. }
  407. return S_OK;
  408. }
  410. STDMETHODIMP CAudioSwitcherFilter::GetSpeakerConfig(bool* pfCustomChannelMapping, DWORD pSpeakerToChannelMap[18][18])
  411. {
  412. if(pfCustomChannelMapping) *pfCustomChannelMapping = m_fCustomChannelMapping;
  413. memcpy(pSpeakerToChannelMap, m_pSpeakerToChannelMap, sizeof(m_pSpeakerToChannelMap));
  415. return S_OK;
  416. }
  418. STDMETHODIMP CAudioSwitcherFilter::SetSpeakerConfig(bool fCustomChannelMapping, DWORD pSpeakerToChannelMap[18][18])
  419. {
  420. if(m_State == State_Stopped || m_fCustomChannelMapping != fCustomChannelMapping
  421. || memcmp(m_pSpeakerToChannelMap, pSpeakerToChannelMap, sizeof(m_pSpeakerToChannelMap)))
  422. {
  423. PauseGraph;
  425. CStreamSwitcherInputPin* pInput = GetInputPin();
  427. SelectInput(NULL);
  429. m_fCustomChannelMapping = fCustomChannelMapping;
  430. memcpy(m_pSpeakerToChannelMap, pSpeakerToChannelMap, sizeof(m_pSpeakerToChannelMap));
  432. SelectInput(pInput);
  434. ResumeGraph;
  435. }
  437. return S_OK;
  438. }
  440. STDMETHODIMP_(int) CAudioSwitcherFilter::GetNumberOfInputChannels()
  441. {
  442. CStreamSwitcherInputPin* pInPin = GetInputPin();
  443. return pInPin ? ((WAVEFORMATEX*)pInPin->CurrentMediaType().pbFormat)->nChannels : 0;
  444. }
  446. STDMETHODIMP_(bool) CAudioSwitcherFilter::IsDownSamplingTo441Enabled()
  447. {
  448. return(m_fDownSampleTo441);
  449. }
  451. STDMETHODIMP CAudioSwitcherFilter::EnableDownSamplingTo441(bool fEnable)
  452. {
  453. if(m_fDownSampleTo441 != fEnable)
  454. {
  455. PauseGraph;
  457. m_fDownSampleTo441 = fEnable;
  459. ResumeGraph;
  460. }
  462. return S_OK;
  463. }
  465. STDMETHODIMP_(REFERENCE_TIME) CAudioSwitcherFilter::GetAudioTimeShift()
  466. {
  467. return(m_rtAudioTimeShift);
  468. }
  470. STDMETHODIMP CAudioSwitcherFilter::SetAudioTimeShift(REFERENCE_TIME rtAudioTimeShift)
  471. {
  472. m_rtAudioTimeShift = rtAudioTimeShift;
  473. return S_OK;
  474. }