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

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

多媒体编程

开发平台：

Visual C++

DiracSplitter.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 <initguid.h>
  25. #include "DiracSplitter.h"
  26. #include "........includemoreuuids.h"
  28. #ifdef REGISTER_FILTER
  30. const AMOVIESETUP_MEDIATYPE sudPinTypesIn[] =
  31. {
  32. {&MEDIATYPE_Stream, &MEDIASUBTYPE_Dirac},
  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_MEDIATYPE sudPinTypesIn2[] =
  43. {
  44. {&MEDIATYPE_Video, &MEDIASUBTYPE_DiracVideo},
  45. };
  47. const AMOVIESETUP_MEDIATYPE sudPinTypesOut2[] =
  48. {
  49. {&MEDIATYPE_Video, &MEDIASUBTYPE_NULL},
  50. };
  52. const AMOVIESETUP_PIN sudpPins2[] =
  53. {
  54.     {L"Input", FALSE, FALSE, FALSE, FALSE, &CLSID_NULL, NULL, countof(sudPinTypesIn2), sudPinTypesIn2},
  55.     {L"Output", FALSE, TRUE, FALSE, FALSE, &CLSID_NULL, NULL, countof(sudPinTypesOut2), sudPinTypesOut2}
  56. };
  58. const AMOVIESETUP_FILTER sudFilter[] =
  59. {
  60. {&__uuidof(CDiracSplitterFilter), L"Dirac Splitter", MERIT_NORMAL, countof(sudpPins), sudpPins},
  61. {&__uuidof(CDiracSourceFilter), L"Dirac Source", MERIT_NORMAL, 0, NULL},
  62. {&__uuidof(CDiracVideoDecoder), L"Dirac Video Decoder", MERIT_UNLIKELY, countof(sudpPins2), sudpPins2},
  63. };
  65. CFactoryTemplate g_Templates[] =
  66. {
  67. {sudFilter[0].strName, sudFilter[0].clsID, CreateInstance<CDiracSplitterFilter>, NULL, &sudFilter[0]},
  68. {sudFilter[1].strName, sudFilter[1].clsID, CreateInstance<CDiracSourceFilter>, NULL, &sudFilter[1]},
  69.     {sudFilter[2].strName, sudFilter[2].clsID, CreateInstance<CDiracVideoDecoder>, NULL, &sudFilter[2]},
  70. };
  72. int g_cTemplates = countof(g_Templates);
  74. STDAPI DllRegisterServer()
  75. {
  76. RegisterSourceFilter(
  77. CLSID_AsyncReader, 
  78. MEDIASUBTYPE_Dirac, 
  79. _T("0,8,,4B572D4449524143"), // KW-DIRAC
  80. _T(".drc"), NULL);
  82. return AMovieDllRegisterServer2(TRUE);
  83. }
  85. STDAPI DllUnregisterServer()
  86. {
  87. UnRegisterSourceFilter(MEDIASUBTYPE_Dirac);
  89. return AMovieDllRegisterServer2(FALSE);
  90. }
  92. extern "C" BOOL WINAPI DllEntryPoint(HINSTANCE, ULONG, LPVOID);
  94. BOOL APIENTRY DllMain(HANDLE hModule, DWORD dwReason, LPVOID lpReserved)
  95. {
  96. return DllEntryPoint((HINSTANCE)hModule, dwReason, 0); // "DllMain" of the dshow baseclasses;
  97. }
  99. #endif
  101. //
  102. // CDiracSplitterFilter
  103. //
  105. CDiracSplitterFilter::CDiracSplitterFilter(LPUNKNOWN pUnk, HRESULT* phr)
  106. : CBaseSplitterFilter(NAME("CDiracSplitterFilter"), pUnk, phr, __uuidof(this))
  107. {
  108. }
  110. STDMETHODIMP CDiracSplitterFilter::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  111. {
  112.     CheckPointer(ppv, E_POINTER);
  114.     return 
  115. __super::NonDelegatingQueryInterface(riid, ppv);
  116. }
  118. HRESULT CDiracSplitterFilter::CreateOutputs(IAsyncReader* pAsyncReader)
  119. {
  120. CheckPointer(pAsyncReader, E_POINTER);
  122. HRESULT hr = E_FAIL;
  124. m_pFile.Free();
  126. m_pFile.Attach(new CDiracSplitterFile(pAsyncReader, hr));
  127. if(!m_pFile) return E_OUTOFMEMORY;
  128. if(FAILED(hr)) {m_pFile.Free(); return hr;}
  130. CArray<CMediaType> mts;
  131. mts.Add(m_pFile->GetMediaType());
  133. CAutoPtr<CBaseSplitterOutputPin> pPinOut(new CBaseSplitterOutputPin(mts, L"Video", this, this, &hr));
  134. AddOutputPin(0, pPinOut);
  136. m_rtNewStart = m_rtCurrent = 0;
  137. m_rtNewStop = m_rtStop = m_rtDuration = m_pFile->GetDuration();
  139. return m_pOutputs.GetCount() > 0 ? S_OK : E_FAIL;
  140. }
  142. bool CDiracSplitterFilter::DemuxInit()
  143. {
  144. if(!m_pFile) return(false);
  146. // TODO
  148. return(true);
  149. }
  151. void CDiracSplitterFilter::DemuxSeek(REFERENCE_TIME rt)
  152. {
  153. REFERENCE_TIME rtPreroll = 0; //10000000;
  155. if(rt <= rtPreroll || m_rtDuration <= 0)
  156. {
  157. m_pFile->Seek(8);
  158. }
  159. else
  160. {
  161. // TODO
  163. __int64 len = m_pFile->GetLength();
  164. __int64 seekpos = (__int64)(1.0*rt/m_rtDuration*len);
  166. m_pFile->Seek(seekpos);
  167. seekpos = 8;
  169. REFERENCE_TIME rtmax = rt - rtPreroll;
  170. REFERENCE_TIME rtmin = rtmax - 5000000;
  172. REFERENCE_TIME pdt = _I64_MIN;
  174. for(int j = 0; j < 10; j++)
  175. {
  176. BYTE code = NOT_START_CODE;
  177. while(m_pFile->Next(code) && code != IFRAME_START_CODE);
  178. if(code != IFRAME_START_CODE) {m_pFile->Seek(seekpos >>= 1); continue;}
  180. __int64 pos = m_pFile->GetPos() - 5;
  182. REFERENCE_TIME rt = ((DIRACINFOHEADER*)m_pFile->GetMediaType().Format())->hdr.AvgTimePerFrame * m_pFile->UnsignedGolombDecode();
  183. REFERENCE_TIME dt = rt - rtmax;
  184. if(dt > 0 && dt == pdt) dt = 10000000i64;
  186. if(rtmin <= rt && rt <= rtmax || pdt > 0 && dt < 0)
  187. {
  188. seekpos = pos;
  189. break;
  190. }
  192. m_pFile->Seek(pos - (__int64)(1.0*dt/m_rtDuration*len));
  194. pdt = dt;
  195. }
  197. m_pFile->Seek(seekpos);
  198. }
  199. }
  201. bool CDiracSplitterFilter::DemuxLoop()
  202. {
  203. HRESULT hr = S_OK;
  204. REFERENCE_TIME rtAvgTimePerFrame = ((DIRACINFOHEADER*)m_pFile->GetMediaType().Format())->hdr.AvgTimePerFrame;
  206. while(SUCCEEDED(hr) && !CheckRequest(NULL))
  207. {
  208. BYTE code = NOT_START_CODE;
  209. int size = 0, fnum = 0;
  210. const BYTE* pBuff = m_pFile->NextBlock(code, size, fnum);
  211. if(!pBuff || size < 5) break;
  213. if(isFrameStartCode(code))
  214. {
  215. CAutoPtr<Packet> p(new Packet());
  216. p->pData.SetSize(size);
  217. memcpy(p->pData.GetData(), pBuff, size);
  219. p->TrackNumber = 0;
  220. p->rtStart = rtAvgTimePerFrame*fnum;
  221. p->rtStop = p->rtStart + rtAvgTimePerFrame;
  222. p->bSyncPoint = code == IFRAME_START_CODE;
  224. hr = DeliverPacket(p);
  225. }
  227. if(code == SEQ_END_CODE)
  228. break;
  229. }
  231. return(true);
  232. }
  234. //
  235. // CDiracSourceFilter
  236. //
  238. CDiracSourceFilter::CDiracSourceFilter(LPUNKNOWN pUnk, HRESULT* phr)
  239. : CDiracSplitterFilter(pUnk, phr)
  240. {
  241. m_clsid = __uuidof(this);
  242. m_pInput.Free();
  243. }
  245. //
  246. // CDiracVideoDecoder
  247. //
  249. CDiracVideoDecoder::CDiracVideoDecoder(LPUNKNOWN lpunk, HRESULT* phr)
  250. : CTransformFilter(NAME("CDiracVideoDecoder"), lpunk, __uuidof(this))
  251. {
  252. if(phr) *phr = S_OK;
  254. m_decoder = NULL;
  255. m_pYUV[0] = NULL;
  256. }
  258. CDiracVideoDecoder::~CDiracVideoDecoder()
  259. {
  260. delete [] m_pYUV[0];
  261. }
  263. void CDiracVideoDecoder::InitDecoder()
  264. {
  265. FreeDecoder();
  267. dirac_decoder_t* decoder = dirac_decoder_init(0);
  269. DIRACINFOHEADER* dvih = (DIRACINFOHEADER*)m_pInput->CurrentMediaType().Format();
  270. dirac_buffer(decoder, (BYTE*)&dvih->dwSequenceHeader[0], (BYTE*)&dvih->dwSequenceHeader[0] + dvih->cbSequenceHeader);
  272. m_decoder = decoder;
  273. }
  275. void CDiracVideoDecoder::FreeDecoder()
  276. {
  277. if(m_decoder)
  278. {
  279. dirac_decoder_close((dirac_decoder_t*)m_decoder);
  280. m_decoder = NULL;
  281. delete [] m_pYUV[0]; m_pYUV[0] = NULL;
  282. }
  283. }
  285. HRESULT CDiracVideoDecoder::Receive(IMediaSample* pIn)
  286. {
  287. CAutoLock cAutoLock(&m_csReceive);
  289. HRESULT hr;
  291.     AM_SAMPLE2_PROPERTIES* const pProps = m_pInput->SampleProps();
  292.     if(pProps->dwStreamId != AM_STREAM_MEDIA)
  293. return m_pOutput->Deliver(pIn);
  295. BYTE* pDataIn = NULL;
  296. if(FAILED(hr = pIn->GetPointer(&pDataIn))) return hr;
  298. long len = pIn->GetActualDataLength();
  299. if(len <= 0) return S_OK; // nothing to do
  301. if(pIn->IsDiscontinuity() == S_OK) 
  302. InitDecoder();
  304. dirac_decoder_t* decoder = (dirac_decoder_t*)m_decoder;
  306. hr = S_OK;
  307. while(SUCCEEDED(hr))
  308. {
  309.         switch(dirac_parse(decoder))
  310.         {
  311.         case STATE_BUFFER:
  312. if(len == 0) return S_OK;
  313. dirac_buffer(decoder, pDataIn, pDataIn + len);
  314. len = 0;
  315. break;
  317.         case STATE_SEQUENCE:
  318. TRACE(_T("STATE_SEQUENCEn"));
  320. {
  321. DIRACINFOHEADER* dvih = (DIRACINFOHEADER*)m_pInput->CurrentMediaType().Format();
  322. if(dvih->hdr.bmiHeader.biWidth != decoder->seq_params.width
  323. || dvih->hdr.bmiHeader.biHeight != decoder->seq_params.height)
  324. return E_FAIL; // hmm
  325. }
  327. if(!m_pYUV[0])
  328. {
  329. int w = decoder->seq_params.width;
  330. int h = decoder->seq_params.height;
  331. int wc = decoder->seq_params.chroma_width;
  332. int hc = decoder->seq_params.chroma_height; 
  333. delete [] m_pYUV[0]; m_pYUV[0] = NULL;
  334. m_pYUV[0] = new BYTE[w*h + wc*hc*2 + w/2*h/2];
  335. m_pYUV[1] = m_pYUV[0] + w*h;
  336. m_pYUV[2] = m_pYUV[1] + wc*hc;
  337. m_pYUV[3] = m_pYUV[2] + wc*hc;
  338. memset(m_pYUV[3], 0x80, w/2*h/2);
  339. m_rtAvgTimePerFrame = 10000000i64 * decoder->seq_params.frame_rate.denominator / decoder->seq_params.frame_rate.numerator;
  340. dirac_set_buf(decoder, m_pYUV, NULL);
  341. }
  343. break;
  345.         case STATE_SEQUENCE_END:
  346. TRACE(_T("STATE_SEQUENCE_ENDn"));
  347.             break;
  349.         case STATE_PICTURE_START:
  350. TRACE(_T("STATE_PICTURE_START, frame_type=%d frame_num=%dn"), decoder->frame_params.ftype, decoder->frame_params.fnum);
  351. dirac_skip(decoder, (m_fDropFrames || decoder->frame_params.fnum * m_rtAvgTimePerFrame < m_tStart) && decoder->frame_params.ftype == L2_frame ? 1 : 0);
  352. if(m_fDropFrames && decoder->frame_params.ftype == L2_frame) return S_OK;
  353.             break;
  355.         case STATE_PICTURE_AVAIL:
  356. TRACE(_T("STATE_PICTURE_AVAIL, frame_type=%d frame_num=%dn"), decoder->frame_params.ftype, decoder->frame_params.fnum);
  357. hr = Deliver(pIn, decoder->frame_params.fnum * m_rtAvgTimePerFrame - m_tStart, (decoder->frame_params.fnum + 1) * m_rtAvgTimePerFrame - m_tStart);
  358. break;
  360.         case STATE_INVALID:
  361. TRACE(_T("STATE_INVALIDn"));
  362. return E_FAIL; // TODO: can we recover from this state?
  363. // break;
  365.         default:
  366. TRACE(_T("unknown staten"));
  367.             continue;
  368.         }
  369.     }
  371. return hr;
  372. }
  374. HRESULT CDiracVideoDecoder::Deliver(IMediaSample* pIn, REFERENCE_TIME rtStart, REFERENCE_TIME rtStop)
  375. {
  376. CheckPointer(pIn, E_POINTER);
  378. HRESULT hr;
  380. if(pIn->IsPreroll() == S_OK || rtStart < 0)
  381. return S_OK;
  383.     CComPtr<IMediaSample> pOut;
  384. BYTE* pDataOut = NULL;
  385. if(FAILED(hr = m_pOutput->GetDeliveryBuffer(&pOut, NULL, NULL, 0))
  386. || FAILED(hr = pOut->GetPointer(&pDataOut)))
  387. return hr;
  389. AM_MEDIA_TYPE* pmt;
  390. if(SUCCEEDED(pOut->GetMediaType(&pmt)) && pmt)
  391. {
  392. CMediaType mt(*pmt);
  393. m_pOutput->SetMediaType(&mt);
  394. DeleteMediaType(pmt);
  395. }
  397. TRACE(_T("CDiracVideoDecoder::Deliver(%I64d, %I64d)n"), rtStart, rtStop);
  399. pOut->SetTime(&rtStart, &rtStop);
  400. pOut->SetMediaTime(NULL, NULL);
  402. pOut->SetDiscontinuity(pIn->IsDiscontinuity() == S_OK);
  403. pOut->SetSyncPoint(TRUE);
  405. if(GetCLSID(m_pOutput->GetConnected()) == CLSID_OverlayMixer)
  406. pOut->SetDiscontinuity(TRUE);
  408. Copy(pDataOut);
  410. return m_pOutput->Deliver(pOut);
  411. }
  413. void CDiracVideoDecoder::Copy(BYTE* pOut)
  414. {
  415. // FIXME: modes other than I420 and Y-only
  417. BITMAPINFOHEADER bihOut;
  418. ExtractBIH(&m_pOutput->CurrentMediaType(), &bihOut);
  420. dirac_decoder_t* decoder = (dirac_decoder_t*)m_decoder;
  422. int w = decoder->seq_params.width;
  423. int h = decoder->seq_params.height;
  424. int wc = decoder->seq_params.chroma_width;
  425. int hc = decoder->seq_params.chroma_height;
  427. int pitchIn = w;
  429. BYTE* pY = m_pYUV[0];
  430. BYTE* pU = w/2 == wc && h/2 == hc ? m_pYUV[1] : m_pYUV[3]; // FIXME
  431. BYTE* pV = w/2 == wc && h/2 == hc ? m_pYUV[2] : m_pYUV[3]; // FIXME
  433. if(bihOut.biCompression == '2YUY')
  434. {
  435. BitBltFromI420ToYUY2(w, h, pOut, bihOut.biWidth*2, pY, pU, pV, pitchIn);
  436. }
  437. else if(bihOut.biCompression == 'I420' || bihOut.biCompression == 'VUYI')
  438. {
  439. BitBltFromI420ToI420(w, h, pOut, pOut + bihOut.biWidth*h, pOut + bihOut.biWidth*h*5/4, bihOut.biWidth, pY, pU, pV, pitchIn);
  440. }
  441. else if(bihOut.biCompression == '21VY')
  442. {
  443. BitBltFromI420ToI420(w, h, pOut, pOut + bihOut.biWidth*h*5/4, pOut + bihOut.biWidth*h, bihOut.biWidth, pY, pU, pV, pitchIn);
  444. }
  445. else if(bihOut.biCompression == BI_RGB || bihOut.biCompression == BI_BITFIELDS)
  446. {
  447. int pitchOut = bihOut.biWidth*bihOut.biBitCount>>3;
  449. if(bihOut.biHeight > 0)
  450. {
  451. pOut += pitchOut*(h-1);
  452. pitchOut = -pitchOut;
  453. }
  455. if(!BitBltFromI420ToRGB(w, h, pOut, pitchOut, bihOut.biBitCount, pY, pU, pV, pitchIn))
  456. {
  457. for(DWORD y = 0; y < h; y++, pOut += pitchOut)
  458. memset(pOut, 0, pitchOut);
  459. }
  460. }
  461. }
  463. HRESULT CDiracVideoDecoder::CheckInputType(const CMediaType* mtIn)
  464. {
  465. DIRACINFOHEADER* dvih = (DIRACINFOHEADER*)mtIn->Format();
  467. if(mtIn->majortype != MEDIATYPE_Video 
  468. || mtIn->subtype != MEDIASUBTYPE_DiracVideo
  469. || mtIn->formattype != FORMAT_DiracVideoInfo
  470. || (dvih->hdr.bmiHeader.biWidth&1) || (dvih->hdr.bmiHeader.biHeight&1))
  471. return VFW_E_TYPE_NOT_ACCEPTED;
  473. return S_OK;
  474. }
  476. HRESULT CDiracVideoDecoder::CheckTransform(const CMediaType* mtIn, const CMediaType* mtOut)
  477. {
  478. if(m_pOutput && m_pOutput->IsConnected())
  479. {
  480. BITMAPINFOHEADER bih1, bih2;
  481. if(ExtractBIH(mtOut, &bih1) && ExtractBIH(&m_pOutput->CurrentMediaType(), &bih2)
  482. && abs(bih1.biHeight) != abs(bih2.biHeight))
  483. return VFW_E_TYPE_NOT_ACCEPTED;
  484. }
  486. return mtIn->majortype == MEDIATYPE_Video && mtIn->subtype == MEDIASUBTYPE_DiracVideo
  487. && mtOut->majortype == MEDIATYPE_Video && (mtOut->subtype == MEDIASUBTYPE_YUY2
  488. || mtOut->subtype == MEDIASUBTYPE_YV12
  489. || mtOut->subtype == MEDIASUBTYPE_I420
  490. || mtOut->subtype == MEDIASUBTYPE_IYUV
  491. || mtOut->subtype == MEDIASUBTYPE_ARGB32
  492. || mtOut->subtype == MEDIASUBTYPE_RGB32
  493. || mtOut->subtype == MEDIASUBTYPE_RGB24
  494. || mtOut->subtype == MEDIASUBTYPE_RGB565
  495. || mtOut->subtype == MEDIASUBTYPE_RGB555)
  496. ? S_OK
  497. : VFW_E_TYPE_NOT_ACCEPTED;
  498. }
  500. HRESULT CDiracVideoDecoder::DecideBufferSize(IMemAllocator* pAllocator, ALLOCATOR_PROPERTIES* pProperties)
  501. {
  502. if(m_pInput->IsConnected() == FALSE) return E_UNEXPECTED;
  504. BITMAPINFOHEADER bih;
  505. ExtractBIH(&m_pOutput->CurrentMediaType(), &bih);
  507. pProperties->cBuffers = 1;
  508. pProperties->cbBuffer = bih.biSizeImage;
  509. pProperties->cbAlign = 1;
  510. pProperties->cbPrefix = 0;
  512. HRESULT hr;
  513. ALLOCATOR_PROPERTIES Actual;
  514.     if(FAILED(hr = pAllocator->SetProperties(pProperties, &Actual))) 
  515. return hr;
  517.     return(pProperties->cBuffers > Actual.cBuffers || pProperties->cbBuffer > Actual.cbBuffer
  518. ? E_FAIL
  519. : NOERROR);
  520. }
  522. HRESULT CDiracVideoDecoder::GetMediaType(int iPosition, CMediaType* pmt)
  523. {
  524.     if(m_pInput->IsConnected() == FALSE) return E_UNEXPECTED;
  526. struct {const GUID* subtype; WORD biPlanes, biBitCount; DWORD biCompression;} fmts[] =
  527. {
  528. {&MEDIASUBTYPE_YV12, 3, 12, '21VY'},
  529. {&MEDIASUBTYPE_I420, 3, 12, '024I'},
  530. {&MEDIASUBTYPE_IYUV, 3, 12, 'VUYI'},
  531. {&MEDIASUBTYPE_YUY2, 1, 16, '2YUY'},
  532. {&MEDIASUBTYPE_ARGB32, 1, 32, BI_RGB},
  533. {&MEDIASUBTYPE_RGB32, 1, 32, BI_RGB},
  534. {&MEDIASUBTYPE_RGB24, 1, 24, BI_RGB},
  535. {&MEDIASUBTYPE_RGB565, 1, 16, BI_RGB},
  536. {&MEDIASUBTYPE_RGB555, 1, 16, BI_RGB},
  537. {&MEDIASUBTYPE_ARGB32, 1, 32, BI_BITFIELDS},
  538. {&MEDIASUBTYPE_RGB32, 1, 32, BI_BITFIELDS},
  539. {&MEDIASUBTYPE_RGB24, 1, 24, BI_BITFIELDS},
  540. {&MEDIASUBTYPE_RGB565, 1, 16, BI_BITFIELDS},
  541. {&MEDIASUBTYPE_RGB555, 1, 16, BI_BITFIELDS},
  542. };
  544. if(m_pInput->CurrentMediaType().formattype == FORMAT_VideoInfo)
  545. iPosition = iPosition*2 + 1;
  547. if(iPosition < 0) return E_INVALIDARG;
  548. if(iPosition >= 2*countof(fmts)) return VFW_S_NO_MORE_ITEMS;
  550. BITMAPINFOHEADER bih;
  551. ExtractBIH(&m_pInput->CurrentMediaType(), &bih);
  553. pmt->majortype = MEDIATYPE_Video;
  554. pmt->subtype = *fmts[iPosition/2].subtype;
  556. BITMAPINFOHEADER bihOut;
  557. memset(&bihOut, 0, sizeof(bihOut));
  558. bihOut.biSize = sizeof(bihOut);
  559. bihOut.biWidth = bih.biWidth;
  560. bihOut.biHeight = bih.biHeight;
  561. bihOut.biPlanes = fmts[iPosition/2].biPlanes;
  562. bihOut.biBitCount = fmts[iPosition/2].biBitCount;
  563. bihOut.biCompression = fmts[iPosition/2].biCompression;
  564. bihOut.biSizeImage = bih.biWidth*bih.biHeight*bihOut.biBitCount>>3;
  566. if(iPosition&1)
  567. {
  568. pmt->formattype = FORMAT_VideoInfo;
  569. VIDEOINFOHEADER* vih = (VIDEOINFOHEADER*)pmt->AllocFormatBuffer(sizeof(VIDEOINFOHEADER));
  570. memset(vih, 0, sizeof(VIDEOINFOHEADER));
  571. vih->bmiHeader = bihOut;
  573. if(m_pInput->CurrentMediaType().formattype == FORMAT_VideoInfo2)
  574. {
  575. vih->bmiHeader.biWidth = ((VIDEOINFOHEADER2*)m_pInput->CurrentMediaType().Format())->dwPictAspectRatioX;
  576. vih->bmiHeader.biHeight = ((VIDEOINFOHEADER2*)m_pInput->CurrentMediaType().Format())->dwPictAspectRatioY;
  577. vih->bmiHeader.biSizeImage = vih->bmiHeader.biWidth*vih->bmiHeader.biHeight*vih->bmiHeader.biBitCount>>3;
  578. }
  579. }
  580. else
  581. {
  582. pmt->formattype = FORMAT_VideoInfo2;
  583. VIDEOINFOHEADER2* vih2 = (VIDEOINFOHEADER2*)pmt->AllocFormatBuffer(sizeof(VIDEOINFOHEADER2));
  584. memset(vih2, 0, sizeof(VIDEOINFOHEADER2));
  585. vih2->bmiHeader = bihOut;
  586. vih2->dwPictAspectRatioX = ((VIDEOINFOHEADER2*)m_pInput->CurrentMediaType().Format())->dwPictAspectRatioX;
  587. vih2->dwPictAspectRatioY = ((VIDEOINFOHEADER2*)m_pInput->CurrentMediaType().Format())->dwPictAspectRatioY;
  588. }
  590. CorrectMediaType(pmt);
  592. return S_OK;
  593. }
  595. HRESULT CDiracVideoDecoder::StartStreaming()
  596. {
  597. InitDecoder();
  598. return __super::StartStreaming();
  599. }
  601. HRESULT CDiracVideoDecoder::StopStreaming()
  602. {
  603. FreeDecoder();
  604. return __super::StopStreaming();
  605. }
  607. HRESULT CDiracVideoDecoder::NewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
  608. {
  609. CAutoLock cAutoLock(&m_csReceive);
  611. m_fDropFrames = false;
  612. m_tStart = tStart;
  614. return __super::NewSegment(tStart, tStop, dRate);
  615. }
  617. HRESULT CDiracVideoDecoder::AlterQuality(Quality q)
  618. {
  619. if(q.Late > 500*10000i64) m_fDropFrames = true;
  620. if(q.Late <= 0) m_fDropFrames = false;
  621. return E_NOTIMPL;
  622. }