Add a new frame generator that cycles through randomly generated slides.

webrtc/test/frame_generator.cc

 /*
  *  Copyright (c) 2013 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 "webrtc/test/frame_generator.h"
@@ skipping 163 matching lines @@
   const size_t width_;
   const size_t height_;
   const size_t frame_size_;
   const std::unique_ptr<uint8_t[]> frame_buffer_;
   const int frame_display_count_;
   int current_display_count_;
   rtc::scoped_refptr<I420Buffer> last_read_buffer_;
   std::unique_ptr<VideoFrame> temp_frame_;
 };
 
+// SlideGenerator works similarly to YuvFileGenerator but it fills the frames
+// with randomly sized and colored squares instead of reading their content
+// from files.
+class SlideGenerator : public FrameGenerator {
+ public:
+  SlideGenerator(size_t width, size_t height, int frame_repeat_count)
+      : width_(width),
+        height_(height),
+        frame_display_count_(frame_repeat_count),
+        current_display_count_(0),
+        random_generator_(1234) {
+    RTC_DCHECK_GT(width, 0);
+    RTC_DCHECK_GT(height, 0);
+    RTC_DCHECK_GT(frame_repeat_count, 0);
+  }
+
+  VideoFrame* NextFrame() override {
+    if (current_display_count_ == 0)
+      GenerateNewFrame();
+    if (++current_display_count_ >= frame_display_count_)
+      current_display_count_ = 0;
+
+    frame_.reset(
+        new VideoFrame(buffer_, 0, 0, webrtc::kVideoRotation_0));
+    return frame_.get();
+  }
+
+  // Generates some randomly sized and colored squares scattered
+  // over the frame.
+  void GenerateNewFrame() {
+    const int kSquareNum = 20;

[sprang_webrtc, 2017/08/23 12:59:24]

I think this will not properly catch the extreme variation in slide complexity
that can happen. I did some short prototyping, visually inspecting the results
and found this to be a reasonable replacement:

const int square_num = 1 << (4 + (random_generator_.Rand(0, 3) * 4));

together with 

int length = random_generator_.Rand(1, width_ > 4 ? width_ / 4 : 1);
length = (length * (square_num - i)) / square_num;

(so big squares towards the end don't overwrite too much detail)

[erikvarga1, 2017/08/23 14:41:25]

Done. I didn't think to take the complexity change into account when writing
this.
I ran some benchmarks to see the frame size distribution over time and it seems
that this version is closer to the YuvFileGenerator than mine was:
https://docs.google.com/spreadsheets/d/1S2pjul33Eqeda5npesHWupqgTgVRwtTteVR8h...

(I got the numbers by running ScreenshareSlidesVP8_3TL_Simulcast with the three
frame generators and logging the delta frame sizes and send times in
rtp_sender.)

+
+    buffer_ = I420Buffer::Create(width_, height_);
+    memset(buffer_->MutableDataY(), 127, height_ * buffer_->StrideY());
+    memset(buffer_->MutableDataU(), 127,
+           buffer_->ChromaHeight() * buffer_->StrideU());
+    memset(buffer_->MutableDataV(), 127,
+           buffer_->ChromaHeight() * buffer_->StrideV());
+
+    for (int i = 0; i < kSquareNum; ++i) {
+      int length = random_generator_.Rand(1, width_ > 4 ? width_ / 4 : 1);
+      int x = random_generator_.Rand(0, width_ - length);
+      int y = random_generator_.Rand(0, height_ - length);
+      uint8_t yuv_y = random_generator_.Rand(0, 255);
+      uint8_t yuv_u = random_generator_.Rand(0, 255);
+      uint8_t yuv_v = random_generator_.Rand(0, 255);
+
+      for (int yy = y; yy < y + length; ++yy) {
+        uint8_t* pos_y =
+            (buffer_->MutableDataY() + x + yy * buffer_->StrideY());
+        memset(pos_y, yuv_y, length);
+      }
+      for (int yy = y; yy < y + length; yy += 2) {
+        uint8_t* pos_u =
+            (buffer_->MutableDataU() + x / 2 + yy / 2 * buffer_->StrideU());
+        memset(pos_u, yuv_u, length / 2);
+        uint8_t* pos_v =
+            (buffer_->MutableDataV() + x / 2 + yy / 2 * buffer_->StrideV());
+        memset(pos_v, yuv_v, length / 2);
+      }
+    }
+  }
+
+ private:
+  const size_t width_;
+  const size_t height_;
+  const int frame_display_count_;
+  int current_display_count_;
+  Random random_generator_;
+  rtc::scoped_refptr<I420Buffer> buffer_;
+  std::unique_ptr<VideoFrame> frame_;
+};
+
 class ScrollingImageFrameGenerator : public FrameGenerator {
  public:
   ScrollingImageFrameGenerator(Clock* clock,
                                const std::vector<FILE*>& files,
                                size_t source_width,
                                size_t source_height,
                                size_t target_width,
                                size_t target_height,
                                int64_t scroll_time_ms,
                                int64_t pause_time_ms)
@@ skipping 120 matching lines @@
   rtc::CritScope lock(&crit_);
   return sink_ != nullptr;
 }
 
 std::unique_ptr<FrameGenerator> FrameGenerator::CreateSquareGenerator(
     int width,
     int height) {
   return std::unique_ptr<FrameGenerator>(new SquareGenerator(width, height));
 }
 
+std::unique_ptr<FrameGenerator> FrameGenerator::CreateSlideGenerator(
+    int width, int height, int frame_repeat_count) {
+  return std::unique_ptr<FrameGenerator>(new SlideGenerator(
+      width, height, frame_repeat_count));
+}
+
 std::unique_ptr<FrameGenerator> FrameGenerator::CreateFromYuvFile(
     std::vector<std::string> filenames,
     size_t width,
     size_t height,
     int frame_repeat_count) {
   RTC_DCHECK(!filenames.empty());
   std::vector<FILE*> files;
   for (const std::string& filename : filenames) {
     FILE* file = fopen(filename.c_str(), "rb");
     RTC_DCHECK(file != nullptr);
@@ skipping 22 matching lines @@
     files.push_back(file);
   }
 
   return std::unique_ptr<FrameGenerator>(new ScrollingImageFrameGenerator(
       clock, files, source_width, source_height, target_width, target_height,
       scroll_time_ms, pause_time_ms));
 }
 
 }  // namespace test
 }  // namespace webrtc