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

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

多媒体编程

开发平台：

Visual C++

AviSplitter.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 <mmreg.h>
  24. #include "AviFile.h"
  25. #include "AviReportWnd.h"
  26. #include "AviSplitter.h"
  28. #ifdef REGISTER_FILTER
  30. const AMOVIESETUP_MEDIATYPE sudPinTypesIn[] =
  31. {
  32. {&MEDIATYPE_Stream, &MEDIASUBTYPE_Avi},
  33. {&MEDIATYPE_Stream, &MEDIASUBTYPE_NULL},
  34. };
  36. const AMOVIESETUP_PIN sudpPins[] =
  37. {
  38.     {L"Input", FALSE, FALSE, FALSE, FALSE, &CLSID_NULL, NULL, countof(sudPinTypesIn), sudPinTypesIn},
  39.     {L"Output", FALSE, TRUE, FALSE, FALSE, &CLSID_NULL, NULL, 0, NULL}
  40. };
  42. const AMOVIESETUP_FILTER sudFilter[] =
  43. {
  44. {&__uuidof(CAviSplitterFilter), L"Avi Splitter", MERIT_NORMAL+1, countof(sudpPins), sudpPins},
  45. {&__uuidof(CAviSourceFilter), L"Avi Source", MERIT_NORMAL+1, 0, NULL},
  46. };
  48. CFactoryTemplate g_Templates[] =
  49. {
  50. {sudFilter[0].strName, sudFilter[0].clsID, CreateInstance<CAviSplitterFilter>, NULL, &sudFilter[0]},
  51. {sudFilter[1].strName, sudFilter[1].clsID, CreateInstance<CAviSourceFilter>, NULL, &sudFilter[1]},
  52. };
  54. int g_cTemplates = countof(g_Templates);
  56. STDAPI DllRegisterServer()
  57. {
  58. RegisterSourceFilter(
  59. CLSID_AsyncReader, 
  60. MEDIASUBTYPE_Avi, 
  61. _T("0,4,,52494646,8,4,41564920"), 
  62. _T(".avi"), _T(".divx"), _T(".vp6"), NULL);
  64. return AMovieDllRegisterServer2(TRUE);
  65. }
  67. STDAPI DllUnregisterServer()
  68. {
  69. // UnRegisterSourceFilter(MEDIASUBTYPE_Avi);
  71. return AMovieDllRegisterServer2(FALSE);
  72. }
  74. extern "C" BOOL WINAPI DllEntryPoint(HINSTANCE, ULONG, LPVOID);
  76. class CAviSplitterApp : public CWinApp
  77. {
  78. public:
  79. CAviSplitterApp() {}
  81. BOOL InitInstance()
  82. {
  83. if(!__super::InitInstance()) return FALSE;
  84. DllEntryPoint(m_hInstance, DLL_PROCESS_ATTACH, 0);
  85. return TRUE;
  86. }
  88. BOOL ExitInstance()
  89. {
  90. DllEntryPoint(m_hInstance, DLL_PROCESS_DETACH, 0);
  91. return __super::ExitInstance();
  92. }
  94. void SetDefaultRegistryKey()
  95. {
  96. SetRegistryKey(_T("Gabest"));
  97. }
  99. DECLARE_MESSAGE_MAP()
  100. };
  102. BEGIN_MESSAGE_MAP(CAviSplitterApp, CWinApp)
  103. END_MESSAGE_MAP()
  105. CAviSplitterApp theApp;
  107. #endif
  109. //
  110. // CAviSplitterFilter
  111. //
  113. CAviSplitterFilter::CAviSplitterFilter(LPUNKNOWN pUnk, HRESULT* phr)
  114. : CBaseSplitterFilter(NAME("CAviSplitterFilter"), pUnk, phr, __uuidof(this))
  115. , m_timeformat(TIME_FORMAT_MEDIA_TIME)
  116. {
  117. }
  119. STDMETHODIMP CAviSplitterFilter::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  120. {
  121. CheckPointer(ppv, E_POINTER);
  123. *ppv = NULL;
  125. return 
  126. __super::NonDelegatingQueryInterface(riid, ppv);
  127. }
  129. HRESULT CAviSplitterFilter::CreateOutputs(IAsyncReader* pAsyncReader)
  130. {
  131. CheckPointer(pAsyncReader, E_POINTER);
  133. HRESULT hr = E_FAIL;
  135. m_pFile.Free();
  136. m_tFrame.Free();
  138. m_pFile.Attach(new CAviFile(pAsyncReader, hr));
  139. if(!m_pFile) return E_OUTOFMEMORY;
  141. bool fShiftDown = !!(::GetKeyState(VK_SHIFT)&0x8000);
  142. bool fShowWarningText = !m_pFile->IsInterleaved(fShiftDown);
  144. if(SUCCEEDED(hr) && (fShowWarningText || fShiftDown))
  145. {
  146. #ifdef REGISTER_FILTER
  147. AFX_MANAGE_STATE(AfxGetStaticModuleState());
  148. #endif
  149. bool fHideWarning = !!AfxGetApp()->GetProfileInt(_T("Settings"), _T("HideAviSplitterWarning"), 0);
  151. if(!fHideWarning && !dynamic_cast<CAviSourceFilter*>(this) || fShiftDown)
  152. {
  153. CAviReportWnd wnd;
  154. fHideWarning = wnd.DoModal(m_pFile, fHideWarning, fShowWarningText);
  155. AfxGetApp()->WriteProfileInt(_T("Settings"), _T("HideAviSplitterWarning"), fHideWarning);
  156. }
  158. if(fShowWarningText) hr = E_FAIL;
  159. }
  161. if(FAILED(hr)) {m_pFile.Free(); return hr;}
  163. m_rtNewStart = m_rtCurrent = 0;
  164. m_rtNewStop = m_rtStop = m_rtDuration = m_pFile->GetTotalTime();
  166. bool fHasIndex = false;
  168. for(DWORD i = 0; !fHasIndex && i < m_pFile->m_strms.GetCount(); i++)
  169. if(m_pFile->m_strms[i]->cs.GetCount() > 0) 
  170. fHasIndex = true;
  172. for(DWORD i = 0; i < m_pFile->m_strms.GetCount(); i++)
  173. {
  174. CAviFile::strm_t* s = m_pFile->m_strms[i];
  176. if(fHasIndex && s->cs.GetCount() == 0) continue;
  178. CMediaType mt;
  179. CArray<CMediaType> mts;
  181. CStringW name, label;
  183. if(s->strh.fccType == FCC('vids'))
  184. {
  185. label = L"Video";
  187. ASSERT(s->strf.GetSize() >= sizeof(BITMAPINFOHEADER));
  189. BITMAPINFOHEADER* pbmi = &((BITMAPINFO*)s->strf.GetData())->bmiHeader;
  191. mt.majortype = MEDIATYPE_Video;
  192. mt.subtype = FOURCCMap(pbmi->biCompression);
  193. mt.formattype = FORMAT_VideoInfo;
  194. VIDEOINFOHEADER* pvih = (VIDEOINFOHEADER*)mt.AllocFormatBuffer(sizeof(VIDEOINFOHEADER) + s->strf.GetSize() - sizeof(BITMAPINFOHEADER));
  195. memset(mt.Format(), 0, mt.FormatLength());
  196. memcpy(&pvih->bmiHeader, s->strf.GetData(), s->strf.GetSize());
  197. if(s->strh.dwRate > 0) pvih->AvgTimePerFrame = 10000000i64 * s->strh.dwScale / s->strh.dwRate;
  198. switch(pbmi->biCompression)
  199. {
  200. case BI_RGB: case BI_BITFIELDS: mt.subtype = 
  201. pbmi->biBitCount == 1 ? MEDIASUBTYPE_RGB1 :
  202. pbmi->biBitCount == 4 ? MEDIASUBTYPE_RGB4 :
  203. pbmi->biBitCount == 8 ? MEDIASUBTYPE_RGB8 :
  204. pbmi->biBitCount == 16 ? MEDIASUBTYPE_RGB565 :
  205. pbmi->biBitCount == 24 ? MEDIASUBTYPE_RGB24 :
  206. pbmi->biBitCount == 32 ? MEDIASUBTYPE_ARGB32 :
  207. MEDIASUBTYPE_NULL;
  208. break;
  209. // case BI_RLE8: mt.subtype = MEDIASUBTYPE_RGB8; break;
  210. // case BI_RLE4: mt.subtype = MEDIASUBTYPE_RGB4; break;
  211. }
  213. if(s->cs.GetCount() && pvih->AvgTimePerFrame > 0)
  214. {
  215. __int64 size = 0;
  216. for(int i = 0; i < s->cs.GetCount(); i++)
  217. size += s->cs[i].orgsize;
  218. pvih->dwBitRate = size*8 / s->cs.GetCount() * 10000000i64 / pvih->AvgTimePerFrame;
  219. }
  221. mt.SetSampleSize(s->strh.dwSuggestedBufferSize > 0 
  222. ? s->strh.dwSuggestedBufferSize*3/2
  223. : (pvih->bmiHeader.biWidth*pvih->bmiHeader.biHeight*4));
  224. mts.Add(mt);
  225. }
  226. else if(s->strh.fccType == FCC('auds'))
  227. {
  228. label = L"Audio";
  230. ASSERT(s->strf.GetSize() >= sizeof(WAVEFORMATEX)
  231. || s->strf.GetSize() == sizeof(PCMWAVEFORMAT));
  233.             WAVEFORMATEX* pwfe = (WAVEFORMATEX*)s->strf.GetData();
  235. if(pwfe->nBlockAlign == 0) continue;
  237. mt.majortype = MEDIATYPE_Audio;
  238. mt.subtype = FOURCCMap(pwfe->wFormatTag);
  239. mt.formattype = FORMAT_WaveFormatEx;
  240. mt.SetFormat(s->strf.GetData(), max(s->strf.GetSize(), sizeof(WAVEFORMATEX)));
  241. pwfe = (WAVEFORMATEX*)mt.Format();
  242. if(s->strf.GetSize() == sizeof(PCMWAVEFORMAT)) pwfe->cbSize = 0;
  243. if(pwfe->wFormatTag == WAVE_FORMAT_PCM) pwfe->nBlockAlign = pwfe->nChannels*pwfe->wBitsPerSample>>3;
  244. mt.SetSampleSize(s->strh.dwSuggestedBufferSize > 0 
  245. ? s->strh.dwSuggestedBufferSize*3/2
  246. : (pwfe->nChannels*pwfe->nSamplesPerSec*32>>3));
  247. mts.Add(mt);
  248. }
  249. else if(s->strh.fccType == FCC('mids'))
  250. {
  251. label = L"Midi";
  253. mt.majortype = MEDIATYPE_Midi;
  254. mt.subtype = MEDIASUBTYPE_NULL;
  255. mt.formattype = FORMAT_None;
  256. mt.SetSampleSize(s->strh.dwSuggestedBufferSize > 0 
  257. ? s->strh.dwSuggestedBufferSize*3/2
  258. : (1024*1024));
  259. mts.Add(mt);
  260. }
  261. else if(s->strh.fccType == FCC('txts'))
  262. {
  263. label = L"Text";
  265. mt.majortype = MEDIATYPE_Text;
  266. mt.subtype = MEDIASUBTYPE_NULL;
  267. mt.formattype = FORMAT_None;
  268. mt.SetSampleSize(s->strh.dwSuggestedBufferSize > 0 
  269. ? s->strh.dwSuggestedBufferSize*3/2
  270. : (1024*1024));
  271. mts.Add(mt);
  272. }
  273. else if(s->strh.fccType == FCC('iavs'))
  274. {
  275. label = L"Interleaved";
  277. ASSERT(s->strh.fccHandler == FCC('dvsd'));
  279. mt.majortype = MEDIATYPE_Interleaved;
  280. mt.subtype = FOURCCMap(s->strh.fccHandler);
  281. mt.formattype = FORMAT_DvInfo;
  282. mt.SetFormat(s->strf.GetData(), max(s->strf.GetSize(), sizeof(DVINFO)));
  283. mt.SetSampleSize(s->strh.dwSuggestedBufferSize > 0 
  284. ? s->strh.dwSuggestedBufferSize*3/2
  285. : (1024*1024));
  286. mts.Add(mt);
  287. }
  289. if(mts.IsEmpty())
  290. {
  291. TRACE(_T("CAviSourceFilter: Unsupported stream (%d)n"), i);
  292. continue;
  293. }
  295. name.Format(L"%s %d", !s->strn.IsEmpty() ? CStringW(s->strn) : label, i);
  297. HRESULT hr;
  299. CAutoPtr<CBaseSplitterOutputPin> pPinOut(new CAviSplitterOutputPin(mts, name, this, this, &hr));
  300. AddOutputPin(i, pPinOut);
  301. }
  303. POSITION pos = m_pFile->m_info.GetStartPosition();
  304. while(pos)
  305. {
  306. DWORD fcc;
  307. CStringA value;
  308. m_pFile->m_info.GetNextAssoc(pos, fcc, value);
  310.         switch(fcc)
  311. {
  312. case FCC('INAM'): SetProperty(L"TITL", CStringW(value)); break;
  313. case FCC('IART'): SetProperty(L"AUTH", CStringW(value)); break;
  314. case FCC('ICOP'): SetProperty(L"CPYR", CStringW(value)); break;
  315. case FCC('ISBJ'): SetProperty(L"DESC", CStringW(value)); break;
  316. }
  317. }
  319. m_tFrame.Attach(new DWORD[m_pFile->m_avih.dwStreams]);
  321. return m_pOutputs.GetCount() > 0 ? S_OK : E_FAIL;
  322. }
  324. bool CAviSplitterFilter::DemuxInit()
  325. {
  326. if(!m_pFile) return(false);
  328. // reindex if needed
  330. bool fReIndex = false;
  332. for(int i = 0; i < (int)m_pFile->m_avih.dwStreams && !fReIndex; i++)
  333. {
  334. if(m_pFile->m_strms[i]->cs.GetCount() == 0 && GetOutputPin(i)) 
  335. fReIndex = true;
  336. }
  338. if(fReIndex)
  339. {
  340. m_pFile->EmptyIndex();
  342. m_fAbort = false;
  343. m_nOpenProgress = 0;
  345. m_rtDuration = 0;
  347. CAutoVectorPtr<UINT64> pSize;
  348. pSize.Allocate(m_pFile->m_avih.dwStreams);
  349. memset((UINT64*)pSize, 0, sizeof(UINT64)*m_pFile->m_avih.dwStreams);
  350. m_pFile->Seek(0);
  351.         ReIndex(m_pFile->GetLength(), pSize);
  353. if(m_fAbort) m_pFile->EmptyIndex();
  355. m_fAbort = false;
  356. m_nOpenProgress = 100;
  357. }
  359. return(true);
  360. }
  362. HRESULT CAviSplitterFilter::ReIndex(__int64 end, UINT64* pSize)
  363. {
  364. HRESULT hr = S_OK;
  366. while(S_OK == hr && m_pFile->GetPos() < end && SUCCEEDED(hr) && !m_fAbort)
  367. {
  368. __int64 pos = m_pFile->GetPos();
  370. DWORD id = 0, size;
  371. if(S_OK != m_pFile->Read(id) || id == 0)
  372. return E_FAIL;
  374. if(id == FCC('RIFF') || id == FCC('LIST'))
  375. {
  376. if(S_OK != m_pFile->Read(size) || S_OK != m_pFile->Read(id))
  377. return E_FAIL;
  379. size += (size&1) + 8;
  381. if(id == FCC('AVI ') || id == FCC('AVIX') || id == FCC('movi') || id == FCC('rec '))
  382. hr = ReIndex(pos + size, pSize);
  383. }
  384. else
  385. {
  386. if(S_OK != m_pFile->Read(size))
  387. return E_FAIL;
  389. DWORD TrackNumber = TRACKNUM(id);
  391. if(TrackNumber < m_pFile->m_strms.GetCount())
  392. {
  393. CAviFile::strm_t* s = m_pFile->m_strms[TrackNumber];
  395. WORD type = TRACKTYPE(id);
  397. if(type == 'db' || type == 'dc' || /*type == 'pc' ||*/ type == 'wb'
  398. || type == 'iv' || type == '__' || type == 'xx')
  399. {
  400. CAviFile::strm_t::chunk c;
  401. c.filepos = pos;
  402. c.size = pSize[TrackNumber];
  403. c.orgsize = size;
  404. c.fKeyFrame = size > 0; // TODO: find a better way...
  405. c.fChunkHdr = true;
  406. s->cs.Add(c);
  408. pSize[TrackNumber] += s->GetChunkSize(size);
  410. REFERENCE_TIME rt = s->GetRefTime(s->cs.GetCount()-1, pSize[TrackNumber]);
  411. m_rtDuration = max(rt, m_rtDuration);
  412. }
  413. }
  415. size += (size&1) + 8;
  416. }
  418. m_pFile->Seek(pos + size);
  420. m_nOpenProgress = m_pFile->GetPos()*100/m_pFile->GetLength();
  422. DWORD cmd;
  423. if(CheckRequest(&cmd))
  424. {
  425. if(cmd == CMD_EXIT) m_fAbort = true;
  426. else Reply(S_OK);
  427. }
  428. }
  430. return hr;
  431. }
  433. void CAviSplitterFilter::DemuxSeek(REFERENCE_TIME rt)
  434. {
  435. memset((DWORD*)m_tFrame, 0, sizeof(DWORD)*m_pFile->m_avih.dwStreams);
  436. m_pFile->Seek(0);
  438. DbgLog((LOG_TRACE, 0, _T("Seek: %I64d"), rt/10000));
  440. if(rt > 0)
  441. {
  442. UINT64 minfp = _I64_MAX;
  444. for(int j = 0; j < (int)m_pFile->m_strms.GetCount(); j++)
  445. {
  446. CAviFile::strm_t* s = m_pFile->m_strms[j];
  448. int f = s->GetKeyFrame(rt);
  449. UINT64 fp = f >= 0 ? s->cs[f].filepos : m_pFile->GetLength();
  451. if(!s->IsRawSubtitleStream())
  452. minfp = min(minfp, fp);
  453. }
  455. for(int j = 0; j < (int)m_pFile->m_strms.GetCount(); j++)
  456. {
  457. CAviFile::strm_t* s = m_pFile->m_strms[j];
  459. for(int i = 0; i < s->cs.GetCount(); i++)
  460. {
  461. CAviFile::strm_t::chunk& c = s->cs[i];
  462. if(c.filepos >= minfp)
  463. {
  464. m_tFrame[j] = i;
  465. break;
  466. }
  467. }
  468. }
  470. DbgLog((LOG_TRACE, 0, _T("minfp: %I64d"), minfp));
  471. }
  472. }
  474. bool CAviSplitterFilter::DemuxLoop()
  475. {
  476. HRESULT hr = S_OK;
  478. int nTracks = (int)m_pFile->m_strms.GetCount();
  480. CArray<BOOL> fDiscontinuity;
  481. fDiscontinuity.SetSize(nTracks);
  482. memset(fDiscontinuity.GetData(), 0, nTracks*sizeof(bool));
  484. while(SUCCEEDED(hr) && !CheckRequest(NULL))
  485. {
  486. int minTrack = nTracks;
  487. UINT64 minFilePos = _I64_MAX;
  489. for(int i = 0; i < nTracks; i++)
  490. {
  491. CAviFile::strm_t* s = m_pFile->m_strms[i];
  493. DWORD f = m_tFrame[i];
  494. if(f >= (DWORD)s->cs.GetCount()) continue;
  496. bool fUrgent = s->IsRawSubtitleStream();
  498. if(fUrgent || s->cs[f].filepos < minFilePos)
  499. {
  500. minTrack = i;
  501. minFilePos = s->cs[f].filepos;
  502. }
  504. if(fUrgent) break;
  505. }
  507. if(minTrack == nTracks)
  508. break;
  510. DWORD& f = m_tFrame[minTrack];
  512. do
  513. {
  514. CAviFile::strm_t* s = m_pFile->m_strms[minTrack];
  516. m_pFile->Seek(s->cs[f].filepos);
  518. DWORD size = 0;
  520. if(s->cs[f].fChunkHdr)
  521. {
  522. DWORD id = 0;
  523. if(S_OK != m_pFile->Read(id) || id == 0 || minTrack != TRACKNUM(id)
  524. || S_OK != m_pFile->Read(size))
  525. {
  526. fDiscontinuity[minTrack] = true;
  527. break;
  528. }
  530. UINT64 expectedsize = -1;
  531. expectedsize = f < (DWORD)s->cs.GetCount()-1
  532. ? s->cs[f+1].size - s->cs[f].size
  533. : s->totalsize - s->cs[f].size;
  535. if(expectedsize != s->GetChunkSize(size))
  536. {
  537. fDiscontinuity[minTrack] = true;
  538. // ASSERT(0);
  539. break;
  540. }
  541. }
  542. else
  543. {
  544. size = s->cs[f].orgsize;
  545. }
  547. CAutoPtr<Packet> p(new Packet());
  549. p->TrackNumber = minTrack;
  550. p->bSyncPoint = (BOOL)s->cs[f].fKeyFrame;
  551. p->bDiscontinuity = fDiscontinuity[minTrack];
  552. p->rtStart = s->GetRefTime(f, s->cs[f].size);
  553. p->rtStop = s->GetRefTime(f+1, f+1 < (DWORD)s->cs.GetCount() ? s->cs[f+1].size : s->totalsize);
  554. p->pData.SetSize(size);
  556. if(S_OK != (hr = m_pFile->Read(p->pData.GetData(), p->pData.GetSize()))) 
  557. return(true); // break;
  558. /*
  559. DbgLog((LOG_TRACE, 0, _T("%d (%d): %I64d - %I64d, %I64d - %I64d (size = %d)"), 
  560. minTrack, (int)p->bSyncPoint,
  561. (p->rtStart)/10000, (p->rtStop)/10000, 
  562. (p->rtStart-m_rtStart)/10000, (p->rtStop-m_rtStart)/10000,
  563. size));
  564. */
  565. hr = DeliverPacket(p);
  567. fDiscontinuity[minTrack] = false;
  568. }
  569. while(0);
  571. f++;
  572. }
  574. return(true);
  575. }
  577. // IMediaSeeking
  579. STDMETHODIMP CAviSplitterFilter::GetDuration(LONGLONG* pDuration)
  580. {
  581. CheckPointer(pDuration, E_POINTER);
  582. CheckPointer(m_pFile, VFW_E_NOT_CONNECTED);
  584. if(m_timeformat == TIME_FORMAT_FRAME)
  585. {
  586. for(int i = 0; i < (int)m_pFile->m_strms.GetCount(); i++)
  587. {
  588. CAviFile::strm_t* s = m_pFile->m_strms[i];
  589. if(s->strh.fccType == FCC('vids'))
  590. {
  591. *pDuration = s->cs.GetCount();
  592. return S_OK;
  593. }
  594. }
  596. return E_UNEXPECTED;
  597. }
  599. return __super::GetDuration(pDuration);
  600. }
  602. //
  604. STDMETHODIMP CAviSplitterFilter::IsFormatSupported(const GUID* pFormat)
  605. {
  606. CheckPointer(pFormat, E_POINTER);
  607. HRESULT hr = __super::IsFormatSupported(pFormat);
  608. if(S_OK == hr) return hr;
  609. return *pFormat == TIME_FORMAT_FRAME ? S_OK : S_FALSE;
  610. }
  612. STDMETHODIMP CAviSplitterFilter::GetTimeFormat(GUID* pFormat)
  613. {
  614. CheckPointer(pFormat, E_POINTER);
  615. *pFormat = m_timeformat;
  616. return S_OK;
  617. }
  619. STDMETHODIMP CAviSplitterFilter::IsUsingTimeFormat(const GUID* pFormat)
  620. {
  621. CheckPointer(pFormat, E_POINTER);
  622. return *pFormat == m_timeformat ? S_OK : S_FALSE;
  623. }
  625. STDMETHODIMP CAviSplitterFilter::SetTimeFormat(const GUID* pFormat)
  626. {
  627. CheckPointer(pFormat, E_POINTER);
  628. if(S_OK != IsFormatSupported(pFormat)) return E_FAIL;
  629. m_timeformat = *pFormat;
  630. return S_OK;
  631. }
  633. STDMETHODIMP CAviSplitterFilter::GetStopPosition(LONGLONG* pStop)
  634. {
  635. CheckPointer(pStop, E_POINTER);
  636. if(FAILED(__super::GetStopPosition(pStop))) return E_FAIL;
  637. if(m_timeformat == TIME_FORMAT_MEDIA_TIME) return S_OK;
  638. LONGLONG rt = *pStop;
  639. if(FAILED(ConvertTimeFormat(pStop, &TIME_FORMAT_FRAME, rt, &TIME_FORMAT_MEDIA_TIME))) return E_FAIL;
  640. return S_OK;
  641. }
  643. STDMETHODIMP CAviSplitterFilter::ConvertTimeFormat(LONGLONG* pTarget, const GUID* pTargetFormat, LONGLONG Source, const GUID* pSourceFormat)
  644. {
  645. CheckPointer(pTarget, E_POINTER);
  647. const GUID& SourceFormat = pSourceFormat ? *pSourceFormat : m_timeformat;
  648. const GUID& TargetFormat = pTargetFormat ? *pTargetFormat : m_timeformat;
  650. if(TargetFormat == SourceFormat)
  651. {
  652. *pTarget = Source; 
  653. return S_OK;
  654. }
  655. else if(TargetFormat == TIME_FORMAT_FRAME && SourceFormat == TIME_FORMAT_MEDIA_TIME)
  656. {
  657. for(int i = 0; i < (int)m_pFile->m_strms.GetCount(); i++)
  658. {
  659. CAviFile::strm_t* s = m_pFile->m_strms[i];
  660. if(s->strh.fccType == FCC('vids'))
  661. {
  662. *pTarget = s->GetFrame(Source);
  663. return S_OK;
  664. }
  665. }
  666. }
  667. else if(TargetFormat == TIME_FORMAT_MEDIA_TIME && SourceFormat == TIME_FORMAT_FRAME)
  668. {
  669. for(int i = 0; i < (int)m_pFile->m_strms.GetCount(); i++)
  670. {
  671. CAviFile::strm_t* s = m_pFile->m_strms[i];
  672. if(s->strh.fccType == FCC('vids'))
  673. {
  674. if(Source < 0 || Source >= s->cs.GetCount()) return E_FAIL;
  675. CAviFile::strm_t::chunk& c = s->cs[(int)Source];
  676. *pTarget = s->GetRefTime((DWORD)Source, c.size);
  677. return S_OK;
  678. }
  679. }
  680. }
  682. return E_FAIL;
  683. }
  685. STDMETHODIMP CAviSplitterFilter::GetPositions(LONGLONG* pCurrent, LONGLONG* pStop)
  686. {
  687. HRESULT hr;
  688. if(FAILED(hr = __super::GetPositions(pCurrent, pStop)) || m_timeformat != TIME_FORMAT_FRAME)
  689. return hr;
  691. if(pCurrent)
  692. if(FAILED(ConvertTimeFormat(pCurrent, &TIME_FORMAT_FRAME, *pCurrent, &TIME_FORMAT_MEDIA_TIME))) return E_FAIL;
  693. if(pStop)
  694. if(FAILED(ConvertTimeFormat(pStop, &TIME_FORMAT_FRAME, *pStop, &TIME_FORMAT_MEDIA_TIME))) return E_FAIL;
  696. return S_OK;
  697. }
  699. HRESULT CAviSplitterFilter::SetPositionsInternal(void* id, LONGLONG* pCurrent, DWORD dwCurrentFlags, LONGLONG* pStop, DWORD dwStopFlags)
  700. {
  701. if(m_timeformat != TIME_FORMAT_FRAME)
  702. return __super::SetPositionsInternal(id, pCurrent, dwCurrentFlags, pStop, dwStopFlags);
  704. if(!pCurrent && !pStop
  705. || (dwCurrentFlags&AM_SEEKING_PositioningBitsMask) == AM_SEEKING_NoPositioning 
  706. && (dwStopFlags&AM_SEEKING_PositioningBitsMask) == AM_SEEKING_NoPositioning)
  707. return S_OK;
  709. REFERENCE_TIME 
  710. rtCurrent = m_rtCurrent,
  711. rtStop = m_rtStop;
  713. if((dwCurrentFlags&AM_SEEKING_PositioningBitsMask)
  714. && FAILED(ConvertTimeFormat(&rtCurrent, &TIME_FORMAT_FRAME, rtCurrent, &TIME_FORMAT_MEDIA_TIME))) 
  715. return E_FAIL;
  716. if((dwStopFlags&AM_SEEKING_PositioningBitsMask)
  717. && FAILED(ConvertTimeFormat(&rtStop, &TIME_FORMAT_FRAME, rtStop, &TIME_FORMAT_MEDIA_TIME)))
  718. return E_FAIL;
  720. if(pCurrent)
  721. switch(dwCurrentFlags&AM_SEEKING_PositioningBitsMask)
  722. {
  723. case AM_SEEKING_NoPositioning: break;
  724. case AM_SEEKING_AbsolutePositioning: rtCurrent = *pCurrent; break;
  725. case AM_SEEKING_RelativePositioning: rtCurrent = rtCurrent + *pCurrent; break;
  726. case AM_SEEKING_IncrementalPositioning: rtCurrent = rtCurrent + *pCurrent; break;
  727. }
  729. if(pStop)
  730. switch(dwStopFlags&AM_SEEKING_PositioningBitsMask)
  731. {
  732. case AM_SEEKING_NoPositioning: break;
  733. case AM_SEEKING_AbsolutePositioning: rtStop = *pStop; break;
  734. case AM_SEEKING_RelativePositioning: rtStop += *pStop; break;
  735. case AM_SEEKING_IncrementalPositioning: rtStop = rtCurrent + *pStop; break;
  736. }
  738. if((dwCurrentFlags&AM_SEEKING_PositioningBitsMask)
  739. && pCurrent)
  740. if(FAILED(ConvertTimeFormat(pCurrent, &TIME_FORMAT_MEDIA_TIME, rtCurrent, &TIME_FORMAT_FRAME))) return E_FAIL;
  741. if((dwStopFlags&AM_SEEKING_PositioningBitsMask)
  742. && pStop)
  743. if(FAILED(ConvertTimeFormat(pStop, &TIME_FORMAT_MEDIA_TIME, rtStop, &TIME_FORMAT_FRAME))) return E_FAIL;
  745. return __super::SetPositionsInternal(id, pCurrent, dwCurrentFlags, pStop, dwStopFlags);
  746. }
  748. // IKeyFrameInfo
  750. STDMETHODIMP CAviSplitterFilter::GetKeyFrameCount(UINT& nKFs)
  751. {
  752. if(!m_pFile) return E_UNEXPECTED;
  754. HRESULT hr = S_OK;
  756. nKFs = 0;
  758. for(int i = 0; i < (int)m_pFile->m_strms.GetCount(); i++)
  759. {
  760. CAviFile::strm_t* s = m_pFile->m_strms[i];
  761. if(s->strh.fccType != FCC('vids')) continue;
  763. for(int j = 0; j < s->cs.GetCount(); j++)
  764. {
  765. CAviFile::strm_t::chunk& c = s->cs[j];
  766. if(c.fKeyFrame) nKFs++;
  767. }
  769. if(nKFs == s->cs.GetCount())
  770. hr = S_FALSE;
  772. break;
  773. }
  775. return hr;
  776. }
  778. STDMETHODIMP CAviSplitterFilter::GetKeyFrames(const GUID* pFormat, REFERENCE_TIME* pKFs, UINT& nKFs)
  779. {
  780. CheckPointer(pFormat, E_POINTER);
  781. CheckPointer(pKFs, E_POINTER);
  783. if(!m_pFile) return E_UNEXPECTED;
  784. if(*pFormat != TIME_FORMAT_MEDIA_TIME && *pFormat != TIME_FORMAT_FRAME) return E_INVALIDARG;
  786. UINT nKFsTmp = 0;
  788. for(int i = 0; i < (int)m_pFile->m_strms.GetCount(); i++)
  789. {
  790. CAviFile::strm_t* s = m_pFile->m_strms[i];
  791. if(s->strh.fccType != FCC('vids')) continue;
  793. bool fConvertToRefTime = !!(*pFormat == TIME_FORMAT_MEDIA_TIME);
  795. for(int j = 0; j < s->cs.GetCount() && nKFsTmp < nKFs; j++)
  796. {
  797. if(s->cs[j].fKeyFrame)
  798. pKFs[nKFsTmp++] = fConvertToRefTime ? s->GetRefTime(j, s->cs[j].size) : j;
  799. }
  801. break;
  802. }
  804. nKFs = nKFsTmp;
  806. return S_OK;
  807. }
  809. //
  810. // CAviSourceFilter
  811. //
  813. CAviSourceFilter::CAviSourceFilter(LPUNKNOWN pUnk, HRESULT* phr)
  814. : CAviSplitterFilter(pUnk, phr)
  815. {
  816. m_clsid = __uuidof(this);
  817. m_pInput.Free();
  818. }
  820. //
  821. // CAviSplitterOutputPin
  822. //
  824. CAviSplitterOutputPin::CAviSplitterOutputPin(CArray<CMediaType>& mts, LPCWSTR pName, CBaseFilter* pFilter, CCritSec* pLock, HRESULT* phr)
  825. : CBaseSplitterOutputPin(mts, pName, pFilter, pLock, phr)
  826. {
  827. }
  829. HRESULT CAviSplitterOutputPin::CheckConnect(IPin* pPin)
  830. {
  831. int iPosition = 0;
  832. CMediaType mt;
  833. while(S_OK == GetMediaType(iPosition++, &mt))
  834. {
  835. if(mt.majortype == MEDIATYPE_Video 
  836. && (mt.subtype == FOURCCMap(FCC('IV32'))
  837. || mt.subtype == FOURCCMap(FCC('IV31'))
  838. || mt.subtype == FOURCCMap(FCC('IF09'))))
  839. {
  840. CLSID clsid = GetCLSID(GetFilterFromPin(pPin));
  841. if(clsid == CLSID_VideoMixingRenderer || clsid == CLSID_OverlayMixer)
  842. return E_FAIL;
  843. }
  845. mt.InitMediaType();
  846. }
  848. return __super::CheckConnect(pPin);
  849. }