Use incoming frame's rotation while converting it to I420

content/renderer/media_recorder/video_track_recorder.cc

 // Copyright 2015 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_recorder/video_track_recorder.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 21 matching lines @@
 #if BUILDFLAG(RTC_USE_H264)
 #include "content/renderer/media_recorder/h264_encoder.h"
 #endif  // #if BUILDFLAG(RTC_USE_H264)
 
 using media::VideoFrame;
 using video_track_recorder::kVEAEncoderMinResolutionWidth;
 using video_track_recorder::kVEAEncoderMinResolutionHeight;
 
 namespace content {
 
+libyuv::RotationMode MediaVideoRotationToRotationMode(
+    media::VideoRotation rotation) {
+  switch (rotation) {
+    case media::VIDEO_ROTATION_0:
+      return libyuv::kRotate0;
+    case media::VIDEO_ROTATION_90:
+      return libyuv::kRotate90;
+    case media::VIDEO_ROTATION_180:
+      return libyuv::kRotate180;
+    case media::VIDEO_ROTATION_270:
+      return libyuv::kRotate270;
+  }
+  NOTREACHED() << rotation;
+  return libyuv::kRotate0;
+}
+
 namespace {
 
 using CodecId = VideoTrackRecorder::CodecId;
 
 static const struct {
   CodecId codec_id;
   media::VideoCodecProfile min_profile;
   media::VideoCodecProfile max_profile;
 } kPreferredCodecIdAndVEAProfiles[] = {
     {CodecId::VP8, media::VP8PROFILE_MIN, media::VP8PROFILE_MAX},
@@ skipping 160 matching lines @@
     // Send black frames (yuv = {0, 127, 127}).
     frame = media::VideoFrame::CreateColorFrame(
         video_frame->visible_rect().size(), 0u, 0x80, 0x80,
         video_frame->timestamp());
   } else {
     // Accelerated decoders produce ARGB/ABGR texture-backed frames (see
     // https://crbug.com/585242), fetch them using a SkCanvasVideoRenderer.
     DCHECK(video_frame->HasTextures());
     DCHECK_EQ(media::PIXEL_FORMAT_ARGB, video_frame->format());
 
+    const gfx::Size& old_visible_size = video_frame->visible_rect().size();
+    gfx::Size new_visible_size = old_visible_size;
+
+    media::VideoRotation video_rotation = media::VIDEO_ROTATION_0;
+    if (video_frame->metadata()->GetRotation(
+            media::VideoFrameMetadata::ROTATION, &video_rotation) &&
+        (video_rotation == media::VIDEO_ROTATION_90 ||
+         video_rotation == media::VIDEO_ROTATION_270)) {
+      new_visible_size.SetSize(old_visible_size.height(),
+                               old_visible_size.width());
+    }
+
     frame = media::VideoFrame::CreateFrame(
-        media::PIXEL_FORMAT_I420, video_frame->coded_size(),
-        video_frame->visible_rect(), video_frame->natural_size(),
-        video_frame->timestamp());
+        media::PIXEL_FORMAT_I420, new_visible_size, gfx::Rect(new_visible_size),
+        new_visible_size, video_frame->timestamp());
 
     const SkImageInfo info = SkImageInfo::MakeN32(
         frame->visible_rect().width(), frame->visible_rect().height(),
         kOpaque_SkAlphaType);
 
     // Create |surface_| if it doesn't exist or incoming resolution has changed.
     if (!canvas_ || canvas_->imageInfo().width() != info.width() ||
         canvas_->imageInfo().height() != info.height()) {
       bitmap_.allocPixels(info);
       canvas_ = base::MakeUnique<cc::SkiaPaintCanvas>(bitmap_);
     }
     if (!video_renderer_)
       video_renderer_.reset(new media::SkCanvasVideoRenderer);
 
     DCHECK(context_provider->ContextGL());
     video_renderer_->Copy(video_frame.get(), canvas_.get(),
                           media::Context3D(context_provider->ContextGL(),
                                            context_provider->GrContext()));
 
     SkPixmap pixmap;
     if (!bitmap_.peekPixels(&pixmap)) {
       DLOG(ERROR) << "Error trying to map PaintSurface's pixels";
       return;
     }
-    // TODO(mcasas): Use the incoming frame's rotation when
-    // https://bugs.chromium.org/p/webrtc/issues/detail?id=6069 is closed.
-    const libyuv::RotationMode source_rotation = libyuv::kRotate0;
+
     const uint32 source_pixel_format =
         (kN32_SkColorType == kRGBA_8888_SkColorType) ? libyuv::FOURCC_ABGR
                                                      : libyuv::FOURCC_ARGB;
-    if (libyuv::ConvertToI420(static_cast<uint8*>(pixmap.writable_addr()),
-                              pixmap.getSafeSize(),
-                              frame->visible_data(media::VideoFrame::kYPlane),
-                              frame->stride(media::VideoFrame::kYPlane),
-                              frame->visible_data(media::VideoFrame::kUPlane),
-                              frame->stride(media::VideoFrame::kUPlane),
-                              frame->visible_data(media::VideoFrame::kVPlane),
-                              frame->stride(media::VideoFrame::kVPlane),
-                              0 /* crop_x */, 0 /* crop_y */,
-                              pixmap.width(), pixmap.height(),
-                              frame->visible_rect().width(),
-                              frame->visible_rect().height(),
-                              source_rotation,
-                              source_pixel_format) != 0) {
+    if (libyuv::ConvertToI420(
+            static_cast<uint8*>(pixmap.writable_addr()), pixmap.getSafeSize(),
+            frame->visible_data(media::VideoFrame::kYPlane),
+            frame->stride(media::VideoFrame::kYPlane),
+            frame->visible_data(media::VideoFrame::kUPlane),
+            frame->stride(media::VideoFrame::kUPlane),
+            frame->visible_data(media::VideoFrame::kVPlane),
+            frame->stride(media::VideoFrame::kVPlane), 0 /* crop_x */,
+            0 /* crop_y */, pixmap.width(), pixmap.height(),
+            old_visible_size.width(), old_visible_size.height(),
+            MediaVideoRotationToRotationMode(video_rotation),
+            source_pixel_format) != 0) {
       DLOG(ERROR) << "Error converting frame to I420";
       return;
     }
   }
 
   encoding_task_runner_->PostTask(
       FROM_HERE, base::Bind(&Encoder::EncodeOnEncodingTaskRunner, this, frame,
                             capture_timestamp));
 }
 
@@ skipping 155 matching lines @@
   MediaStreamVideoSink::DisconnectFromTrack();
   encoder_ = nullptr;
   MediaStreamVideoSink::ConnectToTrack(
       track_,
       media::BindToCurrentLoop(base::Bind(initialize_encoder_callback_,
                                           false /*allow_vea_encoder*/)),
       false);
 }
 
 }  // namespace content