Add multithreaded fake encoder and corresponding FlexFEC VideoSendStreamTest.

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.
  */
 
 #include "webrtc/test/fake_encoder.h"
 
 #include <algorithm>
 
+#include "webrtc/base/atomicops.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/modules/video_coding/include/video_codec_interface.h"
 #include "webrtc/system_wrappers/include/sleep.h"
 #include "webrtc/test/gtest.h"
 
 namespace webrtc {
 namespace test {
 
 FakeEncoder::FakeEncoder(Clock* clock)
     : clock_(clock),
@@ skipping 193 matching lines @@
                                const CodecSpecificInfo* codec_specific_info,
                                const std::vector<FrameType>* frame_types) {
   int delay_ms = 0;
   {
     rtc::CritScope lock(&lock_);
     delay_ms = delay_ms_;
   }
   SleepMs(delay_ms);
   return FakeEncoder::Encode(input_image, codec_specific_info, frame_types);
 }
+
+MultiThreadedFakeEncoder::MultiThreadedFakeEncoder(Clock* clock)
+    : test::FakeEncoder(clock),
+      current_queue_(0),
+      queue1_("Queue 1"),
+      queue2_("Queue 2") {}
+
+MultiThreadedFakeEncoder::~MultiThreadedFakeEncoder() = default;
+
+class MultiThreadedFakeEncoder::EncodeTask : public rtc::QueuedTask {
+ public:
+  EncodeTask(MultiThreadedFakeEncoder* encoder,
+             const VideoFrame& input_image,
+             const CodecSpecificInfo* codec_specific_info,
+             const std::vector<FrameType>* frame_types)
+      : encoder_(encoder),
+        input_image_(input_image),
+        codec_specific_info_(),
+        frame_types_(*frame_types) {
+    if (codec_specific_info)
+      codec_specific_info_ = *codec_specific_info;
+  }
+
+ private:
+  bool Run() override {
+    encoder_->EncodeCallback(input_image_, &codec_specific_info_,
+                             &frame_types_);
+    return true;
+  }
+
+  MultiThreadedFakeEncoder* const encoder_;
+  VideoFrame input_image_;
+  CodecSpecificInfo codec_specific_info_;
+  std::vector<FrameType> frame_types_;
+};
+
+int32_t MultiThreadedFakeEncoder::Encode(
+    const VideoFrame& input_image,
+    const CodecSpecificInfo* codec_specific_info,
+    const std::vector<FrameType>* frame_types) {
+  int current_queue = rtc::AtomicOps::Increment(&current_queue_);
+  rtc::TaskQueue& queue = (current_queue % 2 == 0) ? queue1_ : queue2_;
+
+  queue.PostTask(std::unique_ptr<rtc::QueuedTask>(
+      new EncodeTask(this, input_image, codec_specific_info, frame_types)));
+
+  return 0;
+}
+
+int32_t MultiThreadedFakeEncoder::EncodeCallback(
+    const VideoFrame& input_image,
+    const CodecSpecificInfo* codec_specific_info,
+    const std::vector<FrameType>* frame_types) {
+  return FakeEncoder::Encode(input_image, codec_specific_info, frame_types);

[stefan-webrtc, 2016/12/12 15:18:28]

Doesn't this mean that the encoder will produce twice the bitrate it's been
configured to produce?

[brandtr, 2016/12/13 11:32:23]

Not sure why it would do that?

MultiThreadedFakeEncoder::Encode posts a task to some queue that when run will
call MultiThreadedFakeEncoder::EncodeCallback, which in its turn will run
FakeEncoder::Encode. That is, the MultiThreadedFakeEncoder just distributes
calls to ::Encode onto two different queues.

[stefan-webrtc, 2016/12/13 13:04:46]

Yes, you are right, I misunderstood the code.

+}
+
 }  // namespace test
 }  // namespace webrtc