• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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/output/renderer.h"
11 #include "cc/quads/texture_draw_quad.h"
12 #include "cc/resources/platform_color.h"
13 #include "cc/resources/scoped_resource.h"
14 #include "cc/resources/single_release_callback_impl.h"
15 #include "cc/trees/layer_tree_impl.h"
16 #include "cc/trees/occlusion_tracker.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<SingleReleaseCallbackImpl> release_callback)38 void TextureLayerImpl::SetTextureMailbox(
39     const TextureMailbox& mailbox,
40     scoped_ptr<SingleReleaseCallbackImpl> 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::TextureHintImmutable,
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(RenderPass * render_pass,const OcclusionTracker<LayerImpl> & occlusion_tracker,AppendQuadsData * append_quads_data)142 void TextureLayerImpl::AppendQuads(
143     RenderPass* render_pass,
144     const OcclusionTracker<LayerImpl>& occlusion_tracker,
145     AppendQuadsData* append_quads_data) {
146   DCHECK(external_texture_resource_ || valid_texture_copy_);
147 
148   SharedQuadState* shared_quad_state =
149       render_pass->CreateAndAppendSharedQuadState();
150   PopulateSharedQuadState(shared_quad_state);
151 
152   AppendDebugBorderQuad(
153       render_pass, content_bounds(), shared_quad_state, append_quads_data);
154 
155   SkColor bg_color = blend_background_color_ ?
156       background_color() : SK_ColorTRANSPARENT;
157   bool opaque = contents_opaque() || (SkColorGetA(bg_color) == 0xFF);
158 
159   gfx::Rect quad_rect(content_bounds());
160   gfx::Rect opaque_rect = opaque ? quad_rect : gfx::Rect();
161   gfx::Rect visible_quad_rect =
162       occlusion_tracker.GetCurrentOcclusionForLayer(
163                             draw_properties().target_space_transform)
164           .GetUnoccludedContentRect(quad_rect);
165   if (visible_quad_rect.IsEmpty())
166     return;
167 
168   TextureDrawQuad* quad =
169       render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
170   ResourceProvider::ResourceId id =
171       valid_texture_copy_ ? texture_copy_->id() : external_texture_resource_;
172   quad->SetNew(shared_quad_state,
173                quad_rect,
174                opaque_rect,
175                visible_quad_rect,
176                id,
177                premultiplied_alpha_,
178                uv_top_left_,
179                uv_bottom_right_,
180                bg_color,
181                vertex_opacity_,
182                flipped_);
183 }
184 
VisibleContentOpaqueRegion() const185 SimpleEnclosedRegion TextureLayerImpl::VisibleContentOpaqueRegion() const {
186   if (contents_opaque())
187     return SimpleEnclosedRegion(visible_content_rect());
188 
189   if (blend_background_color_ && (SkColorGetA(background_color()) == 0xFF))
190     return SimpleEnclosedRegion(visible_content_rect());
191 
192   return SimpleEnclosedRegion();
193 }
194 
ReleaseResources()195 void TextureLayerImpl::ReleaseResources() {
196   FreeTextureMailbox();
197   texture_copy_.reset();
198   external_texture_resource_ = 0;
199   valid_texture_copy_ = false;
200 }
201 
SetPremultipliedAlpha(bool premultiplied_alpha)202 void TextureLayerImpl::SetPremultipliedAlpha(bool premultiplied_alpha) {
203   premultiplied_alpha_ = premultiplied_alpha;
204   SetNeedsPushProperties();
205 }
206 
SetBlendBackgroundColor(bool blend)207 void TextureLayerImpl::SetBlendBackgroundColor(bool blend) {
208   blend_background_color_ = blend;
209   SetNeedsPushProperties();
210 }
211 
SetFlipped(bool flipped)212 void TextureLayerImpl::SetFlipped(bool flipped) {
213   flipped_ = flipped;
214   SetNeedsPushProperties();
215 }
216 
SetUVTopLeft(const gfx::PointF top_left)217 void TextureLayerImpl::SetUVTopLeft(const gfx::PointF top_left) {
218   uv_top_left_ = top_left;
219   SetNeedsPushProperties();
220 }
221 
SetUVBottomRight(const gfx::PointF bottom_right)222 void TextureLayerImpl::SetUVBottomRight(const gfx::PointF bottom_right) {
223   uv_bottom_right_ = bottom_right;
224   SetNeedsPushProperties();
225 }
226 
227 // 1--2
228 // |  |
229 // 0--3
SetVertexOpacity(const float vertex_opacity[4])230 void TextureLayerImpl::SetVertexOpacity(const float vertex_opacity[4]) {
231   vertex_opacity_[0] = vertex_opacity[0];
232   vertex_opacity_[1] = vertex_opacity[1];
233   vertex_opacity_[2] = vertex_opacity[2];
234   vertex_opacity_[3] = vertex_opacity[3];
235   SetNeedsPushProperties();
236 }
237 
LayerTypeAsString() const238 const char* TextureLayerImpl::LayerTypeAsString() const {
239   return "cc::TextureLayerImpl";
240 }
241 
FreeTextureMailbox()242 void TextureLayerImpl::FreeTextureMailbox() {
243   if (own_mailbox_) {
244     DCHECK(!external_texture_resource_);
245     if (release_callback_) {
246       release_callback_->Run(texture_mailbox_.sync_point(),
247                              false,
248                              layer_tree_impl()->BlockingMainThreadTaskRunner());
249     }
250     texture_mailbox_ = TextureMailbox();
251     release_callback_.reset();
252   } else if (external_texture_resource_) {
253     DCHECK(!own_mailbox_);
254     ResourceProvider* resource_provider =
255         layer_tree_impl()->resource_provider();
256     resource_provider->DeleteResource(external_texture_resource_);
257     external_texture_resource_ = 0;
258   }
259 }
260 
261 }  // namespace cc
262