Rotation into Video Layer + Content Transform

cc/layers/video_layer_impl.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/layers/video_layer_impl.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "cc/layers/video_frame_provider_client_impl.h"
 #include "cc/quads/io_surface_draw_quad.h"
@@ skipping 20 matching lines @@
     VideoFrameProvider* provider) {
   scoped_ptr<VideoLayerImpl> layer(new VideoLayerImpl(tree_impl, id));
   layer->SetProviderClientImpl(VideoFrameProviderClientImpl::Create(provider));
   DCHECK(tree_impl->proxy()->IsImplThread());
   DCHECK(tree_impl->proxy()->IsMainThreadBlocked());
   return layer.Pass();
 }
 
 VideoLayerImpl::VideoLayerImpl(LayerTreeImpl* tree_impl, int id)
     : LayerImpl(tree_impl, id),
-      frame_(NULL) {}
+      frame_(NULL),
+      video_rotation_(media::VIDEO_ROTATION_0) {
+}
 
 VideoLayerImpl::~VideoLayerImpl() {
   if (!provider_client_impl_->Stopped()) {
     // In impl side painting, we may have a pending and active layer
     // associated with the video provider at the same time. Both have a ref
     // on the VideoFrameProviderClientImpl, but we stop when the first
     // LayerImpl (the one on the pending tree) is destroyed since we know
     // the main thread is blocked for this commit.
     DCHECK(layer_tree_impl()->proxy()->IsImplThread());
     DCHECK(layer_tree_impl()->proxy()->IsMainThreadBlocked());
     provider_client_impl_->Stop();
   }
 }
 
 scoped_ptr<LayerImpl> VideoLayerImpl::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
-  return scoped_ptr<LayerImpl>(new VideoLayerImpl(tree_impl, id()));
+  VideoLayerImpl* impl = new VideoLayerImpl(tree_impl, id());
+  impl->set_video_rotation(video_rotation_);
+  return scoped_ptr<LayerImpl>(impl);
 }
 
 void VideoLayerImpl::PushPropertiesTo(LayerImpl* layer) {
   LayerImpl::PushPropertiesTo(layer);
 
   VideoLayerImpl* other = static_cast<VideoLayerImpl*>(layer);
   other->SetProviderClientImpl(provider_client_impl_);

[danakj, 2014/07/11 21:04:29]

pass the new rotation here, not in CreateLayerImpl

 }
 
 void VideoLayerImpl::DidBecomeActive() {
   provider_client_impl_->set_active_video_layer(this);
 }
 
 bool VideoLayerImpl::WillDraw(DrawMode draw_mode,
                               ResourceProvider* resource_provider) {
   if (draw_mode == DRAW_MODE_RESOURCELESS_SOFTWARE)
     return false;
@@ skipping 49 matching lines @@
 }
 
 void VideoLayerImpl::AppendQuads(
     RenderPass* render_pass,
     const OcclusionTracker<LayerImpl>& occlusion_tracker,
     AppendQuadsData* append_quads_data) {
   DCHECK(frame_.get());
 
   SharedQuadState* shared_quad_state =
       render_pass->CreateAndAppendSharedQuadState();
   PopulateSharedQuadState(shared_quad_state);

[danakj, 2014/07/11 21:04:29]

replace this with a call to SetAll (do this after you compute things), and pass
in the right content bounds and transform there.

 
+  gfx::Size bounds = content_bounds();

[danakj, 2014/07/11 21:04:29]

rotated_content_bounds

+  gfx::Transform transform = shared_quad_state->content_to_target_transform;
+  switch (video_rotation_) {
+    case media::VIDEO_ROTATION_90:
+      transform.Rotate(90);
+      transform.Translate(0, -bounds.width());
+      bounds = gfx::Size(bounds.height(), bounds.width());
+      break;
+    case media::VIDEO_ROTATION_180:
+      transform.Rotate(180);
+      transform.Translate(-bounds.width(), -bounds.height());
+      break;
+    case media::VIDEO_ROTATION_270:
+      transform.Rotate(270);
+      transform.Translate(-bounds.height(), 0);
+      bounds = gfx::Size(bounds.height(), bounds.width());
+    default:

[scherkus (not reviewing), 2014/07/11 18:54:07]

try to avoid default where possible and instead explicitly list the cases

should anything change in the future the compiler will catch missing cases

[danakj, 2014/07/11 21:04:29]

+1

+      break;
+  }
+  shared_quad_state->content_to_target_transform = transform;

[danakj, 2014/07/11 21:04:29]

You want to Preconcat your transform onto the existing transform, not replace
it.

+
   AppendDebugBorderQuad(
-      render_pass, content_bounds(), shared_quad_state, append_quads_data);
+      render_pass, bounds, shared_quad_state, append_quads_data);
 
-  gfx::Rect quad_rect(content_bounds());
+  gfx::Rect quad_rect(bounds);
   gfx::Rect opaque_rect(contents_opaque() ? quad_rect : gfx::Rect());
   gfx::Rect visible_rect = frame_->visible_rect();
   gfx::Size coded_size = frame_->coded_size();
 
   gfx::Rect visible_quad_rect = occlusion_tracker.UnoccludedContentRect(
       quad_rect, draw_properties().target_space_transform);
   if (visible_quad_rect.IsEmpty())
     return;
 
   // Pixels for macroblocked formats.
@@ skipping 171 matching lines @@
 
 void VideoLayerImpl::ReleaseResources() {
   updater_.reset();
 }
 
 void VideoLayerImpl::SetNeedsRedraw() {
   SetUpdateRect(gfx::UnionRects(update_rect(), gfx::RectF(bounds())));
   layer_tree_impl()->SetNeedsRedraw();
 }
 
+void VideoLayerImpl::set_video_rotation(media::VideoRotation video_rotation) {

[danakj, 2014/07/11 21:04:29]

SetVideoRotation, this isn't inline

+  video_rotation_ = video_rotation;
+}

[danakj, 2014/07/11 21:04:29]

You need to call NoteLayerPropertyChanged()

+
 void VideoLayerImpl::SetProviderClientImpl(
     scoped_refptr<VideoFrameProviderClientImpl> provider_client_impl) {
   provider_client_impl_ = provider_client_impl;
 }
 
 const char* VideoLayerImpl::LayerTypeAsString() const {
   return "cc::VideoLayerImpl";
 }
 
 }  // namespace cc