pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2013 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 | |
pbos@webrtc.org | 3f45c2e | 2013-08-05 16:22:53 | [diff] [blame] | 11 | #include <string.h> |
| 12 | |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 13 | #include <map> |
| 14 | #include <vector> |
| 15 | |
Peter Boström | bf9f73c | 2015-09-25 11:58:30 | [diff] [blame^] | 16 | #include "webrtc/audio/audio_receive_stream.h" |
pbos@webrtc.org | 6eaf09a | 2015-03-23 13:12:24 | [diff] [blame] | 17 | #include "webrtc/base/checks.h" |
kwiberg@webrtc.org | deb9dae | 2015-02-26 14:34:55 | [diff] [blame] | 18 | #include "webrtc/base/scoped_ptr.h" |
pbos@webrtc.org | d54aa96 | 2014-09-24 06:05:00 | [diff] [blame] | 19 | #include "webrtc/base/thread_annotations.h" |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 20 | #include "webrtc/call.h" |
Peter Boström | bf9f73c | 2015-09-25 11:58:30 | [diff] [blame^] | 21 | #include "webrtc/call/rtc_event_log.h" |
stefan@webrtc.org | 47f0c41 | 2013-12-04 10:24:26 | [diff] [blame] | 22 | #include "webrtc/common.h" |
pbos@webrtc.org | d05597a | 2013-12-05 12:11:47 | [diff] [blame] | 23 | #include "webrtc/config.h" |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 24 | #include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h" |
sprang@webrtc.org | cce642c | 2015-01-28 12:37:36 | [diff] [blame] | 25 | #include "webrtc/modules/rtp_rtcp/source/byte_io.h" |
Peter Boström | 8e07f3a | 2015-05-08 11:54:38 | [diff] [blame] | 26 | #include "webrtc/modules/utility/interface/process_thread.h" |
Peter Boström | 8e07f3a | 2015-05-08 11:54:38 | [diff] [blame] | 27 | #include "webrtc/system_wrappers/interface/cpu_info.h" |
pbos@webrtc.org | b5d2d16 | 2013-10-02 13:36:09 | [diff] [blame] | 28 | #include "webrtc/system_wrappers/interface/critical_section_wrapper.h" |
pbos@webrtc.org | f076e17 | 2015-01-15 10:09:39 | [diff] [blame] | 29 | #include "webrtc/system_wrappers/interface/logging.h" |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 30 | #include "webrtc/system_wrappers/interface/rw_lock_wrapper.h" |
pbos@webrtc.org | b5d2d16 | 2013-10-02 13:36:09 | [diff] [blame] | 31 | #include "webrtc/system_wrappers/interface/trace.h" |
pbos@webrtc.org | e286393 | 2015-01-29 12:33:07 | [diff] [blame] | 32 | #include "webrtc/system_wrappers/interface/trace_event.h" |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 33 | #include "webrtc/video/video_receive_stream.h" |
| 34 | #include "webrtc/video/video_send_stream.h" |
ivoc | 35fd753 | 2015-09-09 07:09:43 | [diff] [blame] | 35 | #include "webrtc/voice_engine/include/voe_codec.h" |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 36 | |
| 37 | namespace webrtc { |
pbos@webrtc.org | 1c65545 | 2014-09-17 09:02:25 | [diff] [blame] | 38 | |
pbos@webrtc.org | 7da3067 | 2014-10-14 11:52:10 | [diff] [blame] | 39 | const int Call::Config::kDefaultStartBitrateBps = 300000; |
| 40 | |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 41 | namespace internal { |
asapersson@webrtc.org | 8ef6548 | 2014-01-31 10:05:07 | [diff] [blame] | 42 | |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 43 | class Call : public webrtc::Call, public PacketReceiver { |
| 44 | public: |
Peter Boström | 8e07f3a | 2015-05-08 11:54:38 | [diff] [blame] | 45 | explicit Call(const Call::Config& config); |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 46 | virtual ~Call(); |
| 47 | |
kjellander@webrtc.org | 860ac53 | 2015-03-04 12:58:35 | [diff] [blame] | 48 | PacketReceiver* Receiver() override; |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 49 | |
Fredrik Solenberg | ee9b72e | 2015-06-08 11:04:56 | [diff] [blame] | 50 | webrtc::AudioSendStream* CreateAudioSendStream( |
| 51 | const webrtc::AudioSendStream::Config& config) override; |
| 52 | void DestroyAudioSendStream(webrtc::AudioSendStream* send_stream) override; |
| 53 | |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 54 | webrtc::AudioReceiveStream* CreateAudioReceiveStream( |
| 55 | const webrtc::AudioReceiveStream::Config& config) override; |
| 56 | void DestroyAudioReceiveStream( |
| 57 | webrtc::AudioReceiveStream* receive_stream) override; |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 58 | |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 59 | webrtc::VideoSendStream* CreateVideoSendStream( |
| 60 | const webrtc::VideoSendStream::Config& config, |
| 61 | const VideoEncoderConfig& encoder_config) override; |
kjellander@webrtc.org | 860ac53 | 2015-03-04 12:58:35 | [diff] [blame] | 62 | void DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) override; |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 63 | |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 64 | webrtc::VideoReceiveStream* CreateVideoReceiveStream( |
| 65 | const webrtc::VideoReceiveStream::Config& config) override; |
kjellander@webrtc.org | 860ac53 | 2015-03-04 12:58:35 | [diff] [blame] | 66 | void DestroyVideoReceiveStream( |
| 67 | webrtc::VideoReceiveStream* receive_stream) override; |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 68 | |
kjellander@webrtc.org | 860ac53 | 2015-03-04 12:58:35 | [diff] [blame] | 69 | Stats GetStats() const override; |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 70 | |
stefan | 30bf778 | 2015-09-08 12:36:15 | [diff] [blame] | 71 | DeliveryStatus DeliverPacket(MediaType media_type, |
| 72 | const uint8_t* packet, |
| 73 | size_t length, |
| 74 | const PacketTime& packet_time) override; |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 75 | |
kjellander@webrtc.org | 860ac53 | 2015-03-04 12:58:35 | [diff] [blame] | 76 | void SetBitrateConfig( |
| 77 | const webrtc::Call::Config::BitrateConfig& bitrate_config) override; |
| 78 | void SignalNetworkState(NetworkState state) override; |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 79 | |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 80 | private: |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 81 | DeliveryStatus DeliverRtcp(MediaType media_type, const uint8_t* packet, |
| 82 | size_t length); |
stefan | 30bf778 | 2015-09-08 12:36:15 | [diff] [blame] | 83 | DeliveryStatus DeliverRtp(MediaType media_type, |
| 84 | const uint8_t* packet, |
| 85 | size_t length, |
| 86 | const PacketTime& packet_time); |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 87 | |
Peter Boström | 8e07f3a | 2015-05-08 11:54:38 | [diff] [blame] | 88 | void SetBitrateControllerConfig( |
| 89 | const webrtc::Call::Config::BitrateConfig& bitrate_config); |
| 90 | |
pbos | 495b350 | 2015-07-15 15:02:58 | [diff] [blame] | 91 | void ConfigureSync(const std::string& sync_group) |
| 92 | EXCLUSIVE_LOCKS_REQUIRED(receive_crit_); |
| 93 | |
Peter Boström | 8e07f3a | 2015-05-08 11:54:38 | [diff] [blame] | 94 | const int num_cpu_cores_; |
| 95 | const rtc::scoped_ptr<ProcessThread> module_process_thread_; |
| 96 | const rtc::scoped_ptr<ChannelGroup> channel_group_; |
Peter Boström | 8e07f3a | 2015-05-08 11:54:38 | [diff] [blame] | 97 | volatile int next_channel_id_; |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 98 | Call::Config config_; |
| 99 | |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 100 | // Needs to be held while write-locking |receive_crit_| or |send_crit_|. This |
| 101 | // ensures that we have a consistent network state signalled to all senders |
| 102 | // and receivers. |
Peter Boström | 7d6ce5f | 2015-05-01 11:00:41 | [diff] [blame] | 103 | rtc::CriticalSection network_enabled_crit_; |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 104 | bool network_enabled_ GUARDED_BY(network_enabled_crit_); |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 105 | |
kwiberg@webrtc.org | deb9dae | 2015-02-26 14:34:55 | [diff] [blame] | 106 | rtc::scoped_ptr<RWLockWrapper> receive_crit_; |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 107 | std::map<uint32_t, AudioReceiveStream*> audio_receive_ssrcs_ |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 108 | GUARDED_BY(receive_crit_); |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 109 | std::map<uint32_t, VideoReceiveStream*> video_receive_ssrcs_ |
| 110 | GUARDED_BY(receive_crit_); |
| 111 | std::set<VideoReceiveStream*> video_receive_streams_ |
| 112 | GUARDED_BY(receive_crit_); |
pbos | 495b350 | 2015-07-15 15:02:58 | [diff] [blame] | 113 | std::map<std::string, AudioReceiveStream*> sync_stream_mapping_ |
| 114 | GUARDED_BY(receive_crit_); |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 115 | |
kwiberg@webrtc.org | deb9dae | 2015-02-26 14:34:55 | [diff] [blame] | 116 | rtc::scoped_ptr<RWLockWrapper> send_crit_; |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 117 | std::map<uint32_t, VideoSendStream*> video_send_ssrcs_ GUARDED_BY(send_crit_); |
| 118 | std::set<VideoSendStream*> video_send_streams_ GUARDED_BY(send_crit_); |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 119 | |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 120 | VideoSendStream::RtpStateMap suspended_video_send_ssrcs_; |
pbos@webrtc.org | 2fd91bd | 2014-07-07 13:06:48 | [diff] [blame] | 121 | |
ivoc | 35fd753 | 2015-09-09 07:09:43 | [diff] [blame] | 122 | RtcEventLog* event_log_; |
| 123 | |
henrikg | 9199c0e | 2015-09-16 12:37:44 | [diff] [blame] | 124 | RTC_DISALLOW_COPY_AND_ASSIGN(Call); |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 125 | }; |
pbos@webrtc.org | d05597a | 2013-12-05 12:11:47 | [diff] [blame] | 126 | } // namespace internal |
pbos@webrtc.org | c2014fd | 2013-08-14 13:52:52 | [diff] [blame] | 127 | |
stefan@webrtc.org | 47f0c41 | 2013-12-04 10:24:26 | [diff] [blame] | 128 | Call* Call::Create(const Call::Config& config) { |
Peter Boström | 8e07f3a | 2015-05-08 11:54:38 | [diff] [blame] | 129 | return new internal::Call(config); |
pbos@webrtc.org | c2014fd | 2013-08-14 13:52:52 | [diff] [blame] | 130 | } |
pbos@webrtc.org | c2014fd | 2013-08-14 13:52:52 | [diff] [blame] | 131 | |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 132 | namespace internal { |
| 133 | |
Peter Boström | 8e07f3a | 2015-05-08 11:54:38 | [diff] [blame] | 134 | Call::Call(const Call::Config& config) |
| 135 | : num_cpu_cores_(CpuInfo::DetectNumberOfCores()), |
stefan | 63ac87f | 2015-09-11 16:52:15 | [diff] [blame] | 136 | module_process_thread_(ProcessThread::Create("ModuleProcessThread")), |
Peter Boström | a28bdde | 2015-05-28 12:10:39 | [diff] [blame] | 137 | channel_group_(new ChannelGroup(module_process_thread_.get())), |
pbos | cce6141 | 2015-07-23 13:58:33 | [diff] [blame] | 138 | next_channel_id_(0), |
Peter Boström | 8e07f3a | 2015-05-08 11:54:38 | [diff] [blame] | 139 | config_(config), |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 140 | network_enabled_(true), |
| 141 | receive_crit_(RWLockWrapper::CreateRWLock()), |
ivoc | 35fd753 | 2015-09-09 07:09:43 | [diff] [blame] | 142 | send_crit_(RWLockWrapper::CreateRWLock()), |
| 143 | event_log_(nullptr) { |
henrikg | 5c075c8 | 2015-09-17 07:24:34 | [diff] [blame] | 144 | RTC_DCHECK_GE(config.bitrate_config.min_bitrate_bps, 0); |
| 145 | RTC_DCHECK_GE(config.bitrate_config.start_bitrate_bps, |
| 146 | config.bitrate_config.min_bitrate_bps); |
Stefan Holmer | ca55fa1 | 2015-03-26 10:11:06 | [diff] [blame] | 147 | if (config.bitrate_config.max_bitrate_bps != -1) { |
henrikg | 5c075c8 | 2015-09-17 07:24:34 | [diff] [blame] | 148 | RTC_DCHECK_GE(config.bitrate_config.max_bitrate_bps, |
| 149 | config.bitrate_config.start_bitrate_bps); |
pbos@webrtc.org | 5e3f6b4 | 2014-11-25 14:03:34 | [diff] [blame] | 150 | } |
ivoc | 35fd753 | 2015-09-09 07:09:43 | [diff] [blame] | 151 | if (config.voice_engine) { |
| 152 | VoECodec* voe_codec = VoECodec::GetInterface(config.voice_engine); |
| 153 | if (voe_codec) { |
| 154 | event_log_ = voe_codec->GetEventLog(); |
| 155 | voe_codec->Release(); |
| 156 | } |
| 157 | } |
pbos@webrtc.org | 5e3f6b4 | 2014-11-25 14:03:34 | [diff] [blame] | 158 | |
Peter Boström | 8e07f3a | 2015-05-08 11:54:38 | [diff] [blame] | 159 | Trace::CreateTrace(); |
| 160 | module_process_thread_->Start(); |
| 161 | |
Peter Boström | 8e07f3a | 2015-05-08 11:54:38 | [diff] [blame] | 162 | SetBitrateControllerConfig(config_.bitrate_config); |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 163 | } |
| 164 | |
pbos@webrtc.org | bf6d572 | 2013-09-09 15:04:25 | [diff] [blame] | 165 | Call::~Call() { |
henrikg | 5c075c8 | 2015-09-17 07:24:34 | [diff] [blame] | 166 | RTC_CHECK_EQ(0u, video_send_ssrcs_.size()); |
| 167 | RTC_CHECK_EQ(0u, video_send_streams_.size()); |
| 168 | RTC_CHECK_EQ(0u, audio_receive_ssrcs_.size()); |
| 169 | RTC_CHECK_EQ(0u, video_receive_ssrcs_.size()); |
| 170 | RTC_CHECK_EQ(0u, video_receive_streams_.size()); |
pbos@webrtc.org | f71c974 | 2015-02-12 10:48:23 | [diff] [blame] | 171 | |
Peter Boström | 8e07f3a | 2015-05-08 11:54:38 | [diff] [blame] | 172 | module_process_thread_->Stop(); |
| 173 | Trace::ReturnTrace(); |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 174 | } |
| 175 | |
pbos@webrtc.org | bf6d572 | 2013-09-09 15:04:25 | [diff] [blame] | 176 | PacketReceiver* Call::Receiver() { return this; } |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 177 | |
Fredrik Solenberg | ee9b72e | 2015-06-08 11:04:56 | [diff] [blame] | 178 | webrtc::AudioSendStream* Call::CreateAudioSendStream( |
| 179 | const webrtc::AudioSendStream::Config& config) { |
| 180 | return nullptr; |
| 181 | } |
| 182 | |
| 183 | void Call::DestroyAudioSendStream(webrtc::AudioSendStream* send_stream) { |
| 184 | } |
| 185 | |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 186 | webrtc::AudioReceiveStream* Call::CreateAudioReceiveStream( |
| 187 | const webrtc::AudioReceiveStream::Config& config) { |
| 188 | TRACE_EVENT0("webrtc", "Call::CreateAudioReceiveStream"); |
| 189 | LOG(LS_INFO) << "CreateAudioReceiveStream: " << config.ToString(); |
| 190 | AudioReceiveStream* receive_stream = new AudioReceiveStream( |
| 191 | channel_group_->GetRemoteBitrateEstimator(), config); |
| 192 | { |
| 193 | WriteLockScoped write_lock(*receive_crit_); |
henrikg | 5c075c8 | 2015-09-17 07:24:34 | [diff] [blame] | 194 | RTC_DCHECK(audio_receive_ssrcs_.find(config.rtp.remote_ssrc) == |
| 195 | audio_receive_ssrcs_.end()); |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 196 | audio_receive_ssrcs_[config.rtp.remote_ssrc] = receive_stream; |
pbos | 495b350 | 2015-07-15 15:02:58 | [diff] [blame] | 197 | ConfigureSync(config.sync_group); |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 198 | } |
| 199 | return receive_stream; |
| 200 | } |
| 201 | |
| 202 | void Call::DestroyAudioReceiveStream( |
| 203 | webrtc::AudioReceiveStream* receive_stream) { |
| 204 | TRACE_EVENT0("webrtc", "Call::DestroyAudioReceiveStream"); |
henrikg | 5c075c8 | 2015-09-17 07:24:34 | [diff] [blame] | 205 | RTC_DCHECK(receive_stream != nullptr); |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 206 | AudioReceiveStream* audio_receive_stream = |
| 207 | static_cast<AudioReceiveStream*>(receive_stream); |
| 208 | { |
| 209 | WriteLockScoped write_lock(*receive_crit_); |
| 210 | size_t num_deleted = audio_receive_ssrcs_.erase( |
| 211 | audio_receive_stream->config().rtp.remote_ssrc); |
henrikg | 5c075c8 | 2015-09-17 07:24:34 | [diff] [blame] | 212 | RTC_DCHECK(num_deleted == 1); |
pbos | 495b350 | 2015-07-15 15:02:58 | [diff] [blame] | 213 | const std::string& sync_group = audio_receive_stream->config().sync_group; |
| 214 | const auto it = sync_stream_mapping_.find(sync_group); |
| 215 | if (it != sync_stream_mapping_.end() && |
| 216 | it->second == audio_receive_stream) { |
| 217 | sync_stream_mapping_.erase(it); |
| 218 | ConfigureSync(sync_group); |
| 219 | } |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 220 | } |
| 221 | delete audio_receive_stream; |
| 222 | } |
| 223 | |
| 224 | webrtc::VideoSendStream* Call::CreateVideoSendStream( |
| 225 | const webrtc::VideoSendStream::Config& config, |
pbos@webrtc.org | 58b5140 | 2014-09-19 12:30:25 | [diff] [blame] | 226 | const VideoEncoderConfig& encoder_config) { |
pbos@webrtc.org | e286393 | 2015-01-29 12:33:07 | [diff] [blame] | 227 | TRACE_EVENT0("webrtc", "Call::CreateVideoSendStream"); |
pbos@webrtc.org | f076e17 | 2015-01-15 10:09:39 | [diff] [blame] | 228 | LOG(LS_INFO) << "CreateVideoSendStream: " << config.ToString(); |
henrikg | 5c075c8 | 2015-09-17 07:24:34 | [diff] [blame] | 229 | RTC_DCHECK(!config.rtp.ssrcs.empty()); |
pbos@webrtc.org | 63988b2 | 2013-06-10 13:48:26 | [diff] [blame] | 230 | |
mflodman@webrtc.org | f89ce46 | 2014-06-16 08:57:39 | [diff] [blame] | 231 | // TODO(mflodman): Base the start bitrate on a current bandwidth estimate, if |
| 232 | // the call has already started. |
solenberg | be5952f | 2015-09-08 12:13:22 | [diff] [blame] | 233 | VideoSendStream* send_stream = new VideoSendStream(num_cpu_cores_, |
Peter Boström | 8e07f3a | 2015-05-08 11:54:38 | [diff] [blame] | 234 | module_process_thread_.get(), channel_group_.get(), |
| 235 | rtc::AtomicOps::Increment(&next_channel_id_), config, encoder_config, |
| 236 | suspended_video_send_ssrcs_); |
pbos@webrtc.org | 63988b2 | 2013-06-10 13:48:26 | [diff] [blame] | 237 | |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 238 | // This needs to be taken before send_crit_ as both locks need to be held |
| 239 | // while changing network state. |
Peter Boström | 7d6ce5f | 2015-05-01 11:00:41 | [diff] [blame] | 240 | rtc::CritScope lock(&network_enabled_crit_); |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 241 | WriteLockScoped write_lock(*send_crit_); |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 242 | for (uint32_t ssrc : config.rtp.ssrcs) { |
henrikg | 5c075c8 | 2015-09-17 07:24:34 | [diff] [blame] | 243 | RTC_DCHECK(video_send_ssrcs_.find(ssrc) == video_send_ssrcs_.end()); |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 244 | video_send_ssrcs_[ssrc] = send_stream; |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 245 | } |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 246 | video_send_streams_.insert(send_stream); |
| 247 | |
ivoc | 35fd753 | 2015-09-09 07:09:43 | [diff] [blame] | 248 | if (event_log_) |
| 249 | event_log_->LogVideoSendStreamConfig(config); |
| 250 | |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 251 | if (!network_enabled_) |
| 252 | send_stream->SignalNetworkState(kNetworkDown); |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 253 | return send_stream; |
| 254 | } |
| 255 | |
pbos@webrtc.org | 12a93e0 | 2013-11-21 13:49:43 | [diff] [blame] | 256 | void Call::DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) { |
pbos@webrtc.org | e286393 | 2015-01-29 12:33:07 | [diff] [blame] | 257 | TRACE_EVENT0("webrtc", "Call::DestroyVideoSendStream"); |
henrikg | 5c075c8 | 2015-09-17 07:24:34 | [diff] [blame] | 258 | RTC_DCHECK(send_stream != nullptr); |
pbos@webrtc.org | 0020858 | 2013-09-05 12:38:54 | [diff] [blame] | 259 | |
pbos@webrtc.org | 2fd91bd | 2014-07-07 13:06:48 | [diff] [blame] | 260 | send_stream->Stop(); |
| 261 | |
pbos@webrtc.org | 6eaf09a | 2015-03-23 13:12:24 | [diff] [blame] | 262 | VideoSendStream* send_stream_impl = nullptr; |
pbos@webrtc.org | 0020858 | 2013-09-05 12:38:54 | [diff] [blame] | 263 | { |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 264 | WriteLockScoped write_lock(*send_crit_); |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 265 | auto it = video_send_ssrcs_.begin(); |
| 266 | while (it != video_send_ssrcs_.end()) { |
pbos@webrtc.org | 0020858 | 2013-09-05 12:38:54 | [diff] [blame] | 267 | if (it->second == static_cast<VideoSendStream*>(send_stream)) { |
| 268 | send_stream_impl = it->second; |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 269 | video_send_ssrcs_.erase(it++); |
pbos@webrtc.org | 2fd91bd | 2014-07-07 13:06:48 | [diff] [blame] | 270 | } else { |
| 271 | ++it; |
pbos@webrtc.org | 0020858 | 2013-09-05 12:38:54 | [diff] [blame] | 272 | } |
| 273 | } |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 274 | video_send_streams_.erase(send_stream_impl); |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 275 | } |
henrikg | 5c075c8 | 2015-09-17 07:24:34 | [diff] [blame] | 276 | RTC_CHECK(send_stream_impl != nullptr); |
pbos@webrtc.org | 0020858 | 2013-09-05 12:38:54 | [diff] [blame] | 277 | |
pbos@webrtc.org | 2fd91bd | 2014-07-07 13:06:48 | [diff] [blame] | 278 | VideoSendStream::RtpStateMap rtp_state = send_stream_impl->GetRtpStates(); |
| 279 | |
| 280 | for (VideoSendStream::RtpStateMap::iterator it = rtp_state.begin(); |
| 281 | it != rtp_state.end(); |
| 282 | ++it) { |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 283 | suspended_video_send_ssrcs_[it->first] = it->second; |
pbos@webrtc.org | 2fd91bd | 2014-07-07 13:06:48 | [diff] [blame] | 284 | } |
| 285 | |
pbos@webrtc.org | 0020858 | 2013-09-05 12:38:54 | [diff] [blame] | 286 | delete send_stream_impl; |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 287 | } |
| 288 | |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 289 | webrtc::VideoReceiveStream* Call::CreateVideoReceiveStream( |
| 290 | const webrtc::VideoReceiveStream::Config& config) { |
pbos@webrtc.org | e286393 | 2015-01-29 12:33:07 | [diff] [blame] | 291 | TRACE_EVENT0("webrtc", "Call::CreateVideoReceiveStream"); |
pbos@webrtc.org | f076e17 | 2015-01-15 10:09:39 | [diff] [blame] | 292 | LOG(LS_INFO) << "CreateVideoReceiveStream: " << config.ToString(); |
Peter Boström | e7c0a78 | 2015-04-24 13:16:03 | [diff] [blame] | 293 | VideoReceiveStream* receive_stream = new VideoReceiveStream( |
pbos | cce6141 | 2015-07-23 13:58:33 | [diff] [blame] | 294 | num_cpu_cores_, channel_group_.get(), |
Peter Boström | 8e07f3a | 2015-05-08 11:54:38 | [diff] [blame] | 295 | rtc::AtomicOps::Increment(&next_channel_id_), config, |
solenberg | dce9bf3 | 2015-08-28 11:07:10 | [diff] [blame] | 296 | config_.voice_engine); |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 297 | |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 298 | // This needs to be taken before receive_crit_ as both locks need to be held |
| 299 | // while changing network state. |
Peter Boström | 7d6ce5f | 2015-05-01 11:00:41 | [diff] [blame] | 300 | rtc::CritScope lock(&network_enabled_crit_); |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 301 | WriteLockScoped write_lock(*receive_crit_); |
henrikg | 5c075c8 | 2015-09-17 07:24:34 | [diff] [blame] | 302 | RTC_DCHECK(video_receive_ssrcs_.find(config.rtp.remote_ssrc) == |
| 303 | video_receive_ssrcs_.end()); |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 304 | video_receive_ssrcs_[config.rtp.remote_ssrc] = receive_stream; |
pbos@webrtc.org | c71929d | 2014-01-24 09:30:53 | [diff] [blame] | 305 | // TODO(pbos): Configure different RTX payloads per receive payload. |
| 306 | VideoReceiveStream::Config::Rtp::RtxMap::const_iterator it = |
| 307 | config.rtp.rtx.begin(); |
| 308 | if (it != config.rtp.rtx.end()) |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 309 | video_receive_ssrcs_[it->second.ssrc] = receive_stream; |
| 310 | video_receive_streams_.insert(receive_stream); |
pbos@webrtc.org | c71929d | 2014-01-24 09:30:53 | [diff] [blame] | 311 | |
pbos | 495b350 | 2015-07-15 15:02:58 | [diff] [blame] | 312 | ConfigureSync(config.sync_group); |
| 313 | |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 314 | if (!network_enabled_) |
| 315 | receive_stream->SignalNetworkState(kNetworkDown); |
pbos | 495b350 | 2015-07-15 15:02:58 | [diff] [blame] | 316 | |
ivoc | 35fd753 | 2015-09-09 07:09:43 | [diff] [blame] | 317 | if (event_log_) |
| 318 | event_log_->LogVideoReceiveStreamConfig(config); |
| 319 | |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 320 | return receive_stream; |
| 321 | } |
| 322 | |
pbos@webrtc.org | 12a93e0 | 2013-11-21 13:49:43 | [diff] [blame] | 323 | void Call::DestroyVideoReceiveStream( |
| 324 | webrtc::VideoReceiveStream* receive_stream) { |
pbos@webrtc.org | e286393 | 2015-01-29 12:33:07 | [diff] [blame] | 325 | TRACE_EVENT0("webrtc", "Call::DestroyVideoReceiveStream"); |
henrikg | 5c075c8 | 2015-09-17 07:24:34 | [diff] [blame] | 326 | RTC_DCHECK(receive_stream != nullptr); |
pbos@webrtc.org | 6eaf09a | 2015-03-23 13:12:24 | [diff] [blame] | 327 | VideoReceiveStream* receive_stream_impl = nullptr; |
pbos@webrtc.org | 0020858 | 2013-09-05 12:38:54 | [diff] [blame] | 328 | { |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 329 | WriteLockScoped write_lock(*receive_crit_); |
pbos@webrtc.org | c71929d | 2014-01-24 09:30:53 | [diff] [blame] | 330 | // Remove all ssrcs pointing to a receive stream. As RTX retransmits on a |
| 331 | // separate SSRC there can be either one or two. |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 332 | auto it = video_receive_ssrcs_.begin(); |
| 333 | while (it != video_receive_ssrcs_.end()) { |
pbos@webrtc.org | 0020858 | 2013-09-05 12:38:54 | [diff] [blame] | 334 | if (it->second == static_cast<VideoReceiveStream*>(receive_stream)) { |
pbos@webrtc.org | 6eaf09a | 2015-03-23 13:12:24 | [diff] [blame] | 335 | if (receive_stream_impl != nullptr) |
henrikg | 5c075c8 | 2015-09-17 07:24:34 | [diff] [blame] | 336 | RTC_DCHECK(receive_stream_impl == it->second); |
pbos@webrtc.org | 0020858 | 2013-09-05 12:38:54 | [diff] [blame] | 337 | receive_stream_impl = it->second; |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 338 | video_receive_ssrcs_.erase(it++); |
pbos@webrtc.org | c71929d | 2014-01-24 09:30:53 | [diff] [blame] | 339 | } else { |
| 340 | ++it; |
pbos@webrtc.org | 0020858 | 2013-09-05 12:38:54 | [diff] [blame] | 341 | } |
| 342 | } |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 343 | video_receive_streams_.erase(receive_stream_impl); |
henrikg | 5c075c8 | 2015-09-17 07:24:34 | [diff] [blame] | 344 | RTC_CHECK(receive_stream_impl != nullptr); |
pbos | 495b350 | 2015-07-15 15:02:58 | [diff] [blame] | 345 | ConfigureSync(receive_stream_impl->config().sync_group); |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 346 | } |
pbos@webrtc.org | 0020858 | 2013-09-05 12:38:54 | [diff] [blame] | 347 | delete receive_stream_impl; |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 348 | } |
| 349 | |
stefan@webrtc.org | 5232267 | 2014-11-05 14:05:29 | [diff] [blame] | 350 | Call::Stats Call::GetStats() const { |
| 351 | Stats stats; |
Peter Boström | 8e07f3a | 2015-05-08 11:54:38 | [diff] [blame] | 352 | // Fetch available send/receive bitrates. |
stefan@webrtc.org | 5232267 | 2014-11-05 14:05:29 | [diff] [blame] | 353 | uint32_t send_bandwidth = 0; |
Peter Boström | 8e07f3a | 2015-05-08 11:54:38 | [diff] [blame] | 354 | channel_group_->GetBitrateController()->AvailableBandwidth(&send_bandwidth); |
| 355 | std::vector<unsigned int> ssrcs; |
stefan@webrtc.org | 5232267 | 2014-11-05 14:05:29 | [diff] [blame] | 356 | uint32_t recv_bandwidth = 0; |
Peter Boström | 8e07f3a | 2015-05-08 11:54:38 | [diff] [blame] | 357 | channel_group_->GetRemoteBitrateEstimator()->LatestEstimate(&ssrcs, |
| 358 | &recv_bandwidth); |
| 359 | stats.send_bandwidth_bps = send_bandwidth; |
stefan@webrtc.org | 5232267 | 2014-11-05 14:05:29 | [diff] [blame] | 360 | stats.recv_bandwidth_bps = recv_bandwidth; |
Peter Boström | ad9dcaf | 2015-04-27 15:24:33 | [diff] [blame] | 361 | stats.pacer_delay_ms = channel_group_->GetPacerQueuingDelayMs(); |
stefan@webrtc.org | 5232267 | 2014-11-05 14:05:29 | [diff] [blame] | 362 | { |
| 363 | ReadLockScoped read_lock(*send_crit_); |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 364 | for (const auto& kv : video_send_ssrcs_) { |
| 365 | int rtt_ms = kv.second->GetRtt(); |
pbos@webrtc.org | 834b475 | 2014-12-11 13:26:09 | [diff] [blame] | 366 | if (rtt_ms > 0) |
| 367 | stats.rtt_ms = rtt_ms; |
stefan@webrtc.org | 5232267 | 2014-11-05 14:05:29 | [diff] [blame] | 368 | } |
| 369 | } |
| 370 | return stats; |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 371 | } |
| 372 | |
pbos@webrtc.org | 5e3f6b4 | 2014-11-25 14:03:34 | [diff] [blame] | 373 | void Call::SetBitrateConfig( |
| 374 | const webrtc::Call::Config::BitrateConfig& bitrate_config) { |
pbos@webrtc.org | e286393 | 2015-01-29 12:33:07 | [diff] [blame] | 375 | TRACE_EVENT0("webrtc", "Call::SetBitrateConfig"); |
henrikg | 5c075c8 | 2015-09-17 07:24:34 | [diff] [blame] | 376 | RTC_DCHECK_GE(bitrate_config.min_bitrate_bps, 0); |
pbos@webrtc.org | 6eaf09a | 2015-03-23 13:12:24 | [diff] [blame] | 377 | if (bitrate_config.max_bitrate_bps != -1) |
henrikg | 5c075c8 | 2015-09-17 07:24:34 | [diff] [blame] | 378 | RTC_DCHECK_GT(bitrate_config.max_bitrate_bps, 0); |
Stefan Holmer | ca55fa1 | 2015-03-26 10:11:06 | [diff] [blame] | 379 | if (config_.bitrate_config.min_bitrate_bps == |
pbos@webrtc.org | 5e3f6b4 | 2014-11-25 14:03:34 | [diff] [blame] | 380 | bitrate_config.min_bitrate_bps && |
| 381 | (bitrate_config.start_bitrate_bps <= 0 || |
Stefan Holmer | ca55fa1 | 2015-03-26 10:11:06 | [diff] [blame] | 382 | config_.bitrate_config.start_bitrate_bps == |
pbos@webrtc.org | 5e3f6b4 | 2014-11-25 14:03:34 | [diff] [blame] | 383 | bitrate_config.start_bitrate_bps) && |
Stefan Holmer | ca55fa1 | 2015-03-26 10:11:06 | [diff] [blame] | 384 | config_.bitrate_config.max_bitrate_bps == |
pbos@webrtc.org | 5e3f6b4 | 2014-11-25 14:03:34 | [diff] [blame] | 385 | bitrate_config.max_bitrate_bps) { |
| 386 | // Nothing new to set, early abort to avoid encoder reconfigurations. |
| 387 | return; |
| 388 | } |
Stefan Holmer | ca55fa1 | 2015-03-26 10:11:06 | [diff] [blame] | 389 | config_.bitrate_config = bitrate_config; |
Peter Boström | 8e07f3a | 2015-05-08 11:54:38 | [diff] [blame] | 390 | SetBitrateControllerConfig(bitrate_config); |
| 391 | } |
| 392 | |
| 393 | void Call::SetBitrateControllerConfig( |
| 394 | const webrtc::Call::Config::BitrateConfig& bitrate_config) { |
| 395 | BitrateController* bitrate_controller = |
| 396 | channel_group_->GetBitrateController(); |
| 397 | if (bitrate_config.start_bitrate_bps > 0) |
| 398 | bitrate_controller->SetStartBitrate(bitrate_config.start_bitrate_bps); |
| 399 | bitrate_controller->SetMinMaxBitrate(bitrate_config.min_bitrate_bps, |
| 400 | bitrate_config.max_bitrate_bps); |
pbos@webrtc.org | 5e3f6b4 | 2014-11-25 14:03:34 | [diff] [blame] | 401 | } |
| 402 | |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 403 | void Call::SignalNetworkState(NetworkState state) { |
| 404 | // Take crit for entire function, it needs to be held while updating streams |
| 405 | // to guarantee a consistent state across streams. |
Peter Boström | 7d6ce5f | 2015-05-01 11:00:41 | [diff] [blame] | 406 | rtc::CritScope lock(&network_enabled_crit_); |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 407 | network_enabled_ = state == kNetworkUp; |
| 408 | { |
| 409 | ReadLockScoped write_lock(*send_crit_); |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 410 | for (auto& kv : video_send_ssrcs_) { |
| 411 | kv.second->SignalNetworkState(state); |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 412 | } |
| 413 | } |
| 414 | { |
| 415 | ReadLockScoped write_lock(*receive_crit_); |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 416 | for (auto& kv : video_receive_ssrcs_) { |
| 417 | kv.second->SignalNetworkState(state); |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 418 | } |
| 419 | } |
| 420 | } |
| 421 | |
pbos | 495b350 | 2015-07-15 15:02:58 | [diff] [blame] | 422 | void Call::ConfigureSync(const std::string& sync_group) { |
| 423 | // Set sync only if there was no previous one. |
| 424 | if (config_.voice_engine == nullptr || sync_group.empty()) |
| 425 | return; |
| 426 | |
| 427 | AudioReceiveStream* sync_audio_stream = nullptr; |
| 428 | // Find existing audio stream. |
| 429 | const auto it = sync_stream_mapping_.find(sync_group); |
| 430 | if (it != sync_stream_mapping_.end()) { |
| 431 | sync_audio_stream = it->second; |
| 432 | } else { |
| 433 | // No configured audio stream, see if we can find one. |
| 434 | for (const auto& kv : audio_receive_ssrcs_) { |
| 435 | if (kv.second->config().sync_group == sync_group) { |
| 436 | if (sync_audio_stream != nullptr) { |
| 437 | LOG(LS_WARNING) << "Attempting to sync more than one audio stream " |
| 438 | "within the same sync group. This is not " |
| 439 | "supported in the current implementation."; |
| 440 | break; |
| 441 | } |
| 442 | sync_audio_stream = kv.second; |
| 443 | } |
| 444 | } |
| 445 | } |
| 446 | if (sync_audio_stream) |
| 447 | sync_stream_mapping_[sync_group] = sync_audio_stream; |
| 448 | size_t num_synced_streams = 0; |
| 449 | for (VideoReceiveStream* video_stream : video_receive_streams_) { |
| 450 | if (video_stream->config().sync_group != sync_group) |
| 451 | continue; |
| 452 | ++num_synced_streams; |
| 453 | if (num_synced_streams > 1) { |
| 454 | // TODO(pbos): Support synchronizing more than one A/V pair. |
| 455 | // https://code.google.com/p/webrtc/issues/detail?id=4762 |
| 456 | LOG(LS_WARNING) << "Attempting to sync more than one audio/video pair " |
| 457 | "within the same sync group. This is not supported in " |
| 458 | "the current implementation."; |
| 459 | } |
| 460 | // Only sync the first A/V pair within this sync group. |
| 461 | if (sync_audio_stream != nullptr && num_synced_streams == 1) { |
| 462 | video_stream->SetSyncChannel(config_.voice_engine, |
| 463 | sync_audio_stream->config().voe_channel_id); |
| 464 | } else { |
| 465 | video_stream->SetSyncChannel(config_.voice_engine, -1); |
| 466 | } |
| 467 | } |
| 468 | } |
| 469 | |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 470 | PacketReceiver::DeliveryStatus Call::DeliverRtcp(MediaType media_type, |
| 471 | const uint8_t* packet, |
| 472 | size_t length) { |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 473 | // TODO(pbos): Figure out what channel needs it actually. |
| 474 | // Do NOT broadcast! Also make sure it's a valid packet. |
pbos@webrtc.org | bc57e0f | 2014-05-14 13:57:12 | [diff] [blame] | 475 | // Return DELIVERY_UNKNOWN_SSRC if it can be determined that |
| 476 | // there's no receiver of the packet. |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 477 | bool rtcp_delivered = false; |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 478 | if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) { |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 479 | ReadLockScoped read_lock(*receive_crit_); |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 480 | for (VideoReceiveStream* stream : video_receive_streams_) { |
ivoc | 35fd753 | 2015-09-09 07:09:43 | [diff] [blame] | 481 | if (stream->DeliverRtcp(packet, length)) { |
pbos@webrtc.org | 78ab511 | 2013-08-05 12:49:22 | [diff] [blame] | 482 | rtcp_delivered = true; |
ivoc | 35fd753 | 2015-09-09 07:09:43 | [diff] [blame] | 483 | if (event_log_) |
| 484 | event_log_->LogRtcpPacket(true, media_type, packet, length); |
| 485 | } |
pbos@webrtc.org | ce85109 | 2013-08-05 12:01:36 | [diff] [blame] | 486 | } |
| 487 | } |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 488 | if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) { |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 489 | ReadLockScoped read_lock(*send_crit_); |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 490 | for (VideoSendStream* stream : video_send_streams_) { |
ivoc | 35fd753 | 2015-09-09 07:09:43 | [diff] [blame] | 491 | if (stream->DeliverRtcp(packet, length)) { |
pbos@webrtc.org | 78ab511 | 2013-08-05 12:49:22 | [diff] [blame] | 492 | rtcp_delivered = true; |
ivoc | 35fd753 | 2015-09-09 07:09:43 | [diff] [blame] | 493 | if (event_log_) |
| 494 | event_log_->LogRtcpPacket(false, media_type, packet, length); |
| 495 | } |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 496 | } |
| 497 | } |
pbos@webrtc.org | bc57e0f | 2014-05-14 13:57:12 | [diff] [blame] | 498 | return rtcp_delivered ? DELIVERY_OK : DELIVERY_PACKET_ERROR; |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 499 | } |
| 500 | |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 501 | PacketReceiver::DeliveryStatus Call::DeliverRtp(MediaType media_type, |
| 502 | const uint8_t* packet, |
stefan | 30bf778 | 2015-09-08 12:36:15 | [diff] [blame] | 503 | size_t length, |
| 504 | const PacketTime& packet_time) { |
pbos@webrtc.org | f8be3d2 | 2014-07-08 07:38:12 | [diff] [blame] | 505 | // Minimum RTP header size. |
| 506 | if (length < 12) |
| 507 | return DELIVERY_PACKET_ERROR; |
| 508 | |
sprang@webrtc.org | cce642c | 2015-01-28 12:37:36 | [diff] [blame] | 509 | uint32_t ssrc = ByteReader<uint32_t>::ReadBigEndian(&packet[8]); |
pbos@webrtc.org | f8be3d2 | 2014-07-08 07:38:12 | [diff] [blame] | 510 | |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 511 | ReadLockScoped read_lock(*receive_crit_); |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 512 | if (media_type == MediaType::ANY || media_type == MediaType::AUDIO) { |
| 513 | auto it = audio_receive_ssrcs_.find(ssrc); |
| 514 | if (it != audio_receive_ssrcs_.end()) { |
ivoc | 35fd753 | 2015-09-09 07:09:43 | [diff] [blame] | 515 | auto status = it->second->DeliverRtp(packet, length, packet_time) |
| 516 | ? DELIVERY_OK |
| 517 | : DELIVERY_PACKET_ERROR; |
| 518 | if (status == DELIVERY_OK && event_log_) |
| 519 | event_log_->LogRtpHeader(true, media_type, packet, length); |
| 520 | return status; |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 521 | } |
| 522 | } |
| 523 | if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) { |
| 524 | auto it = video_receive_ssrcs_.find(ssrc); |
| 525 | if (it != video_receive_ssrcs_.end()) { |
ivoc | 35fd753 | 2015-09-09 07:09:43 | [diff] [blame] | 526 | auto status = it->second->DeliverRtp(packet, length, packet_time) |
| 527 | ? DELIVERY_OK |
| 528 | : DELIVERY_PACKET_ERROR; |
| 529 | if (status == DELIVERY_OK && event_log_) |
| 530 | event_log_->LogRtpHeader(true, media_type, packet, length); |
| 531 | return status; |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 532 | } |
| 533 | } |
| 534 | return DELIVERY_UNKNOWN_SSRC; |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 535 | } |
| 536 | |
stefan | 30bf778 | 2015-09-08 12:36:15 | [diff] [blame] | 537 | PacketReceiver::DeliveryStatus Call::DeliverPacket( |
| 538 | MediaType media_type, |
| 539 | const uint8_t* packet, |
| 540 | size_t length, |
| 541 | const PacketTime& packet_time) { |
pbos@webrtc.org | 6aae61c | 2014-07-08 12:10:51 | [diff] [blame] | 542 | if (RtpHeaderParser::IsRtcp(packet, length)) |
Fredrik Solenberg | ad86786 | 2015-04-29 13:24:01 | [diff] [blame] | 543 | return DeliverRtcp(media_type, packet, length); |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 544 | |
stefan | 30bf778 | 2015-09-08 12:36:15 | [diff] [blame] | 545 | return DeliverRtp(media_type, packet, length, packet_time); |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 546 | } |
| 547 | |
| 548 | } // namespace internal |
| 549 | } // namespace webrtc |