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

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

多媒体编程

开发平台：

Visual C++

DX7AllocatorPresenter.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 "mplayerc.h"
  24. #include <atlbase.h>
  25. #include <atlcoll.h>
  26. #include "....DSUtilDSUtil.h"
  28. #include <initguid.h>
  29. #include "DX7AllocatorPresenter.h"
  30. #include <ddraw.h>
  31. #include <d3d.h>
  32. #include "....SubPicDX7SubPic.h"
  33. #include "......includeRealMediapntypes.h"
  34. #include "......includeRealMediapnwintyp.h"
  35. #include "......includeRealMediapncom.h"
  36. #include "......includeRealMediarmavsurf.h"
  37. #include "IQTVideoSurface.h"
  39. #include "IPinHook.h"
  41. bool IsVMR7InGraph(IFilterGraph* pFG)
  42. {
  43. BeginEnumFilters(pFG, pEF, pBF)
  44. if(CComQIPtr<IVMRWindowlessControl>(pBF)) return(true);
  45. EndEnumFilters
  46. return(false);
  47. }
  49. namespace DSObjects
  50. {
  52. class CDX7AllocatorPresenter
  53. : public ISubPicAllocatorPresenterImpl
  54. {
  55. protected:
  56. CSize m_ScreenSize;
  58. CComPtr<IDirectDraw7> m_pDD;
  59. CComQIPtr<IDirect3D7, &IID_IDirect3D7> m_pD3D;
  60.     CComPtr<IDirect3DDevice7> m_pD3DDev;
  62. CComPtr<IDirectDrawSurface7> m_pPrimary, m_pBackBuffer;
  63. CComPtr<IDirectDrawSurface7> m_pVideoTexture, m_pVideoSurface;
  65.     virtual HRESULT CreateDevice();
  66. virtual HRESULT AllocSurfaces();
  67. virtual void DeleteSurfaces();
  69. public:
  70. CDX7AllocatorPresenter(HWND hWnd, HRESULT& hr);
  72. // ISubPicAllocatorPresenter
  73. STDMETHODIMP CreateRenderer(IUnknown** ppRenderer);
  74. STDMETHODIMP_(bool) Paint(bool fAll);
  75. STDMETHODIMP GetDIB(BYTE* lpDib, DWORD* size);
  76. };
  78. class CVMR7AllocatorPresenter
  79. : public CDX7AllocatorPresenter
  80. , public IVMRSurfaceAllocator
  81. , public IVMRImagePresenter
  82. , public IVMRWindowlessControl
  83. {
  84. CComPtr<IVMRSurfaceAllocatorNotify> m_pIVMRSurfAllocNotify;
  85. CComPtr<IVMRSurfaceAllocator> m_pSA;
  87. HRESULT CreateDevice();
  88. void DeleteSurfaces();
  90. bool m_fUseInternalTimer;
  92. public:
  93. CVMR7AllocatorPresenter(HWND hWnd, HRESULT& hr);
  95. DECLARE_IUNKNOWN
  96.     STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, void** ppv);
  98. // ISubPicAllocatorPresenter
  99. STDMETHODIMP CreateRenderer(IUnknown** ppRenderer);
  100. STDMETHODIMP_(void) SetTime(REFERENCE_TIME rtNow);
  102. // IVMRSurfaceAllocator
  103.     STDMETHODIMP AllocateSurface(DWORD_PTR dwUserID, VMRALLOCATIONINFO* lpAllocInfo, DWORD* lpdwBuffer, LPDIRECTDRAWSURFACE7* lplpSurface);
  104.     STDMETHODIMP FreeSurface(DWORD_PTR dwUserID);
  105.     STDMETHODIMP PrepareSurface(DWORD_PTR dwUserID, IDirectDrawSurface7* lpSurface, DWORD dwSurfaceFlags);
  106.     STDMETHODIMP AdviseNotify(IVMRSurfaceAllocatorNotify* lpIVMRSurfAllocNotify);
  108. // IVMRImagePresenter
  109.     STDMETHODIMP StartPresenting(DWORD_PTR dwUserID);
  110.     STDMETHODIMP StopPresenting(DWORD_PTR dwUserID);
  111.     STDMETHODIMP PresentImage(DWORD_PTR dwUserID, VMRPRESENTATIONINFO* lpPresInfo);
  113. // IVMRWindowlessControl
  114. STDMETHODIMP GetNativeVideoSize(LONG* lpWidth, LONG* lpHeight, LONG* lpARWidth, LONG* lpARHeight);
  115. STDMETHODIMP GetMinIdealVideoSize(LONG* lpWidth, LONG* lpHeight);
  116. STDMETHODIMP GetMaxIdealVideoSize(LONG* lpWidth, LONG* lpHeight);
  117. STDMETHODIMP SetVideoPosition(const LPRECT lpSRCRect, const LPRECT lpDSTRect);
  118.     STDMETHODIMP GetVideoPosition(LPRECT lpSRCRect, LPRECT lpDSTRect);
  119. STDMETHODIMP GetAspectRatioMode(DWORD* lpAspectRatioMode);
  120. STDMETHODIMP SetAspectRatioMode(DWORD AspectRatioMode);
  121. STDMETHODIMP SetVideoClippingWindow(HWND hwnd);
  122. STDMETHODIMP RepaintVideo(HWND hwnd, HDC hdc);
  123. STDMETHODIMP DisplayModeChanged();
  124. STDMETHODIMP GetCurrentImage(BYTE** lpDib);
  125. STDMETHODIMP SetBorderColor(COLORREF Clr);
  126. STDMETHODIMP GetBorderColor(COLORREF* lpClr);
  127. STDMETHODIMP SetColorKey(COLORREF Clr);
  128. STDMETHODIMP GetColorKey(COLORREF* lpClr);
  129. };
  131. class CRM7AllocatorPresenter
  132. : public CDX7AllocatorPresenter
  133. , public IRMAVideoSurface
  134. {
  135. CComPtr<IDirectDrawSurface7> m_pVideoSurfaceOff;
  136. CComPtr<IDirectDrawSurface7> m_pVideoSurfaceYUY2;
  138.     RMABitmapInfoHeader m_bitmapInfo;
  139.     RMABitmapInfoHeader m_lastBitmapInfo;
  141. protected:
  142. HRESULT AllocSurfaces();
  143. void DeleteSurfaces();
  145. public:
  146. CRM7AllocatorPresenter(HWND hWnd, HRESULT& hr);
  148. DECLARE_IUNKNOWN
  149.     STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, void** ppv);
  151. // IRMAVideoSurface
  152.     STDMETHODIMP Blt(UCHAR* pImageData, RMABitmapInfoHeader* pBitmapInfo, REF(PNxRect) inDestRect, REF(PNxRect) inSrcRect);
  153. STDMETHODIMP BeginOptimizedBlt(RMABitmapInfoHeader* pBitmapInfo);
  154. STDMETHODIMP OptimizedBlt(UCHAR* pImageBits, REF(PNxRect) rDestRect, REF(PNxRect) rSrcRect);
  155. STDMETHODIMP EndOptimizedBlt();
  156. STDMETHODIMP GetOptimizedFormat(REF(RMA_COMPRESSION_TYPE) ulType);
  157.     STDMETHODIMP GetPreferredFormat(REF(RMA_COMPRESSION_TYPE) ulType);
  158. };
  160. class CQT7AllocatorPresenter
  161. : public CDX7AllocatorPresenter
  162. , public IQTVideoSurface
  163. {
  164. CComPtr<IDirectDrawSurface7> m_pVideoSurfaceOff;
  166. protected:
  167. HRESULT AllocSurfaces();
  168. void DeleteSurfaces();
  170. public:
  171. CQT7AllocatorPresenter(HWND hWnd, HRESULT& hr);
  173. DECLARE_IUNKNOWN
  174.     STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, void** ppv);
  176. // IQTVideoSurface
  177. STDMETHODIMP BeginBlt(const BITMAP& bm);
  178. STDMETHODIMP DoBlt(const BITMAP& bm);
  179. };
  181. }
  182. using namespace DSObjects;
  184. //
  186. HRESULT CreateAP7(const CLSID& clsid, HWND hWnd, ISubPicAllocatorPresenter** ppAP)
  187. {
  188. CheckPointer(ppAP, E_POINTER);
  190. *ppAP = NULL;
  192. HRESULT hr;
  193. if(clsid == CLSID_VMR7AllocatorPresenter && !(*ppAP = new CVMR7AllocatorPresenter(hWnd, hr))
  194. || clsid == CLSID_RM7AllocatorPresenter && !(*ppAP = new CRM7AllocatorPresenter(hWnd, hr))
  195. || clsid == CLSID_QT7AllocatorPresenter && !(*ppAP = new CQT7AllocatorPresenter(hWnd, hr)))
  196. return E_OUTOFMEMORY;
  198. if(*ppAP == NULL)
  199. return E_FAIL;
  201. (*ppAP)->AddRef();
  203. if(FAILED(hr))
  204. {
  205. (*ppAP)->Release();
  206. *ppAP = NULL;
  207. }
  209. return hr;
  210. }
  212. //
  214. static HRESULT TextureBlt(CComPtr<IDirect3DDevice7> pD3DDev, CComPtr<IDirectDrawSurface7> pTexture, Vector dst[4], CRect src)
  215. {
  216. if(!pTexture)
  217. return E_POINTER;
  219. HRESULT hr;
  221.     do
  222. {
  223. DDSURFACEDESC2 ddsd;
  224. INITDDSTRUCT(ddsd);
  225. if(FAILED(hr = pTexture->GetSurfaceDesc(&ddsd)))
  226. break;
  228.         float w = (float)ddsd.dwWidth;
  229.         float h = (float)ddsd.dwHeight;
  231. struct
  232. {
  233. float x, y, z, rhw;
  234. float tu, tv;
  235. }
  236. pVertices[] =
  237. {
  238. {(float)dst[0].x, (float)dst[0].y, (float)dst[0].z, 1.0f/(float)dst[0].z, (float)src.left / w, (float)src.top / h},
  239. {(float)dst[1].x, (float)dst[1].y, (float)dst[1].z, 1.0f/(float)dst[1].z, (float)src.right / w, (float)src.top / h},
  240. {(float)dst[2].x, (float)dst[2].y, (float)dst[2].z, 1.0f/(float)dst[2].z, (float)src.left / w, (float)src.bottom / h},
  241. {(float)dst[3].x, (float)dst[3].y, (float)dst[3].z, 1.0f/(float)dst[3].z, (float)src.right / w, (float)src.bottom / h},
  242. };
  244. for(int i = 0; i < countof(pVertices); i++)
  245. {
  246. pVertices[i].x -= 0.5;
  247. pVertices[i].y -= 0.5;
  248. }
  250.         hr = pD3DDev->SetTexture(0, pTexture);
  252.         pD3DDev->SetRenderState(D3DRENDERSTATE_CULLMODE, D3DCULL_NONE);
  253.         pD3DDev->SetRenderState(D3DRENDERSTATE_LIGHTING, FALSE);
  254.         pD3DDev->SetRenderState(D3DRENDERSTATE_BLENDENABLE, FALSE);
  255. pD3DDev->SetRenderState(D3DRENDERSTATE_ALPHATESTENABLE, FALSE); 
  257.         pD3DDev->SetTextureStageState(0, D3DTSS_MAGFILTER, D3DTFG_LINEAR);
  258.         pD3DDev->SetTextureStageState(0, D3DTSS_MINFILTER, D3DTFN_LINEAR);
  259.         pD3DDev->SetTextureStageState(0, D3DTSS_MIPFILTER, D3DTFP_LINEAR);
  261.         pD3DDev->SetTextureStageState(0, D3DTSS_ADDRESS, D3DTADDRESS_CLAMP);
  263. //
  265.         if(FAILED(hr = pD3DDev->BeginScene()))
  266. break;
  268. hr = pD3DDev->DrawPrimitive(D3DPT_TRIANGLESTRIP,
  269. D3DFVF_XYZRHW | D3DFVF_TEX1,
  270. pVertices, 4, D3DDP_WAIT);
  271. pD3DDev->EndScene();
  273.         //
  275. pD3DDev->SetTexture(0, NULL);
  277. return S_OK;
  278.     }
  279. while(0);
  281.     return E_FAIL;
  282. }
  284. //
  285. // CDX7AllocatorPresenter
  286. //
  288. CDX7AllocatorPresenter::CDX7AllocatorPresenter(HWND hWnd, HRESULT& hr) 
  289. : ISubPicAllocatorPresenterImpl(hWnd)
  290. , m_ScreenSize(0, 0)
  291. {
  292.     if(!IsWindow(m_hWnd))
  293.     {
  294.         hr = E_INVALIDARG;
  295.         return;
  296.     }
  298. if(FAILED(hr = DirectDrawCreateEx(NULL, (VOID**)&m_pDD, IID_IDirectDraw7, NULL))
  299. || FAILED(hr = m_pDD->SetCooperativeLevel(AfxGetMainWnd()->GetSafeHwnd(), DDSCL_NORMAL)))
  300. return;
  302. if(!(m_pD3D = m_pDD))
  303. {
  304. hr = E_NOINTERFACE;
  305. return;
  306. }
  308. GetWindowRect(m_hWnd, &m_WindowRect);
  310. hr = CreateDevice();
  311. }
  313. HRESULT CDX7AllocatorPresenter::CreateDevice()
  314. {
  315.     m_pD3DDev = NULL;
  317. m_pPrimary = NULL;
  318. m_pBackBuffer = NULL;
  320.     DDSURFACEDESC2 ddsd;
  321. INITDDSTRUCT(ddsd);
  322.     if(FAILED(m_pDD->GetDisplayMode(&ddsd))
  323. || ddsd.ddpfPixelFormat.dwRGBBitCount <= 8)
  324. return DDERR_INVALIDMODE;
  326. m_ScreenSize.SetSize(ddsd.dwWidth, ddsd.dwHeight);
  328. HRESULT hr;
  330. // m_pPrimary
  332. INITDDSTRUCT(ddsd);
  333.     ddsd.dwFlags = DDSD_CAPS;
  334.     ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
  335.     if(FAILED(hr = m_pDD->CreateSurface(&ddsd, &m_pPrimary, NULL)))
  336.         return hr;
  338. CComPtr<IDirectDrawClipper> pcClipper;
  339.     if(FAILED(hr = m_pDD->CreateClipper(0, &pcClipper, NULL)))
  340.         return hr;
  341. pcClipper->SetHWnd(0, m_hWnd);
  342. m_pPrimary->SetClipper(pcClipper);
  344. // m_pBackBuffer
  346. INITDDSTRUCT(ddsd);
  347.     ddsd.dwFlags        = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
  348.     ddsd.ddsCaps.dwCaps = /*DDSCAPS_OFFSCREENPLAIN |*/ DDSCAPS_VIDEOMEMORY | DDSCAPS_3DDEVICE;
  349. ddsd.dwWidth = m_ScreenSize.cx;
  350. ddsd.dwHeight = m_ScreenSize.cy;
  351. if(FAILED(hr = m_pDD->CreateSurface(&ddsd, &m_pBackBuffer, NULL)))
  352.         return hr;
  354. pcClipper = NULL;
  355.     if(FAILED(hr = m_pDD->CreateClipper(0, &pcClipper, NULL)))
  356. return hr;
  357.     BYTE rgnDataBuffer[1024];
  358. HRGN hrgn = CreateRectRgn(0, 0, ddsd.dwWidth, ddsd.dwHeight);
  359. GetRegionData(hrgn, sizeof(rgnDataBuffer), (RGNDATA*)rgnDataBuffer);
  360. DeleteObject(hrgn);
  361. pcClipper->SetClipList((RGNDATA*)rgnDataBuffer, 0);
  362. m_pBackBuffer->SetClipper(pcClipper);
  364. // m_pD3DDev
  366. if(FAILED(hr = m_pD3D->CreateDevice(IID_IDirect3DHALDevice, m_pBackBuffer, &m_pD3DDev))) // this seems to fail if the desktop size is too large (width or height >2048)
  367. return hr;
  369. //
  371. CComPtr<ISubPicProvider> pSubPicProvider;
  372. if(m_pSubPicQueue) m_pSubPicQueue->GetSubPicProvider(&pSubPicProvider);
  374. CSize size;
  375. switch(AfxGetAppSettings().nSPCMaxRes)
  376. {
  377. case 0: default: size = m_ScreenSize; break;
  378. case 1: size.SetSize(1024, 768); break;
  379. case 2: size.SetSize(800, 600); break;
  380. case 3: size.SetSize(640, 480); break;
  381. case 4: size.SetSize(512, 384); break;
  382. case 5: size.SetSize(384, 288); break;
  383. }
  385. if(m_pAllocator)
  386. {
  387. m_pAllocator->ChangeDevice(m_pD3DDev);
  388. }
  389. else
  390. {
  391. m_pAllocator = new CDX7SubPicAllocator(m_pD3DDev, size, AfxGetAppSettings().fSPCPow2Tex);
  392. if(!m_pAllocator || FAILED(hr))
  393. return E_FAIL;
  394. }
  396. hr = S_OK;
  397. m_pSubPicQueue = AfxGetAppSettings().nSPCSize > 0 
  398. ? (ISubPicQueue*)new CSubPicQueue(AfxGetAppSettings().nSPCSize, m_pAllocator, &hr)
  399. : (ISubPicQueue*)new CSubPicQueueNoThread(m_pAllocator, &hr);
  400. if(!m_pSubPicQueue || FAILED(hr))
  401. return E_FAIL;
  403. if(pSubPicProvider) m_pSubPicQueue->SetSubPicProvider(pSubPicProvider);
  405. return S_OK;
  406. }
  408. HRESULT CDX7AllocatorPresenter::AllocSurfaces()
  409. {
  410.     CAutoLock cAutoLock(this);
  412. AppSettings& s = AfxGetAppSettings();
  414. m_pVideoTexture = NULL;
  415. m_pVideoSurface = NULL;
  417. DDSURFACEDESC2 ddsd;
  418. INITDDSTRUCT(ddsd);
  419. ddsd.dwFlags = DDSD_CAPS|DDSD_WIDTH|DDSD_HEIGHT|DDSD_PIXELFORMAT;
  420. ddsd.ddsCaps.dwCaps = DDSCAPS_VIDEOMEMORY;
  421. ddsd.dwWidth = m_NativeVideoSize.cx;
  422. ddsd.dwHeight = m_NativeVideoSize.cy;
  423. ddsd.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
  424. ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB;
  425. ddsd.ddpfPixelFormat.dwRGBBitCount = 32;
  426. ddsd.ddpfPixelFormat.dwRBitMask = 0x00FF0000;
  427. ddsd.ddpfPixelFormat.dwGBitMask = 0x0000FF00;
  428. ddsd.ddpfPixelFormat.dwBBitMask = 0x000000FF;
  430. if(s.iAPSurfaceUsage == VIDRNDT_AP_TEXTURE2D || s.iAPSurfaceUsage == VIDRNDT_AP_TEXTURE3D)
  431. {
  432. ddsd.ddsCaps.dwCaps |= DDSCAPS_TEXTURE;
  433. // ddsd.ddpfPixelFormat.dwFlags |= DDPF_ALPHAPIXELS;
  434. // ddsd.ddpfPixelFormat.dwRGBAlphaBitMask = 0xFF000000;
  435. }
  437. HRESULT hr = m_pDD->CreateSurface(&ddsd, &m_pVideoSurface, NULL);
  438. if(FAILED(hr))
  439. {
  440. // FIXME: eh, dx9 has no problem creating a 32bpp surface under a 16bpp desktop, but dx7 fails here (textures are ok)
  441. DDSURFACEDESC2 ddsd2;
  442. INITDDSTRUCT(ddsd2);
  443. if(!(s.iAPSurfaceUsage == VIDRNDT_AP_TEXTURE2D || s.iAPSurfaceUsage == VIDRNDT_AP_TEXTURE3D)
  444. && SUCCEEDED(m_pDD->GetDisplayMode(&ddsd2))
  445. && ddsd2.ddpfPixelFormat.dwRGBBitCount == 16)
  446. {
  447. ddsd.ddpfPixelFormat.dwRGBBitCount = 16;
  448. ddsd.ddpfPixelFormat.dwRBitMask = 0x0000F800;
  449. ddsd.ddpfPixelFormat.dwGBitMask = 0x000007E0;
  450. ddsd.ddpfPixelFormat.dwBBitMask = 0x0000001F;
  451. hr = m_pDD->CreateSurface(&ddsd, &m_pVideoSurface, NULL);
  452. }
  454. if(FAILED(hr))
  455. return hr;
  456. }
  458. if(s.iAPSurfaceUsage == VIDRNDT_AP_TEXTURE3D)
  459. m_pVideoTexture = m_pVideoSurface;
  461. DDBLTFX fx;
  462. INITDDSTRUCT(fx);
  463. fx.dwFillColor = 0;
  464. hr = m_pVideoSurface->Blt(NULL, NULL, NULL, DDBLT_WAIT|DDBLT_COLORFILL, &fx);
  466. return S_OK;
  467. }
  469. void CDX7AllocatorPresenter::DeleteSurfaces()
  470. {
  471.     CAutoLock cAutoLock(this);
  473. m_pVideoTexture = NULL;
  474. m_pVideoSurface = NULL;
  475. }
  477. // ISubPicAllocatorPresenter
  479. STDMETHODIMP CDX7AllocatorPresenter::CreateRenderer(IUnknown** ppRenderer)
  480. {
  481. return E_NOTIMPL;
  482. }
  484. STDMETHODIMP_(bool) CDX7AllocatorPresenter::Paint(bool fAll)
  485. {
  486. CAutoLock cAutoLock(this);
  488. if(m_WindowRect.right <= m_WindowRect.left || m_WindowRect.bottom <= m_WindowRect.top
  489. || m_NativeVideoSize.cx <= 0 || m_NativeVideoSize.cy <= 0
  490. || !m_pPrimary || !m_pBackBuffer || !m_pVideoSurface)
  491. return(false);
  493. HRESULT hr;
  495. CRect rSrcVid(CPoint(0, 0), m_NativeVideoSize);
  496. CRect rDstVid(m_VideoRect);
  498. CRect rSrcPri(CPoint(0, 0), m_WindowRect.Size());
  499. CRect rDstPri(m_WindowRect);
  500. MapWindowRect(m_hWnd, HWND_DESKTOP, &rDstPri);
  502. if(fAll)
  503. {
  504. // clear the backbuffer
  506. CRect rl(0, 0, rDstVid.left, rSrcPri.bottom);
  507. CRect rr(rDstVid.right, 0, rSrcPri.right, rSrcPri.bottom);
  508. CRect rt(0, 0, rSrcPri.right, rDstVid.top);
  509. CRect rb(0, rDstVid.bottom, rSrcPri.right, rSrcPri.bottom);
  511. DDBLTFX fx;
  512. INITDDSTRUCT(fx);
  513. fx.dwFillColor = 0;
  514. hr = m_pBackBuffer->Blt(NULL, NULL, NULL, DDBLT_WAIT|DDBLT_COLORFILL, &fx);
  516. // paint the video on the backbuffer
  518. if(!rDstVid.IsRectEmpty())
  519. {
  520. if(m_pVideoTexture)
  521. {
  522. Vector v[4];
  523. Transform(rDstVid, v);
  524. hr = TextureBlt(m_pD3DDev, m_pVideoTexture, v, rSrcVid);
  525. }
  526. else
  527. {
  528. hr = m_pBackBuffer->Blt(rDstVid, m_pVideoSurface, rSrcVid, DDBLT_WAIT, NULL);
  529. }
  530. }
  532. // paint the text on the backbuffer
  534. AlphaBltSubPic(rSrcPri.Size());
  535. }
  537. // wait vsync
  539. m_pDD->WaitForVerticalBlank(DDWAITVB_BLOCKBEGIN, NULL);
  541. // blt to the primary surface
  543. hr = m_pPrimary->Blt(rDstPri, m_pBackBuffer, rSrcPri, DDBLT_WAIT, NULL);
  545. if(hr == DDERR_SURFACELOST)
  546. {
  547. HRESULT hr = DDERR_WRONGMODE; // m_pDD->TestCooperativeLevel();
  549. if(hr == DDERR_WRONGMODE) 
  550. {
  551. DeleteSurfaces();
  552. if(SUCCEEDED(CreateDevice()) || FAILED(hr = AllocSurfaces()))
  553. return(true);
  554. }
  556. hr = S_OK;
  557. }
  559. return(true);
  560. }
  562. STDMETHODIMP CDX7AllocatorPresenter::GetDIB(BYTE* lpDib, DWORD* size)
  563. {
  564. CheckPointer(size, E_POINTER);
  566. HRESULT hr;
  568. DDSURFACEDESC2 ddsd;
  569. INITDDSTRUCT(ddsd);
  570. if(FAILED(m_pVideoSurface->GetSurfaceDesc(&ddsd)))
  571. return E_FAIL;
  573. if(ddsd.ddpfPixelFormat.dwRGBBitCount != 16 && ddsd.ddpfPixelFormat.dwRGBBitCount != 32)
  574. return E_FAIL;
  576. DWORD required = sizeof(BITMAPINFOHEADER) + (ddsd.dwWidth*ddsd.dwHeight*32>>3);
  577. if(!lpDib) {*size = required; return S_OK;}
  578. if(*size < required) return E_OUTOFMEMORY;
  579. *size = required;
  581. INITDDSTRUCT(ddsd);
  582. if(FAILED(hr = m_pVideoSurface->Lock(NULL, &ddsd, DDLOCK_WAIT|DDLOCK_SURFACEMEMORYPTR|DDLOCK_READONLY|DDLOCK_NOSYSLOCK, NULL)))
  583. {
  584. // TODO
  585. return hr;
  586. }
  588. BITMAPINFOHEADER* bih = (BITMAPINFOHEADER*)lpDib;
  589. memset(bih, 0, sizeof(BITMAPINFOHEADER));
  590. bih->biSize = sizeof(BITMAPINFOHEADER);
  591. bih->biWidth = ddsd.dwWidth;
  592. bih->biHeight = ddsd.dwHeight;
  593. bih->biBitCount = 32;
  594. bih->biPlanes = 1;
  595. bih->biSizeImage = bih->biWidth*bih->biHeight*bih->biBitCount>>3;
  597. BitBltFromRGBToRGB(
  598. bih->biWidth, bih->biHeight, 
  599. (BYTE*)(bih + 1), bih->biWidth*bih->biBitCount>>3, bih->biBitCount,
  600. (BYTE*)ddsd.lpSurface + ddsd.lPitch*(ddsd.dwHeight-1), -(int)ddsd.lPitch, ddsd.ddpfPixelFormat.dwRGBBitCount);
  602. m_pVideoSurface->Unlock(NULL);
  604. /*
  605. BitBltFromRGBToRGB(
  606. w, h, 
  607. (BYTE*)ddsd.lpSurface, ddsd.lPitch, ddsd.ddpfPixelFormat.dwRGBBitCount,
  608. (BYTE*)bm.bmBits, bm.bmWidthBytes, bm.bmBitsPixel);
  609. m_pVideoSurfaceOff->Unlock(NULL);
  610. fOk = true;
  611. }
  612. */
  614. return S_OK;
  615. }
  617. //
  618. // CVMR7AllocatorPresenter
  619. //
  621. #define MY_USER_ID 0x6ABE51
  623. CVMR7AllocatorPresenter::CVMR7AllocatorPresenter(HWND hWnd, HRESULT& hr) 
  624. : CDX7AllocatorPresenter(hWnd, hr)
  625. , m_fUseInternalTimer(true)
  626. {
  627.     if(FAILED(hr))
  628. return;
  630. if(FAILED(hr = m_pSA.CoCreateInstance(CLSID_AllocPresenter)))
  631. {
  632. hr = E_FAIL;
  633. return;
  634. }
  635. }
  637. STDMETHODIMP CVMR7AllocatorPresenter::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  638. {
  639.     CheckPointer(ppv, E_POINTER);
  641. return 
  642. QI(IVMRSurfaceAllocator)
  643. QI(IVMRImagePresenter)
  644. QI(IVMRWindowlessControl)
  645. __super::NonDelegatingQueryInterface(riid, ppv);
  646. }
  648. HRESULT CVMR7AllocatorPresenter::CreateDevice()
  649. {
  650. HRESULT hr = __super::CreateDevice();
  651. if(FAILED(hr)) return hr;
  653. if(m_pIVMRSurfAllocNotify)
  654. {
  655. HMONITOR hMonitor = MonitorFromWindow(m_hWnd, MONITOR_DEFAULTTONEAREST);
  656. if(FAILED(hr = m_pIVMRSurfAllocNotify->ChangeDDrawDevice(m_pDD, hMonitor)))
  657. return(false);
  658. }
  660. return hr;
  661. }
  663. void CVMR7AllocatorPresenter::DeleteSurfaces()
  664. {
  665.     CAutoLock cAutoLock(this);
  667. m_pSA->FreeSurface(MY_USER_ID);
  669. __super::DeleteSurfaces();
  670. }
  672. // ISubPicAllocatorPresenter
  674. STDMETHODIMP CVMR7AllocatorPresenter::CreateRenderer(IUnknown** ppRenderer)
  675. {
  676.     CheckPointer(ppRenderer, E_POINTER);
  678. *ppRenderer = NULL;
  680. HRESULT hr;
  682. do
  683. {
  684. CComPtr<IBaseFilter> pBF;
  686. if(FAILED(hr = pBF.CoCreateInstance(CLSID_VideoMixingRenderer)))
  687. break;
  689. CComQIPtr<IVMRFilterConfig> pConfig = pBF;
  690. if(!pConfig)
  691. break;
  693. if(FAILED(hr = pConfig->SetRenderingMode(VMRMode_Renderless)))
  694. break;
  696. CComQIPtr<IVMRSurfaceAllocatorNotify> pSAN = pBF;
  697. if(!pSAN)
  698. break;
  700. if(FAILED(hr = pSAN->AdviseSurfaceAllocator(MY_USER_ID, static_cast<IVMRSurfaceAllocator*>(this)))
  701. || FAILED(hr = AdviseNotify(pSAN)))
  702. break;
  704. CComPtr<IPin> pPin = GetFirstPin(pBF);
  705. HookNewSegment((IPinC*)(IPin*)pPin);
  707. *ppRenderer = (IUnknown*)pBF.Detach();
  709. return S_OK;
  710. }
  711. while(0);
  713.     return E_FAIL;
  714. }
  716. STDMETHODIMP_(void) CVMR7AllocatorPresenter::SetTime(REFERENCE_TIME rtNow)
  717. {
  718. m_fUseInternalTimer = false;
  719. __super::SetTime(rtNow);
  720. }
  722. // IVMRSurfaceAllocator
  724. STDMETHODIMP CVMR7AllocatorPresenter::AllocateSurface(DWORD_PTR dwUserID, VMRALLOCATIONINFO* lpAllocInfo, DWORD* lpdwBuffer, LPDIRECTDRAWSURFACE7* lplpSurface)
  725. {
  726. if(!lpAllocInfo || !lpdwBuffer || !lplpSurface)
  727. return E_POINTER;
  729. if(!m_pIVMRSurfAllocNotify)
  730. return E_FAIL;
  732. HRESULT hr;
  734.     DeleteSurfaces();
  736. // HACK: yv12 will fail to blt onto the backbuffer anyway, but if we first
  737. // allocate it and then let our FreeSurface callback call m_pSA->FreeSurface,
  738. // then that might stall for about 30 seconds because of some unknown buggy code 
  739. // behind <ddraw surface>->Release()
  741. if(lpAllocInfo->lpHdr->biBitCount < 16)
  742. return E_FAIL;
  744. hr = m_pSA->AllocateSurface(dwUserID, lpAllocInfo, lpdwBuffer, lplpSurface);
  745. if(FAILED(hr))
  746. return hr;
  748. m_NativeVideoSize = CSize(abs(lpAllocInfo->lpHdr->biWidth), abs(lpAllocInfo->lpHdr->biHeight));
  749. m_AspectRatio = m_NativeVideoSize;
  750. int arx = lpAllocInfo->szAspectRatio.cx, ary = lpAllocInfo->szAspectRatio.cy;
  751. if(arx > 0 && ary > 0) m_AspectRatio.SetSize(arx, ary);
  753. if(FAILED(hr = AllocSurfaces()))
  754. return hr;
  756. // test if the colorspace is acceptable
  757. if(FAILED(hr = m_pVideoSurface->Blt(NULL, *lplpSurface, NULL, DDBLT_WAIT, NULL)))
  758. {
  759. DeleteSurfaces();
  760. return hr;
  761. }
  763. DDBLTFX fx;
  764. INITDDSTRUCT(fx);
  765. fx.dwFillColor = 0;
  766. m_pVideoSurface->Blt(NULL, NULL, NULL, DDBLT_WAIT|DDBLT_COLORFILL, &fx);
  768. return hr;
  769. }
  771. STDMETHODIMP CVMR7AllocatorPresenter::FreeSurface(DWORD_PTR dwUserID)
  772. {
  773.     DeleteSurfaces();
  774. return S_OK;
  775. }
  777. STDMETHODIMP CVMR7AllocatorPresenter::PrepareSurface(DWORD_PTR dwUserID, IDirectDrawSurface7* lpSurface, DWORD dwSurfaceFlags)
  778. {
  779.     if(!lpSurface)
  780. return E_POINTER;
  782. // FIXME: sometimes the msmpeg4/divx3/wmv decoder wants to reuse our 
  783. // surface (expects it to point to the same mem every time), and to avoid 
  784. // problems we can't cal m_pSA->PrepareSurface (flips? clears?).
  785. return S_OK; 
  786. /*
  787. return m_pSA->PrepareSurface(dwUserID, lpSurface, dwSurfaceFlags);
  788. */
  789. }
  791. STDMETHODIMP CVMR7AllocatorPresenter::AdviseNotify(IVMRSurfaceAllocatorNotify* lpIVMRSurfAllocNotify)
  792. {
  793.     CAutoLock cAutoLock(this);
  795. m_pIVMRSurfAllocNotify = lpIVMRSurfAllocNotify;
  797. HRESULT hr;
  798. HMONITOR hMonitor = MonitorFromWindow(m_hWnd, MONITOR_DEFAULTTONEAREST);
  799. if(FAILED(hr = m_pIVMRSurfAllocNotify->SetDDrawDevice(m_pDD, hMonitor)))
  800. return hr;
  802. return m_pSA->AdviseNotify(lpIVMRSurfAllocNotify);
  803. }
  805. // IVMRImagePresenter
  807. STDMETHODIMP CVMR7AllocatorPresenter::StartPresenting(DWORD_PTR dwUserID)
  808. {
  809.     CAutoLock cAutoLock(this);
  811.     ASSERT(m_pD3DDev);
  813. return m_pD3DDev ? S_OK : E_FAIL;
  814. }
  816. STDMETHODIMP CVMR7AllocatorPresenter::StopPresenting(DWORD_PTR dwUserID)
  817. {
  818. return S_OK;
  819. }
  821. STDMETHODIMP CVMR7AllocatorPresenter::PresentImage(DWORD_PTR dwUserID, VMRPRESENTATIONINFO* lpPresInfo)
  822. {
  823.     HRESULT hr;
  825. {
  826. if(!lpPresInfo || !lpPresInfo->lpSurf)
  827. return E_POINTER;
  829. CAutoLock cAutoLock(this);
  831. hr = m_pVideoSurface->Blt(NULL, lpPresInfo->lpSurf, NULL, DDBLT_WAIT, NULL);
  833. if(lpPresInfo->rtEnd > lpPresInfo->rtStart)
  834. {
  835. REFERENCE_TIME rtTimePerFrame = lpPresInfo->rtEnd - lpPresInfo->rtStart;
  836. m_fps = 10000000.0 / rtTimePerFrame;
  837. if(m_pSubPicQueue) 
  838. {
  839. m_pSubPicQueue->SetFPS(m_fps);
  840. if(m_fUseInternalTimer) __super::SetTime(g_tSegmentStart + lpPresInfo->rtStart);
  841. }
  842. }
  844. CSize VideoSize = m_NativeVideoSize;
  845. int arx = lpPresInfo->szAspectRatio.cx, ary = lpPresInfo->szAspectRatio.cy;
  846. if(arx > 0 && ary > 0) VideoSize.cx = VideoSize.cy*arx/ary;
  847. if(VideoSize != GetVideoSize())
  848. {
  849. m_AspectRatio.SetSize(arx, ary);
  850. AfxGetApp()->m_pMainWnd->PostMessage(WM_REARRANGERENDERLESS);
  851. }
  853. Paint(true);
  855. hr = S_OK;
  856. }
  858. return S_OK;
  859. }
  861. // IVMRWindowlessControl
  862. //
  863. // It is only implemented (partially) for the dvd navigator's 
  864. // menu handling, which needs to know a few things about the 
  865. // location of our window.
  867. STDMETHODIMP CVMR7AllocatorPresenter::GetNativeVideoSize(LONG* lpWidth, LONG* lpHeight, LONG* lpARWidth, LONG* lpARHeight)
  868. {
  869. CSize vs = m_NativeVideoSize, ar = m_AspectRatio;
  870. // DVD Nav. bug workaround fix
  871. vs.cx = vs.cy * ar.cx / ar.cy;
  872. if(lpWidth) *lpWidth = vs.cx;
  873. if(lpHeight) *lpHeight = vs.cy;
  874. if(lpARWidth) *lpARWidth = ar.cx;
  875. if(lpARHeight) *lpARHeight = ar.cy;
  876. return S_OK;
  877. }
  879. STDMETHODIMP CVMR7AllocatorPresenter::GetMinIdealVideoSize(LONG* lpWidth, LONG* lpHeight) {return E_NOTIMPL;}
  880. STDMETHODIMP CVMR7AllocatorPresenter::GetMaxIdealVideoSize(LONG* lpWidth, LONG* lpHeight) {return E_NOTIMPL;}
  881. STDMETHODIMP CVMR7AllocatorPresenter::SetVideoPosition(const LPRECT lpSRCRect, const LPRECT lpDSTRect) {return E_NOTIMPL;} // we have our own method for this
  883. STDMETHODIMP CVMR7AllocatorPresenter::GetVideoPosition(LPRECT lpSRCRect, LPRECT lpDSTRect)
  884. {
  885. CopyRect(lpSRCRect, CRect(CPoint(0, 0), m_NativeVideoSize));
  886. CopyRect(lpDSTRect, &m_VideoRect);
  887. // DVD Nav. bug workaround fix
  888. GetNativeVideoSize(&lpSRCRect->right, &lpSRCRect->bottom, NULL, NULL);
  889. return S_OK;
  890. }
  892. STDMETHODIMP CVMR7AllocatorPresenter::GetAspectRatioMode(DWORD* lpAspectRatioMode)
  893. {
  894. if(lpAspectRatioMode) *lpAspectRatioMode = AM_ARMODE_STRETCHED;
  895. return S_OK;
  896. }
  898. STDMETHODIMP CVMR7AllocatorPresenter::SetAspectRatioMode(DWORD AspectRatioMode) {return E_NOTIMPL;}
  899. STDMETHODIMP CVMR7AllocatorPresenter::SetVideoClippingWindow(HWND hwnd) {return E_NOTIMPL;}
  900. STDMETHODIMP CVMR7AllocatorPresenter::RepaintVideo(HWND hwnd, HDC hdc) {return E_NOTIMPL;}
  901. STDMETHODIMP CVMR7AllocatorPresenter::DisplayModeChanged() {return E_NOTIMPL;}
  902. STDMETHODIMP CVMR7AllocatorPresenter::GetCurrentImage(BYTE** lpDib) {return E_NOTIMPL;}
  903. STDMETHODIMP CVMR7AllocatorPresenter::SetBorderColor(COLORREF Clr) {return E_NOTIMPL;}
  905. STDMETHODIMP CVMR7AllocatorPresenter::GetBorderColor(COLORREF* lpClr)
  906. {
  907. if(lpClr) *lpClr = 0;
  908. return S_OK;
  909. }
  911. STDMETHODIMP CVMR7AllocatorPresenter::SetColorKey(COLORREF Clr) {return E_NOTIMPL;}
  912. STDMETHODIMP CVMR7AllocatorPresenter::GetColorKey(COLORREF* lpClr) {return E_NOTIMPL;}
  914. //
  916. static HRESULT AllocDX7Surface(IDirectDraw7* pDD, CSize size, DWORD compression, int bpp, IDirectDrawSurface7** pSurface)
  917. {
  918. if(!pDD || !pSurface || size.cx <= 0 || size.cy <= 0)
  919. return E_POINTER;
  921. *pSurface = NULL;
  923. DDSURFACEDESC2 ddsd;
  924. INITDDSTRUCT(ddsd);
  925. ddsd.dwFlags = DDSD_CAPS|DDSD_WIDTH|DDSD_HEIGHT|DDSD_PIXELFORMAT;
  926. ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN|DDSCAPS_VIDEOMEMORY;
  927. ddsd.dwWidth = size.cx;
  928. ddsd.dwHeight = size.cy;
  929. ddsd.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
  931. if(compression >= 0x1000)
  932. {
  933. ddsd.ddpfPixelFormat.dwFlags = DDPF_FOURCC;
  934. ddsd.ddpfPixelFormat.dwFourCC = compression;
  935. }
  936. else if((compression == 0 || compression == 3) && (bpp == 15 || bpp == 16 || bpp == 24 || bpp == 32))
  937. {
  938. ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB;
  939. ddsd.ddpfPixelFormat.dwRGBBitCount = max(bpp, 16);
  940. ddsd.ddpfPixelFormat.dwRGBAlphaBitMask = (bpp == 16) ? 0x0000 : (bpp == 15) ? 0x8000 : 0xFF000000;
  941. ddsd.ddpfPixelFormat.dwRBitMask = (bpp == 16) ? 0xf800 : (bpp == 15) ? 0x7c00 : 0x00FF0000;
  942. ddsd.ddpfPixelFormat.dwGBitMask = (bpp == 16) ? 0x07e0 : (bpp == 15) ? 0x03e0 : 0x0000FF00;
  943. ddsd.ddpfPixelFormat.dwBBitMask = (bpp == 16) ? 0x001F : (bpp == 15) ? 0x001F : 0x000000FF;
  944. }
  946. return pDD->CreateSurface(&ddsd, pSurface, NULL);
  947. }
  949. //
  950. // CRM7AllocatorPresenter
  951. //
  953. CRM7AllocatorPresenter::CRM7AllocatorPresenter(HWND hWnd, HRESULT& hr) 
  954. : CDX7AllocatorPresenter(hWnd, hr)
  955. {
  956. }
  958. STDMETHODIMP CRM7AllocatorPresenter::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  959. {
  960.     CheckPointer(ppv, E_POINTER);
  962. return 
  963. QI2(IRMAVideoSurface)
  964. __super::NonDelegatingQueryInterface(riid, ppv);
  965. }
  967. HRESULT CRM7AllocatorPresenter::AllocSurfaces()
  968. {
  969.     CAutoLock cAutoLock(this);
  971. m_pVideoSurfaceOff = NULL;
  972. m_pVideoSurfaceYUY2 = NULL;
  974. DDSURFACEDESC2 ddsd;
  975. DDBLTFX fx;
  977. INITDDSTRUCT(ddsd);
  978. ddsd.dwFlags = DDSD_CAPS|DDSD_WIDTH|DDSD_HEIGHT|DDSD_PIXELFORMAT;
  979. ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
  980. ddsd.dwWidth = m_NativeVideoSize.cx;
  981. ddsd.dwHeight = m_NativeVideoSize.cy;
  982. ddsd.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
  983. ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB;
  984. ddsd.ddpfPixelFormat.dwRGBBitCount = 32;
  985. ddsd.ddpfPixelFormat.dwRGBAlphaBitMask = 0xFF000000;
  986. ddsd.ddpfPixelFormat.dwRBitMask = 0x00FF0000;
  987. ddsd.ddpfPixelFormat.dwGBitMask = 0x0000FF00;
  988. ddsd.ddpfPixelFormat.dwBBitMask = 0x000000FF;
  990. HRESULT hr = m_pDD->CreateSurface(&ddsd, &m_pVideoSurfaceOff, NULL);
  991. if(FAILED(hr)) return E_FAIL;
  993. INITDDSTRUCT(fx);
  994. fx.dwFillColor = 0;
  995. m_pVideoSurfaceOff->Blt(NULL, NULL, NULL, DDBLT_WAIT|DDBLT_COLORFILL, &fx);
  997. INITDDSTRUCT(ddsd);
  998. ddsd.dwFlags = DDSD_CAPS|DDSD_WIDTH|DDSD_HEIGHT|DDSD_PIXELFORMAT;
  999. ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
  1000. ddsd.dwWidth = m_NativeVideoSize.cx;
  1001. ddsd.dwHeight = m_NativeVideoSize.cy;
  1002. ddsd.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
  1003. ddsd.ddpfPixelFormat.dwFlags = DDPF_FOURCC;
  1004. ddsd.ddpfPixelFormat.dwYUVBitCount = 16;
  1005. ddsd.ddpfPixelFormat.dwFourCC = '2YUY';
  1007. hr = m_pDD->CreateSurface(&ddsd, &m_pVideoSurfaceYUY2, NULL);
  1009. if(FAILED(m_pVideoSurfaceOff->Blt(NULL, m_pVideoSurfaceYUY2, NULL, DDBLT_WAIT, NULL)))
  1010. m_pVideoSurfaceYUY2 = NULL;
  1012. if(m_pVideoSurfaceYUY2)
  1013. {
  1014. INITDDSTRUCT(fx);
  1015. fx.dwFillColor = 0x80108010;
  1016. m_pVideoSurfaceYUY2->Blt(NULL, NULL, NULL, DDBLT_WAIT|DDBLT_COLORFILL, &fx);
  1017. }
  1019. return __super::AllocSurfaces();
  1020. }
  1022. void CRM7AllocatorPresenter::DeleteSurfaces()
  1023. {
  1024.     CAutoLock cAutoLock(this);
  1026. m_pVideoSurfaceOff = NULL;
  1027. m_pVideoSurfaceYUY2 = NULL;
  1029. __super::DeleteSurfaces();
  1030. }
  1032. // IRMAVideoSurface
  1034. STDMETHODIMP CRM7AllocatorPresenter::Blt(UCHAR* pImageData, RMABitmapInfoHeader* pBitmapInfo, REF(PNxRect) inDestRect, REF(PNxRect) inSrcRect)
  1035. {
  1036. if(!m_pVideoSurface || !m_pVideoSurfaceOff)
  1037. return E_FAIL;
  1039. bool fRGB = false;
  1040. bool fYUY2 = false;
  1042. CRect src((RECT*)&inSrcRect), dst((RECT*)&inDestRect), src2(CPoint(0,0), src.Size());
  1043. if(src.Width() > dst.Width() || src.Height() > dst.Height())
  1044. return E_FAIL;
  1046. DDSURFACEDESC2 ddsd;
  1048. if(pBitmapInfo->biCompression == '024I')
  1049. {
  1050. DWORD pitch = pBitmapInfo->biWidth;
  1051. DWORD size = pitch*abs(pBitmapInfo->biHeight);
  1053. BYTE* y = pImageData + src.top*pitch + src.left;
  1054. BYTE* u = pImageData + size + src.top*(pitch/2) + src.left/2;
  1055. BYTE* v = pImageData + size + size/4 + src.top*(pitch/2) + src.left/2;
  1057. if(m_pVideoSurfaceYUY2)
  1058. {
  1059. INITDDSTRUCT(ddsd);
  1060. if(SUCCEEDED(m_pVideoSurfaceYUY2->Lock(src2, &ddsd, DDLOCK_WAIT|DDLOCK_SURFACEMEMORYPTR|DDLOCK_WRITEONLY, NULL)))
  1061. {
  1062. BitBltFromI420ToYUY2(src.Width(), src.Height(), (BYTE*)ddsd.lpSurface, ddsd.lPitch, y, u, v, pitch);
  1063. m_pVideoSurfaceYUY2->Unlock(src2);
  1064. fYUY2 = true;
  1065. }
  1066. }
  1067. else
  1068. {
  1069. INITDDSTRUCT(ddsd);
  1070. if(SUCCEEDED(m_pVideoSurfaceOff->Lock(src2, &ddsd, DDLOCK_WAIT|DDLOCK_SURFACEMEMORYPTR|DDLOCK_WRITEONLY, NULL)))
  1071. {
  1072. BitBltFromI420ToRGB(src.Width(), src.Height(), (BYTE*)ddsd.lpSurface, ddsd.lPitch, ddsd.ddpfPixelFormat.dwRGBBitCount, y, u, v, pitch);
  1073. m_pVideoSurfaceOff->Unlock(src2);
  1074. fRGB = true;
  1075. }
  1076. }
  1077. }
  1078. else if(pBitmapInfo->biCompression == '2YUY')
  1079. {
  1080. DWORD w = pBitmapInfo->biWidth;
  1081. DWORD h = abs(pBitmapInfo->biHeight);
  1082. DWORD pitch = pBitmapInfo->biWidth*2;
  1084. BYTE* yvyu = pImageData + src.top*pitch + src.left*2;
  1086. if(m_pVideoSurfaceYUY2)
  1087. {
  1088. INITDDSTRUCT(ddsd);
  1089. if(SUCCEEDED(m_pVideoSurfaceYUY2->Lock(src2, &ddsd, DDLOCK_WAIT|DDLOCK_SURFACEMEMORYPTR|DDLOCK_WRITEONLY, NULL)))
  1090. {
  1091. BitBltFromYUY2ToYUY2(src.Width(), src.Height(), (BYTE*)ddsd.lpSurface, ddsd.lPitch, yvyu, pitch);
  1092. m_pVideoSurfaceYUY2->Unlock(src2);
  1093. fYUY2 = true;
  1094. }
  1095. }
  1096. else
  1097. {
  1098. INITDDSTRUCT(ddsd);
  1099. if(SUCCEEDED(m_pVideoSurfaceOff->Lock(src2, &ddsd, DDLOCK_WAIT|DDLOCK_SURFACEMEMORYPTR|DDLOCK_WRITEONLY, NULL)))
  1100. {
  1101. BitBltFromYUY2ToRGB(src.Width(), src.Height(), (BYTE*)ddsd.lpSurface, ddsd.lPitch, ddsd.ddpfPixelFormat.dwRGBBitCount, yvyu, pitch);
  1102. m_pVideoSurfaceOff->Unlock(src2);
  1103. fRGB = true;
  1104. }
  1105. }
  1106. }
  1107. else if(pBitmapInfo->biCompression == 0 || pBitmapInfo->biCompression == 3
  1108.  || pBitmapInfo->biCompression == 'BGRA')
  1109. {
  1110. DWORD w = pBitmapInfo->biWidth;
  1111. DWORD h = abs(pBitmapInfo->biHeight);
  1112. DWORD pitch = pBitmapInfo->biWidth*pBitmapInfo->biBitCount>>3;
  1114. BYTE* rgb = pImageData + src.top*pitch + src.left*(pBitmapInfo->biBitCount>>3);
  1116. INITDDSTRUCT(ddsd);
  1117. if(SUCCEEDED(m_pVideoSurfaceOff->Lock(src2, &ddsd, DDLOCK_WAIT|DDLOCK_SURFACEMEMORYPTR|DDLOCK_WRITEONLY, NULL)))
  1118. {
  1119. BYTE* lpSurface = (BYTE*)ddsd.lpSurface;
  1120. if(pBitmapInfo->biHeight > 0) {lpSurface += ddsd.lPitch*(src.Height()-1); ddsd.lPitch = -ddsd.lPitch;}
  1121. BitBltFromRGBToRGB(src.Width(), src.Height(), lpSurface, ddsd.lPitch, ddsd.ddpfPixelFormat.dwRGBBitCount, rgb, pitch, pBitmapInfo->biBitCount);
  1122. fRGB = true;
  1123. m_pVideoSurfaceOff->Unlock(src2);
  1124. }
  1125. }
  1127. if(!fRGB && !fYUY2)
  1128. {
  1129. DDBLTFX fx;
  1130. INITDDSTRUCT(fx);
  1131. fx.dwFillColor = 0;
  1132. m_pVideoSurfaceOff->Blt(NULL, NULL, NULL, DDBLT_WAIT|DDBLT_COLORFILL, &fx);
  1134. HDC hDC;
  1135. if(SUCCEEDED(m_pVideoSurfaceOff->GetDC(&hDC)))
  1136. {
  1137. CString str;
  1138. str.Format(_T("Sorry, this format is not supported"));
  1140. SetBkColor(hDC, 0);
  1141. SetTextColor(hDC, 0x404040);
  1142. TextOut(hDC, 10, 10, str, str.GetLength());
  1144. m_pVideoSurfaceOff->ReleaseDC(hDC);
  1146. fRGB = true;
  1147. }
  1148. }
  1151. HRESULT hr;
  1153. if(fRGB)
  1154. hr = m_pVideoSurface->Blt(dst, m_pVideoSurfaceOff, src2, DDBLT_WAIT, NULL);
  1155. if(fYUY2)
  1156. hr = m_pVideoSurface->Blt(dst, m_pVideoSurfaceYUY2, src2, DDBLT_WAIT, NULL);
  1157.     
  1158. Paint(true);
  1160. return PNR_OK;
  1161. }
  1163. STDMETHODIMP CRM7AllocatorPresenter::BeginOptimizedBlt(RMABitmapInfoHeader* pBitmapInfo)
  1164. {
  1165.     CAutoLock cAutoLock(this);
  1166. DeleteSurfaces();
  1167. m_NativeVideoSize = m_AspectRatio = CSize(pBitmapInfo->biWidth, abs(pBitmapInfo->biHeight));
  1168. if(FAILED(AllocSurfaces())) return E_FAIL;
  1169. return PNR_NOTIMPL;
  1170. }
  1172. STDMETHODIMP CRM7AllocatorPresenter::OptimizedBlt(UCHAR* pImageBits, REF(PNxRect) rDestRect, REF(PNxRect) rSrcRect)
  1173. {
  1174. return PNR_NOTIMPL;
  1175. }
  1177. STDMETHODIMP CRM7AllocatorPresenter::EndOptimizedBlt()
  1178. {
  1179. return PNR_NOTIMPL;
  1180. }
  1182. STDMETHODIMP CRM7AllocatorPresenter::GetOptimizedFormat(REF(RMA_COMPRESSION_TYPE) ulType)
  1183. {
  1184. return PNR_NOTIMPL;
  1185. }
  1187. STDMETHODIMP CRM7AllocatorPresenter::GetPreferredFormat(REF(RMA_COMPRESSION_TYPE) ulType)
  1188. {
  1189. ulType = RMA_I420;
  1190. return PNR_OK;
  1191. }
  1193. //
  1194. // CQT7AllocatorPresenter
  1195. //
  1197. CQT7AllocatorPresenter::CQT7AllocatorPresenter(HWND hWnd, HRESULT& hr) 
  1198. : CDX7AllocatorPresenter(hWnd, hr)
  1199. {
  1200. }
  1202. STDMETHODIMP CQT7AllocatorPresenter::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  1203. {
  1204.     CheckPointer(ppv, E_POINTER);
  1206. return 
  1207. QI(IQTVideoSurface)
  1208. __super::NonDelegatingQueryInterface(riid, ppv);
  1209. }
  1211. HRESULT CQT7AllocatorPresenter::AllocSurfaces()
  1212. {
  1213.     CAutoLock cAutoLock(this);
  1215. m_pVideoSurfaceOff = NULL;
  1217. DDSURFACEDESC2 ddsd;
  1218. INITDDSTRUCT(ddsd);
  1219. ddsd.dwFlags = DDSD_CAPS|DDSD_WIDTH|DDSD_HEIGHT|DDSD_PIXELFORMAT;
  1220. ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
  1221. ddsd.dwWidth = m_NativeVideoSize.cx;
  1222. ddsd.dwHeight = m_NativeVideoSize.cy;
  1223. ddsd.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
  1224. ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB;
  1225. ddsd.ddpfPixelFormat.dwRGBBitCount = 32;
  1226. ddsd.ddpfPixelFormat.dwRGBAlphaBitMask = 0xFF000000;
  1227. ddsd.ddpfPixelFormat.dwRBitMask = 0x00FF0000;
  1228. ddsd.ddpfPixelFormat.dwGBitMask = 0x0000FF00;
  1229. ddsd.ddpfPixelFormat.dwBBitMask = 0x000000FF;
  1231. HRESULT hr = m_pDD->CreateSurface(&ddsd, &m_pVideoSurfaceOff, NULL);
  1232. if(FAILED(hr)) return E_FAIL;
  1234. DDBLTFX fx;
  1235. INITDDSTRUCT(fx);
  1236. fx.dwFillColor = 0;
  1237. m_pVideoSurfaceOff->Blt(NULL, NULL, NULL, DDBLT_WAIT|DDBLT_COLORFILL, &fx);
  1239. return __super::AllocSurfaces();
  1240. }
  1242. void CQT7AllocatorPresenter::DeleteSurfaces()
  1243. {
  1244.     CAutoLock cAutoLock(this);
  1246. m_pVideoSurfaceOff = NULL;
  1248. __super::DeleteSurfaces();
  1249. }
  1251. // IQTVideoSurface
  1253. STDMETHODIMP CQT7AllocatorPresenter::BeginBlt(const BITMAP& bm)
  1254. {
  1255.     CAutoLock cAutoLock(this);
  1257. DeleteSurfaces();
  1259. m_NativeVideoSize = m_AspectRatio = CSize(bm.bmWidth, abs(bm.bmHeight));
  1261. HRESULT hr;
  1262. if(FAILED(hr = AllocSurfaces()))
  1263. return hr;
  1265. return S_OK;
  1266. }
  1268. STDMETHODIMP CQT7AllocatorPresenter::DoBlt(const BITMAP& bm)
  1269. {
  1270. if(!m_pVideoSurface || !m_pVideoSurfaceOff)
  1271. return E_FAIL;
  1273. bool fOk = false;
  1275. DDSURFACEDESC2 ddsd;
  1276. INITDDSTRUCT(ddsd);
  1277. if(FAILED(m_pVideoSurfaceOff->GetSurfaceDesc(&ddsd)))
  1278. return E_FAIL;
  1280. int w = bm.bmWidth;
  1281. int h = abs(bm.bmHeight);
  1282. int bpp = bm.bmBitsPixel;
  1284. if((bpp == 16 || bpp == 24 || bpp == 32) && w == ddsd.dwWidth && h == ddsd.dwHeight)
  1285. {
  1286. INITDDSTRUCT(ddsd);
  1287. if(SUCCEEDED(m_pVideoSurfaceOff->Lock(NULL, &ddsd, DDLOCK_WAIT|DDLOCK_SURFACEMEMORYPTR|DDLOCK_WRITEONLY, NULL)))
  1288. {
  1289. BitBltFromRGBToRGB(
  1290. w, h, 
  1291. (BYTE*)ddsd.lpSurface, ddsd.lPitch, ddsd.ddpfPixelFormat.dwRGBBitCount,
  1292. (BYTE*)bm.bmBits, bm.bmWidthBytes, bm.bmBitsPixel);
  1293. m_pVideoSurfaceOff->Unlock(NULL);
  1294. fOk = true;
  1295. }
  1296. }
  1298. if(!fOk)
  1299. {
  1300. DDBLTFX fx;
  1301. INITDDSTRUCT(fx);
  1302. fx.dwFillColor = 0;
  1303. m_pVideoSurfaceOff->Blt(NULL, NULL, NULL, DDBLT_WAIT|DDBLT_COLORFILL, &fx);
  1305. HDC hDC;
  1306. if(SUCCEEDED(m_pVideoSurfaceOff->GetDC(&hDC)))
  1307. {
  1308. CString str;
  1309. str.Format(_T("Sorry, this format is not supported"));
  1311. SetBkColor(hDC, 0);
  1312. SetTextColor(hDC, 0x404040);
  1313. TextOut(hDC, 10, 10, str, str.GetLength());
  1315. m_pVideoSurfaceOff->ReleaseDC(hDC);
  1317. }
  1318. }
  1320. m_pVideoSurface->Blt(NULL, m_pVideoSurfaceOff, NULL, DDBLT_WAIT, NULL);
  1322. Paint(true);
  1324. return S_OK;
  1325. }