61d76a0f99e68380663e6e76c18840ea05511be0
[WebKit-https.git] / Source / WebCore / platform / graphics / ca / win / CACFLayerTreeHost.cpp
1 /*
2  * Copyright (C) 2009 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #include "config.h"
27
28 #if USE(ACCELERATED_COMPOSITING)
29
30 #ifndef NDEBUG
31 #define D3D_DEBUG_INFO
32 #endif
33
34 #include "CACFLayerTreeHost.h"
35
36 #include "PlatformCALayer.h"
37 #include "WebCoreInstanceHandle.h"
38 #include <WebKitSystemInterface/WebKitSystemInterface.h>
39 #include <limits.h>
40 #include <wtf/CurrentTime.h>
41 #include <wtf/HashMap.h>
42 #include <wtf/OwnArrayPtr.h>
43 #include <wtf/OwnPtr.h>
44 #include <wtf/PassOwnPtr.h>
45 #include <wtf/StdLibExtras.h>
46 #include <d3d9.h>
47 #include <d3dx9.h>
48
49 using namespace std;
50
51 #pragma comment(lib, "d3d9")
52 #pragma comment(lib, "d3dx9")
53 #ifdef DEBUG_ALL
54 #pragma comment(lib, "QuartzCore_debug")
55 #else
56 #pragma comment(lib, "QuartzCore")
57 #endif
58
59 static IDirect3D9* s_d3d = 0;
60 static IDirect3D9* d3d()
61 {
62     if (s_d3d)
63         return s_d3d;
64
65     if (!LoadLibrary(TEXT("d3d9.dll")))
66         return 0;
67
68     s_d3d = Direct3DCreate9(D3D_SDK_VERSION);
69
70     return s_d3d;
71 }
72
73 inline static CGRect winRectToCGRect(RECT rc)
74 {
75     return CGRectMake(rc.left, rc.top, (rc.right - rc.left), (rc.bottom - rc.top));
76 }
77
78 inline static CGRect winRectToCGRect(RECT rc, RECT relativeToRect)
79 {
80     return CGRectMake(rc.left, (relativeToRect.bottom-rc.bottom), (rc.right - rc.left), (rc.bottom - rc.top));
81 }
82
83 namespace WebCore {
84
85 static D3DPRESENT_PARAMETERS initialPresentationParameters()
86 {
87     D3DPRESENT_PARAMETERS parameters = {0};
88     parameters.Windowed = TRUE;
89     parameters.SwapEffect = D3DSWAPEFFECT_COPY;
90     parameters.BackBufferCount = 1;
91     parameters.BackBufferFormat = D3DFMT_A8R8G8B8;
92     parameters.MultiSampleType = D3DMULTISAMPLE_NONE;
93
94     return parameters;
95 }
96
97 // FIXME: <rdar://6507851> Share this code with CoreAnimation.
98 static bool hardwareCapabilitiesIndicateCoreAnimationSupport(const D3DCAPS9& caps)
99 {
100     // CoreAnimation needs two or more texture units.
101     if (caps.MaxTextureBlendStages < 2)
102         return false;
103
104     // CoreAnimation needs non-power-of-two textures.
105     if ((caps.TextureCaps & D3DPTEXTURECAPS_POW2) && !(caps.TextureCaps & D3DPTEXTURECAPS_NONPOW2CONDITIONAL))
106         return false;
107
108     // CoreAnimation needs vertex shader 2.0 or greater.
109     if (D3DSHADER_VERSION_MAJOR(caps.VertexShaderVersion) < 2)
110         return false;
111
112     // CoreAnimation needs pixel shader 2.0 or greater.
113     if (D3DSHADER_VERSION_MAJOR(caps.PixelShaderVersion) < 2)
114         return false;
115
116     return true;
117 }
118
119 bool CACFLayerTreeHost::acceleratedCompositingAvailable()
120 {
121     static bool available;
122     static bool tested;
123
124     if (tested)
125         return available;
126
127     tested = true;
128
129     // Initialize available to true since this function will be called from a 
130     // propagation within createRenderer(). We want to be able to return true 
131     // when that happens so that the test can continue.
132     available = true;
133     
134     HMODULE library = LoadLibrary(TEXT("d3d9.dll"));
135     if (!library) {
136         available = false;
137         return available;
138     }
139
140     FreeLibrary(library);
141 #ifdef DEBUG_ALL
142     library = LoadLibrary(TEXT("QuartzCore_debug.dll"));
143 #else
144     library = LoadLibrary(TEXT("QuartzCore.dll"));
145 #endif
146     if (!library) {
147         available = false;
148         return available;
149     }
150
151     FreeLibrary(library);
152
153     // Make a dummy HWND.
154     WNDCLASSEX wcex = { 0 };
155     wcex.cbSize = sizeof(WNDCLASSEX);
156     wcex.lpfnWndProc = DefWindowProc;
157     wcex.hInstance = WebCore::instanceHandle();
158     wcex.lpszClassName = L"CoreAnimationTesterWindowClass";
159     ::RegisterClassEx(&wcex);
160     HWND testWindow = ::CreateWindow(L"CoreAnimationTesterWindowClass", L"CoreAnimationTesterWindow", WS_POPUP, -500, -500, 0, 0, 0, 0, 0, 0);
161
162     if (!testWindow) {
163         available = false;
164         return available;
165     }
166
167     RefPtr<CACFLayerTreeHost> host = CACFLayerTreeHost::create();
168     host->setWindow(testWindow);
169     available = host->createRenderer();
170     ::DestroyWindow(testWindow);
171
172     return available;
173 }
174
175 PassRefPtr<CACFLayerTreeHost> CACFLayerTreeHost::create()
176 {
177     if (!acceleratedCompositingAvailable())
178         return 0;
179     return adoptRef(new CACFLayerTreeHost());
180 }
181
182 CACFLayerTreeHost::CACFLayerTreeHost()
183     : m_client(0)
184     , m_mightBeAbleToCreateDeviceLater(true)
185     , m_rootLayer(PlatformCALayer::create(PlatformCALayer::LayerTypeRootLayer, 0))
186     , m_context(wkCACFContextCreate())
187     , m_window(0)
188     , m_renderTimer(this, &CACFLayerTreeHost::renderTimerFired)
189     , m_mustResetLostDeviceBeforeRendering(false)
190     , m_shouldFlushPendingGraphicsLayerChanges(false)
191 {
192     // Point the CACFContext to this
193     wkCACFContextSetUserData(m_context, this);
194
195     // Under the root layer, we have a clipping layer to clip the content,
196     // that contains a scroll layer that we use for scrolling the content.
197     // The root layer is the size of the client area of the window.
198     // The clipping layer is the size of the WebView client area (window less the scrollbars).
199     // The scroll layer is the size of the root child layer.
200     // Resizing the window will change the bounds of the rootLayer and the clip layer and will not
201     // cause any repositioning.
202     // Scrolling will affect only the position of the scroll layer without affecting the bounds.
203
204     m_rootLayer->setName("CACFLayerTreeHost rootLayer");
205     m_rootLayer->setAnchorPoint(FloatPoint3D(0, 0, 0));
206     m_rootLayer->setGeometryFlipped(true);
207
208 #ifndef NDEBUG
209     CGColorRef debugColor = CGColorCreateGenericRGB(1, 0, 0, 0.8);
210     m_rootLayer->setBackgroundColor(debugColor);
211     CGColorRelease(debugColor);
212 #endif
213
214     if (m_context)
215         wkCACFContextSetLayer(m_context, m_rootLayer->platformLayer());
216
217 #ifndef NDEBUG
218     char* printTreeFlag = getenv("CA_PRINT_TREE");
219     m_printTree = printTreeFlag && atoi(printTreeFlag);
220 #endif
221 }
222
223 CACFLayerTreeHost::~CACFLayerTreeHost()
224 {
225     setWindow(0);
226     wkCACFContextDestroy(m_context);
227 }
228
229 void CACFLayerTreeHost::setWindow(HWND window)
230 {
231     if (window == m_window)
232         return;
233
234     if (m_window)
235         destroyRenderer();
236
237     m_window = window;
238
239     if (m_window)
240         createRenderer();
241 }
242
243 PlatformCALayer* CACFLayerTreeHost::rootLayer() const
244 {
245     return m_rootLayer.get();
246 }
247
248 void CACFLayerTreeHost::addPendingAnimatedLayer(PassRefPtr<PlatformCALayer> layer)
249 {
250     m_pendingAnimatedLayers.add(layer);
251 }
252
253 void CACFLayerTreeHost::setRootChildLayer(PlatformCALayer* layer)
254 {
255     m_rootLayer->removeAllSublayers();
256     m_rootChildLayer = layer;
257     if (m_rootChildLayer)
258         m_rootLayer->appendSublayer(m_rootChildLayer.get());
259 }
260    
261 void CACFLayerTreeHost::layerTreeDidChange()
262 {
263     renderSoon();
264 }
265
266 bool CACFLayerTreeHost::createRenderer()
267 {
268     if (m_d3dDevice || !m_mightBeAbleToCreateDeviceLater)
269         return m_d3dDevice;
270
271     m_mightBeAbleToCreateDeviceLater = false;
272     D3DPRESENT_PARAMETERS parameters = initialPresentationParameters();
273
274     if (!d3d() || !::IsWindow(m_window))
275         return false;
276
277     // D3D doesn't like to make back buffers for 0 size windows. We skirt this problem if we make the
278     // passed backbuffer width and height non-zero. The window will necessarily get set to a non-zero
279     // size eventually, and then the backbuffer size will get reset.
280     RECT rect;
281     GetClientRect(m_window, &rect);
282
283     if (rect.left-rect.right == 0 || rect.bottom-rect.top == 0) {
284         parameters.BackBufferWidth = 1;
285         parameters.BackBufferHeight = 1;
286     }
287
288     D3DCAPS9 d3dCaps;
289     if (FAILED(d3d()->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &d3dCaps)))
290         return false;
291
292     DWORD behaviorFlags = D3DCREATE_FPU_PRESERVE;
293     if ((d3dCaps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT) && d3dCaps.VertexProcessingCaps)
294         behaviorFlags |= D3DCREATE_HARDWARE_VERTEXPROCESSING;
295     else
296         behaviorFlags |= D3DCREATE_SOFTWARE_VERTEXPROCESSING;
297
298     COMPtr<IDirect3DDevice9> device;
299     if (FAILED(d3d()->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, m_window, behaviorFlags, &parameters, &device))) {
300         // In certain situations (e.g., shortly after waking from sleep), Direct3DCreate9() will
301         // return an IDirect3D9 for which IDirect3D9::CreateDevice will always fail. In case we
302         // have one of these bad IDirect3D9s, get rid of it so we'll fetch a new one the next time
303         // we want to call CreateDevice.
304         s_d3d->Release();
305         s_d3d = 0;
306
307         // Even if we don't have a bad IDirect3D9, in certain situations (e.g., shortly after
308         // waking from sleep), CreateDevice will fail, but will later succeed if called again.
309         m_mightBeAbleToCreateDeviceLater = true;
310
311         return false;
312     }
313
314     // Now that we've created the IDirect3DDevice9 based on the capabilities we
315     // got from the IDirect3D9 global object, we requery the device for its
316     // actual capabilities. The capabilities returned by the device can
317     // sometimes be more complete, for example when using software vertex
318     // processing.
319     D3DCAPS9 deviceCaps;
320     if (FAILED(device->GetDeviceCaps(&deviceCaps)))
321         return false;
322
323     if (!hardwareCapabilitiesIndicateCoreAnimationSupport(deviceCaps))
324         return false;
325
326     m_d3dDevice = device;
327
328     initD3DGeometry();
329
330     wkCACFContextSetD3DDevice(m_context, m_d3dDevice.get());
331
332     if (IsWindow(m_window))
333         m_rootLayer->setBounds(bounds());
334
335     return true;
336 }
337
338 void CACFLayerTreeHost::destroyRenderer()
339 {
340     wkCACFContextSetLayer(m_context, m_rootLayer->platformLayer());
341
342     wkCACFContextSetD3DDevice(m_context, 0);
343     m_d3dDevice = 0;
344     if (s_d3d)
345         s_d3d->Release();
346
347     s_d3d = 0;
348     m_rootLayer = 0;
349     m_rootChildLayer = 0;
350
351     m_mightBeAbleToCreateDeviceLater = true;
352 }
353
354 void CACFLayerTreeHost::resize()
355 {
356     if (!m_d3dDevice)
357         return;
358
359     // Resetting the device might fail here. But that's OK, because if it does it we will attempt to
360     // reset the device the next time we try to render.
361     resetDevice(ChangedWindowSize);
362
363     if (m_rootLayer) {
364         m_rootLayer->setBounds(bounds());
365         wkCACFContextFlush(m_context);
366     }
367 }
368
369 static void getDirtyRects(HWND window, Vector<CGRect>& outRects)
370 {
371     ASSERT_ARG(outRects, outRects.isEmpty());
372
373     RECT clientRect;
374     if (!GetClientRect(window, &clientRect))
375         return;
376
377     OwnPtr<HRGN> region(CreateRectRgn(0, 0, 0, 0));
378     int regionType = GetUpdateRgn(window, region.get(), false);
379     if (regionType != COMPLEXREGION) {
380         RECT dirtyRect;
381         if (GetUpdateRect(window, &dirtyRect, false))
382             outRects.append(winRectToCGRect(dirtyRect, clientRect));
383         return;
384     }
385
386     DWORD dataSize = GetRegionData(region.get(), 0, 0);
387     OwnArrayPtr<unsigned char> regionDataBuffer(new unsigned char[dataSize]);
388     RGNDATA* regionData = reinterpret_cast<RGNDATA*>(regionDataBuffer.get());
389     if (!GetRegionData(region.get(), dataSize, regionData))
390         return;
391
392     outRects.resize(regionData->rdh.nCount);
393
394     RECT* rect = reinterpret_cast<RECT*>(regionData->Buffer);
395     for (size_t i = 0; i < outRects.size(); ++i, ++rect)
396         outRects[i] = winRectToCGRect(*rect, clientRect);
397 }
398
399 void CACFLayerTreeHost::renderTimerFired(Timer<CACFLayerTreeHost>*)
400 {
401     paint();
402 }
403
404 void CACFLayerTreeHost::paint()
405 {
406     createRenderer();
407     if (!m_d3dDevice) {
408         if (m_mightBeAbleToCreateDeviceLater)
409             renderSoon();
410         return;
411     }
412
413     Vector<CGRect> dirtyRects;
414     getDirtyRects(m_window, dirtyRects);
415     render(dirtyRects);
416 }
417
418 void CACFLayerTreeHost::render(const Vector<CGRect>& windowDirtyRects)
419 {
420     ASSERT(m_d3dDevice);
421
422     if (m_mustResetLostDeviceBeforeRendering && !resetDevice(LostDevice)) {
423         // We can't reset the device right now. Try again soon.
424         renderSoon();
425         return;
426     }
427
428     if (m_client && !m_client->shouldRender()) {
429         renderSoon();
430         return;
431     }
432
433     if (m_shouldFlushPendingGraphicsLayerChanges) {
434         m_client->flushPendingGraphicsLayerChanges();
435         m_shouldFlushPendingGraphicsLayerChanges = false;
436     }
437
438     // Flush the root layer to the render tree.
439     wkCACFContextFlush(m_context);
440
441     // All pending animations will have been started with the flush. Fire the animationStarted calls
442     double currentTime = WTF::currentTime();
443     double currentMediaTime = CACurrentMediaTime();
444     double t = currentTime + wkCACFContextGetLastCommitTime(m_context) - currentMediaTime;
445     ASSERT(t <= currentTime);
446
447     HashSet<RefPtr<PlatformCALayer> >::iterator end = m_pendingAnimatedLayers.end();
448     for (HashSet<RefPtr<PlatformCALayer> >::iterator it = m_pendingAnimatedLayers.begin(); it != end; ++it) {
449         PlatformCALayerClient* owner = (*it)->owner();
450         owner->platformCALayerAnimationStarted(t);
451     }
452
453     m_pendingAnimatedLayers.clear();
454
455     CGRect bounds = this->bounds();
456
457     // Give the renderer some space to use. This needs to be valid until the
458     // wkCACFContextFinishUpdate() call below.
459     char space[4096];
460     if (!wkCACFContextBeginUpdate(m_context, space, sizeof(space), currentMediaTime, bounds, windowDirtyRects.data(), windowDirtyRects.size()))
461         return;
462
463     HRESULT err = S_OK;
464     CFTimeInterval timeToNextRender = numeric_limits<CFTimeInterval>::infinity();
465
466     do {
467         // FIXME: don't need to clear dirty region if layer tree is opaque.
468
469         WKCACFUpdateRectEnumerator* e = wkCACFContextCopyUpdateRectEnumerator(m_context);
470         if (!e)
471             break;
472
473         Vector<D3DRECT, 64> rects;
474         for (const CGRect* r = wkCACFUpdateRectEnumeratorNextRect(e); r; r = wkCACFUpdateRectEnumeratorNextRect(e)) {
475             D3DRECT rect;
476             rect.x1 = r->origin.x;
477             rect.x2 = rect.x1 + r->size.width;
478             rect.y1 = bounds.origin.y + bounds.size.height - (r->origin.y + r->size.height);
479             rect.y2 = rect.y1 + r->size.height;
480
481             rects.append(rect);
482         }
483         wkCACFUpdateRectEnumeratorRelease(e);
484
485         timeToNextRender = wkCACFContextGetNextUpdateTime(m_context);
486
487         if (rects.isEmpty())
488             break;
489
490         m_d3dDevice->Clear(rects.size(), rects.data(), D3DCLEAR_TARGET, 0, 1.0f, 0);
491
492         m_d3dDevice->BeginScene();
493         wkCACFContextRenderUpdate(m_context);
494         m_d3dDevice->EndScene();
495
496         err = m_d3dDevice->Present(0, 0, 0, 0);
497
498         if (err == D3DERR_DEVICELOST) {
499             wkCACFContextAddUpdateRect(m_context, bounds);
500             if (!resetDevice(LostDevice)) {
501                 // We can't reset the device right now. Try again soon.
502                 renderSoon();
503                 return;
504             }
505         }
506     } while (err == D3DERR_DEVICELOST);
507
508     wkCACFContextFinishUpdate(m_context);
509
510 #ifndef NDEBUG
511     if (m_printTree)
512         m_rootLayer->printTree();
513 #endif
514
515     // If timeToNextRender is not infinity, it means animations are running, so queue up to render again
516     if (timeToNextRender != numeric_limits<CFTimeInterval>::infinity())
517         renderSoon();
518 }
519
520 void CACFLayerTreeHost::renderSoon()
521 {
522     if (!m_renderTimer.isActive())
523         m_renderTimer.startOneShot(0);
524 }
525
526 void CACFLayerTreeHost::flushPendingGraphicsLayerChangesSoon()
527 {
528     m_shouldFlushPendingGraphicsLayerChanges = true;
529     renderSoon();
530 }
531
532 CGRect CACFLayerTreeHost::bounds() const
533 {
534     RECT clientRect;
535     GetClientRect(m_window, &clientRect);
536
537     return winRectToCGRect(clientRect);
538 }
539
540 void CACFLayerTreeHost::initD3DGeometry()
541 {
542     ASSERT(m_d3dDevice);
543
544     CGRect bounds = this->bounds();
545
546     float x0 = bounds.origin.x;
547     float y0 = bounds.origin.y;
548     float x1 = x0 + bounds.size.width;
549     float y1 = y0 + bounds.size.height;
550
551     D3DXMATRIXA16 projection;
552     D3DXMatrixOrthoOffCenterRH(&projection, x0, x1, y0, y1, -1.0f, 1.0f);
553
554     m_d3dDevice->SetTransform(D3DTS_PROJECTION, &projection);
555 }
556
557 bool CACFLayerTreeHost::resetDevice(ResetReason reason)
558 {
559     ASSERT(m_d3dDevice);
560     ASSERT(m_context);
561
562     HRESULT hr = m_d3dDevice->TestCooperativeLevel();
563
564     if (hr == D3DERR_DEVICELOST || hr == D3DERR_DRIVERINTERNALERROR) {
565         // The device cannot be reset at this time. Try again soon.
566         m_mustResetLostDeviceBeforeRendering = true;
567         return false;
568     }
569
570     m_mustResetLostDeviceBeforeRendering = false;
571
572     if (reason == LostDevice && hr == D3D_OK) {
573         // The device wasn't lost after all.
574         return true;
575     }
576
577     // We can reset the device.
578
579     // We have to release the context's D3D resrouces whenever we reset the IDirect3DDevice9 in order to
580     // destroy any D3DPOOL_DEFAULT resources that Core Animation has allocated (e.g., textures used
581     // for mask layers). See <http://msdn.microsoft.com/en-us/library/bb174425(v=VS.85).aspx>.
582     wkCACFContextReleaseD3DResources(m_context);
583
584     D3DPRESENT_PARAMETERS parameters = initialPresentationParameters();
585     hr = m_d3dDevice->Reset(&parameters);
586
587     // TestCooperativeLevel told us the device may be reset now, so we should
588     // not be told here that the device is lost.
589     ASSERT(hr != D3DERR_DEVICELOST);
590
591     initD3DGeometry();
592
593     return true;
594 }
595
596 }
597
598 #endif // USE(ACCELERATED_COMPOSITING)