summaryrefslogtreecommitdiffstats
path: root/gfx/layers/d3d9/DeviceManagerD3D9.h
blob: 394f84d9cd689736a0f0967bd913f15f61b7dfe9 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef GFX_DEVICEMANAGERD3D9_H
#define GFX_DEVICEMANAGERD3D9_H

#include "gfxTypes.h"
#include "nsAutoPtr.h"
#include "d3d9.h"
#include "nsTArray.h"
#include "mozilla/layers/CompositorTypes.h"
#include "mozilla/RefPtr.h"
#include "mozilla/gfx/Rect.h"

namespace mozilla {
namespace layers {

class DeviceManagerD3D9;
class Layer;
class TextureSourceD3D9;

// Shader Constant locations
const int CBmLayerTransform = 0;
const int CBmProjection = 4;
const int CBvRenderTargetOffset = 8;
const int CBvTextureCoords = 9;
const int CBvLayerQuad = 10;
// we don't use opacity with solid color shaders
const int CBfLayerOpacity = 0;
const int CBvColor = 0;
const int CBmYuvColorMatrix = 1;

enum DeviceManagerState {
  // The device and swap chain are OK.
  DeviceOK,
  // The device or swap chain are in a bad state, and we should not render.
  DeviceFail,
  // The device is lost and cannot be reset, the user should forget the
  // current device manager and create a new one.
  DeviceMustRecreate,
};


/**
 * This structure is used to pass rectangles to our shader constant. We can use
 * this for passing rectangular areas to SetVertexShaderConstant. In the format
 * of a 4 component float(x,y,width,height). Our vertex shader can then use
 * this to construct rectangular positions from the 0,0-1,1 quad that we source
 * it with.
 */
struct ShaderConstantRect
{
  float mX, mY, mWidth, mHeight;

  // Provide all the commonly used argument types to prevent all the local
  // casts in the code.
  ShaderConstantRect(float aX, float aY, float aWidth, float aHeight)
    : mX(aX), mY(aY), mWidth(aWidth), mHeight(aHeight)
  { }

  ShaderConstantRect(int32_t aX, int32_t aY, int32_t aWidth, int32_t aHeight)
    : mX((float)aX), mY((float)aY)
    , mWidth((float)aWidth), mHeight((float)aHeight)
  { }

  ShaderConstantRect(int32_t aX, int32_t aY, float aWidth, float aHeight)
    : mX((float)aX), mY((float)aY), mWidth(aWidth), mHeight(aHeight)
  { }

  // For easy passing to SetVertexShaderConstantF.
  operator float* () { return &mX; }
};

/**
 * SwapChain class, this class manages the swap chain belonging to a
 * LayerManagerD3D9.
 */
class SwapChainD3D9 final
{
  NS_INLINE_DECL_REFCOUNTING(SwapChainD3D9)
public:

  /**
   * This function will prepare the device this swap chain belongs to for
   * rendering to this swap chain. Only after calling this function can the
   * swap chain be drawn to, and only until this function is called on another
   * swap chain belonging to this device will the device draw to it. Passed in
   * is the size of the swap chain. If the window size differs from the size
   * during the last call to this function the swap chain will resize. Note that
   * in no case does this function guarantee the backbuffer to still have its
   * old content.
   */
  DeviceManagerState PrepareForRendering();

  already_AddRefed<IDirect3DSurface9> GetBackBuffer();

  /**
   * This function will present the selected rectangle of the swap chain to
   * its associated window.
   */
  void Present(const gfx::IntRect &aRect);
  void Present();

private:
  friend class DeviceManagerD3D9;

  SwapChainD3D9(DeviceManagerD3D9 *aDeviceManager);

  // Private destructor, to discourage deletion outside of Release():
  ~SwapChainD3D9();
  
  bool Init(HWND hWnd);

  /**
   * This causes us to release our swap chain, clearing out our resource usage
   * so the master device may reset.
   */
  void Reset();

  RefPtr<IDirect3DSwapChain9> mSwapChain;
  RefPtr<DeviceManagerD3D9> mDeviceManager;
  HWND mWnd;
};

/**
 * Device manager, this class is used by the layer managers to share the D3D9
 * device and create swap chains for the individual windows the layer managers
 * belong to.
 */
class DeviceManagerD3D9 final
{
public:
  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(DeviceManagerD3D9)

  /**
   * Setup or tear down static resources needed for D3D9.
   */
  static void Init();
  static void Shutdown();

  /**
   * Static accessors and helpers for accessing the global DeviceManagerD3D9
   * instance.
   */
  static RefPtr<DeviceManagerD3D9> Get();
  static RefPtr<IDirect3DDevice9> GetDevice();
  static void OnDeviceManagerDestroy(DeviceManagerD3D9* aDeviceManager);

  /**
   * Sets up the render state for the device for layer rendering.
   */
  void SetupRenderState();

  /**
   * Create a swap chain setup to work with the specified window.
   */
  already_AddRefed<SwapChainD3D9> CreateSwapChain(HWND hWnd);

  IDirect3DDevice9 *device() { return mDevice; }

  bool IsD3D9Ex() { return mDeviceEx; }

  bool HasComponentAlpha() { return mHasComponentAlpha; }

  bool HasDynamicTextures() { return mHasDynamicTextures; }

  enum ShaderMode {
    RGBLAYER,
    RGBALAYER,
    COMPONENTLAYERPASS1,
    COMPONENTLAYERPASS2,
    YCBCRLAYER,
    SOLIDCOLORLAYER
  };

  // returns the register to be used for the mask texture, if appropriate
  uint32_t SetShaderMode(ShaderMode aMode, MaskType aMaskType);

