New method CreateScaledFrame in the VideoFrameFactory interface.

webrtc/media/engine/webrtcvideoframefactory_unittest.cc

 /*
  *  Copyright (c) 2015 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.
  */
 
@@ skipping 19 matching lines @@
     captured_frame_.pixel_width = 1;
     captured_frame_.pixel_height = 1;
     captured_frame_.time_stamp = rtc::TimeNanos();
     captured_frame_.rotation = frame_rotation;
     captured_frame_.width = frame_width;
     captured_frame_.height = frame_height;
     captured_frame_.data_size =
         (frame_width * frame_height) +
         ((frame_width + 1) / 2) * ((frame_height + 1) / 2) * 2;
     captured_frame_buffer_.reset(new uint8_t[captured_frame_.data_size]);
-    // Initialize memory to satisfy DrMemory tests.
-    memset(captured_frame_buffer_.get(), 0, captured_frame_.data_size);
+
+    // Initialize with gradient, Y = 128(x/w + y/h), U = 256 x/w, V = 256 y/h
+    for (int x = 0; x < frame_width; x++)
+      for (int y = 0; y < frame_height; y++) {
+        captured_frame_buffer_[x + y * frame_width] =
+            128 * (x * frame_height + y * frame_width) /
+            (frame_width * frame_height);
+      }
+    int chroma_width = (frame_width + 1) / 2;
+    int chroma_height = (frame_height + 1) / 2;
+    for (int x = 0; x < chroma_width; x++)
+      for (int y = 0; y < chroma_height; y++) {
+        captured_frame_buffer_[frame_width * frame_height +
+                               x + y*chroma_width] = 256 * x / chroma_width;
+        captured_frame_buffer_[frame_width * frame_height +
+                               chroma_width * chroma_height +
+                               x + y*chroma_width] = 256 * y / chroma_height;
+      }
     captured_frame_.data = captured_frame_buffer_.get();
   }
 
   void VerifyFrame(cricket::VideoFrame* dest_frame,
                    webrtc::VideoRotation src_rotation,
                    int src_width,
                    int src_height,
                    bool apply_rotation) {
     if (!apply_rotation) {
       EXPECT_EQ(dest_frame->rotation(), src_rotation);
       EXPECT_EQ(dest_frame->width(), src_width);
       EXPECT_EQ(dest_frame->height(), src_height);
     } else {
       EXPECT_EQ(dest_frame->rotation(), webrtc::kVideoRotation_0);
       if (src_rotation == webrtc::kVideoRotation_90 ||
           src_rotation == webrtc::kVideoRotation_270) {
         EXPECT_EQ(dest_frame->width(), src_height);
         EXPECT_EQ(dest_frame->height(), src_width);
       } else {
         EXPECT_EQ(dest_frame->width(), src_width);
         EXPECT_EQ(dest_frame->height(), src_height);
       }
     }
   }
+  void VerifyCrop(webrtc::VideoFrameBuffer* frame,
+                  webrtc::VideoRotation src_rotation,
+                  double rel_width,
+                  double rel_height,
+                  bool apply_rotation) {
+    // Corners, in counter-clockwise order. E.g, 90 degree rotation
+    // maps (0,0) onto (1,0).
+    struct {
+      int x;
+      int y;
+    } corners[4] = {
+        {0, 0}, {1, 0}, {1, 1}, {0, 1},
+    };
+
+    int rotation = apply_rotation ? src_rotation / 90 : 0;
+
+    int width = frame->width();
+    int height = frame->height();
+    // Check that pixel values in the corners match the gradient used
+    // for initialization.
+    for (int i = 0; i < 4; i++) {
+      // Pixel coordinates of corner 0, after rotation.
+      int x = corners[(i + rotation) % 4].x * (width - 1);
+      int y = corners[(i + rotation) % 4].y * (height - 1);
+      // Pre-rotation coordinates, range 0.0 - 1.0 correspond to the
+      // size of the uncropped input frame.
+      double orig_x = (1 - rel_width) / 2 + corners[i].x * rel_width;
+      double orig_y = (1 - rel_height) / 2 + corners[i].y * rel_height;
+
+      EXPECT_NEAR(frame->DataY()[x + y * frame->StrideY()] / 256.0,
+                  (orig_x + orig_y) / 2, 0.01);
+      EXPECT_NEAR(frame->DataU()[x / 2 + (y / 2) * frame->StrideU()] / 256.0,
+                  orig_x, 0.01);
+      EXPECT_NEAR(frame->DataV()[x / 2 + (y / 2) * frame->StrideV()] / 256.0,
+                  orig_y, 0.01);
+    }
+  }
 
   void TestCreateAliasedFrame(bool apply_rotation) {
     cricket::VideoFrameFactory& factory = factory_;
     factory.SetApplyRotation(apply_rotation);
     InitFrame(webrtc::kVideoRotation_270);
     const cricket::CapturedFrame& captured_frame = get_captured_frame();
     // Create the new frame from the CapturedFrame.
     std::unique_ptr<cricket::VideoFrame> frame;
     int new_width = captured_frame.width / 2;
     int new_height = captured_frame.height / 2;
     frame.reset(factory.CreateAliasedFrame(&captured_frame, new_width,
                                            new_height, new_width, new_height));
     VerifyFrame(frame.get(), webrtc::kVideoRotation_270, new_width, new_height,
                 apply_rotation);
 
     frame.reset(factory.CreateAliasedFrame(
         &captured_frame, new_width, new_height, new_width / 2, new_height / 2));
     VerifyFrame(frame.get(), webrtc::kVideoRotation_270, new_width / 2,
                 new_height / 2, apply_rotation);
 
     // Reset the frame first so it's exclusive hence we could go through the
     // StretchToFrame code path in CreateAliasedFrame.
     frame.reset();
     frame.reset(factory.CreateAliasedFrame(
         &captured_frame, new_width, new_height, new_width / 2, new_height / 2));
     VerifyFrame(frame.get(), webrtc::kVideoRotation_270, new_width / 2,
                 new_height / 2, apply_rotation);
   }
 
