1 // Copyright 2011 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 "cc/layers/texture_layer_impl.h"
6
7 #include <vector>
8
9 #include "base/strings/stringprintf.h"
10 #include "cc/layers/quad_sink.h"
11 #include "cc/output/renderer.h"
12 #include "cc/quads/texture_draw_quad.h"
13 #include "cc/resources/platform_color.h"
14 #include "cc/resources/scoped_resource.h"
15 #include "cc/resources/single_release_callback.h"
16 #include "cc/trees/layer_tree_impl.h"
17
18 namespace cc {
19
TextureLayerImpl(LayerTreeImpl * tree_impl,int id)20 TextureLayerImpl::TextureLayerImpl(LayerTreeImpl* tree_impl, int id)
21 : LayerImpl(tree_impl, id),
22 external_texture_resource_(0),
23 premultiplied_alpha_(true),
24 blend_background_color_(false),
25 flipped_(true),
26 uv_top_left_(0.f, 0.f),
27 uv_bottom_right_(1.f, 1.f),
28 own_mailbox_(false),
29 valid_texture_copy_(false) {
30 vertex_opacity_[0] = 1.0f;
31 vertex_opacity_[1] = 1.0f;
32 vertex_opacity_[2] = 1.0f;
33 vertex_opacity_[3] = 1.0f;
34 }
35
~TextureLayerImpl()36 TextureLayerImpl::~TextureLayerImpl() { FreeTextureMailbox(); }
37
SetTextureMailbox(const TextureMailbox & mailbox,scoped_ptr<SingleReleaseCallback> release_callback)38 void TextureLayerImpl::SetTextureMailbox(
39 const TextureMailbox& mailbox,
40 scoped_ptr<SingleReleaseCallback> release_callback) {
41 DCHECK_EQ(mailbox.IsValid(), !!release_callback);
42 FreeTextureMailbox();
43 texture_mailbox_ = mailbox;
44 release_callback_ = release_callback.Pass();
45 own_mailbox_ = true;
46 valid_texture_copy_ = false;
47 SetNeedsPushProperties();
48 }
49
CreateLayerImpl(LayerTreeImpl * tree_impl)50 scoped_ptr<LayerImpl> TextureLayerImpl::CreateLayerImpl(
51 LayerTreeImpl* tree_impl) {
52 return TextureLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
53 }
54
PushPropertiesTo(LayerImpl * layer)55 void TextureLayerImpl::PushPropertiesTo(LayerImpl* layer) {
56 LayerImpl::PushPropertiesTo(layer);
57
58 TextureLayerImpl* texture_layer = static_cast<TextureLayerImpl*>(layer);
59 texture_layer->SetFlipped(flipped_);
60 texture_layer->SetUVTopLeft(uv_top_left_);
61 texture_layer->SetUVBottomRight(uv_bottom_right_);
62 texture_layer->SetVertexOpacity(vertex_opacity_);
63 texture_layer->SetPremultipliedAlpha(premultiplied_alpha_);
64 texture_layer->SetBlendBackgroundColor(blend_background_color_);
65 if (own_mailbox_) {
66 texture_layer->SetTextureMailbox(texture_mailbox_,
67 release_callback_.Pass());
68 own_mailbox_ = false;
69 }
70 }
71
WillDraw(DrawMode draw_mode,ResourceProvider * resource_provider)72 bool TextureLayerImpl::WillDraw(DrawMode draw_mode,
73 ResourceProvider* resource_provider) {
74 if (draw_mode == DRAW_MODE_RESOURCELESS_SOFTWARE)
75 return false;
76
77 if (own_mailbox_) {
78 DCHECK(!external_texture_resource_);
79 if ((draw_mode == DRAW_MODE_HARDWARE && texture_mailbox_.IsTexture()) ||
80 (draw_mode == DRAW_MODE_SOFTWARE &&
81 texture_mailbox_.IsSharedMemory())) {
82 external_texture_resource_ =
83 resource_provider->CreateResourceFromTextureMailbox(
84 texture_mailbox_, release_callback_.Pass());
85 DCHECK(external_texture_resource_);
86 texture_copy_.reset();
87 valid_texture_copy_ = false;
88 }
89 if (external_texture_resource_)
90 own_mailbox_ = false;
91 }
92
93 if (!valid_texture_copy_ && draw_mode == DRAW_MODE_HARDWARE &&
94 texture_mailbox_.IsSharedMemory()) {
95 DCHECK(!external_texture_resource_);
96 // Have to upload a copy to a texture for it to be used in a
97 // hardware draw.
98 if (!texture_copy_)
99 texture_copy_ = ScopedResource::Create(resource_provider);
100 if (texture_copy_->size() != texture_mailbox_.shared_memory_size() ||
101 resource_provider->InUseByConsumer(texture_copy_->id()))
102 texture_copy_->Free();
103
104 if (!texture_copy_->id()) {
105 texture_copy_->Allocate(texture_mailbox_.shared_memory_size(),
106 ResourceProvider::TextureUsageAny,
107 resource_provider->best_texture_format());
108 }
109
110 if (texture_copy_->id()) {
111 std::vector<uint8> swizzled;
112 uint8* pixels =
113 static_cast<uint8*>(texture_mailbox_.shared_memory()->memory());
114
115 if (!PlatformColor::SameComponentOrder(texture_copy_->format())) {
116 // Swizzle colors. This is slow, but should be really uncommon.
117 size_t bytes = texture_mailbox_.SharedMemorySizeInBytes();
118 swizzled.resize(bytes);
119 for (size_t i = 0; i < bytes; i += 4) {
120 swizzled[i] = pixels[i + 2];
121 swizzled[i + 1] = pixels[i + 1];
122 swizzled[i + 2] = pixels[i];
123 swizzled[i + 3] = pixels[i + 3];
124 }
125 pixels = &swizzled[0];
126 }
127
128 resource_provider->SetPixels(
129 texture_copy_->id(),
130 pixels,
131 gfx::Rect(texture_mailbox_.shared_memory_size()),
132 gfx::Rect(texture_mailbox_.shared_memory_size()),
133 gfx::Vector2d());
134
135 valid_texture_copy_ = true;
136 }
137 }
138 return (external_texture_resource_ || valid_texture_copy_) &&
139 LayerImpl::WillDraw(draw_mode, resource_provider);
140 }
141
AppendQuads(QuadSink * quad_sink,AppendQuadsData * append_quads_data)142 void TextureLayerImpl::AppendQuads(QuadSink* quad_sink,
143 AppendQuadsData* append_quads_data) {
144 DCHECK(external_texture_resource_ || valid_texture_copy_);
145
146 SharedQuadState* shared_quad_state = quad_sink->CreateSharedQuadState();
147 PopulateSharedQuadState(shared_quad_state);
148
149 AppendDebugBorderQuad(
150 quad_sink, content_bounds(), shared_quad_state, append_quads_data);
151
152 SkColor bg_color = blend_background_color_ ?
153 background_color() : SK_ColorTRANSPARENT;
154 bool opaque = contents_opaque() || (SkColorGetA(bg_color) == 0xFF);
155
156 gfx::Rect quad_rect(content_bounds());
157 gfx::Rect opaque_rect = opaque ? quad_rect : gfx::Rect();
158 gfx::Rect visible_quad_rect = quad_sink->UnoccludedContentRect(
159 quad_rect, draw_properties().target_space_transform);
160 if (visible_quad_rect.IsEmpty())
161 return;
162
163 scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
164 ResourceProvider::ResourceId id =
165 valid_texture_copy_ ? texture_copy_->id() : external_texture_resource_;
166 quad->SetNew(shared_quad_state,
167 quad_rect,
168 opaque_rect,
169 visible_quad_rect,
170 id,
171 premultiplied_alpha_,
172 uv_top_left_,
173 uv_bottom_right_,
174 bg_color,
175 vertex_opacity_,
176 flipped_);
177 quad_sink->Append(quad.PassAs<DrawQuad>());
178 }
179
VisibleContentOpaqueRegion() const180 Region TextureLayerImpl::VisibleContentOpaqueRegion() const {
181 if (contents_opaque())
182 return visible_content_rect();
183
184 if (blend_background_color_ && (SkColorGetA(background_color()) == 0xFF))
185 return visible_content_rect();
186
187 return Region();
188 }
189
ReleaseResources()190 void TextureLayerImpl::ReleaseResources() {
191 FreeTextureMailbox();
192 texture_copy_.reset();
193 external_texture_resource_ = 0;
194 valid_texture_copy_ = false;
195 }
196
SetPremultipliedAlpha(bool premultiplied_alpha)197 void TextureLayerImpl::SetPremultipliedAlpha(bool premultiplied_alpha) {
198 premultiplied_alpha_ = premultiplied_alpha;
199 SetNeedsPushProperties();
200 }
201
SetBlendBackgroundColor(bool blend)202 void TextureLayerImpl::SetBlendBackgroundColor(bool blend) {
203 blend_background_color_ = blend;
204 SetNeedsPushProperties();
205 }
206
SetFlipped(bool flipped)207 void TextureLayerImpl::SetFlipped(bool flipped) {
208 flipped_ = flipped;
209 SetNeedsPushProperties();
210 }
211
SetUVTopLeft(const gfx::PointF top_left)212 void TextureLayerImpl::SetUVTopLeft(const gfx::PointF top_left) {
213 uv_top_left_ = top_left;
214 SetNeedsPushProperties();
215 }
216
SetUVBottomRight(const gfx::PointF bottom_right)217 void TextureLayerImpl::SetUVBottomRight(const gfx::PointF bottom_right) {
218 uv_bottom_right_ = bottom_right;
219 SetNeedsPushProperties();
220 }
221
222 // 1--2
223 // | |
224 // 0--3
SetVertexOpacity(const float vertex_opacity[4])225 void TextureLayerImpl::SetVertexOpacity(const float vertex_opacity[4]) {
226 vertex_opacity_[0] = vertex_opacity[0];
227 vertex_opacity_[1] = vertex_opacity[1];
228 vertex_opacity_[2] = vertex_opacity[2];
229 vertex_opacity_[3] = vertex_opacity[3];
230 SetNeedsPushProperties();
231 }
232
LayerTypeAsString() const233 const char* TextureLayerImpl::LayerTypeAsString() const {
234 return "cc::TextureLayerImpl";
235 }
236
FreeTextureMailbox()237 void TextureLayerImpl::FreeTextureMailbox() {
238 if (own_mailbox_) {
239 DCHECK(!external_texture_resource_);
240 if (release_callback_)
241 release_callback_->Run(texture_mailbox_.sync_point(), false);
242 texture_mailbox_ = TextureMailbox();
243 release_callback_.reset();
244 } else if (external_texture_resource_) {
245 DCHECK(!own_mailbox_);
246 ResourceProvider* resource_provider =
247 layer_tree_impl()->resource_provider();
248 resource_provider->DeleteResource(external_texture_resource_);
249 external_texture_resource_ = 0;
250 }
251 }
252
253 } // namespace cc
254