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 263