1// Copyright 2010 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 CC_OUTPUT_GL_RENDERER_H_
6#define CC_OUTPUT_GL_RENDERER_H_
7
8#include "base/cancelable_callback.h"
9#include "cc/base/cc_export.h"
10#include "cc/base/scoped_ptr_deque.h"
11#include "cc/base/scoped_ptr_vector.h"
12#include "cc/output/direct_renderer.h"
13#include "cc/output/gl_renderer_draw_cache.h"
14#include "cc/output/program_binding.h"
15#include "cc/output/renderer.h"
16#include "cc/quads/checkerboard_draw_quad.h"
17#include "cc/quads/debug_border_draw_quad.h"
18#include "cc/quads/io_surface_draw_quad.h"
19#include "cc/quads/render_pass_draw_quad.h"
20#include "cc/quads/solid_color_draw_quad.h"
21#include "cc/quads/tile_draw_quad.h"
22#include "cc/quads/yuv_video_draw_quad.h"
23#include "ui/gfx/geometry/quad_f.h"
24
25class SkBitmap;
26
27namespace gpu {
28namespace gles2 {
29class GLES2Interface;
30}
31}
32
33namespace cc {
34
35class GLRendererShaderTest;
36class OutputSurface;
37class PictureDrawQuad;
38class ScopedResource;
39class StreamVideoDrawQuad;
40class TextureDrawQuad;
41class TextureMailboxDeleter;
42class GeometryBinding;
43class ScopedEnsureFramebufferAllocation;
44
45// Class that handles drawing of composited render layers using GL.
46class CC_EXPORT GLRenderer : public DirectRenderer {
47 public:
48  class ScopedUseGrContext;
49
50  static scoped_ptr<GLRenderer> Create(
51      RendererClient* client,
52      const LayerTreeSettings* settings,
53      OutputSurface* output_surface,
54      ResourceProvider* resource_provider,
55      TextureMailboxDeleter* texture_mailbox_deleter,
56      int highp_threshold_min);
57
58  virtual ~GLRenderer();
59
60  virtual const RendererCapabilitiesImpl& Capabilities() const OVERRIDE;
61
62  // Waits for rendering to finish.
63  virtual void Finish() OVERRIDE;
64
65  virtual void DoNoOp() OVERRIDE;
66  virtual void SwapBuffers(const CompositorFrameMetadata& metadata) OVERRIDE;
67
68  virtual bool IsContextLost();
69
70  static void DebugGLCall(gpu::gles2::GLES2Interface* gl,
71                          const char* command,
72                          const char* file,
73                          int line);
74
75 protected:
76  GLRenderer(RendererClient* client,
77             const LayerTreeSettings* settings,
78             OutputSurface* output_surface,
79             ResourceProvider* resource_provider,
80             TextureMailboxDeleter* texture_mailbox_deleter,
81             int highp_threshold_min);
82
83  virtual void DidChangeVisibility() OVERRIDE;
84
85  bool IsBackbufferDiscarded() const { return is_backbuffer_discarded_; }
86
87  const gfx::QuadF& SharedGeometryQuad() const { return shared_geometry_quad_; }
88  const GeometryBinding* SharedGeometry() const {
89    return shared_geometry_.get();
90  }
91
92  void GetFramebufferPixelsAsync(const gfx::Rect& rect,
93                                 scoped_ptr<CopyOutputRequest> request);
94  void GetFramebufferTexture(unsigned texture_id,
95                             ResourceFormat texture_format,
96                             const gfx::Rect& device_rect);
97  void ReleaseRenderPassTextures();
98
99  void SetStencilEnabled(bool enabled);
100  bool stencil_enabled() const { return stencil_shadow_; }
101  void SetBlendEnabled(bool enabled);
102  bool blend_enabled() const { return blend_shadow_; }
103
104  virtual void BindFramebufferToOutputSurface(DrawingFrame* frame) OVERRIDE;
105  virtual bool BindFramebufferToTexture(DrawingFrame* frame,
106                                        const ScopedResource* resource,
107                                        const gfx::Rect& target_rect) OVERRIDE;
108  virtual void SetDrawViewport(const gfx::Rect& window_space_viewport) OVERRIDE;
109  virtual void SetScissorTestRect(const gfx::Rect& scissor_rect) OVERRIDE;
110  virtual void DiscardPixels(bool has_external_stencil_test,
111                             bool draw_rect_covers_full_surface) OVERRIDE;
112  virtual void ClearFramebuffer(DrawingFrame* frame,
113                                bool has_external_stencil_test) OVERRIDE;
114  virtual void DoDrawQuad(DrawingFrame* frame, const class DrawQuad*) OVERRIDE;
115  virtual void BeginDrawingFrame(DrawingFrame* frame) OVERRIDE;
116  virtual void FinishDrawingFrame(DrawingFrame* frame) OVERRIDE;
117  virtual bool FlippedFramebuffer() const OVERRIDE;
118  virtual void EnsureScissorTestEnabled() OVERRIDE;
119  virtual void EnsureScissorTestDisabled() OVERRIDE;
120  virtual void CopyCurrentRenderPassToBitmap(
121      DrawingFrame* frame,
122      scoped_ptr<CopyOutputRequest> request) OVERRIDE;
123  virtual void FinishDrawingQuadList() OVERRIDE;
124
125  // Check if quad needs antialiasing and if so, inflate the quad and
126  // fill edge array for fragment shader.  local_quad is set to
127  // inflated quad if antialiasing is required, otherwise it is left
128  // unchanged.  edge array is filled with inflated quad's edge data
129  // if antialiasing is required, otherwise it is left unchanged.
130  // Returns true if quad requires antialiasing and false otherwise.
131  static bool SetupQuadForAntialiasing(const gfx::Transform& device_transform,
132                                       const DrawQuad* quad,
133                                       gfx::QuadF* local_quad,
134                                       float edge[24]);
135
136 private:
137  friend class GLRendererShaderPixelTest;
138  friend class GLRendererShaderTest;
139
140  static void ToGLMatrix(float* gl_matrix, const gfx::Transform& transform);
141
142  void DrawCheckerboardQuad(const DrawingFrame* frame,
143                            const CheckerboardDrawQuad* quad);
144  void DrawDebugBorderQuad(const DrawingFrame* frame,
145                           const DebugBorderDrawQuad* quad);
146  scoped_ptr<ScopedResource> GetBackgroundWithFilters(
147      DrawingFrame* frame,
148      const RenderPassDrawQuad* quad,
149      const gfx::Transform& contents_device_transform,
150      const gfx::Transform& contents_device_transformInverse,
151      bool* background_changed);
152  void DrawRenderPassQuad(DrawingFrame* frame, const RenderPassDrawQuad* quad);
153  void DrawSolidColorQuad(const DrawingFrame* frame,
154                          const SolidColorDrawQuad* quad);
155  void DrawStreamVideoQuad(const DrawingFrame* frame,
156                           const StreamVideoDrawQuad* quad);
157  void EnqueueTextureQuad(const DrawingFrame* frame,
158                          const TextureDrawQuad* quad);
159  void FlushTextureQuadCache();
160  void DrawIOSurfaceQuad(const DrawingFrame* frame,
161                         const IOSurfaceDrawQuad* quad);
162  void DrawTileQuad(const DrawingFrame* frame, const TileDrawQuad* quad);
163  void DrawContentQuad(const DrawingFrame* frame,
164                       const ContentDrawQuadBase* quad,
165                       ResourceProvider::ResourceId resource_id);
166  void DrawYUVVideoQuad(const DrawingFrame* frame,
167                        const YUVVideoDrawQuad* quad);
168  void DrawPictureQuad(const DrawingFrame* frame,
169                       const PictureDrawQuad* quad);
170
171  void SetShaderOpacity(float opacity, int alpha_location);
172  void SetShaderQuadF(const gfx::QuadF& quad, int quad_location);
173  void DrawQuadGeometry(const DrawingFrame* frame,
174                        const gfx::Transform& draw_transform,
175                        const gfx::RectF& quad_rect,
176                        int matrix_location);
177  void SetUseProgram(unsigned program);
178
179  void CopyTextureToFramebuffer(const DrawingFrame* frame,
180                                int texture_id,
181                                const gfx::Rect& rect,
182                                const gfx::Transform& draw_matrix,
183                                bool flip_vertically);
184
185  bool UseScopedTexture(DrawingFrame* frame,
186                        const ScopedResource* resource,
187                        const gfx::Rect& viewport_rect);
188
189  bool MakeContextCurrent();
190
191  void InitializeSharedObjects();
192  void CleanupSharedObjects();
193
194  typedef base::Callback<void(scoped_ptr<CopyOutputRequest> copy_request,
195                              bool success)>
196      AsyncGetFramebufferPixelsCleanupCallback;
197  void FinishedReadback(unsigned source_buffer,
198                        unsigned query,
199                        const gfx::Size& size);
200
201  void ReinitializeGLState();
202  void RestoreGLState();
203  void RestoreFramebuffer(DrawingFrame* frame);
204
205  virtual void DiscardBackbuffer() OVERRIDE;
206  virtual void EnsureBackbuffer() OVERRIDE;
207  void EnforceMemoryPolicy();
208
209  void ScheduleOverlays(DrawingFrame* frame);
210
211  typedef ScopedPtrVector<ResourceProvider::ScopedReadLockGL>
212      OverlayResourceLockList;
213  OverlayResourceLockList pending_overlay_resources_;
214  OverlayResourceLockList in_use_overlay_resources_;
215
216  RendererCapabilitiesImpl capabilities_;
217
218  unsigned offscreen_framebuffer_id_;
219
220  scoped_ptr<GeometryBinding> shared_geometry_;
221  gfx::QuadF shared_geometry_quad_;
222
223  // This block of bindings defines all of the programs used by the compositor
224  // itself.  Add any new programs here to GLRendererShaderTest.
225
226  // Tiled layer shaders.
227  typedef ProgramBinding<VertexShaderTile, FragmentShaderRGBATexAlpha>
228      TileProgram;
229  typedef ProgramBinding<VertexShaderTileAA, FragmentShaderRGBATexClampAlphaAA>
230      TileProgramAA;
231  typedef ProgramBinding<VertexShaderTileAA,
232                         FragmentShaderRGBATexClampSwizzleAlphaAA>
233      TileProgramSwizzleAA;
234  typedef ProgramBinding<VertexShaderTile, FragmentShaderRGBATexOpaque>
235      TileProgramOpaque;
236  typedef ProgramBinding<VertexShaderTile, FragmentShaderRGBATexSwizzleAlpha>
237      TileProgramSwizzle;
238  typedef ProgramBinding<VertexShaderTile, FragmentShaderRGBATexSwizzleOpaque>
239      TileProgramSwizzleOpaque;
240  typedef ProgramBinding<VertexShaderPosTex, FragmentShaderCheckerboard>
241      TileCheckerboardProgram;
242
243  // Texture shaders.
244  typedef ProgramBinding<VertexShaderPosTexTransform,
245                         FragmentShaderRGBATexVaryingAlpha> TextureProgram;
246  typedef ProgramBinding<VertexShaderPosTexTransform,
247                         FragmentShaderRGBATexPremultiplyAlpha>
248      NonPremultipliedTextureProgram;
249  typedef ProgramBinding<VertexShaderPosTexTransform,
250                         FragmentShaderTexBackgroundVaryingAlpha>
251      TextureBackgroundProgram;
252  typedef ProgramBinding<VertexShaderPosTexTransform,
253                         FragmentShaderTexBackgroundPremultiplyAlpha>
254      NonPremultipliedTextureBackgroundProgram;
255
256  // Render surface shaders.
257  typedef ProgramBinding<VertexShaderPosTexTransform,
258                         FragmentShaderRGBATexAlpha> RenderPassProgram;
259  typedef ProgramBinding<VertexShaderPosTexTransform,
260                         FragmentShaderRGBATexAlphaMask> RenderPassMaskProgram;
261  typedef ProgramBinding<VertexShaderQuadTexTransformAA,
262                         FragmentShaderRGBATexAlphaAA> RenderPassProgramAA;
263  typedef ProgramBinding<VertexShaderQuadTexTransformAA,
264                         FragmentShaderRGBATexAlphaMaskAA>
265      RenderPassMaskProgramAA;
266  typedef ProgramBinding<VertexShaderPosTexTransform,
267                         FragmentShaderRGBATexColorMatrixAlpha>
268      RenderPassColorMatrixProgram;
269  typedef ProgramBinding<VertexShaderQuadTexTransformAA,
270                         FragmentShaderRGBATexAlphaMaskColorMatrixAA>
271      RenderPassMaskColorMatrixProgramAA;
272  typedef ProgramBinding<VertexShaderQuadTexTransformAA,
273                         FragmentShaderRGBATexAlphaColorMatrixAA>
274      RenderPassColorMatrixProgramAA;
275  typedef ProgramBinding<VertexShaderPosTexTransform,
276                         FragmentShaderRGBATexAlphaMaskColorMatrix>
277      RenderPassMaskColorMatrixProgram;
278
279  // Video shaders.
280  typedef ProgramBinding<VertexShaderVideoTransform, FragmentShaderRGBATex>
281      VideoStreamTextureProgram;
282  typedef ProgramBinding<VertexShaderPosTexYUVStretchOffset,
283                         FragmentShaderYUVVideo> VideoYUVProgram;
284  typedef ProgramBinding<VertexShaderPosTexYUVStretchOffset,
285                         FragmentShaderYUVAVideo> VideoYUVAProgram;
286
287  // Special purpose / effects shaders.
288  typedef ProgramBinding<VertexShaderPos, FragmentShaderColor>
289      DebugBorderProgram;
290  typedef ProgramBinding<VertexShaderQuad, FragmentShaderColor>
291      SolidColorProgram;
292  typedef ProgramBinding<VertexShaderQuadAA, FragmentShaderColorAA>
293      SolidColorProgramAA;
294
295  const TileProgram* GetTileProgram(
296      TexCoordPrecision precision, SamplerType sampler);
297  const TileProgramOpaque* GetTileProgramOpaque(
298      TexCoordPrecision precision, SamplerType sampler);
299  const TileProgramAA* GetTileProgramAA(
300      TexCoordPrecision precision, SamplerType sampler);
301  const TileProgramSwizzle* GetTileProgramSwizzle(
302      TexCoordPrecision precision, SamplerType sampler);
303  const TileProgramSwizzleOpaque* GetTileProgramSwizzleOpaque(
304      TexCoordPrecision precision, SamplerType sampler);
305  const TileProgramSwizzleAA* GetTileProgramSwizzleAA(
306      TexCoordPrecision precision, SamplerType sampler);
307
308  const TileCheckerboardProgram* GetTileCheckerboardProgram();
309
310  const RenderPassProgram* GetRenderPassProgram(
311      TexCoordPrecision precision);
312  const RenderPassProgramAA* GetRenderPassProgramAA(
313      TexCoordPrecision precision);
314  const RenderPassMaskProgram* GetRenderPassMaskProgram(
315      TexCoordPrecision precision);
316  const RenderPassMaskProgramAA* GetRenderPassMaskProgramAA(
317      TexCoordPrecision precision);
318  const RenderPassColorMatrixProgram* GetRenderPassColorMatrixProgram(
319      TexCoordPrecision precision);
320  const RenderPassColorMatrixProgramAA* GetRenderPassColorMatrixProgramAA(
321      TexCoordPrecision precision);
322  const RenderPassMaskColorMatrixProgram* GetRenderPassMaskColorMatrixProgram(
323      TexCoordPrecision precision);
324  const RenderPassMaskColorMatrixProgramAA*
325      GetRenderPassMaskColorMatrixProgramAA(TexCoordPrecision precision);
326
327  const TextureProgram* GetTextureProgram(
328      TexCoordPrecision precision);
329  const NonPremultipliedTextureProgram* GetNonPremultipliedTextureProgram(
330      TexCoordPrecision precision);
331  const TextureBackgroundProgram* GetTextureBackgroundProgram(
332      TexCoordPrecision precision);
333  const NonPremultipliedTextureBackgroundProgram*
334      GetNonPremultipliedTextureBackgroundProgram(TexCoordPrecision precision);
335  const TextureProgram* GetTextureIOSurfaceProgram(
336      TexCoordPrecision precision);
337
338  const VideoYUVProgram* GetVideoYUVProgram(
339      TexCoordPrecision precision);
340  const VideoYUVAProgram* GetVideoYUVAProgram(
341      TexCoordPrecision precision);
342  const VideoStreamTextureProgram* GetVideoStreamTextureProgram(
343      TexCoordPrecision precision);
344
345  const DebugBorderProgram* GetDebugBorderProgram();
346  const SolidColorProgram* GetSolidColorProgram();
347  const SolidColorProgramAA* GetSolidColorProgramAA();
348
349  TileProgram tile_program_[NumTexCoordPrecisions][NumSamplerTypes];
350  TileProgramOpaque
351      tile_program_opaque_[NumTexCoordPrecisions][NumSamplerTypes];
352  TileProgramAA tile_program_aa_[NumTexCoordPrecisions][NumSamplerTypes];
353  TileProgramSwizzle
354      tile_program_swizzle_[NumTexCoordPrecisions][NumSamplerTypes];
355  TileProgramSwizzleOpaque
356      tile_program_swizzle_opaque_[NumTexCoordPrecisions][NumSamplerTypes];
357  TileProgramSwizzleAA
358      tile_program_swizzle_aa_[NumTexCoordPrecisions][NumSamplerTypes];
359
360  TileCheckerboardProgram tile_checkerboard_program_;
361
362  TextureProgram texture_program_[NumTexCoordPrecisions];
363  NonPremultipliedTextureProgram
364      nonpremultiplied_texture_program_[NumTexCoordPrecisions];
365  TextureBackgroundProgram texture_background_program_[NumTexCoordPrecisions];
366  NonPremultipliedTextureBackgroundProgram
367      nonpremultiplied_texture_background_program_[NumTexCoordPrecisions];
368  TextureProgram texture_io_surface_program_[NumTexCoordPrecisions];
369
370  RenderPassProgram render_pass_program_[NumTexCoordPrecisions];
371  RenderPassProgramAA render_pass_program_aa_[NumTexCoordPrecisions];
372  RenderPassMaskProgram render_pass_mask_program_[NumTexCoordPrecisions];
373  RenderPassMaskProgramAA render_pass_mask_program_aa_[NumTexCoordPrecisions];
374  RenderPassColorMatrixProgram
375      render_pass_color_matrix_program_[NumTexCoordPrecisions];
376  RenderPassColorMatrixProgramAA
377      render_pass_color_matrix_program_aa_[NumTexCoordPrecisions];
378  RenderPassMaskColorMatrixProgram
379      render_pass_mask_color_matrix_program_[NumTexCoordPrecisions];
380  RenderPassMaskColorMatrixProgramAA
381      render_pass_mask_color_matrix_program_aa_[NumTexCoordPrecisions];
382
383  VideoYUVProgram video_yuv_program_[NumTexCoordPrecisions];
384  VideoYUVAProgram video_yuva_program_[NumTexCoordPrecisions];
385  VideoStreamTextureProgram
386      video_stream_texture_program_[NumTexCoordPrecisions];
387
388  DebugBorderProgram debug_border_program_;
389  SolidColorProgram solid_color_program_;
390  SolidColorProgramAA solid_color_program_aa_;
391
392  gpu::gles2::GLES2Interface* gl_;
393  gpu::ContextSupport* context_support_;
394
395  TextureMailboxDeleter* texture_mailbox_deleter_;
396
397  gfx::Rect swap_buffer_rect_;
398  gfx::Rect scissor_rect_;
399  gfx::Rect viewport_;
400  bool is_backbuffer_discarded_;
401  bool is_using_bind_uniform_;
402  bool is_scissor_enabled_;
403  bool scissor_rect_needs_reset_;
404  bool stencil_shadow_;
405  bool blend_shadow_;
406  unsigned program_shadow_;
407  TexturedQuadDrawCache draw_cache_;
408  int highp_threshold_min_;
409  int highp_threshold_cache_;
410
411  struct PendingAsyncReadPixels;
412  ScopedPtrVector<PendingAsyncReadPixels> pending_async_read_pixels_;
413
414  scoped_ptr<ResourceProvider::ScopedWriteLockGL> current_framebuffer_lock_;
415
416  class SyncQuery;
417  ScopedPtrDeque<SyncQuery> pending_sync_queries_;
418  ScopedPtrDeque<SyncQuery> available_sync_queries_;
419  scoped_ptr<SyncQuery> current_sync_query_;
420  bool use_sync_query_;
421
422  SkBitmap on_demand_tile_raster_bitmap_;
423  ResourceProvider::ResourceId on_demand_tile_raster_resource_id_;
424
425  DISALLOW_COPY_AND_ASSIGN(GLRenderer);
426};
427
428// Setting DEBUG_GL_CALLS to 1 will call glGetError() after almost every GL
429// call made by the compositor. Useful for debugging rendering issues but
430// will significantly degrade performance.
431#define DEBUG_GL_CALLS 0
432
433#if DEBUG_GL_CALLS && !defined(NDEBUG)
434#define GLC(context, x)                                                        \
435  (x, GLRenderer::DebugGLCall(&* context, #x, __FILE__, __LINE__))
436#else
437#define GLC(context, x) (x)
438#endif
439
440}  // namespace cc
441
442#endif  // CC_OUTPUT_GL_RENDERER_H_
443