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#ifndef UI_SURFACE_ACCELERATED_SURFACE_MAC_H_
6#define UI_SURFACE_ACCELERATED_SURFACE_MAC_H_
7
8#include <CoreFoundation/CoreFoundation.h>
9#include <IOSurface/IOSurfaceAPI.h>
10
11#include "base/callback.h"
12#include "base/mac/scoped_cftyperef.h"
13#include "base/memory/scoped_ptr.h"
14#include "ui/gfx/rect.h"
15#include "ui/gfx/size.h"
16#include "ui/gl/gl_context.h"
17#include "ui/gl/gl_surface.h"
18#include "ui/gl/gpu_preference.h"
19#include "ui/surface/surface_export.h"
20
21// Should not include GL headers in a header file. Forward declare these types
22// instead.
23typedef struct _CGLContextObject* CGLContextObj;
24typedef unsigned int GLenum;
25typedef unsigned int GLuint;
26
27namespace gfx {
28class Rect;
29}
30
31// Encapsulates an accelerated GL surface that can be shared across processes
32// on systems that support it (10.6 and above).
33
34class SURFACE_EXPORT AcceleratedSurface {
35 public:
36  AcceleratedSurface();
37  virtual ~AcceleratedSurface();
38
39  // Set up internal buffers. |share_context|, if non-NULL, is a context
40  // with which the internally created OpenGL context shares textures and
41  // other resources. |allocate_fbo| indicates whether or not this surface
42  // should allocate an offscreen frame buffer object (FBO) internally. If
43  // not, then the user is expected to allocate one. NOTE that allocating
44  // an FBO internally does NOT work properly with client code which uses
45  // OpenGL (i.e., via GLES2 command buffers), because the GLES2
46  // implementation does not know to bind the accelerated surface's
47  // internal FBO when the default FBO is bound. |gpu_preference| indicates
48  // the GPU preference for the internally allocated GLContext. If
49  // |share_context| is non-NULL, then on platforms supporting dual GPUs,
50  // its GPU preference must match the passed one. Returns false upon
51  // failure.
52  bool Initialize(gfx::GLContext* share_context,
53                  bool allocate_fbo,
54                  gfx::GpuPreference gpu_preference);
55  // Tear down. Must be called before destructor to prevent leaks.
56  void Destroy();
57
58  // These methods are used only once the accelerated surface is initialized.
59
60  // Sets the accelerated surface to the given size, creating a new one if
61  // the height or width changes. Returns a unique id of the IOSurface to
62  // which the surface is bound, or 0 if no changes were made or an error
63  // occurred. MakeCurrent() will have been called on the new surface.
64  uint32 SetSurfaceSize(const gfx::Size& size);
65
66  // Returns the id of this surface's IOSurface.
67  uint32 GetSurfaceId();
68
69  // Sets the GL context to be the current one for drawing. Returns true if
70  // it succeeded.
71  bool MakeCurrent();
72  // Clear the surface to be transparent. Assumes the caller has already called
73  // MakeCurrent().
74  void Clear(const gfx::Rect& rect);
75  // Call after making changes to the surface which require a visual update.
76  // Makes the rendering show up in other processes. Assumes the caller has
77  // already called MakeCurrent().
78  //
79  // If this AcceleratedSurface is configured with its own FBO, then
80  // this call causes the color buffer to be transmitted. Otherwise,
81  // it causes the frame buffer of the current GL context to be copied
82  // into an internal texture via glCopyTexSubImage2D.
83  //
84  // The size of the rectangle copied is the size last specified via
85  // SetSurfaceSize.  If another GL context than the one this
86  // AcceleratedSurface contains is responsible for the production of
87  // the pixels, then when this entry point is called, the color
88  // buffer must be in a state where a glCopyTexSubImage2D is
89  // legal. (For example, if using multisampled FBOs, the FBO must
90  // have been resolved into a non-multisampled color texture.)
91  // Additionally, in this situation, the contexts must share
92  // server-side GL objects, so that this AcceleratedSurface's texture
93  // is a legal name in the namespace of the current context.
94  void SwapBuffers();
95
96  CGLContextObj context() {
97    return static_cast<CGLContextObj>(gl_context_->GetHandle());
98  }
99
100  // Get the accelerated surface size.
101  gfx::Size GetSize() const { return surface_size_; }
102
103 private:
104  // Helper function to generate names for the backing texture and FBO.  On
105  // return, the resulting names can be attached to |fbo_|.  |target| is
106  // the target type for the color buffer.
107  void AllocateRenderBuffers(GLenum target, const gfx::Size& size);
108
109  // Helper function to attach the buffers previously allocated by a call to
110  // AllocateRenderBuffers().  On return, |fbo_| can be used for
111  // rendering.  |target| must be the same value as used in the call to
112  // AllocateRenderBuffers().  Returns |true| if the resulting framebuffer
113  // object is valid.
114  bool SetupFrameBufferObject(GLenum target);
115
116  gfx::Size ClampToValidDimensions(const gfx::Size& size);
117
118  // The OpenGL context, and pbuffer drawable, used to transfer data
119  // to the shared region (IOSurface).
120  scoped_refptr<gfx::GLSurface> gl_surface_;
121  scoped_refptr<gfx::GLContext> gl_context_;
122  base::ScopedCFTypeRef<IOSurfaceRef> io_surface_;
123
124  // The id of |io_surface_| or 0 if that's NULL.
125  uint32 io_surface_id_;
126
127  gfx::Size surface_size_;
128  // It's important to avoid allocating zero-width or zero-height
129  // IOSurfaces and textures on the Mac, so we clamp each to a minimum
130  // of 1. This is the real size of the surface; surface_size_ is what
131  // the user requested.
132  gfx::Size real_surface_size_;
133  // TODO(kbr): the FBO management should not be in this class at all.
134  // However, if it is factored out, care needs to be taken to not
135  // introduce another copy of the color data on the GPU; the direct
136  // binding of the internal texture to the IOSurface saves a copy.
137  bool allocate_fbo_;
138  // This texture object is always allocated, regardless of whether
139  // the user requests an FBO be allocated.
140  GLuint texture_;
141  // The FBO and renderbuffer are only allocated if allocate_fbo_ is
142  // true.
143  GLuint fbo_;
144};
145
146#endif  // UI_SURFACE_ACCELERATED_SURFACE_MAC_H_
147