1 /* 2 * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 #ifndef CALL_DEGRADED_CALL_H_ 12 #define CALL_DEGRADED_CALL_H_ 13 14 #include <stddef.h> 15 #include <stdint.h> 16 17 #include <map> 18 #include <memory> 19 #include <string> 20 #include <vector> 21 22 #include "absl/strings/string_view.h" 23 #include "absl/types/optional.h" 24 #include "api/call/transport.h" 25 #include "api/fec_controller.h" 26 #include "api/media_types.h" 27 #include "api/rtp_headers.h" 28 #include "api/task_queue/pending_task_safety_flag.h" 29 #include "api/test/simulated_network.h" 30 #include "call/audio_receive_stream.h" 31 #include "call/audio_send_stream.h" 32 #include "call/call.h" 33 #include "call/fake_network_pipe.h" 34 #include "call/flexfec_receive_stream.h" 35 #include "call/packet_receiver.h" 36 #include "call/rtp_transport_controller_send_interface.h" 37 #include "call/simulated_network.h" 38 #include "call/video_receive_stream.h" 39 #include "call/video_send_stream.h" 40 #include "rtc_base/copy_on_write_buffer.h" 41 #include "rtc_base/network/sent_packet.h" 42 #include "rtc_base/task_queue.h" 43 #include "system_wrappers/include/clock.h" 44 #include "video/config/video_encoder_config.h" 45 46 namespace webrtc { 47 class DegradedCall : public Call, private PacketReceiver { 48 public: 49 struct TimeScopedNetworkConfig : public BuiltInNetworkBehaviorConfig { 50 TimeDelta duration = TimeDelta::PlusInfinity(); 51 }; 52 53 explicit DegradedCall( 54 std::unique_ptr<Call> call, 55 const std::vector<TimeScopedNetworkConfig>& send_configs, 56 const std::vector<TimeScopedNetworkConfig>& receive_configs); 57 ~DegradedCall() override; 58 59 // Implements Call. 60 AudioSendStream* CreateAudioSendStream( 61 const AudioSendStream::Config& config) override; 62 void DestroyAudioSendStream(AudioSendStream* send_stream) override; 63 64 AudioReceiveStreamInterface* CreateAudioReceiveStream( 65 const AudioReceiveStreamInterface::Config& config) override; 66 void DestroyAudioReceiveStream( 67 AudioReceiveStreamInterface* receive_stream) override; 68 69 VideoSendStream* CreateVideoSendStream( 70 VideoSendStream::Config config, 71 VideoEncoderConfig encoder_config) override; 72 VideoSendStream* CreateVideoSendStream( 73 VideoSendStream::Config config, 74 VideoEncoderConfig encoder_config, 75 std::unique_ptr<FecController> fec_controller) override; 76 void DestroyVideoSendStream(VideoSendStream* send_stream) override; 77 78 VideoReceiveStreamInterface* CreateVideoReceiveStream( 79 VideoReceiveStreamInterface::Config configuration) override; 80 void DestroyVideoReceiveStream( 81 VideoReceiveStreamInterface* receive_stream) override; 82 83 FlexfecReceiveStream* CreateFlexfecReceiveStream( 84 const FlexfecReceiveStream::Config config) override; 85 void DestroyFlexfecReceiveStream( 86 FlexfecReceiveStream* receive_stream) override; 87 88 void AddAdaptationResource(rtc::scoped_refptr<Resource> resource) override; 89 90 PacketReceiver* Receiver() override; 91 92 RtpTransportControllerSendInterface* GetTransportControllerSend() override; 93 94 Stats GetStats() const override; 95 96 const FieldTrialsView& trials() const override; 97 98 TaskQueueBase* network_thread() const override; 99 TaskQueueBase* worker_thread() const override; 100 101 void SignalChannelNetworkState(MediaType media, NetworkState state) override; 102 void OnAudioTransportOverheadChanged( 103 int transport_overhead_per_packet) override; 104 void OnLocalSsrcUpdated(AudioReceiveStreamInterface& stream, 105 uint32_t local_ssrc) override; 106 void OnLocalSsrcUpdated(VideoReceiveStreamInterface& stream, 107 uint32_t local_ssrc) override; 108 void OnLocalSsrcUpdated(FlexfecReceiveStream& stream, 109 uint32_t local_ssrc) override; 110 void OnUpdateSyncGroup(AudioReceiveStreamInterface& stream, 111 absl::string_view sync_group) override; 112 void OnSentPacket(const rtc::SentPacket& sent_packet) override; 113 114 protected: 115 // Implements PacketReceiver. 116 DeliveryStatus DeliverPacket(MediaType media_type, 117 rtc::CopyOnWriteBuffer packet, 118 int64_t packet_time_us) override; 119 120 private: 121 class FakeNetworkPipeOnTaskQueue { 122 public: 123 FakeNetworkPipeOnTaskQueue( 124 TaskQueueBase* task_queue, 125 rtc::scoped_refptr<PendingTaskSafetyFlag> call_alive, 126 Clock* clock, 127 std::unique_ptr<NetworkBehaviorInterface> network_behavior); 128 129 void SendRtp(const uint8_t* packet, 130 size_t length, 131 const PacketOptions& options, 132 Transport* transport); 133 void SendRtcp(const uint8_t* packet, size_t length, Transport* transport); 134 135 void AddActiveTransport(Transport* transport); 136 void RemoveActiveTransport(Transport* transport); 137 138 private: 139 // Try to process packets on the fake network queue. 140 // Returns true if call resulted in a delayed process, false if queue empty. 141 bool Process(); 142 143 Clock* const clock_; 144 TaskQueueBase* const task_queue_; 145 rtc::scoped_refptr<PendingTaskSafetyFlag> call_alive_; 146 FakeNetworkPipe pipe_; 147 absl::optional<int64_t> next_process_ms_ RTC_GUARDED_BY(&task_queue_); 148 }; 149 150 class ThreadedPacketReceiver : public PacketReceiver { 151 public: 152 ThreadedPacketReceiver(webrtc::TaskQueueBase* worker_thread, 153 webrtc::TaskQueueBase* network_thread, 154 rtc::scoped_refptr<PendingTaskSafetyFlag> call_alive, 155 PacketReceiver* receiver); 156 ~ThreadedPacketReceiver() override; 157 158 DeliveryStatus DeliverPacket(MediaType media_type, 159 rtc::CopyOnWriteBuffer packet, 160 int64_t packet_time_us) override; 161 162 private: 163 webrtc::TaskQueueBase* const worker_thread_; 164 webrtc::TaskQueueBase* const network_thread_; 165 rtc::scoped_refptr<PendingTaskSafetyFlag> call_alive_; 166 webrtc::PacketReceiver* const receiver_; 167 }; 168 169 // For audio/video send stream, a TransportAdapter instance is used to 170 // intercept packets to be sent, and put them into a common FakeNetworkPipe 171 // in such as way that they will eventually (unless dropped) be forwarded to 172 // the correct Transport for that stream. 173 class FakeNetworkPipeTransportAdapter : public Transport { 174 public: 175 FakeNetworkPipeTransportAdapter(FakeNetworkPipeOnTaskQueue* fake_network, 176 Call* call, 177 Clock* clock, 178 Transport* real_transport); 179 ~FakeNetworkPipeTransportAdapter(); 180 181 bool SendRtp(const uint8_t* packet, 182 size_t length, 183 const PacketOptions& options) override; 184 bool SendRtcp(const uint8_t* packet, size_t length) override; 185 186 private: 187 FakeNetworkPipeOnTaskQueue* const network_pipe_; 188 Call* const call_; 189 Clock* const clock_; 190 Transport* const real_transport_; 191 }; 192 193 void SetClientBitratePreferences( 194 const webrtc::BitrateSettings& preferences) override; 195 void UpdateSendNetworkConfig(); 196 void UpdateReceiveNetworkConfig(); 197 198 Clock* const clock_; 199 const std::unique_ptr<Call> call_; 200 // For cancelling tasks on the network thread when DegradedCall is destroyed 201 rtc::scoped_refptr<PendingTaskSafetyFlag> call_alive_; 202 size_t send_config_index_; 203 const std::vector<TimeScopedNetworkConfig> send_configs_; 204 SimulatedNetwork* send_simulated_network_; 205 std::unique_ptr<FakeNetworkPipeOnTaskQueue> send_pipe_; 206 std::map<AudioSendStream*, std::unique_ptr<FakeNetworkPipeTransportAdapter>> 207 audio_send_transport_adapters_; 208 std::map<VideoSendStream*, std::unique_ptr<FakeNetworkPipeTransportAdapter>> 209 video_send_transport_adapters_; 210 211 size_t receive_config_index_; 212 const std::vector<TimeScopedNetworkConfig> receive_configs_; 213 SimulatedNetwork* receive_simulated_network_; 214 std::unique_ptr<FakeNetworkPipe> receive_pipe_; 215 std::unique_ptr<ThreadedPacketReceiver> packet_receiver_; 216 }; 217 218 } // namespace webrtc 219 220 #endif // CALL_DEGRADED_CALL_H_ 221