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

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

多媒体编程

开发平台：

Visual C++

AVI2AC3Filter.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 <atlbase.h>
  24. #include "avi2ac3filter.h"
  25. #include "......DSUtilDSUtil.h"
  27. #include <initguid.h>
  28. #include "........includemoreuuids.h"
  30. #ifdef REGISTER_FILTER
  32. const AMOVIESETUP_MEDIATYPE sudPinTypesIn[] =
  33. {
  34. {&MEDIATYPE_Audio, &MEDIASUBTYPE_WAVE_DOLBY_AC3},
  35. {&MEDIATYPE_Audio, &MEDIASUBTYPE_WAVE_DTS},
  36. };
  38. const AMOVIESETUP_MEDIATYPE sudPinTypesOut[] =
  39. {
  40. {&MEDIATYPE_Audio, &MEDIASUBTYPE_NULL},
  41. };
  43. const AMOVIESETUP_PIN sudpPins[] =
  44. {
  45.     {L"Input", FALSE, FALSE, FALSE, FALSE, &CLSID_NULL, NULL, countof(sudPinTypesIn), sudPinTypesIn},
  46.     {L"Output", FALSE, TRUE, FALSE, FALSE, &CLSID_NULL, NULL, countof(sudPinTypesOut), sudPinTypesOut}
  47. };
  49. const AMOVIESETUP_FILTER sudFilter[] =
  50. {
  51. {&__uuidof(CAVI2AC3Filter), L"AVI<->AC3/DTS", MERIT_UNLIKELY, countof(sudpPins), sudpPins}
  52. };
  54. CFactoryTemplate g_Templates[] =
  55. {
  56.     {sudFilter[0].strName, sudFilter[0].clsID, CreateInstance<CAVI2AC3Filter>, NULL, &sudFilter[0]}
  57. };
  59. int g_cTemplates = countof(g_Templates);
  61. STDAPI DllRegisterServer()
  62. {
  63. return AMovieDllRegisterServer2(TRUE);
  64. }
  66. STDAPI DllUnregisterServer()
  67. {
  68. return AMovieDllRegisterServer2(FALSE);
  69. }
  71. extern "C" BOOL WINAPI DllEntryPoint(HINSTANCE, ULONG, LPVOID);
  73. BOOL APIENTRY DllMain(HANDLE hModule, DWORD dwReason, LPVOID lpReserved)
  74. {
  75.     return DllEntryPoint((HINSTANCE)hModule, dwReason, 0); // "DllMain" of the dshow baseclasses;
  76. }
  78. #endif
  80. //
  81. // CAVI2AC3Filter
  82. //
  84. CAVI2AC3Filter::CAVI2AC3Filter(LPUNKNOWN lpunk, HRESULT* phr)
  85. : CTransformFilter(NAME("CAVI2AC3Filter"), lpunk, __uuidof(this))
  86. {
  87. if(phr) *phr = S_OK;
  88. }
  90. CAVI2AC3Filter::~CAVI2AC3Filter()
  91. {
  92. }
  94. HRESULT CAVI2AC3Filter::Transform(IMediaSample* pSample, IMediaSample* pOutSample)
  95. {
  96. HRESULT hr;
  98. BYTE* pIn = NULL;
  99. if(FAILED(hr = pSample->GetPointer(&pIn))) return hr;
  100. BYTE* pInOrg = pIn;
  102. long len = pSample->GetActualDataLength();
  103. if(len <= 0) return S_FALSE;
  105. BYTE* pOut = NULL;
  106. if(FAILED(hr = pOutSample->GetPointer(&pOut))) return hr;
  107. BYTE* pOutOrg = pOut;
  109. int size = pOutSample->GetSize();
  111. if((CheckAC3(&m_pInput->CurrentMediaType()) || CheckDTS(&m_pInput->CurrentMediaType()))
  112. && (CheckWAVEAC3(&m_pOutput->CurrentMediaType()) || CheckWAVEDTS(&m_pOutput->CurrentMediaType())))
  113. {
  114. if(*(DWORD*)pIn == 0xBA010000)
  115. {
  116. pIn += 14;
  117. }
  119. if(*(DWORD*)pIn == 0xBD010000)
  120. {
  121. pIn += 8 + 1 + pIn[8] + 1 + 3;
  122. }
  124. len -= (pInOrg - pIn);
  126. if(size < len) return E_FAIL;
  128. memcpy(pOut, pIn, len);
  129. pOut += len;
  130. }
  131. else if((CheckWAVEAC3(&m_pInput->CurrentMediaType()) || CheckWAVEDTS(&m_pInput->CurrentMediaType()))
  132. && (CheckAC3(&m_pOutput->CurrentMediaType()) || CheckDTS(&m_pOutput->CurrentMediaType())))
  133. {
  134. if((m_pOutput->CurrentMediaType().majortype == MEDIATYPE_DVD_ENCRYPTED_PACK
  135. || m_pOutput->CurrentMediaType().majortype == MEDIATYPE_MPEG2_PES)
  136. && (len + 12 + 3) >= 0x10000) // damn, this can happen if the interleave time is too big
  137. {
  138. REFERENCE_TIME rtStart = 0, rtStop = 1;
  139. bool fHasTime = (S_OK == pSample->GetTime(&rtStart, &rtStop));
  141. bool fDiscontinuity = (S_OK == pOutSample->IsDiscontinuity());
  143. int pos = 0;
  144. while(pos < len)
  145. {
  146. int curlen = min(len - pos, 2013);
  147. pos += 2013;
  149. CComPtr<IMediaSample> pOutSample;
  150. hr = InitializeOutputSample(pSample, &pOutSample);
  152. if(fDiscontinuity)
  153. {
  154. if(fHasTime)
  155. {
  156. rtStop = rtStart + (rtStop - rtStart) * curlen / len;
  157. pOutSample->SetTime(&rtStart, &rtStop);
  158. }
  160. fDiscontinuity = false;
  161. }
  162. else
  163. {
  164. pOutSample->SetTime(NULL, NULL);
  165. pOutSample->SetDiscontinuity(FALSE);
  166. }
  168. BYTE* pOut = NULL;
  169. if(FAILED(hr = pOutSample->GetPointer(&pOut))) return hr;
  170. BYTE* pOutOrg = pOut;
  172. int size = pOutSample->GetSize();
  174. const GUID* majortype = &m_pOutput->CurrentMediaType().majortype;
  175. const GUID* subtype = &m_pOutput->CurrentMediaType().subtype;
  177. if(*majortype == MEDIATYPE_DVD_ENCRYPTED_PACK)
  178. {
  179. if(size < curlen + 32 + 3) return E_FAIL;
  181. BYTE PESHeader[] = 
  182. {
  183. 0x00,0x00,0x01,0xBA, // PES id
  184. 0x44,0x00,0x04,0x00,0x04,0x01, // SCR (0)
  185. 0x01,0x89,0xC3,0xF8, // mux rate (1260000 bytes/sec, 22bits), marker (2bits), reserved (~0, 5bits), stuffing (0, 3bits)
  186. };
  188. memcpy(pOut, &PESHeader, sizeof(PESHeader));
  189. pOut += sizeof(PESHeader);
  191. majortype = &MEDIATYPE_MPEG2_PES;
  192. }
  194. if(*majortype == MEDIATYPE_MPEG2_PES)
  195. {
  196. if(size < curlen + 20 + 3) return E_FAIL;
  198. BYTE Private1Header[] = 
  199. {
  200. 0x00,0x00,0x01,0xBD, // private stream 1 id
  201. 0x07,0xEC, // packet length (TODO: modify it later)
  202. 0x81,0x80, // marker, original, PTS - flags
  203. 0x08, // packet data starting offset
  204. 0x21,0x00,0x01,0x00,0x01, // PTS (0)
  205. 0xFF,0xFF,0xFF, // stuffing
  206. 0x80, // stream id (0)
  207. 0x01,0x00,0x01, // no idea about the first byte, the sencond+third seem to show the ac3/dts header sync offset plus one (dvd2avi doesn't output it to the ac3/dts file so we have to put it back)
  208. };
  210. int packetlen = curlen + 12 + 3;
  211. ASSERT(packetlen <= 0xffff);
  212. Private1Header[4] = (packetlen>>8)&0xff;
  213. Private1Header[5] = packetlen&0xff;
  215. if(*subtype == MEDIASUBTYPE_DTS)
  216. {
  217. Private1Header[17] += 8;
  218. }
  220. if(*subtype == MEDIASUBTYPE_DOLBY_AC3)
  221. {
  222. for(int i = 0; i < curlen; i++)
  223. {
  224. if(*(DWORD*)&pIn[i] == 0x770B)
  225. {
  226. i++;
  227. Private1Header[19] = (i>>8)&0xff;
  228. Private1Header[20] = i&0xff;
  229. break;
  230. }
  231. }
  232. }
  233. else if(*subtype == MEDIASUBTYPE_DTS)
  234. {
  235. for(int i = 0; i < curlen; i++)
  236. {
  237. if(*(DWORD*)&pIn[i] == 0x0180FE7F)
  238. {
  239. i++;
  240. Private1Header[19] = (i>>8)&0xff;
  241. Private1Header[20] = i&0xff;
  242. break;
  243. }
  244. }
  245. }
  247. memcpy(pOut, &Private1Header, sizeof(Private1Header));
  248. pOut += sizeof(Private1Header);
  250. majortype = &MEDIATYPE_Audio;
  251. }
  253. if(*majortype == MEDIATYPE_Audio)
  254. {
  255. if(size < curlen) return E_FAIL;
  256. memcpy(pOut, pIn, curlen);
  257. pIn += curlen;
  258. pOut += curlen;
  259. }
  261. pOutSample->SetActualDataLength(pOut - pOutOrg);
  263. hr = m_pOutput->Deliver(pOutSample);
  264. }
  266. return S_FALSE;
  267. }
  268. else // phew, we can do the easier way
  269. {
  270. const GUID* majortype = &m_pOutput->CurrentMediaType().majortype;
  271. const GUID* subtype = &m_pOutput->CurrentMediaType().subtype;
  273. if(*majortype == MEDIATYPE_DVD_ENCRYPTED_PACK)
  274. {
  275. if(size < len + 32 + 3) return E_FAIL;
  277. BYTE PESHeader[] = 
  278. {
  279. 0x00,0x00,0x01,0xBA, // PES id
  280. 0x44,0x00,0x04,0x00,0x04,0x01, // SCR (0)
  281. 0x01,0x89,0xC3,0xF8, // mux rate (1260000 bytes/sec, 22bits), marker (2bits), reserved (~0, 5bits), stuffing (0, 3bits)
  282. };
  284. memcpy(pOut, &PESHeader, sizeof(PESHeader));
  285. pOut += sizeof(PESHeader);
  287. majortype = &MEDIATYPE_MPEG2_PES;
  288. }
  290. if(*majortype == MEDIATYPE_MPEG2_PES)
  291. {
  292. if(size < len + 20 + 3) return E_FAIL;
  294. BYTE Private1Header[] = 
  295. {
  296. 0x00,0x00,0x01,0xBD, // private stream 1 id
  297. 0x07,0xEC, // packet length (TODO: modify it later)
  298. 0x81,0x80, // marker, original, PTS - flags
  299. 0x08, // packet data starting offset
  300. 0x21,0x00,0x01,0x00,0x01, // PTS (0)
  301. 0xFF,0xFF,0xFF, // stuffing
  302. 0x80, // stream id (0)
  303. 0x01,0x00,0x01, // no idea about the first byte, the sencond+third seem to show the ac3/dts header sync offset plus one (dvd2avi doesn't output it to the ac3/dts file so we have to put it back)
  304. };
  306. int packetlen = len + 12 + 3;
  307. ASSERT(packetlen <= 0xffff);
  308. Private1Header[4] = (packetlen>>8)&0xff;
  309. Private1Header[5] = packetlen&0xff;
  311. if(*subtype == MEDIASUBTYPE_DTS)
  312. {
  313. Private1Header[17] += 8;
  314. }
  316. memcpy(pOut, &Private1Header, sizeof(Private1Header));
  317. pOut += sizeof(Private1Header);
  319. majortype = &MEDIATYPE_Audio;
  320. }
  322. if(*majortype == MEDIATYPE_Audio)
  323. {
  324. if(size < len) return E_FAIL;
  326. memcpy(pOut, pIn, len);
  327. pIn += len;
  328. pOut += len;
  329. }
  330. }
  331. }
  332. else
  333. {
  334. return E_FAIL;
  335. }
  337. pOutSample->SetActualDataLength(pOut - pOutOrg);
  339. return S_OK;
  340. }
  342. bool CAVI2AC3Filter::CheckAC3(const CMediaType* pmt)
  343. {
  344. return (pmt->majortype == MEDIATYPE_Audio
  345. || pmt->majortype == MEDIATYPE_MPEG2_PES 
  346. || pmt->majortype == MEDIATYPE_DVD_ENCRYPTED_PACK)
  347. && pmt->subtype == MEDIASUBTYPE_DOLBY_AC3;
  348. }
  350. bool CAVI2AC3Filter::CheckDTS(const CMediaType* pmt)
  351. {
  352. return (pmt->majortype == MEDIATYPE_Audio
  353. || pmt->majortype == MEDIATYPE_MPEG2_PES 
  354. || pmt->majortype == MEDIATYPE_DVD_ENCRYPTED_PACK)
  355. && pmt->subtype == MEDIASUBTYPE_DTS;
  356. }
  358. bool CAVI2AC3Filter::CheckWAVEAC3(const CMediaType* pmt)
  359. {
  360. return pmt->majortype == MEDIATYPE_Audio
  361. && pmt->subtype == MEDIASUBTYPE_WAVE_DOLBY_AC3
  362. && pmt->formattype == FORMAT_WaveFormatEx
  363. && ((WAVEFORMATEX*)pmt->pbFormat)->wFormatTag == WAVE_FORMAT_DOLBY_AC3;
  364. }
  366. bool CAVI2AC3Filter::CheckWAVEDTS(const CMediaType* pmt)
  367. {
  368. return pmt->majortype == MEDIATYPE_Audio
  369. && pmt->subtype == MEDIASUBTYPE_WAVE_DTS
  370. && pmt->formattype == FORMAT_WaveFormatEx
  371. && ((WAVEFORMATEX*)pmt->pbFormat)->wFormatTag == WAVE_FORMAT_DVD_DTS;
  372. }
  374. HRESULT CAVI2AC3Filter::CheckInputType(const CMediaType* mtIn)
  375. {
  376. bool fWaveFormatEx = !!(mtIn->formattype == FORMAT_WaveFormatEx);
  378. return CheckAC3(mtIn) && fWaveFormatEx || CheckDTS(mtIn) && fWaveFormatEx
  379. || CheckWAVEAC3(mtIn) || CheckWAVEDTS(mtIn)
  380. ? S_OK
  381. : VFW_E_TYPE_NOT_ACCEPTED;
  382. }
  384. HRESULT CAVI2AC3Filter::CheckTransform(const CMediaType* mtIn, const CMediaType* mtOut)
  385. {
  386. return CheckAC3(mtIn) && CheckWAVEAC3(mtOut)
  387. || CheckWAVEAC3(mtIn) && CheckAC3(mtOut)
  388. || CheckDTS(mtIn) && CheckWAVEDTS(mtOut)
  389. || CheckWAVEDTS(mtIn) && CheckDTS(mtOut)
  390. ? S_OK
  391. : VFW_E_TYPE_NOT_ACCEPTED;
  392. }
  394. HRESULT CAVI2AC3Filter::DecideBufferSize(IMemAllocator* pAllocator, ALLOCATOR_PROPERTIES* pProperties)
  395. {
  396. if(m_pInput->IsConnected() == FALSE) return E_UNEXPECTED;
  398. CComPtr<IMemAllocator> pAllocatorIn;
  399. m_pInput->GetAllocator(&pAllocatorIn);
  400. if(!pAllocatorIn) return E_UNEXPECTED;
  402. pAllocatorIn->GetProperties(pProperties);
  404. pProperties->cBuffers = 2;
  405. pProperties->cbBuffer = max(pProperties->cbBuffer, 1024*1024); // this should be enough...
  406. pProperties->cbAlign = 1;
  407. pProperties->cbPrefix = 0;
  409. HRESULT hr;
  410. ALLOCATOR_PROPERTIES Actual;
  411.     if(FAILED(hr = pAllocator->SetProperties(pProperties, &Actual))) 
  412. return hr;
  414.     return(pProperties->cBuffers > Actual.cBuffers || pProperties->cbBuffer > Actual.cbBuffer
  415. ? E_FAIL
  416. : NOERROR);
  417. }
  419. HRESULT CAVI2AC3Filter::GetMediaType(int iPosition, CMediaType* pMediaType)
  420. {
  421.     if(m_pInput->IsConnected() == FALSE) return E_UNEXPECTED;
  423. const GUID& majortype = m_pInput->CurrentMediaType().majortype;
  424. const GUID& subtype = m_pInput->CurrentMediaType().subtype;
  426. if(CheckAC3(&m_pInput->CurrentMediaType()) || CheckDTS(&m_pInput->CurrentMediaType()))
  427. {
  428. if(iPosition < 0) return E_INVALIDARG;
  429. if(iPosition > 0) return VFW_S_NO_MORE_ITEMS;
  431. pMediaType->majortype = MEDIATYPE_Audio;
  433. pMediaType->formattype = FORMAT_WaveFormatEx;
  434. WAVEFORMATEX* wfe = (WAVEFORMATEX*)pMediaType->AllocFormatBuffer(sizeof(WAVEFORMATEX));
  435. memset(wfe, 0, sizeof(WAVEFORMATEX));
  436. wfe->cbSize = sizeof(WAVEFORMATEX);
  437. wfe->nAvgBytesPerSec = ((WAVEFORMATEX*)m_pInput->CurrentMediaType().pbFormat)->nAvgBytesPerSec;
  438. wfe->nSamplesPerSec = ((WAVEFORMATEX*)m_pInput->CurrentMediaType().pbFormat)->nSamplesPerSec;
  439. wfe->wBitsPerSample = ((WAVEFORMATEX*)m_pInput->CurrentMediaType().pbFormat)->wBitsPerSample;
  440. wfe->nChannels = 2;
  441. wfe->nBlockAlign = 1;
  443. if(subtype == MEDIASUBTYPE_DOLBY_AC3)
  444. {
  445. pMediaType->subtype = MEDIASUBTYPE_WAVE_DOLBY_AC3;
  446. wfe->wFormatTag = WAVE_FORMAT_DOLBY_AC3;
  447. }
  448. else if(subtype == MEDIASUBTYPE_DTS)
  449. {
  450. pMediaType->subtype = MEDIASUBTYPE_WAVE_DTS;
  451. wfe->wFormatTag = WAVE_FORMAT_DVD_DTS;
  452. }
  453. else
  454. {
  455. return E_INVALIDARG;
  456. }
  457. }
  458. else if(CheckWAVEAC3(&m_pInput->CurrentMediaType()) || CheckWAVEDTS(&m_pInput->CurrentMediaType()))
  459. {
  460. if(iPosition < 0) return E_INVALIDARG;
  461. if(iPosition > 4) return VFW_S_NO_MORE_ITEMS;
  463. if(subtype == MEDIASUBTYPE_WAVE_DOLBY_AC3)
  464. {
  465. pMediaType->subtype = MEDIASUBTYPE_DOLBY_AC3;
  467. pMediaType->formattype = FORMAT_WaveFormatEx;
  468. DOLBYAC3WAVEFORMAT* wfe = (DOLBYAC3WAVEFORMAT*)pMediaType->AllocFormatBuffer(sizeof(DOLBYAC3WAVEFORMAT));
  469. memset(wfe, 0, sizeof(DOLBYAC3WAVEFORMAT));
  470. // unfortunately we can't tell what we are going to get in transform, 
  471. // so we just set the most common values and hope that the ac3 decoder 
  472. // is flexible enough (it is usually :) to find out these from the bitstream
  473. wfe->wfx.cbSize = sizeof(DOLBYAC3WAVEFORMAT) - sizeof(WAVEFORMATEX);
  474. wfe->wfx.wFormatTag = WAVE_FORMAT_DOLBY_AC3;
  475. wfe->wfx.nSamplesPerSec = 48000;
  476. wfe->wfx.nChannels = 6;
  477. wfe->bBigEndian = TRUE;
  478. }
  479. else if(subtype == MEDIASUBTYPE_WAVE_DTS)
  480. {
  481. pMediaType->subtype = MEDIASUBTYPE_DTS;
  483. pMediaType->formattype = FORMAT_WaveFormatEx;
  484. WAVEFORMATEX* wfe = (WAVEFORMATEX*)pMediaType->AllocFormatBuffer(sizeof(WAVEFORMATEX));
  485. memset(wfe, 0, sizeof(WAVEFORMATEX));
  486. // same case as with ac3, but this time we don't even know the structure
  487. wfe->cbSize = sizeof(WAVEFORMATEX);
  488. wfe->wFormatTag = WAVE_FORMAT_PCM;
  489. wfe->nSamplesPerSec = 48000;
  490. wfe->nChannels = 6;
  491. }
  492. else
  493. {
  494. return E_INVALIDARG;
  495. }
  497. switch(iPosition)
  498. {
  499. case 0:
  500. pMediaType->majortype = MEDIATYPE_Audio;
  501. break;
  502. case 1:
  503. pMediaType->ResetFormatBuffer();
  504. pMediaType->formattype = FORMAT_None;
  505. case 2:
  506. pMediaType->majortype = MEDIATYPE_MPEG2_PES;
  507. break;
  508. case 3:
  509. pMediaType->ResetFormatBuffer();
  510. pMediaType->formattype = FORMAT_None;
  511. case 4:
  512. pMediaType->majortype = MEDIATYPE_DVD_ENCRYPTED_PACK;
  513. break;
  514. default:
  515. return E_INVALIDARG;
  516. }
  517. }
  518. else
  519. {
  520. return VFW_S_NO_MORE_ITEMS;
  521. }
  523. return S_OK;
  524. }