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