  /**
   * Returns true if this device was removed.
   */
  bool DeviceWasRemoved() { return mDeviceWasRemoved; }

  uint32_t GetDeviceResetCount() { return mDeviceResetCount; }

  int32_t GetMaxTextureSize() { return mMaxTextureSize; }

  // Removes aHost from our list of texture hosts if it is the head.
  void RemoveTextureListHead(TextureSourceD3D9* aHost);

  /**
   * Creates a texture using our device.
   * If needed, we keep a record of the new texture, so the texture can be
   * released. In this case, aTextureHostIDirect3DTexture9 must be non-null.
   */
  already_AddRefed<IDirect3DTexture9> CreateTexture(const gfx::IntSize &aSize,
                                                _D3DFORMAT aFormat,
                                                D3DPOOL aPool,
                                                TextureSourceD3D9* aTextureHostIDirect3DTexture9);
#ifdef DEBUG
  // Looks for aFind in the list of texture hosts.
  // O(n) so only use for assertions.
  bool IsInTextureHostList(TextureSourceD3D9* aFind);
#endif

  /**
   * This function verifies the device is ready for rendering, internally this
   * will test the cooperative level of the device and reset the device if
   * needed. If this returns false subsequent rendering calls may return errors.
   */
  DeviceManagerState VerifyReadyForRendering();

  static uint32_t sMaskQuadRegister;

private:
  friend class SwapChainD3D9;

  DeviceManagerD3D9();
  ~DeviceManagerD3D9();

  /**
   * Initialises the device manager, the underlying device, and everything else
   * the manager needs.
   * Returns true if initialisation succeeds, false otherwise.
   * Note that if initisalisation fails, you cannot try again - you must throw
   * away the DeviceManagerD3D9 and create a new one.
   */
  bool Initialize();

  void DestroyDevice();

  /**
   * This will fill our vertex buffer with the data of our quad, it may be
   * called when the vertex buffer is recreated.
   */
  bool CreateVertexBuffer();

  /**
   * Release all textures created by this device manager.
   */
  void ReleaseTextureResources();
  /**
   * Add aHost to our list of texture hosts.
   */
  void RegisterTextureHost(TextureSourceD3D9* aHost);

  /* Array used to store all swap chains for device resets */
  nsTArray<SwapChainD3D9*> mSwapChains;

  /* The D3D device we use */
  RefPtr<IDirect3DDevice9> mDevice;

  /* The D3D9Ex device - only valid on Vista+ with WDDM */
  RefPtr<IDirect3DDevice9Ex> mDeviceEx;

  /* An instance of the D3D9 object */
  RefPtr<IDirect3D9> mD3D9;

  /* An instance of the D3D9Ex object - only valid on Vista+ with WDDM */
  RefPtr<IDirect3D9Ex> mD3D9Ex;

  /* Vertex shader used for layer quads */
  RefPtr<IDirect3DVertexShader9> mLayerVS;

  /* Pixel shader used for RGB textures */
  RefPtr<IDirect3DPixelShader9> mRGBPS;

  /* Pixel shader used for RGBA textures */
  RefPtr<IDirect3DPixelShader9> mRGBAPS;

  /* Pixel shader used for component alpha textures (pass 1) */
  RefPtr<IDirect3DPixelShader9> mComponentPass1PS;

  /* Pixel shader used for component alpha textures (pass 2) */
  RefPtr<IDirect3DPixelShader9> mComponentPass2PS;

  /* Pixel shader used for RGB textures */
  RefPtr<IDirect3DPixelShader9> mYCbCrPS;

  /* Pixel shader used for solid colors */
  RefPtr<IDirect3DPixelShader9> mSolidColorPS;

  /* As above, but using a mask layer */
  RefPtr<IDirect3DVertexShader9> mLayerVSMask;
  RefPtr<IDirect3DPixelShader9> mRGBPSMask;
  RefPtr<IDirect3DPixelShader9> mRGBAPSMask;
  RefPtr<IDirect3DPixelShader9> mComponentPass1PSMask;
  RefPtr<IDirect3DPixelShader9> mComponentPass2PSMask;
  RefPtr<IDirect3DPixelShader9> mYCbCrPSMask;
  RefPtr<IDirect3DPixelShader9> mSolidColorPSMask;

  /* Vertex buffer containing our basic vertex structure */
  RefPtr<IDirect3DVertexBuffer9> mVB;

  /* Our vertex declaration */
  RefPtr<IDirect3DVertexDeclaration9> mVD;

  /* We maintain a doubly linked list of all d3d9 texture hosts which host
   * d3d9 textures created by this device manager.
   * Texture hosts must remove themselves when they disappear (i.e., we
   * expect all hosts in the list to be valid).
   * The list is cleared when we release the textures.
   */
  TextureSourceD3D9* mTextureHostList;

  /* Our focus window - this is really a dummy window we can associate our
   * device with.
   */
  HWND mFocusWnd;

  /* we use this to help track if our device temporarily or permanently lost */
  HMONITOR mDeviceMonitor;

  uint32_t mDeviceResetCount;

  uint32_t mMaxTextureSize;

  /**
   * Wrap (repeat) or clamp textures. We prefer the former so we can do buffer
   * rotation, but some older hardware doesn't support it.
   */
  D3DTEXTUREADDRESS mTextureAddressingMode;

  /* If this device supports component alpha */
  bool mHasComponentAlpha;

  /* If this device supports dynamic textures */
  bool mHasDynamicTextures;

  /* If this device was removed */
  bool mDeviceWasRemoved;

  /**
   * Verifies all required device capabilities are present.
   */
  bool VerifyCaps();
};

} /* namespace layers */
} /* namespace mozilla */

#endif /* GFX_DEVICEMANAGERD3D9_H */