Home | History | Annotate | Download | only in gl 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "ui/gl/gl_surface.h"
      6 
      7 #include <dwmapi.h>
      8 
      9 #include "base/command_line.h"
     10 #include "base/debug/trace_event.h"
     11 #include "base/logging.h"
     12 #include "base/memory/scoped_ptr.h"
     13 #include "base/win/windows_version.h"
     14 #include "ui/gfx/frame_time.h"
     15 #include "ui/gfx/native_widget_types.h"
     16 #include "ui/gl/gl_bindings.h"
     17 #include "ui/gl/gl_implementation.h"
     18 #include "ui/gl/gl_surface_egl.h"
     19 #include "ui/gl/gl_surface_osmesa.h"
     20 #include "ui/gl/gl_surface_stub.h"
     21 #include "ui/gl/gl_surface_wgl.h"
     22 
     23 // From ANGLE's egl/eglext.h.
     24 #if !defined(EGL_D3D11_ELSE_D3D9_DISPLAY_ANGLE)
     25 #define EGL_D3D11_ELSE_D3D9_DISPLAY_ANGLE \
     26   reinterpret_cast<EGLNativeDisplayType>(-2)
     27 #endif
     28 #if !defined(EGL_PLATFORM_ANGLE_ANGLE)
     29 #define EGL_PLATFORM_ANGLE_ANGLE 0x3201
     30 #endif
     31 #if !defined(EGL_PLATFORM_ANGLE_TYPE_ANGLE)
     32 #define EGL_PLATFORM_ANGLE_TYPE_ANGLE 0x3202
     33 #endif
     34 #if !defined(EGL_PLATFORM_ANGLE_TYPE_D3D11_WARP_ANGLE)
     35 #define EGL_PLATFORM_ANGLE_TYPE_D3D11_WARP_ANGLE 0x3206
     36 #endif
     37 
     38 namespace gfx {
     39 
     40 // This OSMesa GL surface can use GDI to swap the contents of the buffer to a
     41 // view.
     42 class NativeViewGLSurfaceOSMesa : public GLSurfaceOSMesa {
     43  public:
     44   explicit NativeViewGLSurfaceOSMesa(gfx::AcceleratedWidget window);
     45   virtual ~NativeViewGLSurfaceOSMesa();
     46 
     47   // Implement subset of GLSurface.
     48   virtual bool Initialize() OVERRIDE;
     49   virtual void Destroy() OVERRIDE;
     50   virtual bool IsOffscreen() OVERRIDE;
     51   virtual bool SwapBuffers() OVERRIDE;
     52   virtual bool SupportsPostSubBuffer() OVERRIDE;
     53   virtual bool PostSubBuffer(int x, int y, int width, int height) OVERRIDE;
     54 
     55  private:
     56   gfx::AcceleratedWidget window_;
     57   HDC device_context_;
     58 
     59   DISALLOW_COPY_AND_ASSIGN(NativeViewGLSurfaceOSMesa);
     60 };
     61 
     62 class DWMVSyncProvider : public VSyncProvider {
     63  public:
     64   explicit DWMVSyncProvider() {}
     65 
     66   virtual ~DWMVSyncProvider() {}
     67 
     68   virtual void GetVSyncParameters(const UpdateVSyncCallback& callback) {
     69     TRACE_EVENT0("gpu", "DWMVSyncProvider::GetVSyncParameters");
     70     DWM_TIMING_INFO timing_info;
     71     timing_info.cbSize = sizeof(timing_info);
     72     HRESULT result = DwmGetCompositionTimingInfo(NULL, &timing_info);
     73     if (result != S_OK)
     74       return;
     75 
     76     base::TimeTicks timebase;
     77     // If FrameTime is not high resolution, we do not want to translate the
     78     // QPC value provided by DWM into the low-resolution timebase, which
     79     // would be error prone and jittery. As a fallback, we assume the timebase
     80     // is zero.
     81     if (gfx::FrameTime::TimestampsAreHighRes()) {
     82       timebase = gfx::FrameTime::FromQPCValue(
     83           static_cast<LONGLONG>(timing_info.qpcVBlank));
     84     }
     85 
     86     // Swap the numerator/denominator to convert frequency to period.
     87     if (timing_info.rateRefresh.uiDenominator > 0 &&
     88         timing_info.rateRefresh.uiNumerator > 0) {
     89       base::TimeDelta interval = base::TimeDelta::FromMicroseconds(
     90           timing_info.rateRefresh.uiDenominator *
     91           base::Time::kMicrosecondsPerSecond /
     92           timing_info.rateRefresh.uiNumerator);
     93       callback.Run(timebase, interval);
     94     }
     95   }
     96 
     97  private:
     98   DISALLOW_COPY_AND_ASSIGN(DWMVSyncProvider);
     99 };
    100 
    101 // Helper routine that does one-off initialization like determining the
    102 // pixel format.
    103 bool GLSurface::InitializeOneOffInternal() {
    104   switch (GetGLImplementation()) {
    105     case kGLImplementationDesktopGL:
    106       if (!GLSurfaceWGL::InitializeOneOff()) {
    107         LOG(ERROR) << "GLSurfaceWGL::InitializeOneOff failed.";
    108         return false;
    109       }
    110       break;
    111     case kGLImplementationEGLGLES2:
    112       if (!GLSurfaceEGL::InitializeOneOff()) {
    113         LOG(ERROR) << "GLSurfaceEGL::InitializeOneOff failed.";
    114         return false;
    115       }
    116       break;
    117   }
    118   return true;
    119 }
    120 
    121 NativeViewGLSurfaceOSMesa::NativeViewGLSurfaceOSMesa(
    122     gfx::AcceleratedWidget window)
    123     : GLSurfaceOSMesa(OSMesaSurfaceFormatRGBA, gfx::Size(1, 1)),
    124       window_(window),
    125       device_context_(NULL) {
    126   DCHECK(window);
    127 }
    128 
    129 NativeViewGLSurfaceOSMesa::~NativeViewGLSurfaceOSMesa() {
    130   Destroy();
    131 }
    132 
    133 bool NativeViewGLSurfaceOSMesa::Initialize() {
    134   if (!GLSurfaceOSMesa::Initialize())
    135     return false;
    136 
    137   device_context_ = GetDC(window_);
    138   return true;
    139 }
    140 
    141 void NativeViewGLSurfaceOSMesa::Destroy() {
    142   if (window_ && device_context_)
    143     ReleaseDC(window_, device_context_);
    144 
    145   device_context_ = NULL;
    146 
    147   GLSurfaceOSMesa::Destroy();
    148 }
    149 
    150 bool NativeViewGLSurfaceOSMesa::IsOffscreen() {
    151   return false;
    152 }
    153 
    154 bool NativeViewGLSurfaceOSMesa::SwapBuffers() {
    155   DCHECK(device_context_);
    156 
    157   gfx::Size size = GetSize();
    158 
    159   // Note: negating the height below causes GDI to treat the bitmap data as row
    160   // 0 being at the top.
    161   BITMAPV4HEADER info = { sizeof(BITMAPV4HEADER) };
    162   info.bV4Width = size.width();
    163   info.bV4Height = -size.height();
    164   info.bV4Planes = 1;
    165   info.bV4BitCount = 32;
    166   info.bV4V4Compression = BI_BITFIELDS;
    167   info.bV4RedMask = 0x000000FF;
    168   info.bV4GreenMask = 0x0000FF00;
    169   info.bV4BlueMask = 0x00FF0000;
    170   info.bV4AlphaMask = 0xFF000000;
    171 
    172   // Copy the back buffer to the window's device context. Do not check whether
    173   // StretchDIBits succeeds or not. It will fail if the window has been
    174   // destroyed but it is preferable to allow rendering to silently fail if the
    175   // window is destroyed. This is because the primary application of this
    176   // class of GLContext is for testing and we do not want every GL related ui /
    177   // browser test to become flaky if there is a race condition between GL
    178   // context destruction and window destruction.
    179   StretchDIBits(device_context_,
    180                 0, 0, size.width(), size.height(),
    181                 0, 0, size.width(), size.height(),
    182                 GetHandle(),
    183                 reinterpret_cast<BITMAPINFO*>(&info),
    184                 DIB_RGB_COLORS,
    185                 SRCCOPY);
    186 
    187   return true;
    188 }
    189 
    190 bool NativeViewGLSurfaceOSMesa::SupportsPostSubBuffer() {
    191   return true;
    192 }
    193 
    194 bool NativeViewGLSurfaceOSMesa::PostSubBuffer(
    195     int x, int y, int width, int height) {
    196   DCHECK(device_context_);
    197 
    198   gfx::Size size = GetSize();
    199 
    200   // Note: negating the height below causes GDI to treat the bitmap data as row
    201   // 0 being at the top.
    202   BITMAPV4HEADER info = { sizeof(BITMAPV4HEADER) };
    203   info.bV4Width = size.width();
    204   info.bV4Height = -size.height();
    205   info.bV4Planes = 1;
    206   info.bV4BitCount = 32;
    207   info.bV4V4Compression = BI_BITFIELDS;
    208   info.bV4RedMask = 0x000000FF;
    209   info.bV4GreenMask = 0x0000FF00;
    210   info.bV4BlueMask = 0x00FF0000;
    211   info.bV4AlphaMask = 0xFF000000;
    212 
    213   // Copy the back buffer to the window's device context. Do not check whether
    214   // StretchDIBits succeeds or not. It will fail if the window has been
    215   // destroyed but it is preferable to allow rendering to silently fail if the
    216   // window is destroyed. This is because the primary application of this
    217   // class of GLContext is for testing and we do not want every GL related ui /
    218   // browser test to become flaky if there is a race condition between GL
    219   // context destruction and window destruction.
    220   StretchDIBits(device_context_,
    221                 x, size.height() - y - height, width, height,
    222                 x, y, width, height,
    223                 GetHandle(),
    224                 reinterpret_cast<BITMAPINFO*>(&info),
    225                 DIB_RGB_COLORS,
    226                 SRCCOPY);
    227 
    228   return true;
    229 }
    230 
    231 scoped_refptr<GLSurface> GLSurface::CreateViewGLSurface(
    232     gfx::AcceleratedWidget window) {
    233   TRACE_EVENT0("gpu", "GLSurface::CreateViewGLSurface");
    234   switch (GetGLImplementation()) {
    235     case kGLImplementationOSMesaGL: {
    236       scoped_refptr<GLSurface> surface(
    237           new NativeViewGLSurfaceOSMesa(window));
    238       if (!surface->Initialize())
    239         return NULL;
    240 
    241       return surface;
    242     }
    243     case kGLImplementationEGLGLES2: {
    244       DCHECK(window != gfx::kNullAcceleratedWidget);
    245       scoped_refptr<NativeViewGLSurfaceEGL> surface(
    246           new NativeViewGLSurfaceEGL(window));
    247       scoped_ptr<VSyncProvider> sync_provider;
    248       if (base::win::GetVersion() >= base::win::VERSION_VISTA)
    249         sync_provider.reset(new DWMVSyncProvider);
    250       if (!surface->Initialize(sync_provider.Pass()))
    251         return NULL;
    252 
    253       return surface;
    254     }
    255     case kGLImplementationDesktopGL: {
    256       scoped_refptr<GLSurface> surface(new NativeViewGLSurfaceWGL(
    257           window));
    258       if (!surface->Initialize())
    259         return NULL;
    260 
    261       return surface;
    262     }
    263     case kGLImplementationMockGL:
    264       return new GLSurfaceStub;
    265     default:
    266       NOTREACHED();
    267       return NULL;
    268   }
    269 }
    270 
    271 scoped_refptr<GLSurface> GLSurface::CreateOffscreenGLSurface(
    272     const gfx::Size& size) {
    273   TRACE_EVENT0("gpu", "GLSurface::CreateOffscreenGLSurface");
    274   switch (GetGLImplementation()) {
    275     case kGLImplementationOSMesaGL: {
    276       scoped_refptr<GLSurface> surface(
    277           new GLSurfaceOSMesa(OSMesaSurfaceFormatRGBA, size));
    278       if (!surface->Initialize())
    279         return NULL;
    280 
    281       return surface;
    282     }
    283     case kGLImplementationEGLGLES2: {
    284       scoped_refptr<GLSurface> surface(new PbufferGLSurfaceEGL(size));
    285       if (!surface->Initialize())
    286         return NULL;
    287 
    288       return surface;
    289     }
    290     case kGLImplementationDesktopGL: {
    291       scoped_refptr<GLSurface> surface(new PbufferGLSurfaceWGL(size));
    292       if (!surface->Initialize())
    293         return NULL;
    294 
    295       return surface;
    296     }
    297     case kGLImplementationMockGL:
    298       return new GLSurfaceStub;
    299     default:
    300       NOTREACHED();
    301       return NULL;
    302   }
    303 }
    304 
    305 EGLNativeDisplayType GetPlatformDefaultEGLNativeDisplay() {
    306   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kDisableD3D11) ||
    307       CommandLine::ForCurrentProcess()->HasSwitch(switches::kUseWarp))
    308     return GetDC(NULL);
    309   return EGL_D3D11_ELSE_D3D9_DISPLAY_ANGLE;
    310 }
    311 
    312 }  // namespace gfx
    313