New method CreateScaledFrame in the VideoFrameFactory interface.

webrtc/media/engine/webrtcvideoframefactory.cc

 /*
  *  Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include <memory>
 
+#include "libyuv/convert.h"
+#include "libyuv/scale.h"
+
 #include "webrtc/base/logging.h"
 #include "webrtc/media/engine/webrtcvideoframe.h"
 #include "webrtc/media/engine/webrtcvideoframefactory.h"
 
+// TODO(nisse): Needed for the struct CapturedFrame. Move declaration
+// to videoframefactory.h instead?
+#include "webrtc/media/base/videocapturer.h"
+
 namespace cricket {
 
+std::unique_ptr<VideoFrame> WebRtcVideoFrameFactory::CreateScaledFrame(
+    const CapturedFrame* input_frame,
+    int dst_width,
+    int dst_height) const {
+  // Size of the used portion of the input frame, updated for
+  // cropping, but pre-rotation.
+  int crop_width = input_frame->width;
+  int crop_height = input_frame->height;
+
+  // Cropp the input frame, if needed to preserve aspect ratio.
+  long aspect_diff = static_cast<long>(crop_width) * dst_height -
+                     static_cast<long>(crop_height) * dst_width;
+  if (aspect_diff > 0) {

[magjed_webrtc, 2016/05/09 13:44:55]

This code will be the same for all implementations because the cropped
resolution can be calculated from the input frame resolution and
dst_width/height. How about making this crop calculation in
VideoCapturer::OnFrameCaptured and passing the cropped resolution as argument to
this function instead?

[nisse-webrtc, 2016/05/10 07:56:22]

It used to be a helper function in videocommon. I think the responsibility
belongs to the FrameFactory, but I agree we shouldn't duplicate it. 

It could be a helper method (possibly static) in the VideoFrameFactory base
class.

Or split into a (protected?) method (say, CreateScaledCroppedFrame) to be
implemented in subclasses, and the public CreateScaledFrame implemented in the
base class.

What subclasses of VideoFrameFactory exists? E.g., is the cropping logic
reusable for texture frames?

I'm also considering moving the libyuv calls (ConvertToI420 and I420Scale) to
the I420Buffer class.

+    // Horizontal crop.
+
+    // TODO(nisse): Old code carried a comment saying that MJPG can
+    // only be cropped vertically, and disabled horizontal cropping in
+    // that case. Still needed?
+    crop_width -= aspect_diff / dst_height;
+    RTC_DCHECK(crop_width > 0);
+  } else if (aspect_diff > 0) {
+    // Vertical crop.
+    crop_height -= (-aspect_diff) / dst_width;
+    RTC_DCHECK(crop_height > 0);
+  }
+
+  webrtc::VideoRotation rotation = input_frame->rotation;
+  // The size of the input frame, after cropping and rotation.
+  int src_width = crop_width;
+  int src_height = crop_height;
+  if (apply_rotation_ && (rotation == webrtc::kVideoRotation_90 ||
+                          rotation == webrtc::kVideoRotation_270)) {
+    std::swap(dst_width, dst_height);
+    std::swap(src_width, src_height);
+  }
+
+  rtc::scoped_refptr<webrtc::I420Buffer> buffer(
+      new rtc::RefCountedObject<webrtc::I420Buffer>(src_width, src_height));
+
+  // Color space conversion, cropping, and rotation.
+  uint32_t format = CanonicalFourCC(input_frame->fourcc);
+  int r = libyuv::ConvertToI420(
+      static_cast<const uint8_t*>(input_frame->data), input_frame->data_size,
+      buffer->MutableDataY(), buffer->StrideY(),
+      buffer->MutableDataU(), buffer->StrideU(),
+      buffer->MutableDataV(), buffer->StrideV(),
+      // Cropping coordinates, and width and height, are pre-rotation values.
+      (input_frame->width - crop_width) / 2,
+      (input_frame->height - crop_height) / 2,
+      input_frame->width, input_frame->height,
+      crop_width, crop_height,
+      static_cast<libyuv::RotationMode>(
+          apply_rotation_ ? rotation : webrtc::kVideoRotation_0),
+      format);
+  if (r) {
+    LOG(LS_ERROR) << "Error parsing format: " << GetFourccName(format)
+                  << " return code : " << r;
+    return nullptr;
+  }
+
+  // Scaling, if needed.
+  if (src_width != dst_width || src_height != dst_height) {
+    rtc::scoped_refptr<webrtc::I420Buffer> scaled(
+        new rtc::RefCountedObject<webrtc::I420Buffer>(dst_width, dst_height));
+
+    if (libyuv::I420Scale(buffer->DataY(), buffer->StrideY(),
+                          buffer->DataU(), buffer->StrideU(),
+                          buffer->DataV(), buffer->StrideV(),
+                          buffer->width(), buffer->height(),
+                          scaled->MutableDataY(), scaled->StrideY(),
+                          scaled->MutableDataU(), scaled->StrideU(),
+                          scaled->MutableDataV(), scaled->StrideV(),
+                          scaled->width(), scaled->height(),
+                          libyuv::kFilterBox) < 0) {
+      LOG(LS_ERROR) << "I420Scale failed: src size "
+                    << buffer->width() << " x " << buffer->height()
+                    << ", dst size: "
+                    << scaled->width() << " x " << scaled->height();
+      return nullptr;
+    }
+    buffer = scaled;
+  }
+  return std::unique_ptr<VideoFrame>(new WebRtcVideoFrame(
+      buffer, apply_rotation_ ? webrtc::kVideoRotation_0 : rotation,
+      input_frame->time_stamp / rtc::kNumNanosecsPerMicrosec));
+}
+
 VideoFrame* WebRtcVideoFrameFactory::CreateAliasedFrame(
     const CapturedFrame* aliased_frame, int width, int height) const {
   std::unique_ptr<WebRtcVideoFrame> frame(new WebRtcVideoFrame());
   if (!frame->Init(aliased_frame, width, height, apply_rotation_)) {
     LOG(LS_ERROR) <<
         "Failed to create WebRtcVideoFrame in CreateAliasedFrame.";
     return NULL;
   }
   return frame.release();
 }
 
 }  // namespace cricket