| OLD | NEW |
|---|
| (Empty) |
| 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/video_layer_impl.h" | |
| 6 | |
| 7 #include "base/bind.h" | |
| 8 #include "base/logging.h" | |
| 9 #include "cc/layers/video_frame_provider_client_impl.h" | |
| 10 #include "cc/quads/io_surface_draw_quad.h" | |
| 11 #include "cc/quads/stream_video_draw_quad.h" | |
| 12 #include "cc/quads/texture_draw_quad.h" | |
| 13 #include "cc/quads/yuv_video_draw_quad.h" | |
| 14 #include "cc/resources/resource_provider.h" | |
| 15 #include "cc/resources/single_release_callback_impl.h" | |
| 16 #include "cc/trees/layer_tree_impl.h" | |
| 17 #include "cc/trees/occlusion.h" | |
| 18 #include "cc/trees/proxy.h" | |
| 19 #include "media/base/video_frame.h" | |
| 20 | |
| 21 #if defined(VIDEO_HOLE) | |
| 22 #include "cc/quads/solid_color_draw_quad.h" | |
| 23 #endif // defined(VIDEO_HOLE) | |
| 24 | |
| 25 namespace cc { | |
| 26 | |
| 27 // static | |
| 28 scoped_ptr<VideoLayerImpl> VideoLayerImpl::Create( | |
| 29 LayerTreeImpl* tree_impl, | |
| 30 int id, | |
| 31 VideoFrameProvider* provider, | |
| 32 media::VideoRotation video_rotation) { | |
| 33 scoped_ptr<VideoLayerImpl> layer( | |
| 34 new VideoLayerImpl(tree_impl, id, video_rotation)); | |
| 35 layer->SetProviderClientImpl(VideoFrameProviderClientImpl::Create(provider)); | |
| 36 DCHECK(tree_impl->proxy()->IsImplThread()); | |
| 37 DCHECK(tree_impl->proxy()->IsMainThreadBlocked()); | |
| 38 return layer.Pass(); | |
| 39 } | |
| 40 | |
| 41 VideoLayerImpl::VideoLayerImpl(LayerTreeImpl* tree_impl, | |
| 42 int id, | |
| 43 media::VideoRotation video_rotation) | |
| 44 : LayerImpl(tree_impl, id), | |
| 45 frame_(nullptr), | |
| 46 video_rotation_(video_rotation) { | |
| 47 } | |
| 48 | |
| 49 VideoLayerImpl::~VideoLayerImpl() { | |
| 50 if (!provider_client_impl_->Stopped()) { | |
| 51 // In impl side painting, we may have a pending and active layer | |
| 52 // associated with the video provider at the same time. Both have a ref | |
| 53 // on the VideoFrameProviderClientImpl, but we stop when the first | |
| 54 // LayerImpl (the one on the pending tree) is destroyed since we know | |
| 55 // the main thread is blocked for this commit. | |
| 56 DCHECK(layer_tree_impl()->proxy()->IsImplThread()); | |
| 57 DCHECK(layer_tree_impl()->proxy()->IsMainThreadBlocked()); | |
| 58 provider_client_impl_->Stop(); | |
| 59 } | |
| 60 } | |
| 61 | |
| 62 scoped_ptr<LayerImpl> VideoLayerImpl::CreateLayerImpl( | |
| 63 LayerTreeImpl* tree_impl) { | |
| 64 return make_scoped_ptr(new VideoLayerImpl(tree_impl, id(), video_rotation_)); | |
| 65 } | |
| 66 | |
| 67 void VideoLayerImpl::PushPropertiesTo(LayerImpl* layer) { | |
| 68 LayerImpl::PushPropertiesTo(layer); | |
| 69 | |
| 70 VideoLayerImpl* other = static_cast<VideoLayerImpl*>(layer); | |
| 71 other->SetProviderClientImpl(provider_client_impl_); | |
| 72 } | |
| 73 | |
| 74 void VideoLayerImpl::DidBecomeActive() { | |
| 75 provider_client_impl_->SetActiveVideoLayer(this); | |
| 76 } | |
| 77 | |
| 78 bool VideoLayerImpl::WillDraw(DrawMode draw_mode, | |
| 79 ResourceProvider* resource_provider) { | |
| 80 if (draw_mode == DRAW_MODE_RESOURCELESS_SOFTWARE) | |
| 81 return false; | |
| 82 | |
| 83 // Explicitly acquire and release the provider mutex so it can be held from | |
| 84 // WillDraw to DidDraw. Since the compositor thread is in the middle of | |
| 85 // drawing, the layer will not be destroyed before DidDraw is called. | |
| 86 // Therefore, the only thing that will prevent this lock from being released | |
| 87 // is the GPU process locking it. As the GPU process can't cause the | |
| 88 // destruction of the provider (calling StopUsingProvider), holding this | |
| 89 // lock should not cause a deadlock. | |
| 90 frame_ = provider_client_impl_->AcquireLockAndCurrentFrame(); | |
| 91 | |
| 92 if (!frame_.get()) { | |
| 93 // Drop any resources used by the updater if there is no frame to display. | |
| 94 updater_ = nullptr; | |
| 95 | |
| 96 provider_client_impl_->ReleaseLock(); | |
| 97 return false; | |
| 98 } | |
| 99 | |
| 100 if (!LayerImpl::WillDraw(draw_mode, resource_provider)) | |
| 101 return false; | |
| 102 | |
| 103 if (!updater_) { | |
| 104 updater_.reset( | |
| 105 new VideoResourceUpdater(layer_tree_impl()->context_provider(), | |
| 106 layer_tree_impl()->resource_provider())); | |
| 107 } | |
| 108 | |
| 109 VideoFrameExternalResources external_resources = | |
| 110 updater_->CreateExternalResourcesFromVideoFrame(frame_); | |
| 111 frame_resource_type_ = external_resources.type; | |
| 112 | |
| 113 if (external_resources.type == | |
| 114 VideoFrameExternalResources::SOFTWARE_RESOURCE) { | |
| 115 software_resources_ = external_resources.software_resources; | |
| 116 software_release_callback_ = | |
| 117 external_resources.software_release_callback; | |
| 118 return true; | |
| 119 } | |
| 120 | |
| 121 DCHECK_EQ(external_resources.mailboxes.size(), | |
| 122 external_resources.release_callbacks.size()); | |
| 123 for (size_t i = 0; i < external_resources.mailboxes.size(); ++i) { | |
| 124 unsigned resource_id = resource_provider->CreateResourceFromTextureMailbox( | |
| 125 external_resources.mailboxes[i], | |
| 126 SingleReleaseCallbackImpl::Create( | |
| 127 external_resources.release_callbacks[i])); | |
| 128 frame_resources_.push_back(resource_id); | |
| 129 } | |
| 130 | |
| 131 return true; | |
| 132 } | |
| 133 | |
| 134 void VideoLayerImpl::AppendQuads(RenderPass* render_pass, | |
| 135 AppendQuadsData* append_quads_data) { | |
| 136 DCHECK(frame_.get()); | |
| 137 | |
| 138 gfx::Transform transform = draw_transform(); | |
| 139 gfx::Size rotated_size = content_bounds(); | |
| 140 | |
| 141 switch (video_rotation_) { | |
| 142 case media::VIDEO_ROTATION_90: | |
| 143 rotated_size = gfx::Size(rotated_size.height(), rotated_size.width()); | |
| 144 transform.Rotate(90.0); | |
| 145 transform.Translate(0.0, -rotated_size.height()); | |
| 146 break; | |
| 147 case media::VIDEO_ROTATION_180: | |
| 148 transform.Rotate(180.0); | |
| 149 transform.Translate(-rotated_size.width(), -rotated_size.height()); | |
| 150 break; | |
| 151 case media::VIDEO_ROTATION_270: | |
| 152 rotated_size = gfx::Size(rotated_size.height(), rotated_size.width()); | |
| 153 transform.Rotate(270.0); | |
| 154 transform.Translate(-rotated_size.width(), 0); | |
| 155 case media::VIDEO_ROTATION_0: | |
| 156 break; | |
| 157 } | |
| 158 | |
| 159 SharedQuadState* shared_quad_state = | |
| 160 render_pass->CreateAndAppendSharedQuadState(); | |
| 161 shared_quad_state->SetAll(transform, rotated_size, visible_content_rect(), | |
| 162 clip_rect(), is_clipped(), draw_opacity(), | |
| 163 draw_blend_mode(), sorting_context_id()); | |
| 164 | |
| 165 AppendDebugBorderQuad( | |
| 166 render_pass, rotated_size, shared_quad_state, append_quads_data); | |
| 167 | |
| 168 gfx::Rect quad_rect(rotated_size); | |
| 169 gfx::Rect opaque_rect(contents_opaque() ? quad_rect : gfx::Rect()); | |
| 170 gfx::Rect visible_rect = frame_->visible_rect(); | |
| 171 gfx::Size coded_size = frame_->coded_size(); | |
| 172 | |
| 173 Occlusion occlusion_in_video_space = | |
| 174 draw_properties() | |
| 175 .occlusion_in_content_space.GetOcclusionWithGivenDrawTransform( | |
| 176 transform); | |
| 177 gfx::Rect visible_quad_rect = | |
| 178 occlusion_in_video_space.GetUnoccludedContentRect(quad_rect); | |
| 179 if (visible_quad_rect.IsEmpty()) | |
| 180 return; | |
| 181 | |
| 182 // Pixels for macroblocked formats. | |
| 183 const float tex_width_scale = | |
| 184 static_cast<float>(visible_rect.width()) / coded_size.width(); | |
| 185 const float tex_height_scale = | |
| 186 static_cast<float>(visible_rect.height()) / coded_size.height(); | |
| 187 const float tex_x_offset = | |
| 188 static_cast<float>(visible_rect.x()) / coded_size.width(); | |
| 189 const float tex_y_offset = | |
| 190 static_cast<float>(visible_rect.y()) / coded_size.height(); | |
| 191 | |
| 192 switch (frame_resource_type_) { | |
| 193 // TODO(danakj): Remove this, hide it in the hardware path. | |
| 194 case VideoFrameExternalResources::SOFTWARE_RESOURCE: { | |
| 195 DCHECK_EQ(frame_resources_.size(), 0u); | |
| 196 DCHECK_EQ(software_resources_.size(), 1u); | |
| 197 if (software_resources_.size() < 1u) | |
| 198 break; | |
| 199 bool premultiplied_alpha = true; | |
| 200 gfx::PointF uv_top_left(0.f, 0.f); | |
| 201 gfx::PointF uv_bottom_right(tex_width_scale, tex_height_scale); | |
| 202 float opacity[] = {1.0f, 1.0f, 1.0f, 1.0f}; | |
| 203 bool flipped = false; | |
| 204 bool nearest_neighbor = false; | |
| 205 TextureDrawQuad* texture_quad = | |
| 206 render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>(); | |
| 207 texture_quad->SetNew(shared_quad_state, | |
| 208 quad_rect, | |
| 209 opaque_rect, | |
| 210 visible_quad_rect, | |
| 211 software_resources_[0], | |
| 212 premultiplied_alpha, | |
| 213 uv_top_left, | |
| 214 uv_bottom_right, | |
| 215 SK_ColorTRANSPARENT, | |
| 216 opacity, | |
| 217 flipped, | |
| 218 nearest_neighbor); | |
| 219 break; | |
| 220 } | |
| 221 case VideoFrameExternalResources::YUV_RESOURCE: { | |
| 222 DCHECK_GE(frame_resources_.size(), 3u); | |
| 223 if (frame_resources_.size() < 3u) | |
| 224 break; | |
| 225 YUVVideoDrawQuad::ColorSpace color_space = YUVVideoDrawQuad::REC_601; | |
| 226 if (frame_->format() == media::VideoFrame::YV12J) { | |
| 227 color_space = YUVVideoDrawQuad::JPEG; | |
| 228 } else if (frame_->format() == media::VideoFrame::YV12HD) { | |
| 229 color_space = YUVVideoDrawQuad::REC_709; | |
| 230 } | |
| 231 | |
| 232 gfx::RectF tex_coord_rect( | |
| 233 tex_x_offset, tex_y_offset, tex_width_scale, tex_height_scale); | |
| 234 YUVVideoDrawQuad* yuv_video_quad = | |
| 235 render_pass->CreateAndAppendDrawQuad<YUVVideoDrawQuad>(); | |
| 236 yuv_video_quad->SetNew( | |
| 237 shared_quad_state, quad_rect, opaque_rect, visible_quad_rect, | |
| 238 tex_coord_rect, coded_size, frame_resources_[0], frame_resources_[1], | |
| 239 frame_resources_[2], | |
| 240 frame_resources_.size() > 3 ? frame_resources_[3] : 0, color_space); | |
| 241 break; | |
| 242 } | |
| 243 case VideoFrameExternalResources::RGB_RESOURCE: { | |
| 244 DCHECK_EQ(frame_resources_.size(), 1u); | |
| 245 if (frame_resources_.size() < 1u) | |
| 246 break; | |
| 247 bool premultiplied_alpha = true; | |
| 248 gfx::PointF uv_top_left(0.f, 0.f); | |
| 249 gfx::PointF uv_bottom_right(tex_width_scale, tex_height_scale); | |
| 250 float opacity[] = {1.0f, 1.0f, 1.0f, 1.0f}; | |
| 251 bool flipped = false; | |
| 252 bool nearest_neighbor = false; | |
| 253 TextureDrawQuad* texture_quad = | |
| 254 render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>(); | |
| 255 texture_quad->SetNew(shared_quad_state, | |
| 256 quad_rect, | |
| 257 opaque_rect, | |
| 258 visible_quad_rect, | |
| 259 frame_resources_[0], | |
| 260 premultiplied_alpha, | |
| 261 uv_top_left, | |
| 262 uv_bottom_right, | |
| 263 SK_ColorTRANSPARENT, | |
| 264 opacity, | |
| 265 flipped, | |
| 266 nearest_neighbor); | |
| 267 break; | |
| 268 } | |
| 269 case VideoFrameExternalResources::STREAM_TEXTURE_RESOURCE: { | |
| 270 DCHECK_EQ(frame_resources_.size(), 1u); | |
| 271 if (frame_resources_.size() < 1u) | |
| 272 break; | |
| 273 gfx::Transform scale; | |
| 274 scale.Scale(tex_width_scale, tex_height_scale); | |
| 275 StreamVideoDrawQuad* stream_video_quad = | |
| 276 render_pass->CreateAndAppendDrawQuad<StreamVideoDrawQuad>(); | |
| 277 stream_video_quad->SetNew( | |
| 278 shared_quad_state, | |
| 279 quad_rect, | |
| 280 opaque_rect, | |
| 281 visible_quad_rect, | |
| 282 frame_resources_[0], | |
| 283 scale * provider_client_impl_->stream_texture_matrix()); | |
| 284 break; | |
| 285 } | |
| 286 case VideoFrameExternalResources::IO_SURFACE: { | |
| 287 DCHECK_EQ(frame_resources_.size(), 1u); | |
| 288 if (frame_resources_.size() < 1u) | |
| 289 break; | |
| 290 IOSurfaceDrawQuad* io_surface_quad = | |
| 291 render_pass->CreateAndAppendDrawQuad<IOSurfaceDrawQuad>(); | |
| 292 io_surface_quad->SetNew(shared_quad_state, | |
| 293 quad_rect, | |
| 294 opaque_rect, | |
| 295 visible_quad_rect, | |
| 296 visible_rect.size(), | |
| 297 frame_resources_[0], | |
| 298 IOSurfaceDrawQuad::UNFLIPPED); | |
| 299 break; | |
| 300 } | |
| 301 #if defined(VIDEO_HOLE) | |
| 302 // This block and other blocks wrapped around #if defined(VIDEO_HOLE) is not | |
| 303 // maintained by the general compositor team. Please contact the following | |
| 304 // people instead: | |
| 305 // | |
| 306 // wonsik@chromium.org | |
| 307 // lcwu@chromium.org | |
| 308 case VideoFrameExternalResources::HOLE: { | |
| 309 DCHECK_EQ(frame_resources_.size(), 0u); | |
| 310 SolidColorDrawQuad* solid_color_draw_quad = | |
| 311 render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); | |
| 312 | |
| 313 // Create a solid color quad with transparent black and force no | |
| 314 // blending / no anti-aliasing. | |
| 315 gfx::Rect opaque_rect = quad_rect; | |
| 316 solid_color_draw_quad->SetAll(shared_quad_state, | |
| 317 quad_rect, | |
| 318 opaque_rect, | |
| 319 visible_quad_rect, | |
| 320 false, | |
| 321 SK_ColorTRANSPARENT, | |
| 322 true); | |
| 323 break; | |
| 324 } | |
| 325 #endif // defined(VIDEO_HOLE) | |
| 326 case VideoFrameExternalResources::NONE: | |
| 327 NOTIMPLEMENTED(); | |
| 328 break; | |
| 329 } | |
| 330 } | |
| 331 | |
| 332 void VideoLayerImpl::DidDraw(ResourceProvider* resource_provider) { | |
| 333 LayerImpl::DidDraw(resource_provider); | |
| 334 | |
| 335 DCHECK(frame_.get()); | |
| 336 | |
| 337 if (frame_resource_type_ == | |
| 338 VideoFrameExternalResources::SOFTWARE_RESOURCE) { | |
| 339 for (size_t i = 0; i < software_resources_.size(); ++i) { | |
| 340 software_release_callback_.Run( | |
| 341 0, false, layer_tree_impl()->BlockingMainThreadTaskRunner()); | |
| 342 } | |
| 343 | |
| 344 software_resources_.clear(); | |
| 345 software_release_callback_.Reset(); | |
| 346 } else { | |
| 347 for (size_t i = 0; i < frame_resources_.size(); ++i) | |
| 348 resource_provider->DeleteResource(frame_resources_[i]); | |
| 349 frame_resources_.clear(); | |
| 350 } | |
| 351 | |
| 352 provider_client_impl_->PutCurrentFrame(frame_); | |
| 353 frame_ = nullptr; | |
| 354 | |
| 355 provider_client_impl_->ReleaseLock(); | |
| 356 } | |
| 357 | |
| 358 void VideoLayerImpl::ReleaseResources() { | |
| 359 updater_ = nullptr; | |
| 360 } | |
| 361 | |
| 362 void VideoLayerImpl::SetNeedsRedraw() { | |
| 363 SetUpdateRect(gfx::UnionRects(update_rect(), gfx::Rect(bounds()))); | |
| 364 layer_tree_impl()->SetNeedsRedraw(); | |
| 365 } | |
| 366 | |
| 367 void VideoLayerImpl::SetProviderClientImpl( | |
| 368 scoped_refptr<VideoFrameProviderClientImpl> provider_client_impl) { | |
| 369 provider_client_impl_ = provider_client_impl; | |
| 370 } | |
| 371 | |
| 372 const char* VideoLayerImpl::LayerTypeAsString() const { | |
| 373 return "cc::VideoLayerImpl"; | |
| 374 } | |
| 375 | |
| 376 } // namespace cc | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1057283003:
Remove parts of //cc we aren't using (Closed)
Base URL: git@github.com:domokit/mojo.git@master