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.
5 #include "cc/layers/video_layer_impl.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"
21 #if defined(VIDEO_HOLE)
22 #include "cc/quads/solid_color_draw_quad.h"
23 #endif // defined(VIDEO_HOLE)
28 scoped_ptr
<VideoLayerImpl
> VideoLayerImpl::Create(
29 LayerTreeImpl
* tree_impl
,
31 VideoFrameProvider
* provider
,
32 media::VideoRotation video_rotation
) {
33 DCHECK(tree_impl
->proxy()->IsMainThreadBlocked());
34 DCHECK(tree_impl
->proxy()->IsImplThread());
36 scoped_refptr
<VideoFrameProviderClientImpl
> provider_client_impl
=
37 VideoFrameProviderClientImpl::Create(
38 provider
, tree_impl
->GetVideoFrameControllerClient());
40 return make_scoped_ptr(
41 new VideoLayerImpl(tree_impl
, id
, provider_client_impl
, video_rotation
));
44 VideoLayerImpl::VideoLayerImpl(
45 LayerTreeImpl
* tree_impl
,
47 const scoped_refptr
<VideoFrameProviderClientImpl
>& provider_client_impl
,
48 media::VideoRotation video_rotation
)
49 : LayerImpl(tree_impl
, id
),
50 provider_client_impl_(provider_client_impl
),
52 video_rotation_(video_rotation
) {
55 VideoLayerImpl::~VideoLayerImpl() {
56 if (!provider_client_impl_
->Stopped()) {
57 // In impl side painting, we may have a pending and active layer
58 // associated with the video provider at the same time. Both have a ref
59 // on the VideoFrameProviderClientImpl, but we stop when the first
60 // LayerImpl (the one on the pending tree) is destroyed since we know
61 // the main thread is blocked for this commit.
62 DCHECK(layer_tree_impl()->proxy()->IsImplThread());
63 DCHECK(layer_tree_impl()->proxy()->IsMainThreadBlocked());
64 provider_client_impl_
->Stop();
68 scoped_ptr
<LayerImpl
> VideoLayerImpl::CreateLayerImpl(
69 LayerTreeImpl
* tree_impl
) {
70 return make_scoped_ptr(new VideoLayerImpl(
71 tree_impl
, id(), provider_client_impl_
, video_rotation_
));
74 void VideoLayerImpl::DidBecomeActive() {
75 provider_client_impl_
->SetActiveVideoLayer(this);
78 bool VideoLayerImpl::WillDraw(DrawMode draw_mode
,
79 ResourceProvider
* resource_provider
) {
80 if (draw_mode
== DRAW_MODE_RESOURCELESS_SOFTWARE
)
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();
93 // Drop any resources used by the updater if there is no frame to display.
96 provider_client_impl_
->ReleaseLock();
100 if (!LayerImpl::WillDraw(draw_mode
, resource_provider
))
105 new VideoResourceUpdater(layer_tree_impl()->context_provider(),
106 layer_tree_impl()->resource_provider()));
109 VideoFrameExternalResources external_resources
=
110 updater_
->CreateExternalResourcesFromVideoFrame(frame_
);
111 frame_resource_type_
= external_resources
.type
;
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
;
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
);
134 void VideoLayerImpl::AppendQuads(RenderPass
* render_pass
,
135 AppendQuadsData
* append_quads_data
) {
136 DCHECK(frame_
.get());
138 gfx::Transform transform
= draw_transform();
139 gfx::Size rotated_size
= content_bounds();
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());
147 case media::VIDEO_ROTATION_180
:
148 transform
.Rotate(180.0);
149 transform
.Translate(-rotated_size
.width(), -rotated_size
.height());
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
:
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());
165 AppendDebugBorderQuad(
166 render_pass
, rotated_size
, shared_quad_state
, append_quads_data
);
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();
173 Occlusion occlusion_in_video_space
=
175 .occlusion_in_content_space
.GetOcclusionWithGivenDrawTransform(
177 gfx::Rect visible_quad_rect
=
178 occlusion_in_video_space
.GetUnoccludedContentRect(quad_rect
);
179 if (visible_quad_rect
.IsEmpty())
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();
188 switch (frame_resource_type_
) {
189 // TODO(danakj): Remove this, hide it in the hardware path.
190 case VideoFrameExternalResources::SOFTWARE_RESOURCE
: {
191 DCHECK_EQ(frame_resources_
.size(), 0u);
192 DCHECK_EQ(software_resources_
.size(), 1u);
193 if (software_resources_
.size() < 1u)
195 bool premultiplied_alpha
= true;
196 gfx::PointF
uv_top_left(0.f
, 0.f
);
197 gfx::PointF
uv_bottom_right(tex_width_scale
, tex_height_scale
);
198 float opacity
[] = {1.0f
, 1.0f
, 1.0f
, 1.0f
};
199 bool flipped
= false;
200 bool nearest_neighbor
= false;
201 TextureDrawQuad
* texture_quad
=
202 render_pass
->CreateAndAppendDrawQuad
<TextureDrawQuad
>();
203 texture_quad
->SetNew(shared_quad_state
,
207 software_resources_
[0],
215 ValidateQuadResources(texture_quad
);
218 case VideoFrameExternalResources::YUV_RESOURCE
: {
219 DCHECK_GE(frame_resources_
.size(), 3u);
221 YUVVideoDrawQuad::ColorSpace color_space
= YUVVideoDrawQuad::REC_601
;
222 int videoframe_color_space
;
223 if (frame_
->metadata()->GetInteger(media::VideoFrameMetadata::COLOR_SPACE
,
224 &videoframe_color_space
)) {
225 if (videoframe_color_space
== media::VideoFrame::COLOR_SPACE_JPEG
) {
226 color_space
= YUVVideoDrawQuad::JPEG
;
227 } else if (videoframe_color_space
==
228 media::VideoFrame::COLOR_SPACE_HD_REC709
) {
229 color_space
= YUVVideoDrawQuad::REC_709
;
233 const gfx::Size ya_tex_size
= coded_size
;
234 gfx::Size uv_tex_size
;
236 if (frame_
->storage_type() == media::VideoFrame::STORAGE_TEXTURE
) {
237 DCHECK_EQ(media::VideoFrame::I420
, frame_
->format());
238 DCHECK_EQ(3u, frame_resources_
.size()); // Alpha is not supported yet.
239 DCHECK(visible_rect
.origin().IsOrigin());
240 DCHECK(visible_rect
.size() == coded_size
);
241 uv_tex_size
.SetSize((ya_tex_size
.width() + 1) / 2,
242 (ya_tex_size
.height() + 1) / 2);
244 uv_tex_size
= media::VideoFrame::PlaneSize(
245 frame_
->format(), media::VideoFrame::kUPlane
, coded_size
);
246 DCHECK(uv_tex_size
==
247 media::VideoFrame::PlaneSize(
248 frame_
->format(), media::VideoFrame::kVPlane
, coded_size
));
250 frame_resources_
.size() > 3,
252 media::VideoFrame::PlaneSize(
253 frame_
->format(), media::VideoFrame::kAPlane
, coded_size
));
256 // Compute the UV sub-sampling factor based on the ratio between
257 // |ya_tex_size| and |uv_tex_size|.
258 float uv_subsampling_factor_x
=
259 static_cast<float>(ya_tex_size
.width()) / uv_tex_size
.width();
260 float uv_subsampling_factor_y
=
261 static_cast<float>(ya_tex_size
.height()) / uv_tex_size
.height();
262 gfx::RectF
ya_tex_coord_rect(visible_rect
);
263 gfx::RectF
uv_tex_coord_rect(
264 visible_rect
.x() / uv_subsampling_factor_x
,
265 visible_rect
.y() / uv_subsampling_factor_y
,
266 visible_rect
.width() / uv_subsampling_factor_x
,
267 visible_rect
.height() / uv_subsampling_factor_y
);
269 YUVVideoDrawQuad
* yuv_video_quad
=
270 render_pass
->CreateAndAppendDrawQuad
<YUVVideoDrawQuad
>();
271 yuv_video_quad
->SetNew(
272 shared_quad_state
, quad_rect
, opaque_rect
, visible_quad_rect
,
273 ya_tex_coord_rect
, uv_tex_coord_rect
, ya_tex_size
, uv_tex_size
,
274 frame_resources_
[0], frame_resources_
[1], frame_resources_
[2],
275 frame_resources_
.size() > 3 ? frame_resources_
[3] : 0, color_space
);
276 ValidateQuadResources(yuv_video_quad
);
279 case VideoFrameExternalResources::RGBA_RESOURCE
:
280 case VideoFrameExternalResources::RGB_RESOURCE
: {
281 DCHECK_EQ(frame_resources_
.size(), 1u);
282 if (frame_resources_
.size() < 1u)
284 bool premultiplied_alpha
=
285 (frame_resource_type_
== VideoFrameExternalResources::RGBA_RESOURCE
);
286 gfx::PointF
uv_top_left(0.f
, 0.f
);
287 gfx::PointF
uv_bottom_right(tex_width_scale
, tex_height_scale
);
288 float opacity
[] = {1.0f
, 1.0f
, 1.0f
, 1.0f
};
289 bool flipped
= false;
290 bool nearest_neighbor
= false;
291 TextureDrawQuad
* texture_quad
=
292 render_pass
->CreateAndAppendDrawQuad
<TextureDrawQuad
>();
293 texture_quad
->SetNew(shared_quad_state
,
305 ValidateQuadResources(texture_quad
);
308 case VideoFrameExternalResources::STREAM_TEXTURE_RESOURCE
: {
309 DCHECK_EQ(frame_resources_
.size(), 1u);
310 if (frame_resources_
.size() < 1u)
312 gfx::Transform scale
;
313 scale
.Scale(tex_width_scale
, tex_height_scale
);
314 StreamVideoDrawQuad
* stream_video_quad
=
315 render_pass
->CreateAndAppendDrawQuad
<StreamVideoDrawQuad
>();
316 stream_video_quad
->SetNew(
317 shared_quad_state
, quad_rect
, opaque_rect
, visible_quad_rect
,
319 scale
* provider_client_impl_
->StreamTextureMatrix());
320 ValidateQuadResources(stream_video_quad
);
323 case VideoFrameExternalResources::IO_SURFACE
: {
324 DCHECK_EQ(frame_resources_
.size(), 1u);
325 if (frame_resources_
.size() < 1u)
327 IOSurfaceDrawQuad
* io_surface_quad
=
328 render_pass
->CreateAndAppendDrawQuad
<IOSurfaceDrawQuad
>();
329 io_surface_quad
->SetNew(shared_quad_state
,
335 IOSurfaceDrawQuad::UNFLIPPED
);
336 ValidateQuadResources(io_surface_quad
);
339 #if defined(VIDEO_HOLE)
340 // This block and other blocks wrapped around #if defined(VIDEO_HOLE) is not
341 // maintained by the general compositor team. Please contact the following
344 // wonsik@chromium.org
346 case VideoFrameExternalResources::HOLE
: {
347 DCHECK_EQ(frame_resources_
.size(), 0u);
348 SolidColorDrawQuad
* solid_color_draw_quad
=
349 render_pass
->CreateAndAppendDrawQuad
<SolidColorDrawQuad
>();
351 // Create a solid color quad with transparent black and force no
352 // blending / no anti-aliasing.
353 gfx::Rect opaque_rect
= quad_rect
;
354 solid_color_draw_quad
->SetAll(shared_quad_state
,
363 #endif // defined(VIDEO_HOLE)
364 case VideoFrameExternalResources::NONE
:
370 void VideoLayerImpl::DidDraw(ResourceProvider
* resource_provider
) {
371 LayerImpl::DidDraw(resource_provider
);
373 DCHECK(frame_
.get());
375 if (frame_resource_type_
==
376 VideoFrameExternalResources::SOFTWARE_RESOURCE
) {
377 for (size_t i
= 0; i
< software_resources_
.size(); ++i
) {
378 software_release_callback_
.Run(
379 0, false, layer_tree_impl()->BlockingMainThreadTaskRunner());
382 software_resources_
.clear();
383 software_release_callback_
.Reset();
385 for (size_t i
= 0; i
< frame_resources_
.size(); ++i
)
386 resource_provider
->DeleteResource(frame_resources_
[i
]);
387 frame_resources_
.clear();
390 provider_client_impl_
->PutCurrentFrame();
393 provider_client_impl_
->ReleaseLock();
396 SimpleEnclosedRegion
VideoLayerImpl::VisibleContentOpaqueRegion() const {
397 // If we don't have a frame yet, then we don't have an opaque region.
398 if (!provider_client_impl_
->HasCurrentFrame())
399 return SimpleEnclosedRegion();
400 return LayerImpl::VisibleContentOpaqueRegion();
403 void VideoLayerImpl::ReleaseResources() {
407 void VideoLayerImpl::SetNeedsRedraw() {
408 SetUpdateRect(gfx::UnionRects(update_rect(), gfx::Rect(bounds())));
409 layer_tree_impl()->SetNeedsRedraw();
412 const char* VideoLayerImpl::LayerTypeAsString() const {
413 return "cc::VideoLayerImpl";