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

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

多媒体编程

开发平台：

Visual C++

BaseVideoFilter.cpp：源码内容
  2. /* 
  3.  * Copyright (C) 2003-2005 Gabest
  4.  * http://www.gabest.org
  5.  *
  6.  *  This Program is free software; you can redistribute it and/or modify
  7.  *  it under the terms of the GNU General Public License as published by
  8.  *  the Free Software Foundation; either version 2, or (at your option)
  9.  *  any later version.
  10.  *   
  11.  *  This Program is distributed in the hope that it will be useful,
  12.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14.  *  GNU General Public License for more details.
  15.  *   
  16.  *  You should have received a copy of the GNU General Public License
  17.  *  along with GNU Make; see the file COPYING.  If not, write to
  18.  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 
  19.  *  http://www.gnu.org/copyleft/gpl.html
  20.  *
  21.  */
  23. #include "StdAfx.h"
  24. #include <mmintrin.h>
  25. #include "BaseVideoFilter.h"
  26. #include "......DSUtilDSUtil.h"
  27. #include "......DSUtilMediaTypes.h"
  29. #include <initguid.h>
  30. #include "........includemoreuuids.h"
  32. //
  33. // CBaseVideoFilter
  34. //
  36. CBaseVideoFilter::CBaseVideoFilter(TCHAR* pName, LPUNKNOWN lpunk, HRESULT* phr, REFCLSID clsid) 
  37. : CTransformFilter(pName, lpunk, clsid)
  38. {
  39. if(phr) *phr = S_OK;
  41. if(!(m_pInput = new CBaseVideoInputPin(NAME("CBaseVideoInputPin"), this, phr, L"Video"))) *phr = E_OUTOFMEMORY;
  42. if(FAILED(*phr)) return;
  44. if(!(m_pOutput = new CBaseVideoOutputPin(NAME("CBaseVideoOutputPin"), this, phr, L"Output"))) *phr = E_OUTOFMEMORY;
  45. if(FAILED(*phr))  {delete m_pInput, m_pInput = NULL; return;}
  47. m_wout = m_win = m_w = 0;
  48. m_hout = m_hin = m_h = 0;
  49. m_arxout = m_arxin = m_arx = 0;
  50. m_aryout = m_aryin = m_ary = 0;
  51. }
  53. CBaseVideoFilter::~CBaseVideoFilter()
  54. {
  55. }
  57. int CBaseVideoFilter::GetPinCount()
  58. {
  59. return 2;
  60. }
  62. CBasePin* CBaseVideoFilter::GetPin(int n)
  63. {
  64. switch(n)
  65. {
  66. case 0: return m_pInput;
  67. case 1: return m_pOutput;
  68. }
  69. return NULL;
  70. }
  72. HRESULT CBaseVideoFilter::Receive(IMediaSample* pIn)
  73. {
  74. _mm_empty(); // just for safety
  76. CAutoLock cAutoLock(&m_csReceive);
  78. HRESULT hr;
  80.     AM_SAMPLE2_PROPERTIES* const pProps = m_pInput->SampleProps();
  81.     if(pProps->dwStreamId != AM_STREAM_MEDIA)
  82. return m_pOutput->Deliver(pIn);
  84. AM_MEDIA_TYPE* pmt;
  85. if(SUCCEEDED(pIn->GetMediaType(&pmt)) && pmt)
  86. {
  87. CMediaType mt(*pmt);
  88. m_pInput->SetMediaType(&mt);
  89. DeleteMediaType(pmt);
  90. }
  92. if(FAILED(hr = Transform(pIn)))
  93. return hr;
  95. return S_OK;
  96. }
  98. HRESULT CBaseVideoFilter::GetDeliveryBuffer(int w, int h, IMediaSample** ppOut)
  99. {
  100. CheckPointer(ppOut, E_POINTER);
  102. HRESULT hr;
  104. if(FAILED(hr = ReconnectOutput(w, h)))
  105. return hr;
  107. if(FAILED(hr = m_pOutput->GetDeliveryBuffer(ppOut, NULL, NULL, 0)))
  108. return hr;
  110. AM_MEDIA_TYPE* pmt;
  111. if(SUCCEEDED((*ppOut)->GetMediaType(&pmt)) && pmt)
  112. {
  113. CMediaType mt = *pmt;
  114. m_pOutput->SetMediaType(&mt);
  115. DeleteMediaType(pmt);
  116. }
  118. (*ppOut)->SetDiscontinuity(FALSE);
  119. (*ppOut)->SetSyncPoint(TRUE);
  121. // FIXME: hell knows why but without this the overlay mixer starts very skippy
  122. // (don't enable this for other renderers, the old for example will go crazy if you do)
  123. if(GetCLSID(m_pOutput->GetConnected()) == CLSID_OverlayMixer)
  124. (*ppOut)->SetDiscontinuity(TRUE);
  126. return S_OK;
  127. }
  129. HRESULT CBaseVideoFilter::ReconnectOutput(int w, int h)
  130. {
  131. CMediaType& mt = m_pOutput->CurrentMediaType();
  133. int w_org = m_w;
  134. int h_org = m_h;
  136. bool fForceReconnection = false;
  137. if(w != m_w || h != m_h)
  138. {
  139. fForceReconnection = true;
  140. m_w = w;
  141. m_h = h;
  142. }
  144. HRESULT hr = S_OK;
  146. if(fForceReconnection || m_w != m_wout || m_h != m_hout || m_arx != m_arxout || m_ary != m_aryout)
  147. {
  148. if(GetCLSID(m_pOutput->GetConnected()) == CLSID_VideoRenderer)
  149. {
  150. NotifyEvent(EC_ERRORABORT, 0, 0);
  151. return E_FAIL;
  152. }
  154. BITMAPINFOHEADER* bmi = NULL;
  156. if(mt.formattype == FORMAT_VideoInfo)
  157. {
  158. VIDEOINFOHEADER* vih = (VIDEOINFOHEADER*)mt.Format();
  159. SetRect(&vih->rcSource, 0, 0, m_w, m_h);
  160. SetRect(&vih->rcTarget, 0, 0, m_w, m_h);
  161. bmi = &vih->bmiHeader;
  162. bmi->biXPelsPerMeter = m_w * m_ary;
  163. bmi->biYPelsPerMeter = m_h * m_arx;
  164. }
  165. else if(mt.formattype == FORMAT_VideoInfo2)
  166. {
  167. VIDEOINFOHEADER2* vih = (VIDEOINFOHEADER2*)mt.Format();
  168. SetRect(&vih->rcSource, 0, 0, m_w, m_h);
  169. SetRect(&vih->rcTarget, 0, 0, m_w, m_h);
  170. bmi = &vih->bmiHeader;
  171. vih->dwPictAspectRatioX = m_arx;
  172. vih->dwPictAspectRatioY = m_ary;
  173. }
  175. bmi->biWidth = m_w;
  176. bmi->biHeight = m_h;
  177. bmi->biSizeImage = m_w*m_h*bmi->biBitCount>>3;
  179. hr = m_pOutput->GetConnected()->QueryAccept(&mt);
  180. ASSERT(SUCCEEDED(hr)); // should better not fail, after all "mt" is the current media type, just with a different resolution
  181. HRESULT hr1 = 0, hr2 = 0;
  182. CComPtr<IMediaSample> pOut;
  183. if(SUCCEEDED(hr1 = m_pOutput->GetConnected()->ReceiveConnection(m_pOutput, &mt))
  184. && SUCCEEDED(hr2 = m_pOutput->GetDeliveryBuffer(&pOut, NULL, NULL, 0)))
  185. {
  186. AM_MEDIA_TYPE* pmt;
  187. if(SUCCEEDED(pOut->GetMediaType(&pmt)) && pmt)
  188. {
  189. CMediaType mt = *pmt;
  190. m_pOutput->SetMediaType(&mt);
  191. DeleteMediaType(pmt);
  192. }
  193. else // stupid overlay mixer won't let us know the new pitch...
  194. {
  195. long size = pOut->GetSize();
  196. bmi->biWidth = size / bmi->biHeight * 8 / bmi->biBitCount;
  197. }
  198. }
  199. else
  200. {
  201. m_w = w_org;
  202. m_h = h_org;
  203. return E_FAIL;
  204. }
  206. m_wout = m_w;
  207. m_hout = m_h;
  208. m_arxout = m_arx;
  209. m_aryout = m_ary;
  211. // some renderers don't send this
  212. NotifyEvent(EC_VIDEO_SIZE_CHANGED, MAKELPARAM(m_w, m_h), 0);
  214. return S_OK;
  215. }
  217. return S_FALSE;
  218. }
  220. HRESULT CBaseVideoFilter::CopyBuffer(BYTE* pOut, BYTE* pIn, int w, int h, int pitchIn, const GUID& subtype)
  221. {
  222. int abs_h = abs(h);
  223. BYTE* pInYUV[3] = {pIn, pIn + pitchIn*abs_h, pIn + pitchIn*abs_h + (pitchIn>>1)*(abs_h>>1)};
  224. return CopyBuffer(pOut, pInYUV, w, h, pitchIn, subtype);
  225. }
  227. HRESULT CBaseVideoFilter::CopyBuffer(BYTE* pOut, BYTE** ppIn, int w, int h, int pitchIn, const GUID& subtype)
  228. {
  229. BITMAPINFOHEADER bihOut;
  230. ExtractBIH(&m_pOutput->CurrentMediaType(), &bihOut);
  232. int pitchOut = 0;
  234. if(bihOut.biCompression == BI_RGB || bihOut.biCompression == BI_BITFIELDS)
  235. {
  236. pitchOut = bihOut.biWidth*bihOut.biBitCount>>3;
  238. if(bihOut.biHeight > 0)
  239. {
  240. pOut += pitchOut*(h-1);
  241. pitchOut = -pitchOut;
  242. if(h < 0) h = -h;
  243. }
  244. }
  246. if(h < 0)
  247. {
  248. h = -h;
  249. ppIn[0] += pitchIn*(h-1);
  250. ppIn[1] += (pitchIn>>1)*((h>>1)-1);
  251. ppIn[2] += (pitchIn>>1)*((h>>1)-1);
  252. pitchIn = -pitchIn;
  253. }
  255. if(subtype == MEDIASUBTYPE_I420 || subtype == MEDIASUBTYPE_IYUV || subtype == MEDIASUBTYPE_YV12)
  256. {
  257. BYTE* pIn = ppIn[0];
  258. BYTE* pInU = ppIn[1];
  259. BYTE* pInV = ppIn[2];
  261. if(subtype == MEDIASUBTYPE_YV12) {BYTE* tmp = pInU; pInU = pInV; pInV = tmp;}
  263. BYTE* pOutU = pOut + bihOut.biWidth*h;
  264. BYTE* pOutV = pOut + bihOut.biWidth*h*5/4;
  266. if(bihOut.biCompression == '21VY') {BYTE* tmp = pOutU; pOutU = pOutV; pOutV = tmp;}
  268. ASSERT(w <= abs(pitchIn));
  270. if(bihOut.biCompression == '2YUY')
  271. {
  272. BitBltFromI420ToYUY2(w, h, pOut, bihOut.biWidth*2, pIn, pInU, pInV, pitchIn);
  273. }
  274. else if(bihOut.biCompression == '024I' || bihOut.biCompression == 'VUYI' || bihOut.biCompression == '21VY')
  275. {
  276. BitBltFromI420ToI420(w, h, pOut, pOutU, pOutV, bihOut.biWidth, pIn, pInU, pInV, pitchIn);
  277. }
  278. else if(bihOut.biCompression == BI_RGB || bihOut.biCompression == BI_BITFIELDS)
  279. {
  280. if(!BitBltFromI420ToRGB(w, h, pOut, pitchOut, bihOut.biBitCount, pIn, pInU, pInV, pitchIn))
  281. {
  282. for(DWORD y = 0; y < h; y++, pOut += pitchOut)
  283. memset(pOut, 0, pitchOut);
  284. }
  285. }
  286. }
  287. else if(subtype == MEDIASUBTYPE_YUY2)
  288. {
  289. if(bihOut.biCompression == '2YUY')
  290. {
  291. BitBltFromYUY2ToYUY2(w, h, pOut, bihOut.biWidth*2, ppIn[0], pitchIn);
  292. }
  293. else if(bihOut.biCompression == BI_RGB || bihOut.biCompression == BI_BITFIELDS)
  294. {
  295. if(!BitBltFromYUY2ToRGB(w, h, pOut, pitchOut, bihOut.biBitCount, ppIn[0], pitchIn))
  296. {
  297. for(DWORD y = 0; y < h; y++, pOut += pitchOut)
  298. memset(pOut, 0, pitchOut);
  299. }
  300. }
  301. }
  302. else if(subtype == MEDIASUBTYPE_ARGB32 || subtype == MEDIASUBTYPE_RGB32 || subtype == MEDIASUBTYPE_RGB24 || subtype == MEDIASUBTYPE_RGB565)
  303. {
  304. int sbpp = 
  305. subtype == MEDIASUBTYPE_ARGB32 || subtype == MEDIASUBTYPE_RGB32 ? 32 :
  306. subtype == MEDIASUBTYPE_RGB24 ? 24 :
  307. subtype == MEDIASUBTYPE_RGB565 ? 16 : 0;
  309. if(bihOut.biCompression == '2YUY')
  310. {
  311. // TODO
  312. // BitBltFromRGBToYUY2();
  313. }
  314. else if(bihOut.biCompression == BI_RGB || bihOut.biCompression == BI_BITFIELDS)
  315. {
  316. if(!BitBltFromRGBToRGB(w, h, pOut, pitchOut, bihOut.biBitCount, ppIn[0], pitchIn, sbpp))
  317. {
  318. for(DWORD y = 0; y < h; y++, pOut += pitchOut)
  319. memset(pOut, 0, pitchOut);
  320. }
  321. }
  322. }
  323. else
  324. {
  325. return VFW_E_TYPE_NOT_ACCEPTED;
  326. }
  328. return S_OK;
  329. }
  331. HRESULT CBaseVideoFilter::CheckInputType(const CMediaType* mtIn)
  332. {
  333. BITMAPINFOHEADER bih;
  334. ExtractBIH(mtIn, &bih);
  336. return mtIn->majortype == MEDIATYPE_Video 
  337. && (mtIn->subtype == MEDIASUBTYPE_YV12 
  338.  || mtIn->subtype == MEDIASUBTYPE_I420 
  339.  || mtIn->subtype == MEDIASUBTYPE_IYUV
  340.  || mtIn->subtype == MEDIASUBTYPE_YUY2
  341.  || mtIn->subtype == MEDIASUBTYPE_ARGB32
  342.  || mtIn->subtype == MEDIASUBTYPE_RGB32
  343.  || mtIn->subtype == MEDIASUBTYPE_RGB24
  344.    || mtIn->subtype == MEDIASUBTYPE_RGB565)
  345. && (mtIn->formattype == FORMAT_VideoInfo 
  346.  || mtIn->formattype == FORMAT_VideoInfo2)
  347. && bih.biHeight > 0
  348. ? S_OK
  349. : VFW_E_TYPE_NOT_ACCEPTED;
  350. }
  352. HRESULT CBaseVideoFilter::CheckTransform(const CMediaType* mtIn, const CMediaType* mtOut)
  353. {
  354. if(FAILED(CheckInputType(mtIn)) || mtOut->majortype != MEDIATYPE_Video)
  355. return VFW_E_TYPE_NOT_ACCEPTED;
  357. if(mtIn->majortype == MEDIATYPE_Video 
  358. && (mtIn->subtype == MEDIASUBTYPE_YV12 
  359.  || mtIn->subtype == MEDIASUBTYPE_I420 
  360.  || mtIn->subtype == MEDIASUBTYPE_IYUV))
  361. {
  362. if(mtOut->subtype != MEDIASUBTYPE_YV12
  363. && mtOut->subtype != MEDIASUBTYPE_I420
  364. && mtOut->subtype != MEDIASUBTYPE_IYUV
  365. && mtOut->subtype != MEDIASUBTYPE_YUY2
  366. && mtOut->subtype != MEDIASUBTYPE_ARGB32
  367. && mtOut->subtype != MEDIASUBTYPE_RGB32
  368. && mtOut->subtype != MEDIASUBTYPE_RGB24
  369. && mtOut->subtype != MEDIASUBTYPE_RGB565)
  370. return VFW_E_TYPE_NOT_ACCEPTED;
  371. }
  372. else if(mtIn->majortype == MEDIATYPE_Video 
  373. && (mtIn->subtype == MEDIASUBTYPE_YUY2))
  374. {
  375. if(mtOut->subtype != MEDIASUBTYPE_YUY2
  376. && mtOut->subtype != MEDIASUBTYPE_ARGB32
  377. && mtOut->subtype != MEDIASUBTYPE_RGB32
  378. && mtOut->subtype != MEDIASUBTYPE_RGB24
  379. && mtOut->subtype != MEDIASUBTYPE_RGB565)
  380. return VFW_E_TYPE_NOT_ACCEPTED;
  381. }
  382. else if(mtIn->majortype == MEDIATYPE_Video 
  383. && (mtIn->subtype == MEDIASUBTYPE_ARGB32
  384. || mtIn->subtype == MEDIASUBTYPE_RGB32
  385. || mtIn->subtype == MEDIASUBTYPE_RGB24
  386. || mtIn->subtype == MEDIASUBTYPE_RGB565))
  387. {
  388. if(mtOut->subtype != MEDIASUBTYPE_ARGB32
  389. && mtOut->subtype != MEDIASUBTYPE_RGB32
  390. && mtOut->subtype != MEDIASUBTYPE_RGB24
  391. && mtOut->subtype != MEDIASUBTYPE_RGB565)
  392. return VFW_E_TYPE_NOT_ACCEPTED;
  393. }
  395. return S_OK;
  396. }
  398. HRESULT CBaseVideoFilter::CheckOutputType(const CMediaType& mtOut)
  399. {
  400. int wout = 0, hout = 0, arxout = 0, aryout = 0;
  401. return ExtractDim(&mtOut, wout, hout, arxout, aryout)
  402. && m_h == abs((int)hout)
  403. && mtOut.subtype != MEDIASUBTYPE_ARGB32
  404. ? S_OK
  405. : VFW_E_TYPE_NOT_ACCEPTED;
  406. }
  408. HRESULT CBaseVideoFilter::DecideBufferSize(IMemAllocator* pAllocator, ALLOCATOR_PROPERTIES* pProperties)
  409. {
  410. if(m_pInput->IsConnected() == FALSE) return E_UNEXPECTED;
  412. BITMAPINFOHEADER bih;
  413. ExtractBIH(&m_pOutput->CurrentMediaType(), &bih);
  415. pProperties->cBuffers = 1;
  416. pProperties->cbBuffer = bih.biSizeImage;
  417. pProperties->cbAlign = 1;
  418. pProperties->cbPrefix = 0;
  420. HRESULT hr;
  421. ALLOCATOR_PROPERTIES Actual;
  422.     if(FAILED(hr = pAllocator->SetProperties(pProperties, &Actual))) 
  423. return hr;
  425.     return pProperties->cBuffers > Actual.cBuffers || pProperties->cbBuffer > Actual.cbBuffer
  426. ? E_FAIL
  427. : NOERROR;
  428. }
  430. HRESULT CBaseVideoFilter::GetMediaType(int iPosition, CMediaType* pmt)
  431. {
  432.     if(m_pInput->IsConnected() == FALSE) return E_UNEXPECTED;
  434. struct {const GUID* subtype; WORD biPlanes, biBitCount; DWORD biCompression;} fmts[] =
  435. {
  436. {&MEDIASUBTYPE_YV12, 3, 12, '21VY'},
  437. {&MEDIASUBTYPE_I420, 3, 12, '024I'},
  438. {&MEDIASUBTYPE_IYUV, 3, 12, 'VUYI'},
  439. {&MEDIASUBTYPE_YUY2, 1, 16, '2YUY'},
  440. {&MEDIASUBTYPE_ARGB32, 1, 32, BI_RGB},
  441. {&MEDIASUBTYPE_RGB32, 1, 32, BI_RGB},
  442. {&MEDIASUBTYPE_RGB24, 1, 24, BI_RGB},
  443. {&MEDIASUBTYPE_RGB565, 1, 16, BI_RGB},
  444. {&MEDIASUBTYPE_RGB555, 1, 16, BI_RGB},
  445. {&MEDIASUBTYPE_ARGB32, 1, 32, BI_BITFIELDS},
  446. {&MEDIASUBTYPE_RGB32, 1, 32, BI_BITFIELDS},
  447. {&MEDIASUBTYPE_RGB24, 1, 24, BI_BITFIELDS},
  448. {&MEDIASUBTYPE_RGB565, 1, 16, BI_BITFIELDS},
  449. {&MEDIASUBTYPE_RGB555, 1, 16, BI_BITFIELDS},
  450. };
  452. // this will make sure we won't connect to the old renderer in dvd mode
  453. // that renderer can't switch the format dynamically
  455. bool fFoundDVDNavigator = false;
  456. CComPtr<IBaseFilter> pBF = this;
  457. CComPtr<IPin> pPin = m_pInput;
  458. for(; !fFoundDVDNavigator && (pBF = GetFilterFromPin(GetUpStreamPin(pBF, pPin))); pPin = GetFirstPin(pBF))
  459.         fFoundDVDNavigator = GetCLSID(pBF) == CLSID_DVDNavigator;
  461. if(fFoundDVDNavigator || m_pInput->CurrentMediaType().formattype == FORMAT_VideoInfo2)
  462. iPosition = iPosition*2;
  464. //
  466. if(iPosition < 0) return E_INVALIDARG;
  467. if(iPosition >= 2*countof(fmts)) return VFW_S_NO_MORE_ITEMS;
  469. pmt->majortype = MEDIATYPE_Video;
  470. pmt->subtype = *fmts[iPosition/2].subtype;
  472. int w = m_win, h = m_hin, arx = m_arxin, ary = m_aryin;
  473. GetOutputSize(w, h, arx, ary);
  475. BITMAPINFOHEADER bihOut;
  476. memset(&bihOut, 0, sizeof(bihOut));
  477. bihOut.biSize = sizeof(bihOut);
  478. bihOut.biWidth = w;
  479. bihOut.biHeight = h;
  480. bihOut.biPlanes = fmts[iPosition/2].biPlanes;
  481. bihOut.biBitCount = fmts[iPosition/2].biBitCount;
  482. bihOut.biCompression = fmts[iPosition/2].biCompression;
  483. bihOut.biSizeImage = w*h*bihOut.biBitCount>>3;
  485. if(iPosition&1)
  486. {
  487. pmt->formattype = FORMAT_VideoInfo;
  488. VIDEOINFOHEADER* vih = (VIDEOINFOHEADER*)pmt->AllocFormatBuffer(sizeof(VIDEOINFOHEADER));
  489. memset(vih, 0, sizeof(VIDEOINFOHEADER));
  490. vih->bmiHeader = bihOut;
  491. vih->bmiHeader.biXPelsPerMeter = vih->bmiHeader.biWidth * ary;
  492. vih->bmiHeader.biYPelsPerMeter = vih->bmiHeader.biHeight * arx;
  493. }
  494. else
  495. {
  496. pmt->formattype = FORMAT_VideoInfo2;
  497. VIDEOINFOHEADER2* vih = (VIDEOINFOHEADER2*)pmt->AllocFormatBuffer(sizeof(VIDEOINFOHEADER2));
  498. memset(vih, 0, sizeof(VIDEOINFOHEADER2));
  499. vih->bmiHeader = bihOut;
  500. vih->dwPictAspectRatioX = arx;
  501. vih->dwPictAspectRatioY = ary;
  502. vih->dwCopyProtectFlags &= ~AMCOPYPROTECT_RestrictDuplication; // hehe
  503. }
  505. CMediaType& mt = m_pInput->CurrentMediaType();
  507. // these fields have the same field offset in all four structs
  508. ((VIDEOINFOHEADER*)pmt->Format())->AvgTimePerFrame = ((VIDEOINFOHEADER*)mt.Format())->AvgTimePerFrame;
  509. ((VIDEOINFOHEADER*)pmt->Format())->dwBitRate = ((VIDEOINFOHEADER*)mt.Format())->dwBitRate;
  510. ((VIDEOINFOHEADER*)pmt->Format())->dwBitErrorRate = ((VIDEOINFOHEADER*)mt.Format())->dwBitErrorRate;
  512. CorrectMediaType(pmt);
  514. return S_OK;
  515. }
  517. HRESULT CBaseVideoFilter::SetMediaType(PIN_DIRECTION dir, const CMediaType* pmt)
  518. {
  519. if(dir == PINDIR_INPUT)
  520. {
  521. m_w = m_h = m_arx = m_ary = 0;
  522. ExtractDim(pmt, m_w, m_h, m_arx, m_ary);
  523. m_win = m_w;
  524. m_hin = m_h;
  525. m_arxin = m_arx;
  526. m_aryin = m_ary;
  527. GetOutputSize(m_w, m_h, m_arx, m_ary);
  528. }
  529. else if(dir == PINDIR_OUTPUT)
  530. {
  531. int wout = 0, hout = 0, arxout = 0, aryout = 0;
  532. ExtractDim(pmt, wout, hout, arxout, aryout);
  533. if(m_w == wout && m_h == hout && m_arx == arxout && m_ary == aryout)
  534. {
  535. m_wout = wout;
  536. m_hout = hout;
  537. m_arxout = arxout;
  538. m_aryout = aryout;
  539. }
  540. }
  542. return __super::SetMediaType(dir, pmt);
  543. }
  545. //
  546. // CBaseVideoInputAllocator
  547. //
  549. CBaseVideoInputAllocator::CBaseVideoInputAllocator(HRESULT* phr)
  550. : CMemAllocator(NAME("CBaseVideoInputAllocator"), NULL, phr)
  551. {
  552. if(phr) *phr = S_OK;
  553. }
  555. void CBaseVideoInputAllocator::SetMediaType(const CMediaType& mt)
  556. {
  557. m_mt = mt;
  558. }
  560. STDMETHODIMP CBaseVideoInputAllocator::GetBuffer(IMediaSample** ppBuffer, REFERENCE_TIME* pStartTime, REFERENCE_TIME* pEndTime, DWORD dwFlags)
  561. {
  562. if(!m_bCommitted)
  563.         return VFW_E_NOT_COMMITTED;
  565. HRESULT hr = __super::GetBuffer(ppBuffer, pStartTime, pEndTime, dwFlags);
  567. if(SUCCEEDED(hr) && m_mt.majortype != GUID_NULL)
  568. {
  569. (*ppBuffer)->SetMediaType(&m_mt);
  570. m_mt.majortype = GUID_NULL;
  571. }
  573. return hr;
  574. }
  576. //
  577. // CBaseVideoInputPin
  578. //
  580. CBaseVideoInputPin::CBaseVideoInputPin(TCHAR* pObjectName, CBaseVideoFilter* pFilter, HRESULT* phr, LPCWSTR pName) 
  581. : CTransformInputPin(pObjectName, pFilter, phr, pName)
  582. , m_pAllocator(NULL)
  583. {
  584. }
  586. CBaseVideoInputPin::~CBaseVideoInputPin()
  587. {
  588. delete m_pAllocator;
  589. }
  591. STDMETHODIMP CBaseVideoInputPin::GetAllocator(IMemAllocator** ppAllocator)
  592. {
  593.     CheckPointer(ppAllocator, E_POINTER);
  595.     if(m_pAllocator == NULL)
  596. {
  597. HRESULT hr = S_OK;
  598.         m_pAllocator = new CBaseVideoInputAllocator(&hr);
  599.         m_pAllocator->AddRef();
  600.     }
  602.     (*ppAllocator = m_pAllocator)->AddRef();
  604.     return S_OK;
  605. } 
  607. STDMETHODIMP CBaseVideoInputPin::ReceiveConnection(IPin* pConnector, const AM_MEDIA_TYPE* pmt)
  608. {
  609. CAutoLock cObjectLock(m_pLock);
  611. if(m_Connected)
  612. {
  613. CMediaType mt(*pmt);
  615. if(FAILED(CheckMediaType(&mt)))
  616. return VFW_E_TYPE_NOT_ACCEPTED;
  618. ALLOCATOR_PROPERTIES props, actual;
  620. CComPtr<IMemAllocator> pMemAllocator;
  621. if(FAILED(GetAllocator(&pMemAllocator))
  622. || FAILED(pMemAllocator->Decommit())
  623. || FAILED(pMemAllocator->GetProperties(&props)))
  624. return E_FAIL;
  626. BITMAPINFOHEADER bih;
  627. if(ExtractBIH(pmt, &bih) && bih.biSizeImage)
  628. props.cbBuffer = bih.biSizeImage;
  630. if(FAILED(pMemAllocator->SetProperties(&props, &actual))
  631. || FAILED(pMemAllocator->Commit())
  632. || props.cbBuffer != actual.cbBuffer)
  633. return E_FAIL;
  635. if(m_pAllocator) 
  636. m_pAllocator->SetMediaType(mt);
  638. return SetMediaType(&mt) == S_OK
  639. ? S_OK
  640. : VFW_E_TYPE_NOT_ACCEPTED;
  641. }
  643. return __super::ReceiveConnection(pConnector, pmt);
  644. }
  646. //
  647. // CBaseVideoOutputPin
  648. //
  650. CBaseVideoOutputPin::CBaseVideoOutputPin(TCHAR* pObjectName, CBaseVideoFilter* pFilter, HRESULT* phr, LPCWSTR pName)
  651. : CTransformOutputPin(pObjectName, pFilter, phr, pName)
  652. {
  653. }
  655. HRESULT CBaseVideoOutputPin::CheckMediaType(const CMediaType* mtOut)
  656. {
  657. if(IsConnected())
  658. {
  659. HRESULT hr = ((CBaseVideoFilter*)m_pFilter)->CheckOutputType(*mtOut);
  660. if(FAILED(hr)) return hr;
  661. }
  663. return __super::CheckMediaType(mtOut);
  664. }