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::CreateScaledCroppedFrame(
+    const CapturedFrame* input_frame,
+    int crop_x,
+    int crop_y,
+    int crop_width,
+    int crop_height,
+    int dst_width,
+    int dst_height) const {
+  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);

[nisse-webrtc, 2016/05/12 12:23:06]

But calling CanonicalFourCC seems unnecessary, that's the first thing done by
ConvertToI420 (but with a different incarnation of that function, I guess).

+  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, width and height, are all pre-rotation values.
+      crop_x, crop_y,
+      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) {
+    buffer = webrtc::I420Buffer::Scale(buffer, dst_width, dst_height);
+    if (!buffer) {
+      LOG(LS_ERROR) << "I420Scale failed: src size "
+                    << src_width << " x " << src_height
+                    << ", dst size: "
+                    << dst_width << " x " << dst_height;
+      return nullptr;
+    }
+  }
+  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_)) {

[perkj_webrtc, 2016/05/11 10:05:17]

It looks like |aliased_frame| always is I420? No need to ConvertToI420 above
then. 

[nisse-webrtc, 2016/05/12 12:23:06]

In the (common) case that the CapturedFrame holds I420 data, the ConvertToI420
call boils down to a call to I420Rotate, which in turn boils down to I420Copy.
And we do want a copy.

     LOG(LS_ERROR) <<
         "Failed to create WebRtcVideoFrame in CreateAliasedFrame.";
     return NULL;
   }
   return frame.release();
 }
 
 }  // namespace cricket