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

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

多媒体编程

开发平台：

Visual C++

DX9AllocatorPresenter.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 <Videoacc.h>
  30. #include <initguid.h>
  31. #include "DX9AllocatorPresenter.h"
  32. #include <d3d9.h>
  33. #include <d3dx9.h>
  34. #include <Vmr9.h>
  35. #include "....SubPicDX9SubPic.h"
  36. #include "......includeRealMediapntypes.h"
  37. #include "......includeRealMediapnwintyp.h"
  38. #include "......includeRealMediapncom.h"
  39. #include "......includeRealMediarmavsurf.h"
  40. #include "IQTVideoSurface.h"
  42. #include "MacrovisionKicker.h"
  43. #include "IPinHook.h"
  45. #include "PixelShaderCompiler.h"
  47. bool IsVMR9InGraph(IFilterGraph* pFG)
  48. {
  49. BeginEnumFilters(pFG, pEF, pBF)
  50. if(CComQIPtr<IVMRWindowlessControl9>(pBF)) return(true);
  51. EndEnumFilters
  52. return(false);
  53. }
  55. namespace DSObjects
  56. {
  58. class CDX9AllocatorPresenter
  59. : public ISubPicAllocatorPresenterImpl
  60. {
  61. protected:
  62. CSize m_ScreenSize;
  63. bool m_fVMRSyncFix;
  65. CComPtr<IDirect3D9> m_pD3D;
  66.     CComPtr<IDirect3DDevice9> m_pD3DDev;
  67. CComPtr<IDirect3DTexture9> m_pVideoTexture[2];
  68. CComPtr<IDirect3DSurface9> m_pVideoSurface[2];
  69. CComPtr<IDirect3DPixelShader9> m_pPixelShader, m_pResizerPixelShader[4];
  70. D3DTEXTUREFILTERTYPE m_Filter;
  72. CAutoPtr<CPixelShaderCompiler> m_pPSC;
  74. virtual HRESULT CreateDevice();
  75. virtual HRESULT AllocSurfaces();
  76. virtual void DeleteSurfaces();
  78.     UINT  GetAdapter(IDirect3D9 *pD3D);
  80. public:
  81. CDX9AllocatorPresenter(HWND hWnd, HRESULT& hr);
  83. // ISubPicAllocatorPresenter
  84. STDMETHODIMP CreateRenderer(IUnknown** ppRenderer);
  85. STDMETHODIMP_(bool) Paint(bool fAll);
  86. STDMETHODIMP GetDIB(BYTE* lpDib, DWORD* size);
  87. STDMETHODIMP SetPixelShader(LPCSTR pSrcData, LPCSTR pTarget);
  88. };
  90. class CVMR9AllocatorPresenter
  91. : public CDX9AllocatorPresenter
  92. , public IVMRSurfaceAllocator9
  93. , public IVMRImagePresenter9
  94. , public IVMRWindowlessControl9
  95. {
  96. protected:
  97. CComPtr<IVMRSurfaceAllocatorNotify9> m_pIVMRSurfAllocNotify;
  98. CInterfaceArray<IDirect3DSurface9> m_pSurfaces;
  100. HRESULT CreateDevice();
  101. void DeleteSurfaces();
  103. bool m_fUseInternalTimer;
  105. public:
  106. CVMR9AllocatorPresenter(HWND hWnd, HRESULT& hr);
  108. DECLARE_IUNKNOWN
  109.     STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, void** ppv);
  111. // ISubPicAllocatorPresenter
  112. STDMETHODIMP CreateRenderer(IUnknown** ppRenderer);
  113. STDMETHODIMP_(void) SetTime(REFERENCE_TIME rtNow);
  115.     // IVMRSurfaceAllocator9
  116.     STDMETHODIMP InitializeDevice(DWORD_PTR dwUserID, VMR9AllocationInfo* lpAllocInfo, DWORD* lpNumBuffers);
  117.     STDMETHODIMP TerminateDevice(DWORD_PTR dwID);
  118.     STDMETHODIMP GetSurface(DWORD_PTR dwUserID, DWORD SurfaceIndex, DWORD SurfaceFlags, IDirect3DSurface9** lplpSurface);
  119.     STDMETHODIMP AdviseNotify(IVMRSurfaceAllocatorNotify9* lpIVMRSurfAllocNotify);
  121.     // IVMRImagePresenter9
  122.     STDMETHODIMP StartPresenting(DWORD_PTR dwUserID);
  123.     STDMETHODIMP StopPresenting(DWORD_PTR dwUserID);
  124.     STDMETHODIMP PresentImage(DWORD_PTR dwUserID, VMR9PresentationInfo* lpPresInfo);
  126. // IVMRWindowlessControl9
  127. STDMETHODIMP GetNativeVideoSize(LONG* lpWidth, LONG* lpHeight, LONG* lpARWidth, LONG* lpARHeight);
  128. STDMETHODIMP GetMinIdealVideoSize(LONG* lpWidth, LONG* lpHeight);
  129. STDMETHODIMP GetMaxIdealVideoSize(LONG* lpWidth, LONG* lpHeight);
  130. STDMETHODIMP SetVideoPosition(const LPRECT lpSRCRect, const LPRECT lpDSTRect);
  131.     STDMETHODIMP GetVideoPosition(LPRECT lpSRCRect, LPRECT lpDSTRect);
  132. STDMETHODIMP GetAspectRatioMode(DWORD* lpAspectRatioMode);
  133. STDMETHODIMP SetAspectRatioMode(DWORD AspectRatioMode);
  134. STDMETHODIMP SetVideoClippingWindow(HWND hwnd);
  135. STDMETHODIMP RepaintVideo(HWND hwnd, HDC hdc);
  136. STDMETHODIMP DisplayModeChanged();
  137. STDMETHODIMP GetCurrentImage(BYTE** lpDib);
  138. STDMETHODIMP SetBorderColor(COLORREF Clr);
  139. STDMETHODIMP GetBorderColor(COLORREF* lpClr);
  140. };
  142. class CRM9AllocatorPresenter
  143. : public CDX9AllocatorPresenter
  144. , public IRMAVideoSurface
  145. {
  146. CComPtr<IDirect3DSurface9> m_pVideoSurfaceOff;
  147. CComPtr<IDirect3DSurface9> m_pVideoSurfaceYUY2;
  149.     RMABitmapInfoHeader m_bitmapInfo;
  150.     RMABitmapInfoHeader m_lastBitmapInfo;
  152. protected:
  153. HRESULT AllocSurfaces();
  154. void DeleteSurfaces();
  156. public:
  157. CRM9AllocatorPresenter(HWND hWnd, HRESULT& hr);
  159. DECLARE_IUNKNOWN
  160.     STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, void** ppv);
  162. // IRMAVideoSurface
  163.     STDMETHODIMP Blt(UCHAR* pImageData, RMABitmapInfoHeader* pBitmapInfo, REF(PNxRect) inDestRect, REF(PNxRect) inSrcRect);
  164. STDMETHODIMP BeginOptimizedBlt(RMABitmapInfoHeader* pBitmapInfo);
  165. STDMETHODIMP OptimizedBlt(UCHAR* pImageBits, REF(PNxRect) rDestRect, REF(PNxRect) rSrcRect);
  166. STDMETHODIMP EndOptimizedBlt();
  167. STDMETHODIMP GetOptimizedFormat(REF(RMA_COMPRESSION_TYPE) ulType);
  168.     STDMETHODIMP GetPreferredFormat(REF(RMA_COMPRESSION_TYPE) ulType);
  169. };
  171. class CQT9AllocatorPresenter
  172. : public CDX9AllocatorPresenter
  173. , public IQTVideoSurface
  174. {
  175. CComPtr<IDirect3DSurface9> m_pVideoSurfaceOff;
  177. protected:
  178.  HRESULT AllocSurfaces();
  179.  void DeleteSurfaces();
  181. public:
  182. CQT9AllocatorPresenter(HWND hWnd, HRESULT& hr);
  184. DECLARE_IUNKNOWN
  185.     STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, void** ppv);
  187. // IQTVideoSurface
  188. STDMETHODIMP BeginBlt(const BITMAP& bm);
  189. STDMETHODIMP DoBlt(const BITMAP& bm);
  190. };
  192. }
  193. using namespace DSObjects;
  195. //
  197. HRESULT CreateAP9(const CLSID& clsid, HWND hWnd, ISubPicAllocatorPresenter** ppAP)
  198. {
  199. CheckPointer(ppAP, E_POINTER);
  201. *ppAP = NULL;
  203. HRESULT hr;
  204. if(clsid == CLSID_VMR9AllocatorPresenter && !(*ppAP = new CVMR9AllocatorPresenter(hWnd, hr))
  205. || clsid == CLSID_RM9AllocatorPresenter && !(*ppAP = new CRM9AllocatorPresenter(hWnd, hr))
  206. || clsid == CLSID_QT9AllocatorPresenter && !(*ppAP = new CQT9AllocatorPresenter(hWnd, hr)))
  207. return E_OUTOFMEMORY;
  209. if(*ppAP == NULL)
  210. return E_FAIL;
  212. (*ppAP)->AddRef();
  214. if(FAILED(hr))
  215. {
  216. (*ppAP)->Release();
  217. *ppAP = NULL;
  218. }
  220. return hr;
  221. }
  223. //
  225. static HRESULT TextureBlt(CComPtr<IDirect3DTexture9> pTexture, Vector dst[4], CRect src, DWORD filter = D3DTEXF_LINEAR)
  226. {
  227. if(!pTexture)
  228. return E_POINTER;
  230. CComPtr<IDirect3DDevice9> pD3DDev;
  231. if(FAILED(pTexture->GetDevice(&pD3DDev)) || !pD3DDev)
  232. return E_FAIL;
  234. HRESULT hr;
  236.     do
  237. {
  238. D3DSURFACE_DESC d3dsd;
  239. ZeroMemory(&d3dsd, sizeof(d3dsd));
  240. if(FAILED(pTexture->GetLevelDesc(0, &d3dsd)))
  241. break;
  243.         float w = (float)d3dsd.Width;
  244.         float h = (float)d3dsd.Height;
  246. struct
  247. {
  248. float x, y, z, rhw;
  249. float tu, tv;
  250. }
  251. pVertices[] =
  252. {
  253. // {(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 },
  254. // {(float)(dst[0].x + 2*(dst[1].x-dst[0].x)), (float)(dst[0].y + 2*(dst[1].y-dst[0].y)), (float)dst[1].z, 1.0f/(float)dst[1].z, (float)(src.left + 2*(src.right-src.left)) / w, (float)src.top / h},
  255. // {(float)(dst[0].x + 2*(dst[2].x-dst[0].x)), (float)(dst[0].y + 2*(dst[2].y-dst[0].y)), (float)dst[2].z, 1.0f/(float)dst[2].z, (float)src.left / w, (float)(src.top + 2*(src.bottom-src.top)) / h},
  256. {(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},
  257. {(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},
  258. {(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},
  259. {(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},
  260. };
  262. for(int i = 0; i < countof(pVertices); i++)
  263. {
  264. pVertices[i].x -= 0.5;
  265. pVertices[i].y -= 0.5;
  266. }
  268.         hr = pD3DDev->SetTexture(0, pTexture);
  270.         hr = pD3DDev->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
  271.         hr = pD3DDev->SetRenderState(D3DRS_LIGHTING, FALSE);
  272. hr = pD3DDev->SetRenderState(D3DRS_ZENABLE, FALSE);
  273.      hr = pD3DDev->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
  274. hr = pD3DDev->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); 
  276. hr = pD3DDev->SetSamplerState(0, D3DSAMP_MAGFILTER, filter);
  277.         hr = pD3DDev->SetSamplerState(0, D3DSAMP_MINFILTER, filter);
  278.         hr = pD3DDev->SetSamplerState(0, D3DSAMP_MIPFILTER, filter);
  280. hr = pD3DDev->SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
  281. hr = pD3DDev->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
  283. //
  285. if(FAILED(hr = pD3DDev->BeginScene()))
  286. break;
  288.         hr = pD3DDev->SetFVF(D3DFVF_XYZRHW | D3DFVF_TEX1);
  289. //     hr = pD3DDev->DrawPrimitiveUP(D3DPT_TRIANGLELIST, 1, pVertices, sizeof(pVertices[0]));
  290. hr = pD3DDev->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, 2, pVertices, sizeof(pVertices[0]));
  292. hr = pD3DDev->EndScene();
  294.         //
  296. pD3DDev->SetTexture(0, NULL);
  298. return S_OK;
  299.     }
  300. while(0);
  302.     return E_FAIL;
  303. }
  305. static HRESULT TextureBlt(CComPtr<IDirect3DTexture9> pTexture, CRect dst, CRect src, DWORD filter = D3DTEXF_LINEAR)
  306. {
  307. if(!pTexture)
  308. return E_POINTER;
  310. CComPtr<IDirect3DDevice9> pD3DDev;
  311. if(FAILED(pTexture->GetDevice(&pD3DDev)) || !pD3DDev)
  312. return E_FAIL;
  314. HRESULT hr;
  316.     do
  317. {
  318. D3DSURFACE_DESC d3dsd;
  319. ZeroMemory(&d3dsd, sizeof(d3dsd));
  320. if(FAILED(pTexture->GetLevelDesc(0, &d3dsd)))
  321. break;
  323.         float w = (float)d3dsd.Width;
  324.         float h = (float)d3dsd.Height;
  326. struct
  327. {
  328. float x, y, z, rhw;
  329. float tu, tv;
  330. }
  331. pVertices[] =
  332. {
  333. {(float)dst.left, (float)dst.top, 0.5f, 2.0f, (float)src.left / w, (float)src.top / h},
  334. {(float)dst.right, (float)dst.top, 0.5f, 2.0f, (float)src.right / w, (float)src.top / h},
  335. {(float)dst.left, (float)dst.bottom, 0.5f, 2.0f, (float)src.left / w, (float)src.bottom / h},
  336. {(float)dst.right, (float)dst.bottom, 0.5f, 2.0f, (float)src.right / w, (float)src.bottom / h},
  337. };
  339. for(int i = 0; i < countof(pVertices); i++)
  340. {
  341. pVertices[i].x -= 0.5;
  342. pVertices[i].y -= 0.5;
  343. }
  345.         hr = pD3DDev->SetTexture(0, pTexture);
  347.         hr = pD3DDev->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
  348.         hr = pD3DDev->SetRenderState(D3DRS_LIGHTING, FALSE);
  349. hr = pD3DDev->SetRenderState(D3DRS_ZENABLE, FALSE);
  350.      hr = pD3DDev->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
  351. hr = pD3DDev->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); 
  353. hr = pD3DDev->SetSamplerState(0, D3DSAMP_MAGFILTER, filter);
  354.         hr = pD3DDev->SetSamplerState(0, D3DSAMP_MINFILTER, filter);
  355.         hr = pD3DDev->SetSamplerState(0, D3DSAMP_MIPFILTER, filter);
  357. hr = pD3DDev->SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
  358. hr = pD3DDev->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
  360. //
  362. if(FAILED(hr = pD3DDev->BeginScene()))
  363. break;
  365.         hr = pD3DDev->SetFVF(D3DFVF_XYZRHW | D3DFVF_TEX1);
  366. hr = pD3DDev->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, 2, pVertices, sizeof(pVertices[0]));
  368. hr = pD3DDev->EndScene();
  370.         //
  372. pD3DDev->SetTexture(0, NULL);
  374. return S_OK;
  375.     }
  376. while(0);
  378.     return E_FAIL;
  379. }
  381. // CDX9AllocatorPresenter
  383. CDX9AllocatorPresenter::CDX9AllocatorPresenter(HWND hWnd, HRESULT& hr) 
  384. : ISubPicAllocatorPresenterImpl(hWnd)
  385. , m_ScreenSize(0, 0)
  386. {
  387.     if(!IsWindow(m_hWnd))
  388.     {
  389.         hr = E_INVALIDARG;
  390.         return;
  391.     }
  393. m_pD3D.Attach(Direct3DCreate9(D3D_SDK_VERSION));
  394. if(!m_pD3D) m_pD3D.Attach(Direct3DCreate9(D3D_SDK_VERSION));
  396. if(!m_pD3D)
  397. {
  398. hr = E_FAIL;
  399. return;
  400. }
  402. GetWindowRect(m_hWnd, &m_WindowRect);
  404. hr = CreateDevice();
  405. }
  407. HRESULT CDX9AllocatorPresenter::CreateDevice()
  408. {
  409. m_pPSC.Free();
  410.     m_pD3DDev = NULL;
  412. D3DDISPLAYMODE d3ddm;
  413. ZeroMemory(&d3ddm, sizeof(d3ddm));
  414. if(FAILED(m_pD3D->GetAdapterDisplayMode(GetAdapter(m_pD3D), &d3ddm)))
  415. return E_UNEXPECTED;
  417. m_ScreenSize.SetSize(d3ddm.Width, d3ddm.Height);
  419.     D3DPRESENT_PARAMETERS pp;
  420.     ZeroMemory(&pp, sizeof(pp));
  421.     pp.Windowed = TRUE;
  422.     pp.hDeviceWindow = m_hWnd;
  423.     pp.SwapEffect = D3DSWAPEFFECT_COPY;
  424. pp.Flags = D3DPRESENTFLAG_VIDEO;
  425. pp.BackBufferWidth = d3ddm.Width;
  426. pp.BackBufferHeight = d3ddm.Height;
  428. if(m_fVMRSyncFix = AfxGetMyApp()->m_s.fVMRSyncFix)
  429. pp.Flags = D3DPRESENTFLAG_LOCKABLE_BACKBUFFER;
  431. HRESULT hr = m_pD3D->CreateDevice(
  432. GetAdapter(m_pD3D), D3DDEVTYPE_HAL, m_hWnd,
  433. D3DCREATE_SOFTWARE_VERTEXPROCESSING|D3DCREATE_MULTITHREADED, //D3DCREATE_MANAGED 
  434. &pp, &m_pD3DDev);
  435. if(FAILED(hr))
  436. return hr;
  438. m_pPSC.Attach(new CPixelShaderCompiler(m_pD3DDev, true));
  440. //
  442. m_Filter = D3DTEXF_NONE;
  444. D3DCAPS9 caps;
  445.     ZeroMemory(&caps, sizeof(caps));
  446. m_pD3DDev->GetDeviceCaps(&caps);
  447. if((caps.StretchRectFilterCaps&D3DPTFILTERCAPS_MINFLINEAR)
  448. && (caps.StretchRectFilterCaps&D3DPTFILTERCAPS_MAGFLINEAR))
  449. m_Filter = D3DTEXF_LINEAR;
  451. //
  453. if(caps.PixelShaderVersion >= D3DVS_VERSION(2, 0))
  454. {
  455. CStringA data;
  456. if(LoadResource(IDF_SHADER_RESIZER, data, _T("FILE")))
  457. {
  458. m_pPSC->CompileShader(data, "main_bilinear", "ps_2_0", 0, &m_pResizerPixelShader[0]);
  460. {
  461. CStringA str = data;
  462. str.Replace("_The_Value_Of_A_Is_Set_Here_", "(-0.60)");
  463. m_pPSC->CompileShader(str, "main_bicubic", "ps_2_0", 0, &m_pResizerPixelShader[1]);
  464. }
  466. {
  467. CStringA str = data;
  468. str.Replace("_The_Value_Of_A_Is_Set_Here_", "(-0.75)");
  469. m_pPSC->CompileShader(str, "main_bicubic", "ps_2_0", 0, &m_pResizerPixelShader[2]);
  470. }
  472. {
  473. CStringA str = data;
  474. str.Replace("_The_Value_Of_A_Is_Set_Here_", "(-1.00)");
  475. m_pPSC->CompileShader(str, "main_bicubic", "ps_2_0", 0, &m_pResizerPixelShader[3]);
  476. }
  477. }
  478. }
  480. //
  482. CComPtr<ISubPicProvider> pSubPicProvider;
  483. if(m_pSubPicQueue) m_pSubPicQueue->GetSubPicProvider(&pSubPicProvider);
  485. CSize size;
  486. switch(AfxGetAppSettings().nSPCMaxRes)
  487. {
  488. case 0: default: size = m_ScreenSize; break;
  489. case 1: size.SetSize(1024, 768); break;
  490. case 2: size.SetSize(800, 600); break;
  491. case 3: size.SetSize(640, 480); break;
  492. case 4: size.SetSize(512, 384); break;
  493. case 5: size.SetSize(384, 288); break;
  494. }
  496. if(m_pAllocator)
  497. {
  498. m_pAllocator->ChangeDevice(m_pD3DDev);
  499. }
  500. else
  501. {
  502. m_pAllocator = new CDX9SubPicAllocator(m_pD3DDev, size, AfxGetAppSettings().fSPCPow2Tex);
  503. if(!m_pAllocator)
  504. return E_FAIL;
  505. }
  507. hr = S_OK;
  508. m_pSubPicQueue = AfxGetAppSettings().nSPCSize > 0 
  509. ? (ISubPicQueue*)new CSubPicQueue(AfxGetAppSettings().nSPCSize, m_pAllocator, &hr)
  510. : (ISubPicQueue*)new CSubPicQueueNoThread(m_pAllocator, &hr);
  511. if(!m_pSubPicQueue || FAILED(hr))
  512. return E_FAIL;
  514. if(pSubPicProvider) m_pSubPicQueue->SetSubPicProvider(pSubPicProvider);
  516. return S_OK;
  517. } 
  519. HRESULT CDX9AllocatorPresenter::AllocSurfaces()
  520. {
  521.     CAutoLock cAutoLock(this);
  523. AppSettings& s = AfxGetAppSettings();
  525. m_pVideoTexture[0] = NULL;
  526. m_pVideoTexture[1] = NULL;
  527. m_pVideoSurface[0] = NULL;
  528. m_pVideoSurface[1] = NULL;
  530. HRESULT hr;
  532. if(s.iAPSurfaceUsage == VIDRNDT_AP_TEXTURE2D || s.iAPSurfaceUsage == VIDRNDT_AP_TEXTURE3D)
  533. {
  534. if(FAILED(hr = m_pD3DDev->CreateTexture(
  535. m_NativeVideoSize.cx, m_NativeVideoSize.cy, 1, D3DUSAGE_RENDERTARGET, /*D3DFMT_X8R8G8B8*/D3DFMT_A8R8G8B8, 
  536. D3DPOOL_DEFAULT, &m_pVideoTexture[0], NULL)))
  537. return hr;
  539. if(FAILED(hr = m_pVideoTexture[0]->GetSurfaceLevel(0, &m_pVideoSurface[0])))
  540. return hr;
  542. if(s.iAPSurfaceUsage == VIDRNDT_AP_TEXTURE3D)
  543. {
  544. if(FAILED(hr = m_pD3DDev->CreateTexture(
  545. m_NativeVideoSize.cx, m_NativeVideoSize.cy, 1, D3DUSAGE_RENDERTARGET, /*D3DFMT_X8R8G8B8*/D3DFMT_A8R8G8B8, 
  546. D3DPOOL_DEFAULT, &m_pVideoTexture[1], NULL)))
  547. return hr;
  549. if(FAILED(hr = m_pVideoTexture[1]->GetSurfaceLevel(0, &m_pVideoSurface[1])))
  550. return hr;
  551. }
  553. if(s.iAPSurfaceUsage == VIDRNDT_AP_TEXTURE2D)
  554. m_pVideoTexture[0] = NULL, m_pVideoTexture[1] = NULL;
  555. }
  556. else
  557. {
  558. if(FAILED(hr = m_pD3DDev->CreateOffscreenPlainSurface(
  559. m_NativeVideoSize.cx, m_NativeVideoSize.cy, D3DFMT_X8R8G8B8/*D3DFMT_A8R8G8B8*/, 
  560. D3DPOOL_DEFAULT, &m_pVideoSurface[0], NULL)))
  561. return hr;
  562. }
  564. hr = m_pD3DDev->ColorFill(m_pVideoSurface[0], NULL, 0);
  566. return S_OK;
  567. }
  569. void CDX9AllocatorPresenter::DeleteSurfaces()
  570. {
  571.     CAutoLock cAutoLock(this);
  573. m_pVideoTexture[0] = m_pVideoTexture[1] = NULL;
  574. m_pVideoSurface[0] = m_pVideoSurface[1] = NULL;
  575. }
  577. UINT CDX9AllocatorPresenter::GetAdapter(IDirect3D9 *pD3D)
  578. {
  579. if(m_hWnd == NULL || pD3D == NULL)
  580. return D3DADAPTER_DEFAULT;
  582. HMONITOR hMonitor = MonitorFromWindow(m_hWnd, MONITOR_DEFAULTTONEAREST);
  583. if(hMonitor == NULL) return D3DADAPTER_DEFAULT;
  585. for(UINT adp = 0, num_adp = pD3D->GetAdapterCount(); adp < num_adp; ++adp)
  586. {
  587. HMONITOR hAdpMon = pD3D->GetAdapterMonitor(adp);
  588. if(hAdpMon == hMonitor) return adp;
  589. }
  591. return D3DADAPTER_DEFAULT;
  592. }
  594. // ISubPicAllocatorPresenter
  596. STDMETHODIMP CDX9AllocatorPresenter::CreateRenderer(IUnknown** ppRenderer)
  597. {
  598. return E_NOTIMPL;
  599. }
  601. static bool ClipToSurface(IDirect3DSurface9* pSurface, CRect& s, CRect& d)   
  602. {   
  603. D3DSURFACE_DESC d3dsd;   
  604. ZeroMemory(&d3dsd, sizeof(d3dsd));   
  605. if(FAILED(pSurface->GetDesc(&d3dsd)))   
  606. return(false);   
  608. int w = d3dsd.Width, h = d3dsd.Height;   
  609. int sw = s.Width(), sh = s.Height();   
  610. int dw = d.Width(), dh = d.Height();   
  612. if(d.left >= w || d.right < 0 || d.top >= h || d.bottom < 0   
  613. || sw <= 0 || sh <= 0 || dw <= 0 || dh <= 0)   
  614. {   
  615. s.SetRectEmpty();   
  616. d.SetRectEmpty();   
  617. return(true);   
  618. }   
  620. if(d.right > w) {s.right -= (d.right-w)*sw/dw; d.right = w;}   
  621. if(d.bottom > h) {s.bottom -= (d.bottom-h)*sh/dh; d.bottom = h;}   
  622. if(d.left < 0) {s.left += (0-d.left)*sw/dw; d.left = 0;}   
  623. if(d.top < 0) {s.top += (0-d.top)*sh/dh; d.top = 0;}   
  625. return(true);   
  626. } 
  628. STDMETHODIMP_(bool) CDX9AllocatorPresenter::Paint(bool fAll)
  629. {
  630. CAutoLock cAutoLock(this);
  632. if(m_WindowRect.right <= m_WindowRect.left || m_WindowRect.bottom <= m_WindowRect.top
  633. || m_NativeVideoSize.cx <= 0 || m_NativeVideoSize.cy <= 0
  634. || !m_pVideoSurface)
  635. return(false);
  637. HRESULT hr;
  639. CRect rSrcVid(CPoint(0, 0), m_NativeVideoSize);
  640. CRect rDstVid(m_VideoRect);
  642. CRect rSrcPri(CPoint(0, 0), m_WindowRect.Size());
  643. CRect rDstPri(m_WindowRect);
  645. CComPtr<IDirect3DSurface9> pBackBuffer;
  646. m_pD3DDev->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &pBackBuffer);
  648. if(fAll)
  649. {
  650. // clear the backbuffer
  652. hr = m_pD3DDev->Clear(0, NULL, D3DCLEAR_TARGET, 0, 1.0f, 0);
  654. // paint the video on the backbuffer
  656. if(!rDstVid.IsRectEmpty())
  657. {
  658. if(m_pVideoTexture[0])
  659. {
  660. CComPtr<IDirect3DTexture9> pVideoTexture = m_pVideoTexture[0];
  662. if(m_pVideoTexture[1] && m_pPixelShader)
  663. {
  664. static __int64 counter = 0;
  665. static long start = clock();
  667. long stop = clock();
  668. long diff = stop - start;
  670. if(diff >= 10*60*CLOCKS_PER_SEC) start = stop; // reset after 10 min (ps float has its limits in both range and accuracy)
  672. float fConstData[][4] = 
  673. {
  674. {(float)m_NativeVideoSize.cx, (float)m_NativeVideoSize.cy, (float)(counter++), (float)diff / CLOCKS_PER_SEC},
  675. {1.0f / m_NativeVideoSize.cx, 1.0f / m_NativeVideoSize.cy, 0, 0},
  676. };
  678. CComPtr<IDirect3DSurface9> pRT;
  679. hr = m_pD3DDev->GetRenderTarget(0, &pRT);
  680. hr = m_pD3DDev->SetRenderTarget(0, m_pVideoSurface[1]);
  681. hr = m_pD3DDev->SetPixelShaderConstantF(0, (float*)fConstData, countof(fConstData));
  682. hr = m_pD3DDev->SetPixelShader(m_pPixelShader);
  684. TextureBlt(m_pVideoTexture[0], rSrcVid, rSrcVid);
  686. hr = m_pD3DDev->SetRenderTarget(0, pRT);
  687. hr = m_pD3DDev->SetPixelShader(NULL);
  689. pVideoTexture = m_pVideoTexture[1];
  690. }
  692. DWORD resizer = AfxGetAppSettings().iDX9Resizer;
  693. DWORD filter = resizer == 0 ? D3DTEXF_POINT : D3DTEXF_LINEAR;
  695. CComPtr<IDirect3DPixelShader9> pResizerPixelShader;
  697. if(rSrcVid != rDstVid)
  698. {
  699. if(resizer == 2 && m_pResizerPixelShader[0]) pResizerPixelShader = m_pResizerPixelShader[0];
  700. else if(resizer == 3 && m_pResizerPixelShader[1]) pResizerPixelShader = m_pResizerPixelShader[1];
  701. else if(resizer == 4 && m_pResizerPixelShader[2]) pResizerPixelShader = m_pResizerPixelShader[2];
  702. else if(resizer == 5 && m_pResizerPixelShader[3]) pResizerPixelShader = m_pResizerPixelShader[3];
  703. }
  705. if(pResizerPixelShader)
  706. {
  707. float fConstData[][4] = 
  708. {
  709. {(float)m_NativeVideoSize.cx, (float)m_NativeVideoSize.cy, 0, 0},
  710. {1.0f / m_NativeVideoSize.cx, 1.0f / m_NativeVideoSize.cy, 0, 0},
  711. {1.0f / m_NativeVideoSize.cx, 0, 0, 0},
  712. {0, 1.0f / m_NativeVideoSize.cy, 0, 0},
  713. };
  715. hr = m_pD3DDev->SetPixelShaderConstantF(0, (float*)fConstData, countof(fConstData));
  716. hr = m_pD3DDev->SetPixelShader(pResizerPixelShader);
  718. filter = D3DTEXF_POINT;
  719. }
  721. Vector v[4];
  722. Transform(rDstVid, v);
  723. hr = TextureBlt(pVideoTexture, v, rSrcVid, filter);
  725. if(pResizerPixelShader)
  726. hr = m_pD3DDev->SetPixelShader(NULL);
  727. }
  728. else
  729. {
  730. if(pBackBuffer)
  731. {
  732. ClipToSurface(pBackBuffer, rSrcVid, rDstVid); // grrr
  733. // IMPORTANT: rSrcVid has to be aligned on mod2 for yuy2->rgb conversion with StretchRect!!!
  734. rSrcVid.left &= ~1; rSrcVid.right &= ~1;
  735. rSrcVid.top &= ~1; rSrcVid.bottom &= ~1;
  736. hr = m_pD3DDev->StretchRect(m_pVideoSurface[0], rSrcVid, pBackBuffer, rDstVid, m_Filter);
  737. }
  738. }
  739. }
  741. // paint the text on the backbuffer
  743. AlphaBltSubPic(rSrcPri.Size());
  744. }
  746. if(m_fVMRSyncFix)
  747. {
  748. D3DLOCKED_RECT lr;
  749. if(SUCCEEDED(pBackBuffer->LockRect(&lr, NULL, 0)))
  750. pBackBuffer->UnlockRect();
  751. }
  753. hr = m_pD3DDev->Present(rSrcPri, rDstPri, NULL, NULL);
  755. if(hr == D3DERR_DEVICELOST)
  756. {
  757. if(m_pD3DDev->TestCooperativeLevel() == D3DERR_DEVICENOTRESET) 
  758. {
  759. DeleteSurfaces();
  760. if(FAILED(hr = CreateDevice()) || FAILED(hr = AllocSurfaces()))
  761. return(false);
  762. }
  764. hr = S_OK;
  765. }
  767. return(true);
  768. }
  770. STDMETHODIMP CDX9AllocatorPresenter::GetDIB(BYTE* lpDib, DWORD* size)
  771. {
  772. CheckPointer(size, E_POINTER);
  774. HRESULT hr;
  776. D3DSURFACE_DESC desc;
  777. memset(&desc, 0, sizeof(desc));
  778. m_pVideoSurface[0]->GetDesc(&desc);
  780. DWORD required = sizeof(BITMAPINFOHEADER) + (desc.Width * desc.Height * 32 >> 3);
  781. if(!lpDib) {*size = required; return S_OK;}
  782. if(*size < required) return E_OUTOFMEMORY;
  783. *size = required;
  785. CComPtr<IDirect3DSurface9> pSurface = m_pVideoSurface[0];
  786. D3DLOCKED_RECT r;
  787. if(FAILED(hr = pSurface->LockRect(&r, NULL, D3DLOCK_READONLY)))
  788. {
  789. pSurface = NULL;
  790. if(FAILED(hr = m_pD3DDev->CreateOffscreenPlainSurface(desc.Width, desc.Height, desc.Format, D3DPOOL_SYSTEMMEM, &pSurface, NULL))
  791. || FAILED(hr = m_pD3DDev->GetRenderTargetData(m_pVideoSurface[0], pSurface))
  792. || FAILED(hr = pSurface->LockRect(&r, NULL, D3DLOCK_READONLY)))
  793. return hr;
  794. }
  796. BITMAPINFOHEADER* bih = (BITMAPINFOHEADER*)lpDib;
  797. memset(bih, 0, sizeof(BITMAPINFOHEADER));
  798. bih->biSize = sizeof(BITMAPINFOHEADER);
  799. bih->biWidth = desc.Width;
  800. bih->biHeight = desc.Height;
  801. bih->biBitCount = 32;
  802. bih->biPlanes = 1;
  803. bih->biSizeImage = bih->biWidth * bih->biHeight * bih->biBitCount >> 3;
  805. BitBltFromRGBToRGB(
  806. bih->biWidth, bih->biHeight, 
  807. (BYTE*)(bih + 1), bih->biWidth*bih->biBitCount>>3, bih->biBitCount,
  808. (BYTE*)r.pBits + r.Pitch*(desc.Height-1), -(int)r.Pitch, 32);
  810. pSurface->UnlockRect();
  812. return S_OK;
  813. }
  815. STDMETHODIMP CDX9AllocatorPresenter::SetPixelShader(LPCSTR pSrcData, LPCSTR pTarget)
  816. {
  817. CAutoLock cAutoLock(this);
  819. m_pPixelShader = NULL;
  820. m_pD3DDev->SetPixelShader(NULL);
  822. if(!pSrcData || !pTarget)
  823. return E_INVALIDARG;
  825. HRESULT hr = m_pPSC->CompileShader(pSrcData, "main", pTarget, 0, &m_pPixelShader);
  826. if(FAILED(hr)) return hr;
  828. Paint(true);
  830. return S_OK;
  831. }
  833. //
  834. // CVMR9AllocatorPresenter
  835. //
  837. #define MY_USER_ID 0x6ABE51
  839. CVMR9AllocatorPresenter::CVMR9AllocatorPresenter(HWND hWnd, HRESULT& hr) 
  840. : CDX9AllocatorPresenter(hWnd, hr)
  841. , m_fUseInternalTimer(true)
  842. {
  843. }
  845. STDMETHODIMP CVMR9AllocatorPresenter::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  846. {
  847.     CheckPointer(ppv, E_POINTER);
  849. return 
  850. QI(IVMRSurfaceAllocator9)
  851. QI(IVMRImagePresenter9)
  852. QI(IVMRWindowlessControl9)
  853. __super::NonDelegatingQueryInterface(riid, ppv);
  854. }
  856. HRESULT CVMR9AllocatorPresenter::CreateDevice()
  857. {
  858. HRESULT hr = __super::CreateDevice();
  859. if(FAILED(hr)) return hr;
  861. if(m_pIVMRSurfAllocNotify)
  862. {
  863. HMONITOR hMonitor = m_pD3D->GetAdapterMonitor(GetAdapter(m_pD3D));
  864. if(FAILED(hr = m_pIVMRSurfAllocNotify->ChangeD3DDevice(m_pD3DDev, hMonitor)))
  865. return(false);
  866. }
  868. return hr;
  869. }
  871. void CVMR9AllocatorPresenter::DeleteSurfaces()
  872. {
  873.     CAutoLock cAutoLock(this);
  875. m_pSurfaces.RemoveAll();
  877. return __super::DeleteSurfaces();
  878. }
  880. // ISubPicAllocatorPresenter
  882. class COuterVMR9
  883. : public CUnknown
  884. , public IVideoWindow
  885. , public IBasicVideo2
  886. , public IVMRWindowlessControl
  887. {
  888. CComPtr<IUnknown> m_pVMR;
  890. public:
  892. COuterVMR9(const TCHAR* pName, LPUNKNOWN pUnk) : CUnknown(pName, pUnk)
  893. {
  894. m_pVMR.CoCreateInstance(CLSID_VideoMixingRenderer9, GetOwner());
  895. }
  897. DECLARE_IUNKNOWN;
  898. STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, void** ppv)
  899. {
  900. HRESULT hr = m_pVMR ? m_pVMR->QueryInterface(riid, ppv) : E_NOINTERFACE;
  902. if(m_pVMR && FAILED(hr))
  903. {
  904. if(riid == __uuidof(IVideoWindow))
  905. return GetInterface((IVideoWindow*)this, ppv);
  906. if(riid == __uuidof(IBasicVideo))
  907. return GetInterface((IBasicVideo*)this, ppv);
  908. if(riid == __uuidof(IBasicVideo2))
  909. return GetInterface((IBasicVideo2*)this, ppv);
  910. /* if(riid == __uuidof(IVMRWindowlessControl))
  911. return GetInterface((IVMRWindowlessControl*)this, ppv);
  912. */ }
  914. return SUCCEEDED(hr) ? hr : __super::NonDelegatingQueryInterface(riid, ppv);
  915. }
  917. // IVMRWindowlessControl
  919. STDMETHODIMP GetNativeVideoSize(LONG* lpWidth, LONG* lpHeight, LONG* lpARWidth, LONG* lpARHeight)
  920. {
  921. if(CComQIPtr<IVMRWindowlessControl9> pWC9 = m_pVMR)
  922. {
  923. return pWC9->GetNativeVideoSize(lpWidth, lpHeight, lpARWidth, lpARHeight);
  924. }
  926. return E_NOTIMPL;
  927. }
  928. STDMETHODIMP GetMinIdealVideoSize(LONG* lpWidth, LONG* lpHeight) {return E_NOTIMPL;}
  929. STDMETHODIMP GetMaxIdealVideoSize(LONG* lpWidth, LONG* lpHeight) {return E_NOTIMPL;}
  930. STDMETHODIMP SetVideoPosition(const LPRECT lpSRCRect, const LPRECT lpDSTRect) {return E_NOTIMPL;}
  931.     STDMETHODIMP GetVideoPosition(LPRECT lpSRCRect, LPRECT lpDSTRect)
  932. {
  933. if(CComQIPtr<IVMRWindowlessControl9> pWC9 = m_pVMR)
  934. {
  935. return pWC9->GetVideoPosition(lpSRCRect, lpDSTRect);
  936. }
  938. return E_NOTIMPL;
  939. }
  940. STDMETHODIMP GetAspectRatioMode(DWORD* lpAspectRatioMode)
  941. {
  942. if(CComQIPtr<IVMRWindowlessControl9> pWC9 = m_pVMR)
  943. {
  944. *lpAspectRatioMode = VMR_ARMODE_NONE;
  945. return S_OK;
  946. }
  948. return E_NOTIMPL;
  949. }
  950. STDMETHODIMP SetAspectRatioMode(DWORD AspectRatioMode) {return E_NOTIMPL;}
  951. STDMETHODIMP SetVideoClippingWindow(HWND hwnd) {return E_NOTIMPL;}
  952. STDMETHODIMP RepaintVideo(HWND hwnd, HDC hdc) {return E_NOTIMPL;}
  953. STDMETHODIMP DisplayModeChanged() {return E_NOTIMPL;}
  954. STDMETHODIMP GetCurrentImage(BYTE** lpDib) {return E_NOTIMPL;}
  955. STDMETHODIMP SetBorderColor(COLORREF Clr) {return E_NOTIMPL;}
  956. STDMETHODIMP GetBorderColor(COLORREF* lpClr) {return E_NOTIMPL;}
  957. STDMETHODIMP SetColorKey(COLORREF Clr) {return E_NOTIMPL;}
  958. STDMETHODIMP GetColorKey(COLORREF* lpClr) {return E_NOTIMPL;}
  960. // IVideoWindow
  961. STDMETHODIMP GetTypeInfoCount(UINT* pctinfo) {return E_NOTIMPL;}
  962. STDMETHODIMP GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo) {return E_NOTIMPL;}
  963. STDMETHODIMP GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames, UINT cNames, LCID lcid, DISPID* rgDispId) {return E_NOTIMPL;}
  964. STDMETHODIMP Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr) {return E_NOTIMPL;}
  965.     STDMETHODIMP put_Caption(BSTR strCaption) {return E_NOTIMPL;}
  966.     STDMETHODIMP get_Caption(BSTR* strCaption) {return E_NOTIMPL;}
  967. STDMETHODIMP put_WindowStyle(long WindowStyle) {return E_NOTIMPL;}
  968. STDMETHODIMP get_WindowStyle(long* WindowStyle) {return E_NOTIMPL;}
  969. STDMETHODIMP put_WindowStyleEx(long WindowStyleEx) {return E_NOTIMPL;}
  970. STDMETHODIMP get_WindowStyleEx(long* WindowStyleEx) {return E_NOTIMPL;}
  971. STDMETHODIMP put_AutoShow(long AutoShow) {return E_NOTIMPL;}
  972. STDMETHODIMP get_AutoShow(long* AutoShow) {return E_NOTIMPL;}
  973. STDMETHODIMP put_WindowState(long WindowState) {return E_NOTIMPL;}
  974. STDMETHODIMP get_WindowState(long* WindowState) {return E_NOTIMPL;}
  975. STDMETHODIMP put_BackgroundPalette(long BackgroundPalette) {return E_NOTIMPL;}
  976. STDMETHODIMP get_BackgroundPalette(long* pBackgroundPalette) {return E_NOTIMPL;}
  977. STDMETHODIMP put_Visible(long Visible) {return E_NOTIMPL;}
  978. STDMETHODIMP get_Visible(long* pVisible) {return E_NOTIMPL;}
  979. STDMETHODIMP put_Left(long Left) {return E_NOTIMPL;}
  980. STDMETHODIMP get_Left(long* pLeft) {return E_NOTIMPL;}
  981. STDMETHODIMP put_Width(long Width) {return E_NOTIMPL;}
  982. STDMETHODIMP get_Width(long* pWidth)
  983. {
  984. if(CComQIPtr<IVMRWindowlessControl9> pWC9 = m_pVMR)
  985. {
  986. CRect s, d;
  987. HRESULT hr = pWC9->GetVideoPosition(&s, &d);
  988. *pWidth = d.Width();
  989. return hr;
  990. }
  992. return E_NOTIMPL;
  993. }
  994. STDMETHODIMP put_Top(long Top) {return E_NOTIMPL;}
  995. STDMETHODIMP get_Top(long* pTop) {return E_NOTIMPL;}
  996. STDMETHODIMP put_Height(long Height) {return E_NOTIMPL;}
  997. STDMETHODIMP get_Height(long* pHeight)
  998. {
  999. if(CComQIPtr<IVMRWindowlessControl9> pWC9 = m_pVMR)
  1000. {
  1001. CRect s, d;
  1002. HRESULT hr = pWC9->GetVideoPosition(&s, &d);
  1003. *pHeight = d.Height();
  1004. return hr;
  1005. }
  1007. return E_NOTIMPL;
  1008. }
  1009. STDMETHODIMP put_Owner(OAHWND Owner) {return E_NOTIMPL;}
  1010. STDMETHODIMP get_Owner(OAHWND* Owner) {return E_NOTIMPL;}
  1011. STDMETHODIMP put_MessageDrain(OAHWND Drain) {return E_NOTIMPL;}
  1012. STDMETHODIMP get_MessageDrain(OAHWND* Drain) {return E_NOTIMPL;}
  1013. STDMETHODIMP get_BorderColor(long* Color) {return E_NOTIMPL;}
  1014. STDMETHODIMP put_BorderColor(long Color) {return E_NOTIMPL;}
  1015. STDMETHODIMP get_FullScreenMode(long* FullScreenMode) {return E_NOTIMPL;}
  1016. STDMETHODIMP put_FullScreenMode(long FullScreenMode) {return E_NOTIMPL;}
  1017.     STDMETHODIMP SetWindowForeground(long Focus) {return E_NOTIMPL;}
  1018.     STDMETHODIMP NotifyOwnerMessage(OAHWND hwnd, long uMsg, LONG_PTR wParam, LONG_PTR lParam) {return E_NOTIMPL;}
  1019.     STDMETHODIMP SetWindowPosition(long Left, long Top, long Width, long Height) {return E_NOTIMPL;}
  1020. STDMETHODIMP GetWindowPosition(long* pLeft, long* pTop, long* pWidth, long* pHeight) {return E_NOTIMPL;}
  1021. STDMETHODIMP GetMinIdealImageSize(long* pWidth, long* pHeight) {return E_NOTIMPL;}
  1022. STDMETHODIMP GetMaxIdealImageSize(long* pWidth, long* pHeight) {return E_NOTIMPL;}
  1023. STDMETHODIMP GetRestorePosition(long* pLeft, long* pTop, long* pWidth, long* pHeight) {return E_NOTIMPL;}
  1024. STDMETHODIMP HideCursor(long HideCursor) {return E_NOTIMPL;}
  1025. STDMETHODIMP IsCursorHidden(long* CursorHidden) {return E_NOTIMPL;}
  1027. // IBasicVideo2
  1028.     STDMETHODIMP get_AvgTimePerFrame(REFTIME* pAvgTimePerFrame) {return E_NOTIMPL;}
  1029.     STDMETHODIMP get_BitRate(long* pBitRate) {return E_NOTIMPL;}
  1030.     STDMETHODIMP get_BitErrorRate(long* pBitErrorRate) {return E_NOTIMPL;}
  1031.     STDMETHODIMP get_VideoWidth(long* pVideoWidth) {return E_NOTIMPL;}
  1032.     STDMETHODIMP get_VideoHeight(long* pVideoHeight) {return E_NOTIMPL;}
  1033.     STDMETHODIMP put_SourceLeft(long SourceLeft) {return E_NOTIMPL;}
  1034.     STDMETHODIMP get_SourceLeft(long* pSourceLeft) {return E_NOTIMPL;}
  1035.     STDMETHODIMP put_SourceWidth(long SourceWidth) {return E_NOTIMPL;}
  1036.     STDMETHODIMP get_SourceWidth(long* pSourceWidth) {return E_NOTIMPL;}
  1037.     STDMETHODIMP put_SourceTop(long SourceTop) {return E_NOTIMPL;}
  1038.     STDMETHODIMP get_SourceTop(long* pSourceTop) {return E_NOTIMPL;}
  1039.     STDMETHODIMP put_SourceHeight(long SourceHeight) {return E_NOTIMPL;}
  1040.     STDMETHODIMP get_SourceHeight(long* pSourceHeight) {return E_NOTIMPL;}
  1041.     STDMETHODIMP put_DestinationLeft(long DestinationLeft) {return E_NOTIMPL;}
  1042.     STDMETHODIMP get_DestinationLeft(long* pDestinationLeft) {return E_NOTIMPL;}
  1043.     STDMETHODIMP put_DestinationWidth(long DestinationWidth) {return E_NOTIMPL;}
  1044.     STDMETHODIMP get_DestinationWidth(long* pDestinationWidth) {return E_NOTIMPL;}
  1045.     STDMETHODIMP put_DestinationTop(long DestinationTop) {return E_NOTIMPL;}
  1046.     STDMETHODIMP get_DestinationTop(long* pDestinationTop) {return E_NOTIMPL;}
  1047.     STDMETHODIMP put_DestinationHeight(long DestinationHeight) {return E_NOTIMPL;}
  1048.     STDMETHODIMP get_DestinationHeight(long* pDestinationHeight) {return E_NOTIMPL;}
  1049.     STDMETHODIMP SetSourcePosition(long Left, long Top, long Width, long Height) {return E_NOTIMPL;}
  1050.     STDMETHODIMP GetSourcePosition(long* pLeft, long* pTop, long* pWidth, long* pHeight)
  1051. {
  1052. // DVD Nav. bug workaround fix
  1053. {
  1054. *pLeft = *pTop = 0;
  1055. return GetVideoSize(pWidth, pHeight);
  1056. }
  1057. /*
  1058. if(CComQIPtr<IVMRWindowlessControl9> pWC9 = m_pVMR)
  1059. {
  1060. CRect s, d;
  1061. HRESULT hr = pWC9->GetVideoPosition(&s, &d);
  1062. *pLeft = s.left;
  1063. *pTop = s.top;
  1064. *pWidth = s.Width();
  1065. *pHeight = s.Height();
  1066. return hr;
  1067. }
  1068. */
  1069. return E_NOTIMPL;
  1070. }
  1071.     STDMETHODIMP SetDefaultSourcePosition() {return E_NOTIMPL;}
  1072.     STDMETHODIMP SetDestinationPosition(long Left, long Top, long Width, long Height) {return E_NOTIMPL;}
  1073.     STDMETHODIMP GetDestinationPosition(long* pLeft, long* pTop, long* pWidth, long* pHeight)
  1074. {
  1075. if(CComQIPtr<IVMRWindowlessControl9> pWC9 = m_pVMR)
  1076. {
  1077. CRect s, d;
  1078. HRESULT hr = pWC9->GetVideoPosition(&s, &d);
  1079. *pLeft = d.left;
  1080. *pTop = d.top;
  1081. *pWidth = d.Width();
  1082. *pHeight = d.Height();
  1083. return hr;
  1084. }
  1086. return E_NOTIMPL;
  1087. }
  1088.     STDMETHODIMP SetDefaultDestinationPosition() {return E_NOTIMPL;}
  1089.     STDMETHODIMP GetVideoSize(long* pWidth, long* pHeight)
  1090. {
  1091. if(CComQIPtr<IVMRWindowlessControl9> pWC9 = m_pVMR)
  1092. {
  1093. LONG aw, ah;
  1094. // return pWC9->GetNativeVideoSize(pWidth, pHeight, &aw, &ah);
  1095. // DVD Nav. bug workaround fix
  1096. HRESULT hr = pWC9->GetNativeVideoSize(pWidth, pHeight, &aw, &ah);
  1097. *pWidth = *pHeight * aw / ah;
  1098. return hr;
  1099. }
  1101. return E_NOTIMPL;
  1102. }
  1103.     STDMETHODIMP GetVideoPaletteEntries(long StartIndex, long Entries, long* pRetrieved, long* pPalette) {return E_NOTIMPL;}
  1104.     STDMETHODIMP GetCurrentImage(long* pBufferSize, long* pDIBImage) {return E_NOTIMPL;}
  1105.     STDMETHODIMP IsUsingDefaultSource() {return E_NOTIMPL;}
  1106.     STDMETHODIMP IsUsingDefaultDestination() {return E_NOTIMPL;}
  1108. STDMETHODIMP GetPreferredAspectRatio(long* plAspectX, long* plAspectY)
  1109. {
  1110. if(CComQIPtr<IVMRWindowlessControl9> pWC9 = m_pVMR)
  1111. {
  1112. LONG w, h;
  1113. return pWC9->GetNativeVideoSize(&w, &h, plAspectX, plAspectY);
  1114. }
  1116. return E_NOTIMPL;
  1117. }
  1118. };
  1120. STDMETHODIMP CVMR9AllocatorPresenter::CreateRenderer(IUnknown** ppRenderer)
  1121. {
  1122.     CheckPointer(ppRenderer, E_POINTER);
  1124. *ppRenderer = NULL;
  1126. HRESULT hr;
  1128. do
  1129. {
  1130. CMacrovisionKicker* pMK = new CMacrovisionKicker(NAME("CMacrovisionKicker"), NULL);
  1131. CComPtr<IUnknown> pUnk = (IUnknown*)(INonDelegatingUnknown*)pMK;
  1132. pMK->SetInner((IUnknown*)(INonDelegatingUnknown*)new COuterVMR9(NAME("COuterVMR9"), pUnk));
  1133. CComQIPtr<IBaseFilter> pBF = pUnk;
  1134. /*
  1135. CComQIPtr<IBaseFilter> pBF = (IUnknown*)(INonDelegatingUnknown*)new COuterVMR9(NAME("COuterVMR9"), NULL);
  1136. if(!pBF) pBF.CoCreateInstance(CLSID_VideoMixingRenderer9);
  1137. */
  1139. CComQIPtr<IVMRFilterConfig9> pConfig = pBF;
  1140. if(!pConfig)
  1141. break;
  1143. if(FAILED(hr = pConfig->SetRenderingMode(VMR9Mode_Renderless)))
  1144. break;
  1146. CComQIPtr<IVMRSurfaceAllocatorNotify9> pSAN = pBF;
  1147. if(!pSAN)
  1148. break;
  1150. if(FAILED(hr = pSAN->AdviseSurfaceAllocator(MY_USER_ID, static_cast<IVMRSurfaceAllocator9*>(this)))
  1151. || FAILED(hr = AdviseNotify(pSAN)))
  1152. break;
  1154. CComPtr<IPin> pPin = GetFirstPin(pBF);
  1155. HookNewSegment((IPinC*)(IPin*)pPin);
  1157. *ppRenderer = (IUnknown*)pBF.Detach();
  1159. return S_OK;
  1160. }
  1161. while(0);
  1163.     return E_FAIL;
  1164. }
  1166. STDMETHODIMP_(void) CVMR9AllocatorPresenter::SetTime(REFERENCE_TIME rtNow)
  1167. {
  1168. m_fUseInternalTimer = false;
  1169. __super::SetTime(rtNow);
  1170. }
  1172. // IVMRSurfaceAllocator9
  1174. STDMETHODIMP CVMR9AllocatorPresenter::InitializeDevice(DWORD_PTR dwUserID, VMR9AllocationInfo* lpAllocInfo, DWORD* lpNumBuffers)
  1175. {
  1176. if(!lpAllocInfo || !lpNumBuffers)
  1177. return E_POINTER;
  1179. if(!m_pIVMRSurfAllocNotify)
  1180. return E_FAIL;
  1182. // StretchRect's yv12 -> rgb conversion looks horribly bright compared to the result of yuy2 -> rgb
  1183. if(lpAllocInfo->Format == '21VY' || lpAllocInfo->Format == '024Y')
  1184. return E_FAIL;
  1186. DeleteSurfaces();
  1187. m_pSurfaces.SetCount(*lpNumBuffers);
  1189.     HRESULT hr;
  1191. hr = m_pIVMRSurfAllocNotify->AllocateSurfaceHelper(lpAllocInfo, lpNumBuffers, &m_pSurfaces[0]);
  1192. if(FAILED(hr))
  1193. return hr;
  1195. m_NativeVideoSize = CSize(lpAllocInfo->dwWidth, abs((int)lpAllocInfo->dwHeight));
  1196. m_AspectRatio = m_NativeVideoSize;
  1197. int arx = lpAllocInfo->szAspectRatio.cx, ary = lpAllocInfo->szAspectRatio.cy;
  1198. if(arx > 0 && ary > 0) m_AspectRatio.SetSize(arx, ary);
  1200. if(FAILED(hr = AllocSurfaces()))
  1201. return hr;
  1203. // test if the colorspace is acceptable
  1204. if(FAILED(hr = m_pD3DDev->StretchRect(m_pSurfaces[0], NULL, m_pVideoSurface[0], NULL, D3DTEXF_NONE)))
  1205. {
  1206. DeleteSurfaces();
  1207. return E_FAIL;
  1208. }
  1210. hr = m_pD3DDev->ColorFill(m_pVideoSurface[0], NULL, 0);
  1212. return hr;
  1213. }
  1215. STDMETHODIMP CVMR9AllocatorPresenter::TerminateDevice(DWORD_PTR dwUserID)
  1216. {
  1217.     DeleteSurfaces();
  1218.     return S_OK;
  1219. }
  1221. STDMETHODIMP CVMR9AllocatorPresenter::GetSurface(DWORD_PTR dwUserID, DWORD SurfaceIndex, DWORD SurfaceFlags, IDirect3DSurface9** lplpSurface)
  1222. {
  1223.     if(!lplpSurface)
  1224. return E_POINTER;
  1226. if(SurfaceIndex >= m_pSurfaces.GetCount()) 
  1227.         return E_FAIL;
  1229.     CAutoLock cAutoLock(this);
  1231. (*lplpSurface = m_pSurfaces[SurfaceIndex])->AddRef();
  1233. return S_OK;
  1234. }
  1236. STDMETHODIMP CVMR9AllocatorPresenter::AdviseNotify(IVMRSurfaceAllocatorNotify9* lpIVMRSurfAllocNotify)
  1237. {
  1238.     CAutoLock cAutoLock(this);
  1240. m_pIVMRSurfAllocNotify = lpIVMRSurfAllocNotify;
  1242. HRESULT hr;
  1243.     HMONITOR hMonitor = m_pD3D->GetAdapterMonitor(GetAdapter(m_pD3D));
  1244.     if(FAILED(hr = m_pIVMRSurfAllocNotify->SetD3DDevice(m_pD3DDev, hMonitor)))
  1245. return hr;
  1247.     return S_OK;
  1248. }
  1250. // IVMRImagePresenter9
  1252. STDMETHODIMP CVMR9AllocatorPresenter::StartPresenting(DWORD_PTR dwUserID)
  1253. {
  1254.     CAutoLock cAutoLock(this);
  1256.     ASSERT(m_pD3DDev);
  1258. return m_pD3DDev ? S_OK : E_FAIL;
  1259. }
  1261. STDMETHODIMP CVMR9AllocatorPresenter::StopPresenting(DWORD_PTR dwUserID)
  1262. {
  1263. return S_OK;
  1264. }
  1266. STDMETHODIMP CVMR9AllocatorPresenter::PresentImage(DWORD_PTR dwUserID, VMR9PresentationInfo* lpPresInfo)
  1267. {
  1268.     HRESULT hr;
  1270. {
  1271. if(!m_pIVMRSurfAllocNotify)
  1272. return E_FAIL;
  1274. D3DDEVICE_CREATION_PARAMETERS Parameters;
  1275. if(FAILED(m_pD3DDev->GetCreationParameters(&Parameters)))
  1276. {
  1277. ASSERT(0);
  1278. return E_FAIL;
  1279. }
  1281. HMONITOR hCurMonitor = m_pD3D->GetAdapterMonitor(Parameters.AdapterOrdinal);
  1282. HMONITOR hMonitor = m_pD3D->GetAdapterMonitor(GetAdapter(m_pD3D));
  1284. if(hMonitor != hCurMonitor)
  1285. {
  1286. ASSERT(0);
  1287. }
  1288. }
  1290. /*
  1291.     // if we are in the middle of the display change
  1292.     if(NeedToHandleDisplayChange())
  1293.     {
  1294.         // NOTE: this piece of code is left as a user exercise.  
  1295.         // The D3DDevice here needs to be switched
  1296.         // to the device that is using another adapter
  1297.     }
  1298. */
  1299. {
  1300. if(!lpPresInfo || !lpPresInfo->lpSurf)
  1301. return E_POINTER;
  1303. CAutoLock cAutoLock(this);
  1305. hr = m_pD3DDev->StretchRect(lpPresInfo->lpSurf, NULL, m_pVideoSurface[0], NULL, D3DTEXF_NONE);
  1307. if(lpPresInfo->rtEnd > lpPresInfo->rtStart)
  1308. {
  1309. REFERENCE_TIME rtTimePerFrame = lpPresInfo->rtEnd - lpPresInfo->rtStart;
  1310. m_fps = 10000000.0 / rtTimePerFrame;
  1312. if(m_pSubPicQueue)
  1313. {
  1314. m_pSubPicQueue->SetFPS(m_fps);
  1315. if(m_fUseInternalTimer) __super::SetTime(g_tSegmentStart + lpPresInfo->rtStart);
  1316. }
  1317. }
  1319. CSize VideoSize = m_NativeVideoSize;
  1320. int arx = lpPresInfo->szAspectRatio.cx, ary = lpPresInfo->szAspectRatio.cy;
  1321. if(arx > 0 && ary > 0) VideoSize.cx = VideoSize.cy*arx/ary;
  1322. if(VideoSize != GetVideoSize())
  1323. {
  1324. m_AspectRatio.SetSize(arx, ary);
  1325. AfxGetApp()->m_pMainWnd->PostMessage(WM_REARRANGERENDERLESS);
  1326. }
  1328. Paint(true);
  1330. hr = S_OK;
  1331. }
  1333.     return hr;
  1334. }
  1336. // IVMRWindowlessControl9
  1337. //
  1338. // It is only implemented (partially) for the dvd navigator's 
  1339. // menu handling, which needs to know a few things about the 
  1340. // location of our window.
  1342. STDMETHODIMP CVMR9AllocatorPresenter::GetNativeVideoSize(LONG* lpWidth, LONG* lpHeight, LONG* lpARWidth, LONG* lpARHeight)
  1343. {
  1344. if(lpWidth) *lpWidth = m_NativeVideoSize.cx;
  1345. if(lpHeight) *lpHeight = m_NativeVideoSize.cy;
  1346. if(lpARWidth) *lpARWidth = m_AspectRatio.cx;
  1347. if(lpARHeight) *lpARHeight = m_AspectRatio.cy;
  1348. return S_OK;
  1349. }
  1350. STDMETHODIMP CVMR9AllocatorPresenter::GetMinIdealVideoSize(LONG* lpWidth, LONG* lpHeight) {return E_NOTIMPL;}
  1351. STDMETHODIMP CVMR9AllocatorPresenter::GetMaxIdealVideoSize(LONG* lpWidth, LONG* lpHeight) {return E_NOTIMPL;}
  1352. STDMETHODIMP CVMR9AllocatorPresenter::SetVideoPosition(const LPRECT lpSRCRect, const LPRECT lpDSTRect) {return E_NOTIMPL;} // we have our own method for this
  1353. STDMETHODIMP CVMR9AllocatorPresenter::GetVideoPosition(LPRECT lpSRCRect, LPRECT lpDSTRect)
  1354. {
  1355. CopyRect(lpSRCRect, CRect(CPoint(0, 0), m_NativeVideoSize));
  1356. CopyRect(lpDSTRect, &m_VideoRect);
  1357. return S_OK;
  1358. }
  1359. STDMETHODIMP CVMR9AllocatorPresenter::GetAspectRatioMode(DWORD* lpAspectRatioMode)
  1360. {
  1361. if(lpAspectRatioMode) *lpAspectRatioMode = AM_ARMODE_STRETCHED;
  1362. return S_OK;
  1363. }
  1364. STDMETHODIMP CVMR9AllocatorPresenter::SetAspectRatioMode(DWORD AspectRatioMode) {return E_NOTIMPL;}
  1365. STDMETHODIMP CVMR9AllocatorPresenter::SetVideoClippingWindow(HWND hwnd) {return E_NOTIMPL;}
  1366. STDMETHODIMP CVMR9AllocatorPresenter::RepaintVideo(HWND hwnd, HDC hdc) {return E_NOTIMPL;}
  1367. STDMETHODIMP CVMR9AllocatorPresenter::DisplayModeChanged() {return E_NOTIMPL;}
  1368. STDMETHODIMP CVMR9AllocatorPresenter::GetCurrentImage(BYTE** lpDib) {return E_NOTIMPL;}
  1369. STDMETHODIMP CVMR9AllocatorPresenter::SetBorderColor(COLORREF Clr) {return E_NOTIMPL;}
  1370. STDMETHODIMP CVMR9AllocatorPresenter::GetBorderColor(COLORREF* lpClr)
  1371. {
  1372. if(lpClr) *lpClr = 0;
  1373. return S_OK;
  1374. }
  1376. //
  1377. // CRM9AllocatorPresenter
  1378. //
  1380. CRM9AllocatorPresenter::CRM9AllocatorPresenter(HWND hWnd, HRESULT& hr) 
  1381. : CDX9AllocatorPresenter(hWnd, hr)
  1382. {
  1383. }
  1385. STDMETHODIMP CRM9AllocatorPresenter::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  1386. {
  1387.     CheckPointer(ppv, E_POINTER);
  1389. return 
  1390. QI2(IRMAVideoSurface)
  1391. __super::NonDelegatingQueryInterface(riid, ppv);
  1392. }
  1394. HRESULT CRM9AllocatorPresenter::AllocSurfaces()
  1395. {
  1396.     CAutoLock cAutoLock(this);
  1398. m_pVideoSurfaceOff = NULL;
  1399. m_pVideoSurfaceYUY2 = NULL;
  1401. HRESULT hr;
  1403. if(FAILED(hr = m_pD3DDev->CreateOffscreenPlainSurface(
  1404. m_NativeVideoSize.cx, m_NativeVideoSize.cy, D3DFMT_X8R8G8B8, 
  1405. D3DPOOL_DEFAULT, &m_pVideoSurfaceOff, NULL)))
  1406. return hr;
  1408. m_pD3DDev->ColorFill(m_pVideoSurfaceOff, NULL, 0);
  1410. if(FAILED(hr = m_pD3DDev->CreateOffscreenPlainSurface(
  1411. m_NativeVideoSize.cx, m_NativeVideoSize.cy, D3DFMT_YUY2, 
  1412. D3DPOOL_DEFAULT, &m_pVideoSurfaceYUY2, NULL)))
  1413. m_pVideoSurfaceYUY2 = NULL;
  1415. if(m_pVideoSurfaceYUY2)
  1416. {
  1417. m_pD3DDev->ColorFill(m_pVideoSurfaceOff, NULL, 0x80108010);
  1418. }
  1420. return __super::AllocSurfaces();
  1421. }
  1423. void CRM9AllocatorPresenter::DeleteSurfaces()
  1424. {
  1425.     CAutoLock cAutoLock(this);
  1426. m_pVideoSurfaceOff = NULL;
  1427. m_pVideoSurfaceYUY2 = NULL;
  1428. __super::DeleteSurfaces();
  1429. }
  1431. // IRMAVideoSurface
  1433. STDMETHODIMP CRM9AllocatorPresenter::Blt(UCHAR* pImageData, RMABitmapInfoHeader* pBitmapInfo, REF(PNxRect) inDestRect, REF(PNxRect) inSrcRect)
  1434. {
  1435. if(!m_pVideoSurface || !m_pVideoSurfaceOff)
  1436. return E_FAIL;
  1438. bool fRGB = false;
  1439. bool fYUY2 = false;
  1441. CRect src((RECT*)&inSrcRect), dst((RECT*)&inDestRect), src2(CPoint(0,0), src.Size());
  1442. if(src.Width() > dst.Width() || src.Height() > dst.Height())
  1443. return E_FAIL;
  1445. D3DSURFACE_DESC d3dsd;
  1446. ZeroMemory(&d3dsd, sizeof(d3dsd));
  1447. if(FAILED(m_pVideoSurfaceOff->GetDesc(&d3dsd)))
  1448. return E_FAIL;
  1450. int dbpp = 
  1451. d3dsd.Format == D3DFMT_R8G8B8 || d3dsd.Format == D3DFMT_X8R8G8B8 || d3dsd.Format == D3DFMT_A8R8G8B8 ? 32 : 
  1452. d3dsd.Format == D3DFMT_R5G6B5 ? 16 : 0;
  1454. if(pBitmapInfo->biCompression == '024I')
  1455. {
  1456. DWORD pitch = pBitmapInfo->biWidth;
  1457. DWORD size = pitch*abs(pBitmapInfo->biHeight);
  1459. BYTE* y = pImageData + src.top*pitch + src.left;
  1460. BYTE* u = pImageData + size + src.top*(pitch/2) + src.left/2;
  1461. BYTE* v = pImageData + size + size/4 + src.top*(pitch/2) + src.left/2;
  1463. if(m_pVideoSurfaceYUY2)
  1464. {
  1465. D3DLOCKED_RECT r;
  1466. if(SUCCEEDED(m_pVideoSurfaceYUY2->LockRect(&r, src2, 0)))
  1467. {
  1468. BitBltFromI420ToYUY2(src.Width(), src.Height(), (BYTE*)r.pBits, r.Pitch, y, u, v, pitch);
  1469. m_pVideoSurfaceYUY2->UnlockRect();
  1470. fYUY2 = true;
  1471. }
  1472. }
  1473. else
  1474. {
  1475. D3DLOCKED_RECT r;
  1476. if(SUCCEEDED(m_pVideoSurfaceOff->LockRect(&r, src2, 0)))
  1477. {
  1478. BitBltFromI420ToRGB(src.Width(), src.Height(), (BYTE*)r.pBits, r.Pitch, dbpp, y, u, v, pitch);
  1479. m_pVideoSurfaceOff->UnlockRect();
  1480. fRGB = true;
  1481. }
  1482. }
  1483. }
  1484. else if(pBitmapInfo->biCompression == '2YUY')
  1485. {
  1486. DWORD w = pBitmapInfo->biWidth;
  1487. DWORD h = abs(pBitmapInfo->biHeight);
  1488. DWORD pitch = pBitmapInfo->biWidth*2;
  1490. BYTE* yvyu = pImageData + src.top*pitch + src.left*2;
  1492. if(m_pVideoSurfaceYUY2)
  1493. {
  1494. D3DLOCKED_RECT r;
  1495. if(SUCCEEDED(m_pVideoSurfaceYUY2->LockRect(&r, src2, 0)))
  1496. {
  1497. BitBltFromYUY2ToYUY2(src.Width(), src.Height(), (BYTE*)r.pBits, r.Pitch, yvyu, pitch);
  1498. m_pVideoSurfaceYUY2->UnlockRect();
  1499. fYUY2 = true;
  1500. }
  1501. }
  1502. else
  1503. {
  1504. D3DLOCKED_RECT r;
  1505. if(SUCCEEDED(m_pVideoSurfaceOff->LockRect(&r, src2, 0)))
  1506. {
  1507. BitBltFromYUY2ToRGB(src.Width(), src.Height(), (BYTE*)r.pBits, r.Pitch, dbpp, yvyu, pitch);
  1508. m_pVideoSurfaceOff->UnlockRect();
  1509. fRGB = true;
  1510. }
  1511. }
  1512. }
  1513. else if(pBitmapInfo->biCompression == 0 || pBitmapInfo->biCompression == 3
  1514.  || pBitmapInfo->biCompression == 'BGRA')
  1515. {
  1516. DWORD w = pBitmapInfo->biWidth;
  1517. DWORD h = abs(pBitmapInfo->biHeight);
  1518. DWORD pitch = pBitmapInfo->biWidth*pBitmapInfo->biBitCount>>3;
  1520. BYTE* rgb = pImageData + src.top*pitch + src.left*(pBitmapInfo->biBitCount>>3);
  1522. D3DLOCKED_RECT r;
  1523. if(SUCCEEDED(m_pVideoSurfaceOff->LockRect(&r, src2, 0)))
  1524. {
  1525. BYTE* pBits = (BYTE*)r.pBits;
  1526. if(pBitmapInfo->biHeight > 0) {pBits += r.Pitch*(src.Height()-1); r.Pitch = -r.Pitch;}
  1527. BitBltFromRGBToRGB(src.Width(), src.Height(), pBits, r.Pitch, dbpp, rgb, pitch, pBitmapInfo->biBitCount);
  1528. m_pVideoSurfaceOff->UnlockRect();
  1529. fRGB = true;
  1530. }
  1531. }
  1533. if(!fRGB && !fYUY2)
  1534. {
  1535. m_pD3DDev->ColorFill(m_pVideoSurfaceOff, NULL, 0);
  1537. HDC hDC;
  1538. if(SUCCEEDED(m_pVideoSurfaceOff->GetDC(&hDC)))
  1539. {
  1540. CString str;
  1541. str.Format(_T("Sorry, this format is not supported"));
  1543. SetBkColor(hDC, 0);
  1544. SetTextColor(hDC, 0x404040);
  1545. TextOut(hDC, 10, 10, str, str.GetLength());
  1547. m_pVideoSurfaceOff->ReleaseDC(hDC);
  1549. fRGB = true;
  1550. }
  1551. }
  1553. HRESULT hr;
  1555. if(fRGB)
  1556. hr = m_pD3DDev->StretchRect(m_pVideoSurfaceOff, src2, m_pVideoSurface[0], dst, D3DTEXF_NONE);
  1557. if(fYUY2)
  1558. hr = m_pD3DDev->StretchRect(m_pVideoSurfaceYUY2, src2, m_pVideoSurface[0], dst, D3DTEXF_NONE);
  1560. Paint(true);
  1562. return PNR_OK;
  1563. }
  1565. STDMETHODIMP CRM9AllocatorPresenter::BeginOptimizedBlt(RMABitmapInfoHeader* pBitmapInfo)
  1566. {
  1567.     CAutoLock cAutoLock(this);
  1568. DeleteSurfaces();
  1569. m_NativeVideoSize = m_AspectRatio = CSize(pBitmapInfo->biWidth, abs(pBitmapInfo->biHeight));
  1570. if(FAILED(AllocSurfaces())) return E_FAIL;
  1571. return PNR_NOTIMPL;
  1572. }
  1574. STDMETHODIMP CRM9AllocatorPresenter::OptimizedBlt(UCHAR* pImageBits, REF(PNxRect) rDestRect, REF(PNxRect) rSrcRect)
  1575. {
  1576. return PNR_NOTIMPL;
  1577. }
  1579. STDMETHODIMP CRM9AllocatorPresenter::EndOptimizedBlt()
  1580. {
  1581. return PNR_NOTIMPL;
  1582. }
  1584. STDMETHODIMP CRM9AllocatorPresenter::GetOptimizedFormat(REF(RMA_COMPRESSION_TYPE) ulType)
  1585. {
  1586. return PNR_NOTIMPL;
  1587. }
  1589. STDMETHODIMP CRM9AllocatorPresenter::GetPreferredFormat(REF(RMA_COMPRESSION_TYPE) ulType)
  1590. {
  1591. ulType = RMA_I420;
  1592. return PNR_OK;
  1593. }
  1595. //
  1596. // CQT9AllocatorPresenter
  1597. //
  1599. CQT9AllocatorPresenter::CQT9AllocatorPresenter(HWND hWnd, HRESULT& hr) 
  1600. : CDX9AllocatorPresenter(hWnd, hr)
  1601. {
  1602. }
  1604. STDMETHODIMP CQT9AllocatorPresenter::NonDelegatingQueryInterface(REFIID riid, void** ppv)
  1605. {
  1606.     CheckPointer(ppv, E_POINTER);
  1608. return 
  1609. QI(IQTVideoSurface)
  1610. __super::NonDelegatingQueryInterface(riid, ppv);
  1611. }
  1613. HRESULT CQT9AllocatorPresenter::AllocSurfaces()
  1614. {
  1615. HRESULT hr;
  1617. m_pVideoSurfaceOff = NULL;
  1619. if(FAILED(hr = m_pD3DDev->CreateOffscreenPlainSurface(
  1620. m_NativeVideoSize.cx, m_NativeVideoSize.cy, D3DFMT_X8R8G8B8, 
  1621. D3DPOOL_DEFAULT, &m_pVideoSurfaceOff, NULL)))
  1622. return hr;
  1624. return __super::AllocSurfaces();
  1625. }
  1627. void CQT9AllocatorPresenter::DeleteSurfaces()
  1628. {
  1629. m_pVideoSurfaceOff = NULL;
  1631. __super::DeleteSurfaces();
  1632. }
  1634. // IQTVideoSurface
  1636. STDMETHODIMP CQT9AllocatorPresenter::BeginBlt(const BITMAP& bm)
  1637. {
  1638.     CAutoLock cAutoLock(this);
  1639. DeleteSurfaces();
  1640. m_NativeVideoSize = m_AspectRatio = CSize(bm.bmWidth, abs(bm.bmHeight));
  1641. if(FAILED(AllocSurfaces())) return E_FAIL;
  1642. return S_OK;
  1643. }
  1645. STDMETHODIMP CQT9AllocatorPresenter::DoBlt(const BITMAP& bm)
  1646. {
  1647. if(!m_pVideoSurface || !m_pVideoSurfaceOff)
  1648. return E_FAIL;
  1650. bool fOk = false;
  1652. D3DSURFACE_DESC d3dsd;
  1653. ZeroMemory(&d3dsd, sizeof(d3dsd));
  1654. if(FAILED(m_pVideoSurfaceOff->GetDesc(&d3dsd)))
  1655. return E_FAIL;
  1657. int w = bm.bmWidth;
  1658. int h = abs(bm.bmHeight);
  1659. int bpp = bm.bmBitsPixel;
  1660. int dbpp = 
  1661. d3dsd.Format == D3DFMT_R8G8B8 || d3dsd.Format == D3DFMT_X8R8G8B8 || d3dsd.Format == D3DFMT_A8R8G8B8 ? 32 : 
  1662. d3dsd.Format == D3DFMT_R5G6B5 ? 16 : 0;
  1664. if((bpp == 16 || bpp == 24 || bpp == 32) && w == d3dsd.Width && h == d3dsd.Height)
  1665. {
  1666. D3DLOCKED_RECT r;
  1667. if(SUCCEEDED(m_pVideoSurfaceOff->LockRect(&r, NULL, 0)))
  1668. {
  1669. BitBltFromRGBToRGB(
  1670. w, h,
  1671. (BYTE*)r.pBits, r.Pitch, dbpp,
  1672. (BYTE*)bm.bmBits, bm.bmWidthBytes, bm.bmBitsPixel);
  1673. m_pVideoSurfaceOff->UnlockRect();
  1674. fOk = true;
  1675. }
  1676. }
  1678. if(!fOk)
  1679. {
  1680. m_pD3DDev->ColorFill(m_pVideoSurfaceOff, NULL, 0);
  1682. HDC hDC;
  1683. if(SUCCEEDED(m_pVideoSurfaceOff->GetDC(&hDC)))
  1684. {
  1685. CString str;
  1686. str.Format(_T("Sorry, this color format is not supported"));
  1688. SetBkColor(hDC, 0);
  1689. SetTextColor(hDC, 0x404040);
  1690. TextOut(hDC, 10, 10, str, str.GetLength());
  1692. m_pVideoSurfaceOff->ReleaseDC(hDC);
  1693. }
  1694. }
  1696. m_pD3DDev->StretchRect(m_pVideoSurfaceOff, NULL, m_pVideoSurface[0], NULL, D3DTEXF_NONE);
  1698. Paint(true);
  1700. return S_OK;
  1701. }