src/cc/quads/render_pass.cc

   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/quads/render_pass.h"
   6
   7 #include "base/debug/trace_event_argument.h"
   8 #include "base/values.h"
   9 #include "cc/base/math_util.h"
  10 #include "cc/debug/traced_value.h"
  11 #include "cc/output/copy_output_request.h"
  12 #include "cc/quads/checkerboard_draw_quad.h"
  13 #include "cc/quads/debug_border_draw_quad.h"
  14 #include "cc/quads/draw_quad.h"
  15 #include "cc/quads/io_surface_draw_quad.h"
  16 #include "cc/quads/largest_draw_quad.h"
  17 #include "cc/quads/picture_draw_quad.h"
  18 #include "cc/quads/render_pass_draw_quad.h"
  19 #include "cc/quads/shared_quad_state.h"
  20 #include "cc/quads/solid_color_draw_quad.h"
  21 #include "cc/quads/stream_video_draw_quad.h"
  22 #include "cc/quads/surface_draw_quad.h"
  23 #include "cc/quads/texture_draw_quad.h"
  24 #include "cc/quads/tile_draw_quad.h"
  25 #include "cc/quads/yuv_video_draw_quad.h"
  26
  27 namespace {
  28 const size_t kDefaultNumSharedQuadStatesToReserve = 32;
  29 const size_t kDefaultNumQuadsToReserve = 128;
  30 }
  31
  32 namespace cc {
  33
  34 QuadList::QuadList(size_t default_size_to_reserve)
  35     : ListContainer<DrawQuad>(sizeof(kLargestDrawQuad),
  36                               default_size_to_reserve) {
  37 }
  38
  39 scoped_ptr<RenderPass> RenderPass::Create() {
  40   return make_scoped_ptr(new RenderPass());
  41 }
  42
  43 scoped_ptr<RenderPass> RenderPass::Create(size_t num_layers) {
  44   return make_scoped_ptr(new RenderPass(num_layers));
  45 }
  46
  47 RenderPass::RenderPass()
  48     : id(RenderPassId(-1, -1)),
  49       has_transparent_background(true),
  50       quad_list(kDefaultNumQuadsToReserve) {
  51   shared_quad_state_list.reserve(kDefaultNumSharedQuadStatesToReserve);
  52 }
  53
  54 RenderPass::RenderPass(size_t num_layers)
  55     : id(RenderPassId(-1, -1)),
  56       has_transparent_background(true),
  57       quad_list(kDefaultNumQuadsToReserve) {
  58   // Each layer usually produces one shared quad state, so the number of layers
  59   // is a good hint for what to reserve here.
  60   shared_quad_state_list.reserve(num_layers);
  61 }
  62
  63 RenderPass::~RenderPass() {
  64   TRACE_EVENT_OBJECT_DELETED_WITH_ID(
  65       TRACE_DISABLED_BY_DEFAULT("cc.debug.quads"),
  66       "cc::RenderPass", id.AsTracingId());
  67 }
  68
  69 scoped_ptr<RenderPass> RenderPass::Copy(RenderPassId new_id) const {
  70   scoped_ptr<RenderPass> copy_pass(Create());
  71   copy_pass->SetAll(new_id,
  72                     output_rect,
  73                     damage_rect,
  74                     transform_to_root_target,
  75                     has_transparent_background);
  76   return copy_pass.Pass();
  77 }
  78
  79 // static
  80 void RenderPass::CopyAll(const ScopedPtrVector<RenderPass>& in,
  81                          ScopedPtrVector<RenderPass>* out) {
  82   for (size_t i = 0; i < in.size(); ++i) {
  83     RenderPass* source = in[i];
  84
  85     // Since we can't copy these, it's wrong to use CopyAll in a situation where
  86     // you may have copy_requests present.
  87     DCHECK_EQ(source->copy_requests.size(), 0u);
  88
  89     scoped_ptr<RenderPass> copy_pass(Create());
  90     copy_pass->SetAll(source->id,
  91                       source->output_rect,
  92                       source->damage_rect,
  93                       source->transform_to_root_target,
  94                       source->has_transparent_background);
  95     for (size_t i = 0; i < source->shared_quad_state_list.size(); ++i) {
  96       SharedQuadState* copy_shared_quad_state =
  97           copy_pass->CreateAndAppendSharedQuadState();
  98       copy_shared_quad_state->CopyFrom(source->shared_quad_state_list[i]);
  99     }
 100     size_t sqs_i = 0;
 101     for (QuadList::Iterator iter = source->quad_list.begin();
 102          iter != source->quad_list.end();
 103          ++iter) {
 104       while (iter->shared_quad_state != source->shared_quad_state_list[sqs_i]) {
 105         ++sqs_i;
 106         DCHECK_LT(sqs_i, source->shared_quad_state_list.size());
 107       }
 108       DCHECK(iter->shared_quad_state == source->shared_quad_state_list[sqs_i]);
 109
 110       DrawQuad* quad = &*iter;
 111
 112       if (quad->material == DrawQuad::RENDER_PASS) {
 113         const RenderPassDrawQuad* pass_quad =
 114             RenderPassDrawQuad::MaterialCast(quad);
 115         copy_pass->CopyFromAndAppendRenderPassDrawQuad(
 116             pass_quad,
 117             copy_pass->shared_quad_state_list[sqs_i],
 118             pass_quad->render_pass_id);
 119       } else {
 120         copy_pass->CopyFromAndAppendDrawQuad(
 121             quad, copy_pass->shared_quad_state_list[sqs_i]);
 122       }
 123     }
 124     out->push_back(copy_pass.Pass());
 125   }
 126 }
 127
 128 void RenderPass::SetNew(RenderPassId id,
 129                         const gfx::Rect& output_rect,
 130                         const gfx::Rect& damage_rect,
 131                         const gfx::Transform& transform_to_root_target) {
 132   DCHECK_GT(id.layer_id, 0);
 133   DCHECK_GE(id.index, 0);
 134   DCHECK(damage_rect.IsEmpty() || output_rect.Contains(damage_rect))
 135       << "damage_rect: " << damage_rect.ToString()
 136       << " output_rect: " << output_rect.ToString();
 137
 138   this->id = id;
 139   this->output_rect = output_rect;
 140   this->damage_rect = damage_rect;
 141   this->transform_to_root_target = transform_to_root_target;
 142
 143   DCHECK(quad_list.empty());
 144   DCHECK(shared_quad_state_list.empty());
 145 }
 146
 147 void RenderPass::SetAll(RenderPassId id,
 148                         const gfx::Rect& output_rect,
 149                         const gfx::Rect& damage_rect,
 150                         const gfx::Transform& transform_to_root_target,
 151                         bool has_transparent_background) {
 152   DCHECK_GT(id.layer_id, 0);
 153   DCHECK_GE(id.index, 0);
 154
 155   this->id = id;
 156   this->output_rect = output_rect;
 157   this->damage_rect = damage_rect;
 158   this->transform_to_root_target = transform_to_root_target;
 159   this->has_transparent_background = has_transparent_background;
 160
 161   DCHECK(quad_list.empty());
 162   DCHECK(shared_quad_state_list.empty());
 163 }
 164
 165 void RenderPass::AsValueInto(base::debug::TracedValue* value) const {
 166   value->BeginArray("output_rect");
 167   MathUtil::AddToTracedValue(output_rect, value);
 168   value->EndArray();
 169
 170   value->BeginArray("damage_rect");
 171   MathUtil::AddToTracedValue(damage_rect, value);
 172   value->EndArray();
 173
 174   value->SetBoolean("has_transparent_background", has_transparent_background);
 175   value->SetInteger("copy_requests", copy_requests.size());
 176
 177   value->BeginArray("shared_quad_state_list");
 178   for (size_t i = 0; i < shared_quad_state_list.size(); ++i) {
 179     value->BeginDictionary();
 180     shared_quad_state_list[i]->AsValueInto(value);
 181     value->EndDictionary();
 182   }
 183   value->EndArray();
 184
 185   value->BeginArray("quad_list");
 186   for (QuadList::ConstIterator iter = quad_list.begin();
 187        iter != quad_list.end();
 188        ++iter) {
 189     value->BeginDictionary();
 190     iter->AsValueInto(value);
 191     value->EndDictionary();
 192   }
 193   value->EndArray();
 194
 195   TracedValue::MakeDictIntoImplicitSnapshotWithCategory(
 196       TRACE_DISABLED_BY_DEFAULT("cc.debug.quads"),
 197       value,
 198       "cc::RenderPass",
 199       id.AsTracingId());
 200 }
 201
 202 SharedQuadState* RenderPass::CreateAndAppendSharedQuadState() {
 203   shared_quad_state_list.push_back(make_scoped_ptr(new SharedQuadState));
 204   return shared_quad_state_list.back();
 205 }
 206
 207 RenderPassDrawQuad* RenderPass::CopyFromAndAppendRenderPassDrawQuad(
 208     const RenderPassDrawQuad* quad,
 209     const SharedQuadState* shared_quad_state,
 210     RenderPassId render_pass_id) {
 211   RenderPassDrawQuad* copy_quad =
 212       CopyFromAndAppendTypedDrawQuad<RenderPassDrawQuad>(quad);
 213   copy_quad->shared_quad_state = shared_quad_state;
 214   copy_quad->render_pass_id = render_pass_id;
 215   return copy_quad;
 216 }
 217
 218 DrawQuad* RenderPass::CopyFromAndAppendDrawQuad(
 219     const DrawQuad* quad,
 220     const SharedQuadState* shared_quad_state) {
 221   switch (quad->material) {
 222     case DrawQuad::CHECKERBOARD:
 223       CopyFromAndAppendTypedDrawQuad<CheckerboardDrawQuad>(quad);
 224       break;
 225     case DrawQuad::DEBUG_BORDER:
 226       CopyFromAndAppendTypedDrawQuad<DebugBorderDrawQuad>(quad);
 227       break;
 228     case DrawQuad::IO_SURFACE_CONTENT:
 229       CopyFromAndAppendTypedDrawQuad<IOSurfaceDrawQuad>(quad);
 230       break;
 231     case DrawQuad::PICTURE_CONTENT:
 232       CopyFromAndAppendTypedDrawQuad<PictureDrawQuad>(quad);
 233       break;
 234     case DrawQuad::TEXTURE_CONTENT:
 235       CopyFromAndAppendTypedDrawQuad<TextureDrawQuad>(quad);
 236       break;
 237     case DrawQuad::SOLID_COLOR:
 238       CopyFromAndAppendTypedDrawQuad<SolidColorDrawQuad>(quad);
 239       break;
 240     case DrawQuad::TILED_CONTENT:
 241       CopyFromAndAppendTypedDrawQuad<TileDrawQuad>(quad);
 242       break;
 243     case DrawQuad::STREAM_VIDEO_CONTENT:
 244       CopyFromAndAppendTypedDrawQuad<StreamVideoDrawQuad>(quad);
 245       break;
 246     case DrawQuad::SURFACE_CONTENT:
 247       CopyFromAndAppendTypedDrawQuad<SurfaceDrawQuad>(quad);
 248       break;
 249     case DrawQuad::YUV_VIDEO_CONTENT:
 250       CopyFromAndAppendTypedDrawQuad<YUVVideoDrawQuad>(quad);
 251       break;
 252     // RenderPass quads need to use specific CopyFrom function.
 253     case DrawQuad::RENDER_PASS:
 254     case DrawQuad::INVALID:
 255       LOG(FATAL) << "Invalid DrawQuad material " << quad->material;
 256       break;
 257   }
 258   quad_list.back()->shared_quad_state = shared_quad_state;
 259   return quad_list.back();
 260 }
 261
 262 }  // namespace cc