blob: d1715cbcdff4b45cdc50437272046a1d3e58ddfc (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
// Copyright 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CC_OUTPUT_OUTPUT_SURFACE_H_
#define CC_OUTPUT_OUTPUT_SURFACE_H_
#include <deque>
#include <memory>
#include "base/macros.h"
#include "base/memory/ref_counted.h"
#include "base/threading/thread_checker.h"
#include "cc/cc_export.h"
#include "cc/output/context_provider.h"
#include "cc/output/overlay_candidate_validator.h"
#include "cc/output/software_output_device.h"
#include "cc/output/vulkan_context_provider.h"
#include "cc/resources/returned_resource.h"
#include "gpu/command_buffer/common/texture_in_use_response.h"
#include "ui/gfx/color_space.h"
namespace gfx {
class ColorSpace;
class Size;
}
namespace cc {
class OutputSurfaceClient;
class OutputSurfaceFrame;
// This class represents a platform-independent API for presenting
// buffers to display via GPU or software compositing. Implementations
// can provide platform-specific behaviour.
class CC_EXPORT OutputSurface {
public:
struct Capabilities {
Capabilities() = default;
int max_frames_pending = 1;
// Whether this output surface renders to the default OpenGL zero
// framebuffer or to an offscreen framebuffer.
bool uses_default_gl_framebuffer = true;
// Whether this OutputSurface is flipped or not.
bool flipped_output_surface = false;
// Whether this OutputSurface supports stencil operations or not.
// Note: HasExternalStencilTest() must return false when an output surface
// has been configured for stencil usage.
bool supports_stencil = false;
};
// Constructor for GL-based compositing.
explicit OutputSurface(scoped_refptr<ContextProvider> context_provider);
// Constructor for software compositing.
explicit OutputSurface(std::unique_ptr<SoftwareOutputDevice> software_device);
// Constructor for Vulkan-based compositing.
explicit OutputSurface(
scoped_refptr<VulkanContextProvider> vulkan_context_provider);
virtual ~OutputSurface();
const Capabilities& capabilities() const { return capabilities_; }
// Obtain the 3d context or the software device associated with this output
// surface. Either of these may return a null pointer, but not both.
// In the event of a lost context, the entire output surface should be
// recreated.
ContextProvider* context_provider() const { return context_provider_.get(); }
VulkanContextProvider* vulkan_context_provider() const {
return vulkan_context_provider_.get();
}
SoftwareOutputDevice* software_device() const {
return software_device_.get();
}
virtual void BindToClient(OutputSurfaceClient* client) = 0;
virtual void EnsureBackbuffer() = 0;
virtual void DiscardBackbuffer() = 0;
// Bind the default framebuffer for drawing to, only valid for GL backed
// OutputSurfaces.
virtual void BindFramebuffer() = 0;
// Marks that the given rectangle will be drawn to on the default, bound
// framebuffer. Only valid for surfaces with dc_layers in the context
// capabilities.
virtual void SetDrawRectangle(const gfx::Rect& rect) = 0;
// Get the class capable of informing cc of hardware overlay capability.
virtual OverlayCandidateValidator* GetOverlayCandidateValidator() const = 0;
// Returns true if a main image overlay plane should be scheduled.
virtual bool IsDisplayedAsOverlayPlane() const = 0;
// Get the texture for the main image's overlay.
virtual unsigned GetOverlayTextureId() const = 0;
// If this returns true, then the surface will not attempt to draw.
virtual bool SurfaceIsSuspendForRecycle() const = 0;
virtual void Reshape(const gfx::Size& size,
float device_scale_factor,
const gfx::ColorSpace& color_space,
bool has_alpha,
bool use_stencil) = 0;
virtual bool HasExternalStencilTest() const = 0;
virtual void ApplyExternalStencil() = 0;
// Gives the GL internal format that should be used for calling CopyTexImage2D
// when the framebuffer is bound via BindFramebuffer().
virtual uint32_t GetFramebufferCopyTextureFormat() = 0;
// Swaps the current backbuffer to the screen. For successful swaps, the
// implementation must call OutputSurfaceClient::DidReceiveSwapBuffersAck()
// after returning from this method in order to unblock the next frame.
virtual void SwapBuffers(OutputSurfaceFrame frame) = 0;
protected:
struct OutputSurface::Capabilities capabilities_;
scoped_refptr<ContextProvider> context_provider_;
scoped_refptr<VulkanContextProvider> vulkan_context_provider_;
std::unique_ptr<SoftwareOutputDevice> software_device_;
private:
DISALLOW_COPY_AND_ASSIGN(OutputSurface);
};
} // namespace cc
#endif // CC_OUTPUT_OUTPUT_SURFACE_H_
|
