Remove uses of CACFContextRef and CARender* from WebCore
[WebKit-https.git] / WebCore / platform / graphics / win / WKCACFLayerRenderer.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 "WKCACFLayerRenderer.h"
35
36 #include "WKCACFContextFlusher.h"
37 #include "WKCACFLayer.h"
38 #include "WebCoreInstanceHandle.h"
39 #include <WebKitSystemInterface/WebKitSystemInterface.h>
40 #include <wtf/HashMap.h>
41 #include <wtf/OwnArrayPtr.h>
42 #include <wtf/OwnPtr.h>
43 #include <wtf/PassOwnPtr.h>
44 #include <wtf/StdLibExtras.h>
45 #include <d3d9.h>
46 #include <d3dx9.h>
47
48 #pragma comment(lib, "d3d9")
49 #pragma comment(lib, "d3dx9")
50 #ifdef DEBUG_ALL
51 #pragma comment(lib, "QuartzCore_debug")
52 #else
53 #pragma comment(lib, "QuartzCore")
54 #endif
55
56 static IDirect3D9* s_d3d = 0;
57 static IDirect3D9* d3d()
58 {
59     if (s_d3d)
60         return s_d3d;
61
62     if (!LoadLibrary(TEXT("d3d9.dll")))
63         return 0;
64
65     s_d3d = Direct3DCreate9(D3D_SDK_VERSION);
66
67     return s_d3d;
68 }
69
70 inline static CGRect winRectToCGRect(RECT rc)
71 {
72     return CGRectMake(rc.left, rc.top, (rc.right - rc.left), (rc.bottom - rc.top));
73 }
74
75 inline static CGRect winRectToCGRect(RECT rc, RECT relativeToRect)
76 {
77     return CGRectMake(rc.left, (relativeToRect.bottom-rc.bottom), (rc.right - rc.left), (rc.bottom - rc.top));
78 }
79
80 namespace WebCore {
81
82 // Subclass of WKCACFLayer to allow the root layer to have a back pointer to the layer renderer
83 // to fire off a draw
84 class WKCACFRootLayer : public WKCACFLayer {
85 public:
86     WKCACFRootLayer(WKCACFLayerRenderer* renderer)
87         : WKCACFLayer(WKCACFLayer::Layer)
88     {
89         m_renderer = renderer;
90     }
91
92     static PassRefPtr<WKCACFRootLayer> create(WKCACFLayerRenderer* renderer)
93     {
94         if (!WKCACFLayerRenderer::acceleratedCompositingAvailable())
95             return 0;
96         return adoptRef(new WKCACFRootLayer(renderer));
97     }
98
99     virtual void setNeedsRender() { m_renderer->layerTreeDidChange(); }
100
101     // Overload this to avoid calling setNeedsDisplay on the layer, which would override the contents
102     // we have placed on the root layer.
103     virtual void setNeedsDisplay(const CGRect* dirtyRect) { setNeedsCommit(); }
104
105 private:
106     WKCACFLayerRenderer* m_renderer;
107 };
108
109 typedef HashMap<WKCACFContext*, WKCACFLayerRenderer*> ContextToWindowMap;
110
111 static ContextToWindowMap& windowsForContexts()
112 {
113     DEFINE_STATIC_LOCAL(ContextToWindowMap, map, ());
114     return map;
115 }
116
117 static D3DPRESENT_PARAMETERS initialPresentationParameters()
118 {
119     D3DPRESENT_PARAMETERS parameters = {0};
120     parameters.Windowed = TRUE;
121     parameters.SwapEffect = D3DSWAPEFFECT_COPY;
122     parameters.BackBufferCount = 1;
123     parameters.BackBufferFormat = D3DFMT_A8R8G8B8;
124     parameters.MultiSampleType = D3DMULTISAMPLE_NONE;
125
126     return parameters;
127 }
128
129 // FIXME: <rdar://6507851> Share this code with CoreAnimation.
130 static bool hardwareCapabilitiesIndicateCoreAnimationSupport(const D3DCAPS9& caps)
131 {
132     // CoreAnimation needs two or more texture units.
133     if (caps.MaxTextureBlendStages < 2)
134         return false;
135
136     // CoreAnimation needs non-power-of-two textures.
137     if ((caps.TextureCaps & D3DPTEXTURECAPS_POW2) && !(caps.TextureCaps & D3DPTEXTURECAPS_NONPOW2CONDITIONAL))
138         return false;
139
140     // CoreAnimation needs vertex shader 2.0 or greater.
141     if (D3DSHADER_VERSION_MAJOR(caps.VertexShaderVersion) < 2)
142         return false;
143
144     // CoreAnimation needs pixel shader 2.0 or greater.
145     if (D3DSHADER_VERSION_MAJOR(caps.PixelShaderVersion) < 2)
146         return false;
147
148     return true;
149 }
150
151 bool WKCACFLayerRenderer::acceleratedCompositingAvailable()
152 {
153     static bool available;
154     static bool tested;
155
156     if (tested)
157         return available;
158
159     tested = true;
160
161     // Initialize available to true since this function will be called from a 
162     // propagation within createRenderer(). We want to be able to return true 
163     // when that happens so that the test can continue.
164     available = true;
165     
166     HMODULE library = LoadLibrary(TEXT("d3d9.dll"));
167     if (!library) {
168         available = false;
169         return available;
170     }
171
172     FreeLibrary(library);
173 #ifdef DEBUG_ALL
174     library = LoadLibrary(TEXT("QuartzCore_debug.dll"));
175 #else
176     library = LoadLibrary(TEXT("QuartzCore.dll"));
177 #endif
178     if (!library) {
179         available = false;
180         return available;
181     }
182
183     FreeLibrary(library);
184
185     // Make a dummy HWND.
186     WNDCLASSEX wcex = { 0 };
187     wcex.cbSize = sizeof(WNDCLASSEX);
188     wcex.lpfnWndProc = DefWindowProc;
189     wcex.hInstance = WebCore::instanceHandle();
190     wcex.lpszClassName = L"CoreAnimationTesterWindowClass";
191     ::RegisterClassEx(&wcex);
192     HWND testWindow = ::CreateWindow(L"CoreAnimationTesterWindowClass", L"CoreAnimationTesterWindow", WS_POPUP, -500, -500, 0, 0, 0, 0, 0, 0);
193
194     if (!testWindow) {
195         available = false;
196         return available;
197     }
198
199     OwnPtr<WKCACFLayerRenderer> testLayerRenderer = WKCACFLayerRenderer::create(0);
200     testLayerRenderer->setHostWindow(testWindow);
201     available = testLayerRenderer->createRenderer();
202     ::DestroyWindow(testWindow);
203
204     return available;
205 }
206
207 void WKCACFLayerRenderer::didFlushContext(WKCACFContext* context)
208 {
209     WKCACFLayerRenderer* window = windowsForContexts().get(context);
210     if (!window)
211         return;
212
213     window->renderSoon();
214 }
215
216 PassOwnPtr<WKCACFLayerRenderer> WKCACFLayerRenderer::create(WKCACFLayerRendererClient* client)
217 {
218     if (!acceleratedCompositingAvailable())
219         return 0;
220     return new WKCACFLayerRenderer(client);
221 }
222
223 WKCACFLayerRenderer::WKCACFLayerRenderer(WKCACFLayerRendererClient* client)
224     : m_client(client)
225     , m_mightBeAbleToCreateDeviceLater(true)
226     , m_rootLayer(WKCACFRootLayer::create(this))
227     , m_context(wkCACFContextCreate())
228     , m_hostWindow(0)
229     , m_renderTimer(this, &WKCACFLayerRenderer::renderTimerFired)
230     , m_backingStoreDirty(false)
231     , m_mustResetLostDeviceBeforeRendering(false)
232 {
233     windowsForContexts().set(m_context, this);
234
235     // Under the root layer, we have a clipping layer to clip the content,
236     // that contains a scroll layer that we use for scrolling the content.
237     // The root layer is the size of the client area of the window.
238     // The clipping layer is the size of the WebView client area (window less the scrollbars).
239     // The scroll layer is the size of the root child layer.
240     // Resizing the window will change the bounds of the rootLayer and the clip layer and will not
241     // cause any repositioning.
242     // Scrolling will affect only the position of the scroll layer without affecting the bounds.
243
244     m_rootLayer->setName("WKCACFLayerRenderer rootLayer");
245     m_rootLayer->setAnchorPoint(CGPointMake(0, 0));
246     m_rootLayer->setGeometryFlipped(true);
247
248 #ifndef NDEBUG
249     CGColorRef debugColor = CGColorCreateGenericRGB(1, 0, 0, 0.8);
250     m_rootLayer->setBackgroundColor(debugColor);
251     CGColorRelease(debugColor);
252 #endif
253
254     if (m_context)
255         m_rootLayer->becomeRootLayerForContext(m_context);
256
257 #ifndef NDEBUG
258     char* printTreeFlag = getenv("CA_PRINT_TREE");
259     m_printTree = printTreeFlag && atoi(printTreeFlag);
260 #endif
261 }
262
263 WKCACFLayerRenderer::~WKCACFLayerRenderer()
264 {
265     destroyRenderer();
266     wkCACFContextDestroy(m_context);
267 }
268
269 WKCACFLayer* WKCACFLayerRenderer::rootLayer() const
270 {
271     return m_rootLayer.get();
272 }
273
274 void WKCACFLayerRenderer::setRootContents(CGImageRef image)
275 {
276     ASSERT(m_rootLayer);
277     m_rootLayer->setContents(image);
278     renderSoon();
279 }
280
281 void WKCACFLayerRenderer::setRootContentsAndDisplay(CGImageRef image)
282 {
283     ASSERT(m_rootLayer);
284     m_rootLayer->setContents(image);
285     paint();
286 }
287
288 void WKCACFLayerRenderer::setRootChildLayer(WKCACFLayer* layer)
289 {
290     m_rootLayer->removeAllSublayers();
291     m_rootChildLayer = layer;
292     if (m_rootChildLayer)
293         m_rootLayer->addSublayer(m_rootChildLayer);
294 }
295    
296 void WKCACFLayerRenderer::layerTreeDidChange()
297 {
298     WKCACFContextFlusher::shared().addContext(m_context);
299     renderSoon();
300 }
301
302 void WKCACFLayerRenderer::setNeedsDisplay()
303 {
304     ASSERT(m_rootLayer);
305     m_rootLayer->setNeedsDisplay(0);
306     renderSoon();
307 }
308
309 bool WKCACFLayerRenderer::createRenderer()
310 {
311     if (m_d3dDevice || !m_mightBeAbleToCreateDeviceLater)
312         return m_d3dDevice;
313
314     m_mightBeAbleToCreateDeviceLater = false;
315     D3DPRESENT_PARAMETERS parameters = initialPresentationParameters();
316
317     if (!d3d() || !::IsWindow(m_hostWindow))
318         return false;
319
320     // D3D doesn't like to make back buffers for 0 size windows. We skirt this problem if we make the
321     // passed backbuffer width and height non-zero. The window will necessarily get set to a non-zero
322     // size eventually, and then the backbuffer size will get reset.
323     RECT rect;
324     GetClientRect(m_hostWindow, &rect);
325
326     if (rect.left-rect.right == 0 || rect.bottom-rect.top == 0) {
327         parameters.BackBufferWidth = 1;
328         parameters.BackBufferHeight = 1;
329     }
330
331     D3DCAPS9 d3dCaps;
332     if (FAILED(d3d()->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &d3dCaps)))
333         return false;
334
335     DWORD behaviorFlags = D3DCREATE_FPU_PRESERVE;
336     if ((d3dCaps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT) && d3dCaps.VertexProcessingCaps)
337         behaviorFlags |= D3DCREATE_HARDWARE_VERTEXPROCESSING;
338     else
339         behaviorFlags |= D3DCREATE_SOFTWARE_VERTEXPROCESSING;
340
341     COMPtr<IDirect3DDevice9> device;
342     if (FAILED(d3d()->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, m_hostWindow, behaviorFlags, &parameters, &device))) {
343         // In certain situations (e.g., shortly after waking from sleep), Direct3DCreate9() will
344         // return an IDirect3D9 for which IDirect3D9::CreateDevice will always fail. In case we
345         // have one of these bad IDirect3D9s, get rid of it so we'll fetch a new one the next time
346         // we want to call CreateDevice.
347         s_d3d->Release();
348         s_d3d = 0;
349
350         // Even if we don't have a bad IDirect3D9, in certain situations (e.g., shortly after
351         // waking from sleep), CreateDevice will fail, but will later succeed if called again.
352         m_mightBeAbleToCreateDeviceLater = true;
353
354         return false;
355     }
356
357     // Now that we've created the IDirect3DDevice9 based on the capabilities we
358     // got from the IDirect3D9 global object, we requery the device for its
359     // actual capabilities. The capabilities returned by the device can
360     // sometimes be more complete, for example when using software vertex
361     // processing.
362     D3DCAPS9 deviceCaps;
363     if (FAILED(device->GetDeviceCaps(&deviceCaps)))
364         return false;
365
366     if (!hardwareCapabilitiesIndicateCoreAnimationSupport(deviceCaps))
367         return false;
368
369     m_d3dDevice = device;
370
371     initD3DGeometry();
372
373     wkCACFContextInitializeD3DDevice(m_context, m_d3dDevice.get());
374
375     if (IsWindow(m_hostWindow))
376         m_rootLayer->setBounds(bounds());
377
378     return true;
379 }
380
381 void WKCACFLayerRenderer::destroyRenderer()
382 {
383     if (m_context) {
384         windowsForContexts().remove(m_context);
385         WKCACFContextFlusher::shared().removeContext(m_context);
386     }
387
388     m_d3dDevice = 0;
389     if (s_d3d)
390         s_d3d->Release();
391
392     s_d3d = 0;
393     m_rootLayer = 0;
394     m_rootChildLayer = 0;
395
396     m_mightBeAbleToCreateDeviceLater = true;
397 }
398
399 void WKCACFLayerRenderer::resize()
400 {
401     if (!m_d3dDevice)
402         return;
403
404     // Resetting the device might fail here. But that's OK, because if it does it we will attempt to
405     // reset the device the next time we try to render.
406     resetDevice(ChangedWindowSize);
407
408     if (m_rootLayer) {
409         m_rootLayer->setBounds(bounds());
410         WKCACFContextFlusher::shared().flushAllContexts();
411     }
412 }
413
414 static void getDirtyRects(HWND window, Vector<CGRect>& outRects)
415 {
416     ASSERT_ARG(outRects, outRects.isEmpty());
417
418     RECT clientRect;
419     if (!GetClientRect(window, &clientRect))
420         return;
421
422     OwnPtr<HRGN> region(CreateRectRgn(0, 0, 0, 0));
423     int regionType = GetUpdateRgn(window, region.get(), false);
424     if (regionType != COMPLEXREGION) {
425         RECT dirtyRect;
426         if (GetUpdateRect(window, &dirtyRect, false))
427             outRects.append(winRectToCGRect(dirtyRect, clientRect));
428         return;
429     }
430
431     DWORD dataSize = GetRegionData(region.get(), 0, 0);
432     OwnArrayPtr<unsigned char> regionDataBuffer(new unsigned char[dataSize]);
433     RGNDATA* regionData = reinterpret_cast<RGNDATA*>(regionDataBuffer.get());
434     if (!GetRegionData(region.get(), dataSize, regionData))
435         return;
436
437     outRects.resize(regionData->rdh.nCount);
438
439     RECT* rect = reinterpret_cast<RECT*>(regionData->Buffer);
440     for (size_t i = 0; i < outRects.size(); ++i, ++rect)
441         outRects[i] = winRectToCGRect(*rect, clientRect);
442 }
443
444 void WKCACFLayerRenderer::renderTimerFired(Timer<WKCACFLayerRenderer>*)
445 {
446     paint();
447 }
448
449 void WKCACFLayerRenderer::paint()
450 {
451     createRenderer();
452     if (!m_d3dDevice) {
453         if (m_mightBeAbleToCreateDeviceLater)
454             renderSoon();
455         return;
456     }
457
458     if (m_backingStoreDirty) {
459         // If the backing store is still dirty when we are about to draw the
460         // composited content, we need to force the window to paint into the
461         // backing store. The paint will only paint the dirty region that
462         // if being tracked in WebView.
463         UpdateWindow(m_hostWindow);
464         return;
465     }
466
467     Vector<CGRect> dirtyRects;
468     getDirtyRects(m_hostWindow, dirtyRects);
469     render(dirtyRects);
470 }
471
472 void WKCACFLayerRenderer::render(const Vector<CGRect>& windowDirtyRects)
473 {
474     ASSERT(m_d3dDevice);
475
476     if (m_mustResetLostDeviceBeforeRendering && !resetDevice(LostDevice)) {
477         // We can't reset the device right now. Try again soon.
478         renderSoon();
479         return;
480     }
481
482     if (m_client && !m_client->shouldRender()) {
483         renderSoon();
484         return;
485     }
486
487     // Flush the root layer to the render tree.
488     WKCACFContextFlusher::shared().flushAllContexts();
489
490     CGRect bounds = this->bounds();
491
492     CFTimeInterval t = CACurrentMediaTime();
493
494     // Give the renderer some space to use. This needs to be valid until the
495     // wkCACFContextFinishUpdate() call below.
496     char space[4096];
497     if (!wkCACFContextBeginUpdate(m_context, space, sizeof(space), t, bounds, windowDirtyRects.data(), windowDirtyRects.size()))
498         return;
499
500     HRESULT err = S_OK;
501     do {
502         // FIXME: don't need to clear dirty region if layer tree is opaque.
503
504         WKCACFUpdateRectEnumerator* e = wkCACFContextCopyUpdateRectEnumerator(m_context);
505         if (!e)
506             break;
507
508         Vector<D3DRECT, 64> rects;
509         for (const CGRect* r = wkCACFUpdateRectEnumeratorNextRect(e); r; r = wkCACFUpdateRectEnumeratorNextRect(e)) {
510             D3DRECT rect;
511             rect.x1 = r->origin.x;
512             rect.x2 = rect.x1 + r->size.width;
513             rect.y1 = bounds.origin.y + bounds.size.height - (r->origin.y + r->size.height);
514             rect.y2 = rect.y1 + r->size.height;
515
516             rects.append(rect);
517         }
518         wkCACFUpdateRectEnumeratorRelease(e);
519
520         if (rects.isEmpty())
521             break;
522
523         m_d3dDevice->Clear(rects.size(), rects.data(), D3DCLEAR_TARGET, 0, 1.0f, 0);
524
525         m_d3dDevice->BeginScene();
526         wkCACFContextRenderUpdate(m_context);
527         m_d3dDevice->EndScene();
528
529         err = m_d3dDevice->Present(0, 0, 0, 0);
530
531         if (err == D3DERR_DEVICELOST) {
532             wkCACFContextAddUpdateRect(m_context, bounds);
533             if (!resetDevice(LostDevice)) {
534                 // We can't reset the device right now. Try again soon.
535                 renderSoon();
536                 return;
537             }
538         }
539     } while (err == D3DERR_DEVICELOST);
540
541     wkCACFContextFinishUpdate(m_context);
542
543 #ifndef NDEBUG
544     if (m_printTree)
545         m_rootLayer->printTree();
546 #endif
547 }
548
549 void WKCACFLayerRenderer::renderSoon()
550 {
551     if (!m_renderTimer.isActive())
552         m_renderTimer.startOneShot(0);
553 }
554
555 CGRect WKCACFLayerRenderer::bounds() const
556 {
557     RECT clientRect;
558     GetClientRect(m_hostWindow, &clientRect);
559
560     return winRectToCGRect(clientRect);
561 }
562
563 void WKCACFLayerRenderer::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 WKCACFLayerRenderer::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)