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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
DX7AllocatorPresenter.cpp
资源名称：bfyy.rar　[点击查看]
上传用户：tangyu_668
上传日期：2014-02-27
资源大小：678k
文件大小：36k
源码类别：

多媒体编程

开发平台：

Visual C++

DX7AllocatorPresenter.cpp：源码内容
  1. /* 
  2.  * Copyright (C) 2003-2006 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, hr)
  290. , m_ScreenSize(0, 0)
  291. {
  292. if(FAILED(hr)) return;
  294. if(FAILED(hr = DirectDrawCreateEx(NULL, (VOID**)&m_pDD, IID_IDirectDraw7, NULL))
  295. || FAILED(hr = m_pDD->SetCooperativeLevel(AfxGetMainWnd()->GetSafeHwnd(), DDSCL_NORMAL)))
  296. return;
  298. if(!(m_pD3D = m_pDD)) {hr = E_NOINTERFACE; return;}
  300. hr = CreateDevice();
  301. }
  303. HRESULT CDX7AllocatorPresenter::CreateDevice()
  304. {
  305.     m_pD3DDev = NULL;
  307. m_pPrimary = NULL;
  308. m_pBackBuffer = NULL;
  310.     DDSURFACEDESC2 ddsd;
  311. INITDDSTRUCT(ddsd);
  312.     if(FAILED(m_pDD->GetDisplayMode(&ddsd))
  313. || ddsd.ddpfPixelFormat.dwRGBBitCount <= 8)
  314. return DDERR_INVALIDMODE;
  316. m_ScreenSize.SetSize(ddsd.dwWidth, ddsd.dwHeight);
  318. HRESULT hr;
  320. // m_pPrimary
  322. INITDDSTRUCT(ddsd);
  323.     ddsd.dwFlags = DDSD_CAPS;
  324.     ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
  325.     if(FAILED(hr = m_pDD->CreateSurface(&ddsd, &m_pPrimary, NULL)))
  326.         return hr;
  328. CComPtr<IDirectDrawClipper> pcClipper;
  329.     if(FAILED(hr = m_pDD->CreateClipper(0, &pcClipper, NULL)))
  330.         return hr;
  331. pcClipper->SetHWnd(0, m_hWnd);
  332. m_pPrimary->SetClipper(pcClipper);
  334. // m_pBackBuffer
  336. INITDDSTRUCT(ddsd);
  337.     ddsd.dwFlags        = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
  338.     ddsd.ddsCaps.dwCaps = /*DDSCAPS_OFFSCREENPLAIN |*/ DDSCAPS_VIDEOMEMORY | DDSCAPS_3DDEVICE;
  339. ddsd.dwWidth = m_ScreenSize.cx;
  340. ddsd.dwHeight = m_ScreenSize.cy;
  341. if(FAILED(hr = m_pDD->CreateSurface(&ddsd, &m_pBackBuffer, NULL)))
  342.         return hr;
  344. pcClipper = NULL;
  345.     if(FAILED(hr = m_pDD->CreateClipper(0, &pcClipper, NULL)))
  346. return hr;
  347.     BYTE rgnDataBuffer[1024];
  348. HRGN hrgn = CreateRectRgn(0, 0, ddsd.dwWidth, ddsd.dwHeight);
  349. GetRegionData(hrgn, sizeof(rgnDataBuffer), (RGNDATA*)rgnDataBuffer);
  350. DeleteObject(hrgn);
  351. pcClipper->SetClipList((RGNDATA*)rgnDataBuffer, 0);
  352. m_pBackBuffer->SetClipper(pcClipper);
  354. // m_pD3DDev
  356. 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)
  357. return hr;
  359. //
  361. CComPtr<ISubPicProvider> pSubPicProvider;
  362. if(m_pSubPicQueue) m_pSubPicQueue->GetSubPicProvider(&pSubPicProvider);
  364. CSize size;
  365. switch(AfxGetAppSettings().nSPCMaxRes)
  366. {
  367. case 0: default: size = m_ScreenSize; break;
  368. case 1: size.SetSize(1024, 768); break;
  369. case 2: size.SetSize(800, 600); break;
  370. case 3: size.SetSize(640, 480); break;
  371. case 4: size.SetSize(512, 384); break;
  372. case 5: size.SetSize(384, 288); break;
  373. }
  375. if(m_pAllocator)
  376. {
  377. m_pAllocator->ChangeDevice(m_pD3DDev);
  378. }
  379. else
  380. {
  381. m_pAllocator = new CDX7SubPicAllocator(m_pD3DDev, size, AfxGetAppSettings().fSPCPow2Tex);
  382. if(!m_pAllocator || FAILED(hr))
  383. return E_FAIL;
  384. }
  386. hr = S_OK;
  387. m_pSubPicQueue = AfxGetAppSettings().nSPCSize > 0 
  388. ? (ISubPicQueue*)new CSubPicQueue(AfxGetAppSettings().nSPCSize, m_pAllocator, &hr)
  389. : (ISubPicQueue*)new CSubPicQueueNoThread(m_pAllocator, &hr);
  390. if(!m_pSubPicQueue || FAILED(hr))
  391. return E_FAIL;
  393. if(pSubPicProvider) m_pSubPicQueue->SetSubPicProvider(pSubPicProvider);
  395. return S_OK;
  396. }
  398. HRESULT CDX7AllocatorPresenter::AllocSurfaces()
  399. {
  400.     CAutoLock cAutoLock(this);
  402. AppSettings& s = AfxGetAppSettings();
  404. m_pVideoTexture = NULL;
  405. m_pVideoSurface = NULL;
  407. DDSURFACEDESC2 ddsd;
  408. INITDDSTRUCT(ddsd);
  409. ddsd.dwFlags = DDSD_CAPS|DDSD_WIDTH|DDSD_HEIGHT|DDSD_PIXELFORMAT;
  410. ddsd.ddsCaps.dwCaps = DDSCAPS_VIDEOMEMORY;
  411. ddsd.dwWidth = m_NativeVideoSize.cx;
  412. ddsd.dwHeight = m_NativeVideoSize.cy;
  413. ddsd.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
  414. ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB;
  415. ddsd.ddpfPixelFormat.dwRGBBitCount = 32;
  416. ddsd.ddpfPixelFormat.dwRBitMask = 0x00FF0000;
  417. ddsd.ddpfPixelFormat.dwGBitMask = 0x0000FF00;
  418. ddsd.ddpfPixelFormat.dwBBitMask = 0x000000FF;
  420. if(s.iAPSurfaceUsage == VIDRNDT_AP_TEXTURE2D || s.iAPSurfaceUsage == VIDRNDT_AP_TEXTURE3D)
  421. {
  422. ddsd.ddsCaps.dwCaps |= DDSCAPS_TEXTURE;
  423. // ddsd.ddpfPixelFormat.dwFlags |= DDPF_ALPHAPIXELS;
  424. // ddsd.ddpfPixelFormat.dwRGBAlphaBitMask = 0xFF000000;
  425. }
  427. HRESULT hr = m_pDD->CreateSurface(&ddsd, &m_pVideoSurface, NULL);
  428. if(FAILED(hr))
  429. {
  430. // FIXME: eh, dx9 has no problem creating a 32bpp surface under a 16bpp desktop, but dx7 fails here (textures are ok)
  431. DDSURFACEDESC2 ddsd2;
  432. INITDDSTRUCT(ddsd2);
  433. if(!(s.iAPSurfaceUsage == VIDRNDT_AP_TEXTURE2D || s.iAPSurfaceUsage == VIDRNDT_AP_TEXTURE3D)
  434. && SUCCEEDED(m_pDD->GetDisplayMode(&ddsd2))
  435. && ddsd2.ddpfPixelFormat.dwRGBBitCount == 16)
  436. {
  437. ddsd.ddpfPixelFormat.dwRGBBitCount = 16;
  438. ddsd.ddpfPixelFormat.dwRBitMask = 0x0000F800;
  439. ddsd.ddpfPixelFormat.dwGBitMask = 0x000007E0;
  440. ddsd.ddpfPixelFormat.dwBBitMask = 0x0000001F;
  441. hr = m_pDD->CreateSurface(&ddsd, &m_pVideoSurface, NULL);
  442. }
  444. if(FAILED(hr))
  445. return hr;
  446. }
  448. if(s.iAPSurfaceUsage == VIDRNDT_AP_TEXTURE3D)
  449. m_pVideoTexture = m_pVideoSurface;
  451. DDBLTFX fx;
  452. INITDDSTRUCT(fx);
  453. fx.dwFillColor = 0;
  454. hr = m_pVideoSurface->Blt(NULL, NULL, NULL, DDBLT_WAIT|DDBLT_COLORFILL, &fx);
  456. return S_OK;
  457. }
  459. void CDX7AllocatorPresenter::DeleteSurfaces()
  460. {
  461.     CAutoLock cAutoLock(this);
  463. m_pVideoTexture = NULL;
  464. m_pVideoSurface = NULL;
  465. }
  467. // ISubPicAllocatorPresenter
  469. STDMETHODIMP CDX7AllocatorPresenter::CreateRenderer(IUnknown** ppRenderer)
  470. {
  471. return E_NOTIMPL;
  472. }
  474. STDMETHODIMP_(bool) CDX7AllocatorPresenter::Paint(bool fAll)
  475. {
  476. CAutoLock cAutoLock(this);
  478. if(m_WindowRect.right <= m_WindowRect.left || m_WindowRect.bottom <= m_WindowRect.top
  479. || m_NativeVideoSize.cx <= 0 || m_NativeVideoSize.cy <= 0
  480. || !m_pPrimary || !m_pBackBuffer || !m_pVideoSurface)
  481. return(false);
  483. HRESULT hr;
  485. CRect rSrcVid(CPoint(0, 0), m_NativeVideoSize);
  486. CRect rDstVid(m_VideoRect);
  488. CRect rSrcPri(CPoint(0, 0), m_WindowRect.Size());
  489. CRect rDstPri(m_WindowRect);
  490. MapWindowRect(m_hWnd, HWND_DESKTOP, &rDstPri);
  492. if(fAll)
  493. {
  494. // clear the backbuffer
  496. CRect rl(0, 0, rDstVid.left, rSrcPri.bottom);
  497. CRect rr(rDstVid.right, 0, rSrcPri.right, rSrcPri.bottom);
  498. CRect rt(0, 0, rSrcPri.right, rDstVid.top);
  499. CRect rb(0, rDstVid.bottom, rSrcPri.right, rSrcPri.bottom);
  501. DDBLTFX fx;
  502. INITDDSTRUCT(fx);
  503. fx.dwFillColor = 0;
  504. hr = m_pBackBuffer->Blt(NULL, NULL, NULL, DDBLT_WAIT|DDBLT_COLORFILL, &fx);
  506. // paint the video on the backbuffer
  508. if(!rDstVid.IsRectEmpty())
  509. {
  510. if(m_pVideoTexture)
  511. {
  512. Vector v[4];
  513. Transform(rDstVid, v);
  514. hr = TextureBlt(m_pD3DDev, m_pVideoTexture, v, rSrcVid);
  515. }
  516. else
  517. {
  518. hr = m_pBackBuffer->Blt(rDstVid, m_pVideoSurface, rSrcVid, DDBLT_WAIT, NULL);
  519. }
  520. }
  522. // paint the text on the backbuffer
  524. AlphaBltSubPic(rSrcPri.Size());
  525. }
  527. // wait vsync
  529. m_pDD->WaitForVerticalBlank(DDWAITVB_BLOCKBEGIN, NULL);
  531. // blt to the primary surface
  533. hr = m_pPrimary->Blt(rDstPri, m_pBackBuffer, rSrcPri, DDBLT_WAIT, NULL);
  535. if(hr == DDERR_SURFACELOST)
  536. {
  537. HRESULT hr = DDERR_WRONGMODE; // m_pDD->TestCooperativeLevel();
  539. if(hr == DDERR_WRONGMODE) 
  540. {
  541. DeleteSurfaces();
  542. if(SUCCEEDED(CreateDevice()) || FAILED(hr = AllocSurfaces()))
  543. return(true);
  544. }
  546. hr = S_OK;
  547. }
  549. return(true);
  550. }
  552. STDMETHODIMP CDX7AllocatorPresenter::GetDIB(BYTE* lpDib, DWORD* size)
  553. {
  554. CheckPointer(size, E_POINTER);
  556. HRESULT hr;
  558. DDSURFACEDESC2 ddsd;
  559. INITDDSTRUCT(ddsd);
  560. if(FAILED(m_pVideoSurface->GetSurfaceDesc(&ddsd)))
  561. return E_FAIL;
  563. if(ddsd.ddpfPixelFormat.dwRGBBitCount != 16 && ddsd.ddpfPixelFormat.dwRGBBitCount != 32)
  564. return E_FAIL;
  566. DWORD required = sizeof(BITMAPINFOHEADER) + (ddsd.dwWidth*ddsd.dwHeight*32>>3);
  567. if(!lpDib) {*size = required; return S_OK;}
  568. if(*size < required) return E_OUTOFMEMORY;
  569. *size = required;
  571. INITDDSTRUCT(ddsd);
  572. if(FAILED(hr = m_pVideoSurface->Lock(NULL, &ddsd, DDLOCK_WAIT|DDLOCK_SURFACEMEMORYPTR|DDLOCK_READONLY|DDLOCK_NOSYSLOCK, NULL)))
  573. {
  574. // TODO
  575. return hr;
  576. }
  578. BITMAPINFOHEADER* bih = (BITMAPINFOHEADER*)lpDib;
  579. memset(bih, 0, sizeof(BITMAPINFOHEADER));
  580. bih->biSize = sizeof(BITMAPINFOHEADER);
  581. bih->biWidth = ddsd.dwWidth;
  582. bih->biHeight = ddsd.dwHeight;
  583. bih->biBitCount = 32;
  584. bih->biPlanes = 1;
  585. bih->biSizeImage = bih->biWidth*bih->biHeight*bih->biBitCount>>3;
  587. BitBltFromRGBToRGB(
  588. bih->biWidth, bih->biHeight, 
  589. (BYTE*)(bih + 1), bih->biWidth*bih->biBitCount>>3, bih->biBitCount,
  590. (BYTE*)ddsd.lpSurface + ddsd.lPitch*(ddsd.dwHeight-1), -(int)ddsd.lPitch, ddsd.ddpfPixelFormat.dwRGBBitCount);
  592. m_pVideoSurface->Unlock(NULL);
  594. /*
  595. BitBltFromRGBToRGB(
  596. w, h, 
  597. (BYTE*)ddsd.lpSurface, ddsd.lPitch, ddsd.ddpfPixelFormat.dwRGBBitCount,
  598. (BYTE*)bm.bmBits, bm.bmWidthBytes, bm.bmBitsPixel);
  599. m_pVideoSurfaceOff->Unlock(NULL);
  600. fOk = true;
  601. }
  602. */
  604. return S_OK;
  605. }
  607. //
  608. // CVMR7AllocatorPresenter
  609. //
  611. #define MY_USER_ID 0x6ABE51
  613. CVMR7AllocatorPresenter::CVMR7AllocatorPresenter(HWND hWnd, HRESULT& hr) 
  614. : CDX7AllocatorPresenter(hWnd, hr)
  615. , m_fUseInternalTimer(false)
  616. {
  617.     if(FAILED(hr))
  618. return;
  620. if(FAILED(hr = m_pSA.CoCreateInstance(CLSID_AllocPresenter)))
  621. {
  622. hr = E_FAIL;
  623. return;
  624. }
  625. }
  627. STDMETHODIMP CVMR7AllocatorPresenter::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  628. {
  629.     CheckPointer(ppv, E_POINTER);
  631. return 
  632. QI(IVMRSurfaceAllocator)
  633. QI(IVMRImagePresenter)
  634. QI(IVMRWindowlessControl)
  635. __super::NonDelegatingQueryInterface(riid, ppv);
  636. }
  638. HRESULT CVMR7AllocatorPresenter::CreateDevice()
  639. {
  640. HRESULT hr = __super::CreateDevice();
  641. if(FAILED(hr)) return hr;
  643. if(m_pIVMRSurfAllocNotify)
  644. {
  645. HMONITOR hMonitor = MonitorFromWindow(m_hWnd, MONITOR_DEFAULTTONEAREST);
  646. if(FAILED(hr = m_pIVMRSurfAllocNotify->ChangeDDrawDevice(m_pDD, hMonitor)))
  647. return(false);
  648. }
  650. return hr;
  651. }
  653. void CVMR7AllocatorPresenter::DeleteSurfaces()
  654. {
  655.     CAutoLock cAutoLock(this);
  657. m_pSA->FreeSurface(MY_USER_ID);
  659. __super::DeleteSurfaces();
  660. }
  662. // ISubPicAllocatorPresenter
  664. STDMETHODIMP CVMR7AllocatorPresenter::CreateRenderer(IUnknown** ppRenderer)
  665. {
  666.     CheckPointer(ppRenderer, E_POINTER);
  668. *ppRenderer = NULL;
  670. HRESULT hr;
  672. do
  673. {
  674. CComPtr<IBaseFilter> pBF;
  676. if(FAILED(hr = pBF.CoCreateInstance(CLSID_VideoMixingRenderer)))
  677. break;
  679. CComQIPtr<IVMRFilterConfig> pConfig = pBF;
  680. if(!pConfig)
  681. break;
  683. if(FAILED(hr = pConfig->SetRenderingMode(VMRMode_Renderless)))
  684. break;
  686. CComQIPtr<IVMRSurfaceAllocatorNotify> pSAN = pBF;
  687. if(!pSAN)
  688. break;
  690. if(FAILED(hr = pSAN->AdviseSurfaceAllocator(MY_USER_ID, static_cast<IVMRSurfaceAllocator*>(this)))
  691. || FAILED(hr = AdviseNotify(pSAN)))
  692. break;
  694. CComPtr<IPin> pPin = GetFirstPin(pBF);
  695. CComQIPtr<IMemInputPin> pMemInputPin = pPin;
  696. m_fUseInternalTimer = HookNewSegmentAndReceive((IPinC*)(IPin*)pPin, (IMemInputPinC*)(IMemInputPin*)pMemInputPin);
  698. *ppRenderer = (IUnknown*)pBF.Detach();
  700. return S_OK;
  701. }
  702. while(0);
  704.     return E_FAIL;
  705. }
  707. STDMETHODIMP_(void) CVMR7AllocatorPresenter::SetTime(REFERENCE_TIME rtNow)
  708. {
  709. __super::SetTime(rtNow);
  710. m_fUseInternalTimer = false;
  711. }
  713. // IVMRSurfaceAllocator
  715. STDMETHODIMP CVMR7AllocatorPresenter::AllocateSurface(DWORD_PTR dwUserID, VMRALLOCATIONINFO* lpAllocInfo, DWORD* lpdwBuffer, LPDIRECTDRAWSURFACE7* lplpSurface)
  716. {
  717. if(!lpAllocInfo || !lpdwBuffer || !lplpSurface)
  718. return E_POINTER;
  720. if(!m_pIVMRSurfAllocNotify)
  721. return E_FAIL;
  723. HRESULT hr;
  725.     DeleteSurfaces();
  727. // HACK: yv12 will fail to blt onto the backbuffer anyway, but if we first
  728. // allocate it and then let our FreeSurface callback call m_pSA->FreeSurface,
  729. // then that might stall for about 30 seconds because of some unknown buggy code 
  730. // behind <ddraw surface>->Release()
  732. if(lpAllocInfo->lpHdr->biBitCount < 16)
  733. return E_FAIL;
  735. hr = m_pSA->AllocateSurface(dwUserID, lpAllocInfo, lpdwBuffer, lplpSurface);
  736. if(FAILED(hr))
  737. return hr;
  739. m_NativeVideoSize = CSize(abs(lpAllocInfo->lpHdr->biWidth), abs(lpAllocInfo->lpHdr->biHeight));
  740. m_AspectRatio = m_NativeVideoSize;
  741. int arx = lpAllocInfo->szAspectRatio.cx, ary = lpAllocInfo->szAspectRatio.cy;
  742. if(arx > 0 && ary > 0) m_AspectRatio.SetSize(arx, ary);
  744. if(FAILED(hr = AllocSurfaces()))
  745. return hr;
  747. // test if the colorspace is acceptable
  748. if(FAILED(hr = m_pVideoSurface->Blt(NULL, *lplpSurface, NULL, DDBLT_WAIT, NULL)))
  749. {
  750. DeleteSurfaces();
  751. return hr;
  752. }
  754. DDBLTFX fx;
  755. INITDDSTRUCT(fx);
  756. fx.dwFillColor = 0;
  757. m_pVideoSurface->Blt(NULL, NULL, NULL, DDBLT_WAIT|DDBLT_COLORFILL, &fx);
  759. return hr;
  760. }
  762. STDMETHODIMP CVMR7AllocatorPresenter::FreeSurface(DWORD_PTR dwUserID)
  763. {
  764.     DeleteSurfaces();
  765. return S_OK;
  766. }
  768. STDMETHODIMP CVMR7AllocatorPresenter::PrepareSurface(DWORD_PTR dwUserID, IDirectDrawSurface7* lpSurface, DWORD dwSurfaceFlags)
  769. {
  770.     if(!lpSurface)
  771. return E_POINTER;
  773. // FIXME: sometimes the msmpeg4/divx3/wmv decoder wants to reuse our 
  774. // surface (expects it to point to the same mem every time), and to avoid 
  775. // problems we can't call m_pSA->PrepareSurface (flips? clears?).
  776. return S_OK; 
  777. /*
  778. return m_pSA->PrepareSurface(dwUserID, lpSurface, dwSurfaceFlags);
  779. */
  780. }
  782. STDMETHODIMP CVMR7AllocatorPresenter::AdviseNotify(IVMRSurfaceAllocatorNotify* lpIVMRSurfAllocNotify)
  783. {
  784.     CAutoLock cAutoLock(this);
  786. m_pIVMRSurfAllocNotify = lpIVMRSurfAllocNotify;
  788. HRESULT hr;
  789. HMONITOR hMonitor = MonitorFromWindow(m_hWnd, MONITOR_DEFAULTTONEAREST);
  790. if(FAILED(hr = m_pIVMRSurfAllocNotify->SetDDrawDevice(m_pDD, hMonitor)))
  791. return hr;
  793. return m_pSA->AdviseNotify(lpIVMRSurfAllocNotify);
  794. }
  796. // IVMRImagePresenter
  798. STDMETHODIMP CVMR7AllocatorPresenter::StartPresenting(DWORD_PTR dwUserID)
  799. {
  800.     CAutoLock cAutoLock(this);
  802.     ASSERT(m_pD3DDev);
  804. return m_pD3DDev ? S_OK : E_FAIL;
  805. }
  807. STDMETHODIMP CVMR7AllocatorPresenter::StopPresenting(DWORD_PTR dwUserID)
  808. {
  809. return S_OK;
  810. }
  812. STDMETHODIMP CVMR7AllocatorPresenter::PresentImage(DWORD_PTR dwUserID, VMRPRESENTATIONINFO* lpPresInfo)
  813. {
  814.     HRESULT hr;
  816. {
  817. if(!lpPresInfo || !lpPresInfo->lpSurf)
  818. return E_POINTER;
  820. CAutoLock cAutoLock(this);
  822. hr = m_pVideoSurface->Blt(NULL, lpPresInfo->lpSurf, NULL, DDBLT_WAIT, NULL);
  824. if(lpPresInfo->rtEnd > lpPresInfo->rtStart)
  825. {
  826. REFERENCE_TIME rtTimePerFrame = lpPresInfo->rtEnd - lpPresInfo->rtStart;
  827. m_fps = 10000000.0 / rtTimePerFrame;
  829. if(m_pSubPicQueue) 
  830. {
  831. m_pSubPicQueue->SetFPS(m_fps);
  833. if(m_fUseInternalTimer)
  834. {
  835. __super::SetTime(g_tSegmentStart + g_tSampleStart);
  836. }
  837. }
  838. }
  840. CSize VideoSize = m_NativeVideoSize;
  841. int arx = lpPresInfo->szAspectRatio.cx, ary = lpPresInfo->szAspectRatio.cy;
  842. if(arx > 0 && ary > 0) VideoSize.cx = VideoSize.cy*arx/ary;
  843. if(VideoSize != GetVideoSize())
  844. {
  845. m_AspectRatio.SetSize(arx, ary);
  846. AfxGetApp()->m_pMainWnd->PostMessage(WM_REARRANGERENDERLESS);
  847. }
  849. Paint(true);
  851. hr = S_OK;
  852. }
  854. return S_OK;
  855. }
  857. // IVMRWindowlessControl
  858. //
  859. // It is only implemented (partially) for the dvd navigator's 
  860. // menu handling, which needs to know a few things about the 
  861. // location of our window.
  863. STDMETHODIMP CVMR7AllocatorPresenter::GetNativeVideoSize(LONG* lpWidth, LONG* lpHeight, LONG* lpARWidth, LONG* lpARHeight)
  864. {
  865. CSize vs = m_NativeVideoSize, ar = m_AspectRatio;
  866. // DVD Nav. bug workaround fix
  867. vs.cx = vs.cy * ar.cx / ar.cy;
  868. if(lpWidth) *lpWidth = vs.cx;
  869. if(lpHeight) *lpHeight = vs.cy;
  870. if(lpARWidth) *lpARWidth = ar.cx;
  871. if(lpARHeight) *lpARHeight = ar.cy;
  872. return S_OK;
  873. }
  875. STDMETHODIMP CVMR7AllocatorPresenter::GetMinIdealVideoSize(LONG* lpWidth, LONG* lpHeight) {return E_NOTIMPL;}
  876. STDMETHODIMP CVMR7AllocatorPresenter::GetMaxIdealVideoSize(LONG* lpWidth, LONG* lpHeight) {return E_NOTIMPL;}
  877. STDMETHODIMP CVMR7AllocatorPresenter::SetVideoPosition(const LPRECT lpSRCRect, const LPRECT lpDSTRect) {return E_NOTIMPL;} // we have our own method for this
  879. STDMETHODIMP CVMR7AllocatorPresenter::GetVideoPosition(LPRECT lpSRCRect, LPRECT lpDSTRect)
  880. {
  881. CopyRect(lpSRCRect, CRect(CPoint(0, 0), m_NativeVideoSize));
  882. CopyRect(lpDSTRect, &m_VideoRect);
  883. // DVD Nav. bug workaround fix
  884. GetNativeVideoSize(&lpSRCRect->right, &lpSRCRect->bottom, NULL, NULL);
  885. return S_OK;
  886. }
  888. STDMETHODIMP CVMR7AllocatorPresenter::GetAspectRatioMode(DWORD* lpAspectRatioMode)
  889. {
  890. if(lpAspectRatioMode) *lpAspectRatioMode = AM_ARMODE_STRETCHED;
  891. return S_OK;
  892. }
  894. STDMETHODIMP CVMR7AllocatorPresenter::SetAspectRatioMode(DWORD AspectRatioMode) {return E_NOTIMPL;}
  895. STDMETHODIMP CVMR7AllocatorPresenter::SetVideoClippingWindow(HWND hwnd) {return E_NOTIMPL;}
  896. STDMETHODIMP CVMR7AllocatorPresenter::RepaintVideo(HWND hwnd, HDC hdc) {return E_NOTIMPL;}
  897. STDMETHODIMP CVMR7AllocatorPresenter::DisplayModeChanged() {return E_NOTIMPL;}
  898. STDMETHODIMP CVMR7AllocatorPresenter::GetCurrentImage(BYTE** lpDib) {return E_NOTIMPL;}
  899. STDMETHODIMP CVMR7AllocatorPresenter::SetBorderColor(COLORREF Clr) {return E_NOTIMPL;}
  901. STDMETHODIMP CVMR7AllocatorPresenter::GetBorderColor(COLORREF* lpClr)
  902. {
  903. if(lpClr) *lpClr = 0;
  904. return S_OK;
  905. }
  907. STDMETHODIMP CVMR7AllocatorPresenter::SetColorKey(COLORREF Clr) {return E_NOTIMPL;}
  908. STDMETHODIMP CVMR7AllocatorPresenter::GetColorKey(COLORREF* lpClr) {return E_NOTIMPL;}
  910. //
  912. static HRESULT AllocDX7Surface(IDirectDraw7* pDD, CSize size, DWORD compression, int bpp, IDirectDrawSurface7** pSurface)
  913. {
  914. if(!pDD || !pSurface || size.cx <= 0 || size.cy <= 0)
  915. return E_POINTER;
  917. *pSurface = NULL;
  919. DDSURFACEDESC2 ddsd;
  920. INITDDSTRUCT(ddsd);
  921. ddsd.dwFlags = DDSD_CAPS|DDSD_WIDTH|DDSD_HEIGHT|DDSD_PIXELFORMAT;
  922. ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN|DDSCAPS_VIDEOMEMORY;
  923. ddsd.dwWidth = size.cx;
  924. ddsd.dwHeight = size.cy;
  925. ddsd.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
  927. if(compression >= 0x1000)
  928. {
  929. ddsd.ddpfPixelFormat.dwFlags = DDPF_FOURCC;
  930. ddsd.ddpfPixelFormat.dwFourCC = compression;
  931. }
  932. else if((compression == 0 || compression == 3) && (bpp == 15 || bpp == 16 || bpp == 24 || bpp == 32))
  933. {
  934. ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB;
  935. ddsd.ddpfPixelFormat.dwRGBBitCount = max(bpp, 16);
  936. ddsd.ddpfPixelFormat.dwRGBAlphaBitMask = (bpp == 16) ? 0x0000 : (bpp == 15) ? 0x8000 : 0xFF000000;
  937. ddsd.ddpfPixelFormat.dwRBitMask = (bpp == 16) ? 0xf800 : (bpp == 15) ? 0x7c00 : 0x00FF0000;
  938. ddsd.ddpfPixelFormat.dwGBitMask = (bpp == 16) ? 0x07e0 : (bpp == 15) ? 0x03e0 : 0x0000FF00;
  939. ddsd.ddpfPixelFormat.dwBBitMask = (bpp == 16) ? 0x001F : (bpp == 15) ? 0x001F : 0x000000FF;
  940. }
  942. return pDD->CreateSurface(&ddsd, pSurface, NULL);
  943. }
  945. //
  946. // CRM7AllocatorPresenter
  947. //
  949. CRM7AllocatorPresenter::CRM7AllocatorPresenter(HWND hWnd, HRESULT& hr) 
  950. : CDX7AllocatorPresenter(hWnd, hr)
  951. {
  952. }
  954. STDMETHODIMP CRM7AllocatorPresenter::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  955. {
  956.     CheckPointer(ppv, E_POINTER);
  958. return 
  959. QI2(IRMAVideoSurface)
  960. __super::NonDelegatingQueryInterface(riid, ppv);
  961. }
  963. HRESULT CRM7AllocatorPresenter::AllocSurfaces()
  964. {
  965.     CAutoLock cAutoLock(this);
  967. m_pVideoSurfaceOff = NULL;
  968. m_pVideoSurfaceYUY2 = NULL;
  970. DDSURFACEDESC2 ddsd;
  971. DDBLTFX fx;
  973. INITDDSTRUCT(ddsd);
  974. ddsd.dwFlags = DDSD_CAPS|DDSD_WIDTH|DDSD_HEIGHT|DDSD_PIXELFORMAT;
  975. ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
  976. ddsd.dwWidth = m_NativeVideoSize.cx;
  977. ddsd.dwHeight = m_NativeVideoSize.cy;
  978. ddsd.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
  979. ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB;
  980. ddsd.ddpfPixelFormat.dwRGBBitCount = 32;
  981. ddsd.ddpfPixelFormat.dwRGBAlphaBitMask = 0xFF000000;
  982. ddsd.ddpfPixelFormat.dwRBitMask = 0x00FF0000;
  983. ddsd.ddpfPixelFormat.dwGBitMask = 0x0000FF00;
  984. ddsd.ddpfPixelFormat.dwBBitMask = 0x000000FF;
  986. HRESULT hr = m_pDD->CreateSurface(&ddsd, &m_pVideoSurfaceOff, NULL);
  987. if(FAILED(hr)) return E_FAIL;
  989. INITDDSTRUCT(fx);
  990. fx.dwFillColor = 0;
  991. m_pVideoSurfaceOff->Blt(NULL, NULL, NULL, DDBLT_WAIT|DDBLT_COLORFILL, &fx);
  993. INITDDSTRUCT(ddsd);
  994. ddsd.dwFlags = DDSD_CAPS|DDSD_WIDTH|DDSD_HEIGHT|DDSD_PIXELFORMAT;
  995. ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
  996. ddsd.dwWidth = m_NativeVideoSize.cx;
  997. ddsd.dwHeight = m_NativeVideoSize.cy;
  998. ddsd.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
  999. ddsd.ddpfPixelFormat.dwFlags = DDPF_FOURCC;
  1000. ddsd.ddpfPixelFormat.dwYUVBitCount = 16;
  1001. ddsd.ddpfPixelFormat.dwFourCC = '2YUY';
  1003. hr = m_pDD->CreateSurface(&ddsd, &m_pVideoSurfaceYUY2, NULL);
  1005. if(FAILED(m_pVideoSurfaceOff->Blt(NULL, m_pVideoSurfaceYUY2, NULL, DDBLT_WAIT, NULL)))
  1006. m_pVideoSurfaceYUY2 = NULL;
  1008. if(m_pVideoSurfaceYUY2)
  1009. {
  1010. INITDDSTRUCT(fx);
  1011. fx.dwFillColor = 0x80108010;
  1012. m_pVideoSurfaceYUY2->Blt(NULL, NULL, NULL, DDBLT_WAIT|DDBLT_COLORFILL, &fx);
  1013. }
  1015. return __super::AllocSurfaces();
  1016. }
  1018. void CRM7AllocatorPresenter::DeleteSurfaces()
  1019. {
  1020.     CAutoLock cAutoLock(this);
  1022. m_pVideoSurfaceOff = NULL;
  1023. m_pVideoSurfaceYUY2 = NULL;
  1025. __super::DeleteSurfaces();
  1026. }
  1028. // IRMAVideoSurface
  1030. STDMETHODIMP CRM7AllocatorPresenter::Blt(UCHAR* pImageData, RMABitmapInfoHeader* pBitmapInfo, REF(PNxRect) inDestRect, REF(PNxRect) inSrcRect)
  1031. {
  1032. if(!m_pVideoSurface || !m_pVideoSurfaceOff)
  1033. return E_FAIL;
  1035. bool fRGB = false;
  1036. bool fYUY2 = false;
  1038. CRect src((RECT*)&inSrcRect), dst((RECT*)&inDestRect), src2(CPoint(0,0), src.Size());
  1039. if(src.Width() > dst.Width() || src.Height() > dst.Height())
  1040. return E_FAIL;
  1042. DDSURFACEDESC2 ddsd;
  1044. if(pBitmapInfo->biCompression == '024I')
  1045. {
  1046. DWORD pitch = pBitmapInfo->biWidth;
  1047. DWORD size = pitch*abs(pBitmapInfo->biHeight);
  1049. BYTE* y = pImageData + src.top*pitch + src.left;
  1050. BYTE* u = pImageData + size + src.top*(pitch/2) + src.left/2;
  1051. BYTE* v = pImageData + size + size/4 + src.top*(pitch/2) + src.left/2;
  1053. if(m_pVideoSurfaceYUY2)
  1054. {
  1055. INITDDSTRUCT(ddsd);
  1056. if(SUCCEEDED(m_pVideoSurfaceYUY2->Lock(src2, &ddsd, DDLOCK_WAIT|DDLOCK_SURFACEMEMORYPTR|DDLOCK_WRITEONLY, NULL)))
  1057. {
  1058. BitBltFromI420ToYUY2(src.Width(), src.Height(), (BYTE*)ddsd.lpSurface, ddsd.lPitch, y, u, v, pitch);
  1059. m_pVideoSurfaceYUY2->Unlock(src2);
  1060. fYUY2 = true;
  1061. }
  1062. }
  1063. else
  1064. {
  1065. INITDDSTRUCT(ddsd);
  1066. if(SUCCEEDED(m_pVideoSurfaceOff->Lock(src2, &ddsd, DDLOCK_WAIT|DDLOCK_SURFACEMEMORYPTR|DDLOCK_WRITEONLY, NULL)))
  1067. {
  1068. BitBltFromI420ToRGB(src.Width(), src.Height(), (BYTE*)ddsd.lpSurface, ddsd.lPitch, ddsd.ddpfPixelFormat.dwRGBBitCount, y, u, v, pitch);
  1069. m_pVideoSurfaceOff->Unlock(src2);
  1070. fRGB = true;
  1071. }
  1072. }
  1073. }
  1074. else if(pBitmapInfo->biCompression == '2YUY')
  1075. {
  1076. DWORD w = pBitmapInfo->biWidth;
  1077. DWORD h = abs(pBitmapInfo->biHeight);
  1078. DWORD pitch = pBitmapInfo->biWidth*2;
  1080. BYTE* yvyu = pImageData + src.top*pitch + src.left*2;
  1082. if(m_pVideoSurfaceYUY2)
  1083. {
  1084. INITDDSTRUCT(ddsd);
  1085. if(SUCCEEDED(m_pVideoSurfaceYUY2->Lock(src2, &ddsd, DDLOCK_WAIT|DDLOCK_SURFACEMEMORYPTR|DDLOCK_WRITEONLY, NULL)))
  1086. {
  1087. BitBltFromYUY2ToYUY2(src.Width(), src.Height(), (BYTE*)ddsd.lpSurface, ddsd.lPitch, yvyu, pitch);
  1088. m_pVideoSurfaceYUY2->Unlock(src2);
  1089. fYUY2 = true;
  1090. }
  1091. }
  1092. else
  1093. {
  1094. INITDDSTRUCT(ddsd);
  1095. if(SUCCEEDED(m_pVideoSurfaceOff->Lock(src2, &ddsd, DDLOCK_WAIT|DDLOCK_SURFACEMEMORYPTR|DDLOCK_WRITEONLY, NULL)))
  1096. {
  1097. BitBltFromYUY2ToRGB(src.Width(), src.Height(), (BYTE*)ddsd.lpSurface, ddsd.lPitch, ddsd.ddpfPixelFormat.dwRGBBitCount, yvyu, pitch);
  1098. m_pVideoSurfaceOff->Unlock(src2);
  1099. fRGB = true;
  1100. }
  1101. }
  1102. }
  1103. else if(pBitmapInfo->biCompression == 0 || pBitmapInfo->biCompression == 3
  1104.  || pBitmapInfo->biCompression == 'BGRA')
  1105. {
  1106. DWORD w = pBitmapInfo->biWidth;
  1107. DWORD h = abs(pBitmapInfo->biHeight);
  1108. DWORD pitch = pBitmapInfo->biWidth*pBitmapInfo->biBitCount>>3;
  1110. BYTE* rgb = pImageData + src.top*pitch + src.left*(pBitmapInfo->biBitCount>>3);
  1112. INITDDSTRUCT(ddsd);
  1113. if(SUCCEEDED(m_pVideoSurfaceOff->Lock(src2, &ddsd, DDLOCK_WAIT|DDLOCK_SURFACEMEMORYPTR|DDLOCK_WRITEONLY, NULL)))
  1114. {
  1115. BYTE* lpSurface = (BYTE*)ddsd.lpSurface;
  1116. if(pBitmapInfo->biHeight > 0) {lpSurface += ddsd.lPitch*(src.Height()-1); ddsd.lPitch = -ddsd.lPitch;}
  1117. BitBltFromRGBToRGB(src.Width(), src.Height(), lpSurface, ddsd.lPitch, ddsd.ddpfPixelFormat.dwRGBBitCount, rgb, pitch, pBitmapInfo->biBitCount);
  1118. fRGB = true;
  1119. m_pVideoSurfaceOff->Unlock(src2);
  1120. }
  1121. }
  1123. if(!fRGB && !fYUY2)
  1124. {
  1125. DDBLTFX fx;
  1126. INITDDSTRUCT(fx);
  1127. fx.dwFillColor = 0;
  1128. m_pVideoSurfaceOff->Blt(NULL, NULL, NULL, DDBLT_WAIT|DDBLT_COLORFILL, &fx);
  1130. HDC hDC;
  1131. if(SUCCEEDED(m_pVideoSurfaceOff->GetDC(&hDC)))
  1132. {
  1133. CString str;
  1134. str.Format(_T("Sorry, this format is not supported"));
  1136. SetBkColor(hDC, 0);
  1137. SetTextColor(hDC, 0x404040);
  1138. TextOut(hDC, 10, 10, str, str.GetLength());
  1140. m_pVideoSurfaceOff->ReleaseDC(hDC);
  1142. fRGB = true;
  1143. }
  1144. }
  1147. HRESULT hr;
  1149. if(fRGB)
  1150. hr = m_pVideoSurface->Blt(dst, m_pVideoSurfaceOff, src2, DDBLT_WAIT, NULL);
  1151. if(fYUY2)
  1152. hr = m_pVideoSurface->Blt(dst, m_pVideoSurfaceYUY2, src2, DDBLT_WAIT, NULL);
  1153.     
  1154. Paint(true);
  1156. return PNR_OK;
  1157. }
  1159. STDMETHODIMP CRM7AllocatorPresenter::BeginOptimizedBlt(RMABitmapInfoHeader* pBitmapInfo)
  1160. {
  1161.     CAutoLock cAutoLock(this);
  1162. DeleteSurfaces();
  1163. m_NativeVideoSize = m_AspectRatio = CSize(pBitmapInfo->biWidth, abs(pBitmapInfo->biHeight));
  1164. if(FAILED(AllocSurfaces())) return E_FAIL;
  1165. return PNR_NOTIMPL;
  1166. }
  1168. STDMETHODIMP CRM7AllocatorPresenter::OptimizedBlt(UCHAR* pImageBits, REF(PNxRect) rDestRect, REF(PNxRect) rSrcRect)
  1169. {
  1170. return PNR_NOTIMPL;
  1171. }
  1173. STDMETHODIMP CRM7AllocatorPresenter::EndOptimizedBlt()
  1174. {
  1175. return PNR_NOTIMPL;
  1176. }
  1178. STDMETHODIMP CRM7AllocatorPresenter::GetOptimizedFormat(REF(RMA_COMPRESSION_TYPE) ulType)
  1179. {
  1180. return PNR_NOTIMPL;
  1181. }
  1183. STDMETHODIMP CRM7AllocatorPresenter::GetPreferredFormat(REF(RMA_COMPRESSION_TYPE) ulType)
  1184. {
  1185. ulType = RMA_I420;
  1186. return PNR_OK;
  1187. }
  1189. //
  1190. // CQT7AllocatorPresenter
  1191. //
  1193. CQT7AllocatorPresenter::CQT7AllocatorPresenter(HWND hWnd, HRESULT& hr) 
  1194. : CDX7AllocatorPresenter(hWnd, hr)
  1195. {
  1196. }
  1198. STDMETHODIMP CQT7AllocatorPresenter::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  1199. {
  1200.     CheckPointer(ppv, E_POINTER);
  1202. return 
  1203. QI(IQTVideoSurface)
  1204. __super::NonDelegatingQueryInterface(riid, ppv);
  1205. }
  1207. HRESULT CQT7AllocatorPresenter::AllocSurfaces()
  1208. {
  1209.     CAutoLock cAutoLock(this);
  1211. m_pVideoSurfaceOff = NULL;
  1213. DDSURFACEDESC2 ddsd;
  1214. INITDDSTRUCT(ddsd);
  1215. ddsd.dwFlags = DDSD_CAPS|DDSD_WIDTH|DDSD_HEIGHT|DDSD_PIXELFORMAT;
  1216. ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
  1217. ddsd.dwWidth = m_NativeVideoSize.cx;
  1218. ddsd.dwHeight = m_NativeVideoSize.cy;
  1219. ddsd.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
  1220. ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB;
  1221. ddsd.ddpfPixelFormat.dwRGBBitCount = 32;
  1222. ddsd.ddpfPixelFormat.dwRGBAlphaBitMask = 0xFF000000;
  1223. ddsd.ddpfPixelFormat.dwRBitMask = 0x00FF0000;
  1224. ddsd.ddpfPixelFormat.dwGBitMask = 0x0000FF00;
  1225. ddsd.ddpfPixelFormat.dwBBitMask = 0x000000FF;
  1227. HRESULT hr = m_pDD->CreateSurface(&ddsd, &m_pVideoSurfaceOff, NULL);
  1228. if(FAILED(hr)) return E_FAIL;
  1230. DDBLTFX fx;
  1231. INITDDSTRUCT(fx);
  1232. fx.dwFillColor = 0;
  1233. m_pVideoSurfaceOff->Blt(NULL, NULL, NULL, DDBLT_WAIT|DDBLT_COLORFILL, &fx);
  1235. return __super::AllocSurfaces();
  1236. }
  1238. void CQT7AllocatorPresenter::DeleteSurfaces()
  1239. {
  1240.     CAutoLock cAutoLock(this);
  1242. m_pVideoSurfaceOff = NULL;
  1244. __super::DeleteSurfaces();
  1245. }
  1247. // IQTVideoSurface
  1249. STDMETHODIMP CQT7AllocatorPresenter::BeginBlt(const BITMAP& bm)
  1250. {
  1251.     CAutoLock cAutoLock(this);
  1253. DeleteSurfaces();
  1255. m_NativeVideoSize = m_AspectRatio = CSize(bm.bmWidth, abs(bm.bmHeight));
  1257. HRESULT hr;
  1258. if(FAILED(hr = AllocSurfaces()))
  1259. return hr;
  1261. return S_OK;
  1262. }
  1264. STDMETHODIMP CQT7AllocatorPresenter::DoBlt(const BITMAP& bm)
  1265. {
  1266. if(!m_pVideoSurface || !m_pVideoSurfaceOff)
  1267. return E_FAIL;
  1269. bool fOk = false;
  1271. DDSURFACEDESC2 ddsd;
  1272. INITDDSTRUCT(ddsd);
  1273. if(FAILED(m_pVideoSurfaceOff->GetSurfaceDesc(&ddsd)))
  1274. return E_FAIL;
  1276. int w = bm.bmWidth;
  1277. int h = abs(bm.bmHeight);
  1278. int bpp = bm.bmBitsPixel;
  1280. if((bpp == 16 || bpp == 24 || bpp == 32) && w == ddsd.dwWidth && h == ddsd.dwHeight)
  1281. {
  1282. INITDDSTRUCT(ddsd);
  1283. if(SUCCEEDED(m_pVideoSurfaceOff->Lock(NULL, &ddsd, DDLOCK_WAIT|DDLOCK_SURFACEMEMORYPTR|DDLOCK_WRITEONLY, NULL)))
  1284. {
  1285. BitBltFromRGBToRGB(
  1286. w, h, 
  1287. (BYTE*)ddsd.lpSurface, ddsd.lPitch, ddsd.ddpfPixelFormat.dwRGBBitCount,
  1288. (BYTE*)bm.bmBits, bm.bmWidthBytes, bm.bmBitsPixel);
  1289. m_pVideoSurfaceOff->Unlock(NULL);
  1290. fOk = true;
  1291. }
  1292. }
  1294. if(!fOk)
  1295. {
  1296. DDBLTFX fx;
  1297. INITDDSTRUCT(fx);
  1298. fx.dwFillColor = 0;
  1299. m_pVideoSurfaceOff->Blt(NULL, NULL, NULL, DDBLT_WAIT|DDBLT_COLORFILL, &fx);
  1301. HDC hDC;
  1302. if(SUCCEEDED(m_pVideoSurfaceOff->GetDC(&hDC)))
  1303. {
  1304. CString str;
  1305. str.Format(_T("Sorry, this format is not supported"));
  1307. SetBkColor(hDC, 0);
  1308. SetTextColor(hDC, 0x404040);
  1309. TextOut(hDC, 10, 10, str, str.GetLength());
  1311. m_pVideoSurfaceOff->ReleaseDC(hDC);
  1313. }
  1314. }
  1316. m_pVideoSurface->Blt(NULL, m_pVideoSurfaceOff, NULL, DDBLT_WAIT, NULL);
  1318. Paint(true);
  1320. return S_OK;
  1321. }