+  void TestCreateScaledFrame(bool apply_rotation) {
+    cricket::VideoFrameFactory& factory = factory_;
+    factory.SetApplyRotation(apply_rotation);
+    InitFrame(webrtc::kVideoRotation_270);
+    const cricket::CapturedFrame& captured_frame = get_captured_frame();
+    // Create the new frame from the CapturedFrame.
+    std::unique_ptr<cricket::VideoFrame> frame;
+    int new_width = captured_frame.width / 2;
+    int new_height = captured_frame.height / 2;
+    frame = factory.CreateScaledFrame(&captured_frame, new_width, new_height);
+    VerifyFrame(frame.get(), webrtc::kVideoRotation_270, new_width, new_height,
+                apply_rotation);
+
+    frame = factory.CreateScaledFrame(&captured_frame,
+                                      new_width / 2, new_height / 2);
+    VerifyFrame(frame.get(), webrtc::kVideoRotation_270, new_width / 2,
+                new_height / 2, apply_rotation);
+
+    // Vertical cropping
+    frame = factory.CreateScaledFrame(&captured_frame,
+                                      new_width / 2, new_height / 3);
+    VerifyFrame(frame.get(), webrtc::kVideoRotation_270, new_width / 2,
+                new_height / 3, apply_rotation);
+    VerifyCrop(frame->video_frame_buffer(), webrtc::kVideoRotation_270,
+               1.0, 2.0 / 3.0, apply_rotation);
+
+    // Horizontal cropping
+    frame = factory.CreateScaledFrame(&captured_frame,
+                                      new_width / 3, new_height / 2);
+    VerifyFrame(frame.get(), webrtc::kVideoRotation_270, new_width / 3,
+                new_height / 2, apply_rotation);
+    VerifyCrop(frame->video_frame_buffer(), webrtc::kVideoRotation_270,
+               2.0 / 3.0, 1.0, apply_rotation);
+  }
   const cricket::CapturedFrame& get_captured_frame() { return captured_frame_; }
 
  private:
   cricket::CapturedFrame captured_frame_;
   std::unique_ptr<uint8_t[]> captured_frame_buffer_;
   cricket::WebRtcVideoFrameFactory factory_;
 };
 
-TEST_F(WebRtcVideoFrameFactoryTest, NoApplyRotation) {
+TEST_F(WebRtcVideoFrameFactoryTest, CreateAliasedFrameNoApplyRotation) {
   TestCreateAliasedFrame(false);
 }
 
-TEST_F(WebRtcVideoFrameFactoryTest, ApplyRotation) {
+TEST_F(WebRtcVideoFrameFactoryTest, CreateAliasedFrameApplyRotation) {
   TestCreateAliasedFrame(true);
 }
+
+TEST_F(WebRtcVideoFrameFactoryTest, CreateScaledFrameNoApplyRotation) {
+  TestCreateScaledFrame(false);
+}
+
+TEST_F(WebRtcVideoFrameFactoryTest, CreateScaledFrameApplyRotation) {
+  TestCreateScaledFrame(true);
+}