Fix SetRates for encoders with internal sources.

webrtc/test/fake_encoder.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.
  */
 
@@ skipping 185 matching lines @@
 DelayedEncoder::DelayedEncoder(Clock* clock, int delay_ms)
     : test::FakeEncoder(clock),
       delay_ms_(delay_ms) {}
 
 int32_t DelayedEncoder::Encode(const VideoFrame& input_image,
                                const CodecSpecificInfo* codec_specific_info,
                                const std::vector<FrameType>* frame_types) {
   SleepMs(delay_ms_);
   return FakeEncoder::Encode(input_image, codec_specific_info, frame_types);
 }
+
+InternalSourceEncoder::InternalSourceEncoder(Clock* clock,
+                                             uint32_t frame_period_ms,
+                                             uint32_t first_frame_timestamp_ms)
+    : test::FakeEncoder(clock),
+      thread_(EncoderProcess, this, "InternalSourceEncoderProcess"),
+      frame_period_ms_(frame_period_ms),
+      current_frame_timestamp_ms_(first_frame_timestamp_ms),
+      shutting_down_(false),
+      next_frame_type_(kVideoFrameKey) {}
+
+int32_t InternalSourceEncoder::InitEncode(const VideoCodec* config,
+                                          int32_t number_of_cores,
+                                          size_t max_payload_size) {
+  int32_t result =
+      test::FakeEncoder::InitEncode(config, number_of_cores, max_payload_size);
+  thread_.Start();
+  return result;
+}
+
+bool InternalSourceEncoder::EncoderProcess(void* encoder_void_ptr) {
+  InternalSourceEncoder* encoder =
+      static_cast<InternalSourceEncoder*>(encoder_void_ptr);
+  SleepMs(encoder->frame_period_ms_);
+  return encoder->EncodeFrame();
+}
+
+bool InternalSourceEncoder::EncodeFrame() {
+  FrameType frame_type;
+  {
+    rtc::CritScope crit(&lock_);
+    if (shutting_down_) {
+      return false;
+    }
+    frame_type = next_frame_type_;
+    // Reset the frame type, now that we've consumed a keyframe request (if it
+    // was kVideoFrameKey).
+    next_frame_type_ = kVideoFrameDelta;
+  }
+  VideoFrame input_image(rtc::scoped_refptr<webrtc::VideoFrameBuffer>(),
+                         current_frame_timestamp_ms_ * 90,
+                         current_frame_timestamp_ms_, kVideoRotation_0);
+  current_frame_timestamp_ms_ += frame_period_ms_;
+  std::vector<FrameType> frame_types{frame_type};
+
+  // Call the base class explicitly, to skip our no-op override.
+  test::FakeEncoder::Encode(input_image, nullptr, &frame_types);
+  return true;
+}
+
+int32_t InternalSourceEncoder::Release() {
+  {
+    rtc::CritScope crit(&lock_);
+    shutting_down_ = true;
+  }
+  thread_.Stop();
+  return test::FakeEncoder::Release();
+}
+
+int32_t InternalSourceEncoder::Encode(
+    const VideoFrame& input_image,
+    const CodecSpecificInfo* codec_specific_info,
+    const std::vector<FrameType>* frame_types) {
+  // Check for keyframe requests.
+  if (frame_types) {
+    for (FrameType type : *frame_types) {
+      if (type == kVideoFrameKey) {
+        rtc::CritScope crit(&lock_);
+        next_frame_type_ = kVideoFrameKey;
+        break;
+      }
+    }
+  }
+  return WEBRTC_VIDEO_CODEC_OK;
+}
+
 }  // namespace test
 }  // namespace webrtc