Use simulcast for screenshare only in conference mode

webrtc/video/vie_encoder_unittest.cc

 /*
  *  Copyright (c) 2016 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 <algorithm>
 #include <limits>
 #include <utility>
 
 #include "webrtc/api/video/i420_buffer.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/media/base/videoadapter.h"
+#include "webrtc/modules/video_coding/codecs/vp8/temporal_layers.h"
 #include "webrtc/modules/video_coding/utility/default_video_bitrate_allocator.h"
 #include "webrtc/system_wrappers/include/metrics_default.h"
 #include "webrtc/system_wrappers/include/sleep.h"
 #include "webrtc/test/encoder_settings.h"
 #include "webrtc/test/fake_encoder.h"
 #include "webrtc/test/frame_generator.h"
 #include "webrtc/test/gmock.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/video/send_statistics_proxy.h"
 #include "webrtc/video/vie_encoder.h"
@@ skipping 233 matching lines @@
 
     void CheckLastTimeStampsMatch(int64_t ntp_time_ms,
                                   uint32_t timestamp) const {
       rtc::CritScope lock(&local_crit_sect_);
       EXPECT_EQ(timestamp_, timestamp);
       EXPECT_EQ(ntp_time_ms_, ntp_time_ms);
     }
 
     void SetQualityScaling(bool b) { quality_scaling_ = b; }
 
+    void ForceInitEncodeFailure(bool force_failure) {
+      rtc::CritScope lock(&local_crit_sect_);
+      force_init_encode_failed_ = force_failure;
+    }
+
    private:
     int32_t Encode(const VideoFrame& input_image,
                    const CodecSpecificInfo* codec_specific_info,
                    const std::vector<FrameType>* frame_types) override {
       bool block_encode;
       {
         rtc::CritScope lock(&local_crit_sect_);
         EXPECT_GT(input_image.timestamp(), timestamp_);
         EXPECT_GT(input_image.ntp_time_ms(), ntp_time_ms_);
         EXPECT_EQ(input_image.timestamp(), input_image.ntp_time_ms() * 90);
 
         timestamp_ = input_image.timestamp();
         ntp_time_ms_ = input_image.ntp_time_ms();
         last_input_width_ = input_image.width();
         last_input_height_ = input_image.height();
         block_encode = block_next_encode_;
         block_next_encode_ = false;
       }
       int32_t result =
           FakeEncoder::Encode(input_image, codec_specific_info, frame_types);
       if (block_encode)
         EXPECT_TRUE(continue_encode_event_.Wait(kDefaultTimeoutMs));
       return result;
     }
 
+    int32_t InitEncode(const VideoCodec* config,
+                       int32_t number_of_cores,
+                       size_t max_payload_size) override {
+      int res =
+          FakeEncoder::InitEncode(config, number_of_cores, max_payload_size);
+      rtc::CritScope lock(&local_crit_sect_);
+      if (config->codecType == kVideoCodecVP8 && config->VP8().tl_factory) {
+        // Simulate setting up temporal layers, in order to validate the life
+        // cycle of these objects.
+        int num_streams = std::max<int>(1, config->numberOfSimulcastStreams);
+        int num_temporal_layers =
+            std::max<int>(1, config->VP8().numberOfTemporalLayers);
+        for (int i = 0; i < num_streams; ++i) {
+          allocated_temporal_layers_.emplace_back(
+              config->VP8().tl_factory->Create(i, num_temporal_layers, 42));
+        }
+      }
+      if (force_init_encode_failed_)
+        return -1;
+      return res;
+    }
+
     rtc::CriticalSection local_crit_sect_;
-    bool block_next_encode_ = false;
+    bool block_next_encode_ GUARDED_BY(local_crit_sect_) = false;
     rtc::Event continue_encode_event_;
-    uint32_t timestamp_ = 0;
-    int64_t ntp_time_ms_ = 0;
-    int last_input_width_ = 0;
-    int last_input_height_ = 0;
-    bool quality_scaling_ = true;
+    uint32_t timestamp_ GUARDED_BY(local_crit_sect_) = 0;
+    int64_t ntp_time_ms_ GUARDED_BY(local_crit_sect_) = 0;
+    int last_input_width_ GUARDED_BY(local_crit_sect_) = 0;
+    int last_input_height_ GUARDED_BY(local_crit_sect_) = 0;
+    bool quality_scaling_ GUARDED_BY(local_crit_sect_) = true;
+    std::vector<std::unique_ptr<TemporalLayers>> allocated_temporal_layers_
+        GUARDED_BY(local_crit_sect_);
+    bool force_init_encode_failed_ GUARDED_BY(local_crit_sect_) = false;
   };
 
   class TestSink : public ViEEncoder::EncoderSink {
    public:
     explicit TestSink(TestEncoder* test_encoder)
         : test_encoder_(test_encoder), encoded_frame_event_(false, false) {}
 
     void WaitForEncodedFrame(int64_t expected_ntp_time) {
       uint32_t timestamp = 0;
       EXPECT_TRUE(encoded_frame_event_.Wait(kDefaultTimeoutMs));
@@ skipping 922 matching lines @@
   sink_.WaitForEncodedFrame((kFrameWidth * 3) / 4, (kFrameHeight * 3) / 4);
 
   // Trigger CPU normal use, return to original resoluton;
   vie_encoder_->TriggerCpuNormalUsage();
   video_source_.IncomingCapturedFrame(
       CreateFrame(3, kFrameWidth, kFrameHeight));
   sink_.WaitForEncodedFrame(kFrameWidth, kFrameHeight);
 
   vie_encoder_->Stop();
 }
+
+TEST_F(ViEEncoderTest, FailingInitEncodeDoesntCauseCrash) {
+  fake_encoder_.ForceInitEncodeFailure(true);
+  vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
+  ResetEncoder("VP8", 2, 1, true);
+  const int kFrameWidth = 1280;
+  const int kFrameHeight = 720;
+  video_source_.IncomingCapturedFrame(
+      CreateFrame(1, kFrameWidth, kFrameHeight));
+  sink_.ExpectDroppedFrame();
+  vie_encoder_->Stop();
+}
 }  // namespace webrtc