Let ViEEncoder handle resolution changes.

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"
 
 #include <math.h>
 #include <stdio.h>
 #include <string.h>
 
 #include <memory>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/test/frame_utils.h"
 
 namespace webrtc {
 namespace test {
 namespace {
 
 class ChromaGenerator : public FrameGenerator {
  public:
-  ChromaGenerator(size_t width, size_t height)
-      : angle_(0.0), width_(width), height_(height) {
+  ChromaGenerator(size_t width, size_t height) : angle_(0.0) {
+    ChangeResolution(width, height);
+  }
+
+  void ChangeResolution(size_t width, size_t height) override {
+    rtc::CritScope lock(&crit_);
+    width_ = width;
+    height_ = height;
     RTC_CHECK(width_ > 0);
     RTC_CHECK(height_ > 0);
     half_width_ = (width_ + 1) / 2;
     y_size_ = width_ * height_;
     uv_size_ = half_width_ * ((height_ + 1) / 2);
   }
 
   VideoFrame* NextFrame() override {
+    rtc::CritScope lock(&crit_);
     angle_ += 30.0;
     uint8_t u = fabs(sin(angle_)) * 0xFF;
     uint8_t v = fabs(cos(angle_)) * 0xFF;
 
     // Ensure stride == width.
     rtc::scoped_refptr<I420Buffer> buffer(I420Buffer::Create(
         static_cast<int>(width_), static_cast<int>(height_),
         static_cast<int>(width_), static_cast<int>(half_width_),
         static_cast<int>(half_width_)));
 
     memset(buffer->MutableDataY(), 0x80, y_size_);
     memset(buffer->MutableDataU(), u, uv_size_);
     memset(buffer->MutableDataV(), v, uv_size_);
 
     frame_.reset(new VideoFrame(buffer, 0, 0, webrtc::kVideoRotation_0));
     return frame_.get();
   }
 
  private:
-  double angle_;
-  size_t width_;
-  size_t height_;
-  size_t half_width_;
-  size_t y_size_;
-  size_t uv_size_;
-  std::unique_ptr<VideoFrame> frame_;
+  rtc::CriticalSection crit_;
+  double angle_ GUARDED_BY(&crit_);
+  size_t width_ GUARDED_BY(&crit_);
+  size_t height_ GUARDED_BY(&crit_);
+  size_t half_width_ GUARDED_BY(&crit_);
+  size_t y_size_ GUARDED_BY(&crit_);
+  size_t uv_size_ GUARDED_BY(&crit_);
+  std::unique_ptr<VideoFrame> frame_ GUARDED_BY(&crit_);
 };
 
 class YuvFileGenerator : public FrameGenerator {
  public:
   YuvFileGenerator(std::vector<FILE*> files,
                    size_t width,
                    size_t height,
                    int frame_repeat_count)
       : file_index_(0),
         files_(files),
@@ skipping 221 matching lines @@
     files.push_back(file);
   }
 
   return new ScrollingImageFrameGenerator(
       clock, files, source_width, source_height, target_width, target_height,
       scroll_time_ms, pause_time_ms);
 }
 
 }  // namespace test
 }  // namespace webrtc