texture_layer_impl.cc revision 116680a4aac90f2aa7413d9095a592090648e557 
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.h"
15#include "cc/trees/layer_tree_impl.h"
16#include "cc/trees/occlusion_tracker.h"
17
18namespace cc {
19
20TextureLayerImpl::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
36TextureLayerImpl::~TextureLayerImpl() { FreeTextureMailbox(); }
37
38void 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
50scoped_ptr<LayerImpl> TextureLayerImpl::CreateLayerImpl(
51    LayerTreeImpl* tree_impl) {
52  return TextureLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
53}
54
55void 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
72bool 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
142void 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 = occlusion_tracker.UnoccludedContentRect(
162      quad_rect, draw_properties().target_space_transform);
163  if (visible_quad_rect.IsEmpty())
164    return;
165
166  TextureDrawQuad* quad =
167      render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
168  ResourceProvider::ResourceId id =
169      valid_texture_copy_ ? texture_copy_->id() : external_texture_resource_;
170  quad->SetNew(shared_quad_state,
171               quad_rect,
172               opaque_rect,
173               visible_quad_rect,
174               id,
175               premultiplied_alpha_,
176               uv_top_left_,
177               uv_bottom_right_,
178               bg_color,
179               vertex_opacity_,
180               flipped_);
181}
182
183Region TextureLayerImpl::VisibleContentOpaqueRegion() const {
184  if (contents_opaque())
185    return visible_content_rect();
186
187  if (blend_background_color_ && (SkColorGetA(background_color()) == 0xFF))
188    return visible_content_rect();
189
190  return Region();
191}
192
193void TextureLayerImpl::ReleaseResources() {
194  FreeTextureMailbox();
195  texture_copy_.reset();
196  external_texture_resource_ = 0;
197  valid_texture_copy_ = false;
198}
199
200void TextureLayerImpl::SetPremultipliedAlpha(bool premultiplied_alpha) {
201  premultiplied_alpha_ = premultiplied_alpha;
202  SetNeedsPushProperties();
203}
204
205void TextureLayerImpl::SetBlendBackgroundColor(bool blend) {
206  blend_background_color_ = blend;
207  SetNeedsPushProperties();
208}
209
210void TextureLayerImpl::SetFlipped(bool flipped) {
211  flipped_ = flipped;
212  SetNeedsPushProperties();
213}
214
215void TextureLayerImpl::SetUVTopLeft(const gfx::PointF top_left) {
216  uv_top_left_ = top_left;
217  SetNeedsPushProperties();
218}
219
220void TextureLayerImpl::SetUVBottomRight(const gfx::PointF bottom_right) {
221  uv_bottom_right_ = bottom_right;
222  SetNeedsPushProperties();
223}
224
225// 1--2
226// |  |
227// 0--3
228void TextureLayerImpl::SetVertexOpacity(const float vertex_opacity[4]) {
229  vertex_opacity_[0] = vertex_opacity[0];
230  vertex_opacity_[1] = vertex_opacity[1];
231  vertex_opacity_[2] = vertex_opacity[2];
232  vertex_opacity_[3] = vertex_opacity[3];
233  SetNeedsPushProperties();
234}
235
236const char* TextureLayerImpl::LayerTypeAsString() const {
237  return "cc::TextureLayerImpl";
238}
239
240void TextureLayerImpl::FreeTextureMailbox() {
241  if (own_mailbox_) {
242    DCHECK(!external_texture_resource_);
243    if (release_callback_)
244      release_callback_->Run(texture_mailbox_.sync_point(), false);
245    texture_mailbox_ = TextureMailbox();
246    release_callback_.reset();
247  } else if (external_texture_resource_) {
248    DCHECK(!own_mailbox_);
249    ResourceProvider* resource_provider =
250        layer_tree_impl()->resource_provider();
251    resource_provider->DeleteResource(external_texture_resource_);
252    external_texture_resource_ = 0;
253  }
254}
255
256}  // namespace cc
257