Apply rotation for texture backed VideoFrames

content/renderer/media/webmediaplayer_ms.cc

 // Copyright 2013 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 "content/renderer/media/webmediaplayer_ms.h"
 
 #include <stddef.h>
 #include <limits>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "build/build_config.h"
 #include "cc/blink/web_layer_impl.h"
 #include "cc/layers/video_frame_provider_client_impl.h"
 #include "cc/layers/video_layer.h"
 #include "content/common/gpu/client/context_provider_command_buffer.h"
 #include "content/public/renderer/media_stream_audio_renderer.h"
 #include "content/public/renderer/media_stream_renderer_factory.h"
 #include "content/public/renderer/media_stream_video_renderer.h"
 #include "content/renderer/media/web_media_element_source_utils.h"
 #include "content/renderer/media/webmediaplayer_ms_compositor.h"
 #include "content/renderer/render_frame_impl.h"
 #include "content/renderer/render_thread_impl.h"
 #include "media/base/media_log.h"
 #include "media/base/video_frame.h"
+#include "media/base/video_rotation.h"
 #include "media/blink/webmediaplayer_util.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayerClient.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayerSource.h"
 #include "third_party/WebKit/public/platform/WebRect.h"
 #include "third_party/WebKit/public/platform/WebSize.h"
 
 namespace content {
 
 WebMediaPlayerMS::WebMediaPlayerMS(
     blink::WebFrame* frame,
@@ skipping 10 matching lines @@
     : frame_(frame),
       network_state_(WebMediaPlayer::NetworkStateEmpty),
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
       buffered_(static_cast<size_t>(0)),
       client_(client),
       delegate_(delegate),
       delegate_id_(0),
       paused_(true),
       render_frame_suspended_(false),
       received_first_frame_(false),
+      video_rotation_(media::VIDEO_ROTATION_0),
       media_log_(media_log),
       renderer_factory_(std::move(factory)),
       media_task_runner_(media_task_runner),
       worker_task_runner_(worker_task_runner),
       gpu_factories_(gpu_factories),
       compositor_task_runner_(compositor_task_runner),
       initial_audio_output_device_id_(sink_id.utf8()),
       initial_security_origin_(security_origin.isNull()
                                    ? url::Origin()
                                    : url::Origin(security_origin)),
@@ skipping 189 matching lines @@
   return (video_frame_provider_.get() != nullptr);
 }
 
 bool WebMediaPlayerMS::hasAudio() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return (audio_renderer_.get() != nullptr);
 }
 
 blink::WebSize WebMediaPlayerMS::naturalSize() const {
   DCHECK(thread_checker_.CalledOnValidThread());
+  if (video_rotation_ == media::VIDEO_ROTATION_90 ||
+      video_rotation_ == media::VideoRotation::VIDEO_ROTATION_270) {
+    const gfx::Size& current_size = compositor_->GetCurrentSize();
+    return blink::WebSize(current_size.height(), current_size.width());

[mcasas, 2016/07/15 01:57:34]

nit: blink::WebSize has a ctor with gfx::Size as parameter [1]
so you can do
return blink::WebSize(compositor->GetCurrentSize());



[1]
https://cs.chromium.org/chromium/src/third_party/WebKit/public/platform/WebSi...

[chcunningham, 2016/07/15 18:25:52]

I think he means to swap width and height here. IIUC your suggestion wouldn't do
the rotation.

[emircan, 2016/07/15 18:43:13]

I am swapping height and width here as ccunningham@ pointed out.

+  }
   return blink::WebSize(compositor_->GetCurrentSize());
 }
 
 bool WebMediaPlayerMS::paused() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return paused_;
 }
 
 bool WebMediaPlayerMS::seeking() const {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 61 matching lines @@
     auto* provider =
         RenderThreadImpl::current()->SharedMainThreadContextProvider().get();
     // GPU Process crashed.
     if (!provider)
       return;
     context_3d = media::Context3D(provider->ContextGL(), provider->GrContext());
     DCHECK(context_3d.gl);
   }
   const gfx::RectF dest_rect(rect.x, rect.y, rect.width, rect.height);
   video_renderer_.Paint(frame, canvas, dest_rect, alpha, mode,
-                        media::VIDEO_ROTATION_0, context_3d);
+                        video_rotation_, context_3d);
 }
 
 bool WebMediaPlayerMS::hasSingleSecurityOrigin() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return true;
 }
 
 bool WebMediaPlayerMS::didPassCORSAccessCheck() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return true;
@@ skipping 128 matching lines @@
   }
 
   if (!received_first_frame_) {
     received_first_frame_ = true;
     if (getReadyState() < WebMediaPlayer::ReadyStateHaveEnoughData) {
       SetReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
       SetReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
     }
 
     if (video_frame_provider_.get()) {
+      if (frame->metadata()->GetRotation(media::VideoFrameMetadata::ROTATION,
+                                         &video_rotation_)) {
+        DVLOG(3) << "Applying rotation: " << video_rotation_;
+      }

[mcasas, 2016/07/15 01:57:34]

All metadata() methods are marked WARN_UNUSED_RESULT,
but you don't have to use a DVLOG just for that. Instead, 
please use ignore_result() to signify that here, you don't care.

https://cs.chromium.org/chromium/src/base/macros.h?sq=package:chromium&dr=C&r...

[chcunningham, 2016/07/15 18:25:52]

He does care though right? Line 510 where he uses video_rotation_

[emircan, 2016/07/15 18:43:13]

What I ignore here is the return bool of GetRotation, video_rotation_ is used in
all cases.

[emircan, 2016/07/15 18:43:13]

Done.

+
       video_weblayer_.reset(new cc_blink::WebLayerImpl(
-          cc::VideoLayer::Create(compositor_.get(), media::VIDEO_ROTATION_0)));
+          cc::VideoLayer::Create(compositor_.get(), video_rotation_)));
       video_weblayer_->layer()->SetContentsOpaque(false);
       video_weblayer_->SetContentsOpaqueIsFixed(true);
       get_client()->setWebLayer(video_weblayer_.get());
     }
   }
 
   compositor_->EnqueueFrame(frame);
 }
 
 void WebMediaPlayerMS::RepaintInternal() {
@@ skipping 29 matching lines @@
 void WebMediaPlayerMS::ResetCanvasCache() {
   DCHECK(thread_checker_.CalledOnValidThread());
   video_renderer_.ResetCache();
 }
 
 void WebMediaPlayerMS::TriggerResize() {
   get_client()->sizeChanged();
 }
 
 }  // namespace content