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 <assert.h> |
| 12 | #include <string.h> |
| 13 | |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 14 | #include <map> |
| 15 | #include <vector> |
| 16 | |
pbos@webrtc.org | d54aa96 | 2014-09-24 06:05:00 | [diff] [blame] | 17 | #include "webrtc/base/thread_annotations.h" |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 18 | #include "webrtc/call.h" |
stefan@webrtc.org | 47f0c41 | 2013-12-04 10:24:26 | [diff] [blame] | 19 | #include "webrtc/common.h" |
pbos@webrtc.org | d05597a | 2013-12-05 12:11:47 | [diff] [blame] | 20 | #include "webrtc/config.h" |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 21 | #include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h" |
pbos@webrtc.org | 1c65545 | 2014-09-17 09:02:25 | [diff] [blame] | 22 | #include "webrtc/modules/video_coding/codecs/vp8/include/vp8.h" |
marpan@webrtc.org | 6637388 | 2014-11-01 06:10:48 | [diff] [blame] | 23 | #include "webrtc/modules/video_coding/codecs/vp9/include/vp9.h" |
pbos@webrtc.org | b5d2d16 | 2013-10-02 13:36:09 | [diff] [blame] | 24 | #include "webrtc/system_wrappers/interface/critical_section_wrapper.h" |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 25 | #include "webrtc/system_wrappers/interface/rw_lock_wrapper.h" |
pbos@webrtc.org | b5d2d16 | 2013-10-02 13:36:09 | [diff] [blame] | 26 | #include "webrtc/system_wrappers/interface/scoped_ptr.h" |
| 27 | #include "webrtc/system_wrappers/interface/trace.h" |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 28 | #include "webrtc/video/video_receive_stream.h" |
| 29 | #include "webrtc/video/video_send_stream.h" |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 30 | #include "webrtc/video_engine/include/vie_base.h" |
| 31 | #include "webrtc/video_engine/include/vie_codec.h" |
| 32 | #include "webrtc/video_engine/include/vie_rtp_rtcp.h" |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 33 | #include "webrtc/video_engine/include/vie_network.h" |
| 34 | #include "webrtc/video_engine/include/vie_rtp_rtcp.h" |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 35 | |
| 36 | namespace webrtc { |
pbos@webrtc.org | d05597a | 2013-12-05 12:11:47 | [diff] [blame] | 37 | const char* RtpExtension::kTOffset = "urn:ietf:params:rtp-hdrext:toffset"; |
| 38 | const char* RtpExtension::kAbsSendTime = |
| 39 | "http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time"; |
pbos@webrtc.org | f0a119f | 2014-07-20 15:27:35 | [diff] [blame] | 40 | |
| 41 | bool RtpExtension::IsSupported(const std::string& name) { |
| 42 | return name == webrtc::RtpExtension::kTOffset || |
| 43 | name == webrtc::RtpExtension::kAbsSendTime; |
| 44 | } |
| 45 | |
pbos@webrtc.org | 1c65545 | 2014-09-17 09:02:25 | [diff] [blame] | 46 | VideoEncoder* VideoEncoder::Create(VideoEncoder::EncoderType codec_type) { |
| 47 | switch (codec_type) { |
| 48 | case kVp8: |
| 49 | return VP8Encoder::Create(); |
marpan@webrtc.org | 6637388 | 2014-11-01 06:10:48 | [diff] [blame] | 50 | case kVp9: |
| 51 | return VP9Encoder::Create(); |
pbos@webrtc.org | 1c65545 | 2014-09-17 09:02:25 | [diff] [blame] | 52 | } |
| 53 | assert(false); |
| 54 | return NULL; |
| 55 | } |
| 56 | |
pbos@webrtc.org | 7b5a896 | 2014-10-29 15:28:39 | [diff] [blame] | 57 | VideoDecoder* VideoDecoder::Create(VideoDecoder::DecoderType codec_type) { |
| 58 | switch (codec_type) { |
| 59 | case kVp8: |
| 60 | return VP8Decoder::Create(); |
stefan@webrtc.org | 385606f | 2014-11-04 19:41:15 | [diff] [blame] | 61 | case kVp9: |
| 62 | return VP9Decoder::Create(); |
pbos@webrtc.org | 7b5a896 | 2014-10-29 15:28:39 | [diff] [blame] | 63 | } |
| 64 | assert(false); |
| 65 | return NULL; |
| 66 | } |
| 67 | |
pbos@webrtc.org | 7da3067 | 2014-10-14 11:52:10 | [diff] [blame] | 68 | const int Call::Config::kDefaultStartBitrateBps = 300000; |
| 69 | |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 70 | namespace internal { |
asapersson@webrtc.org | 8ef6548 | 2014-01-31 10:05:07 | [diff] [blame] | 71 | |
| 72 | class CpuOveruseObserverProxy : public webrtc::CpuOveruseObserver { |
| 73 | public: |
pbos@webrtc.org | d3e3c9b | 2014-10-03 11:25:45 | [diff] [blame] | 74 | explicit CpuOveruseObserverProxy(LoadObserver* overuse_callback) |
asapersson@webrtc.org | 8ef6548 | 2014-01-31 10:05:07 | [diff] [blame] | 75 | : crit_(CriticalSectionWrapper::CreateCriticalSection()), |
| 76 | overuse_callback_(overuse_callback) { |
| 77 | assert(overuse_callback != NULL); |
| 78 | } |
| 79 | |
| 80 | virtual ~CpuOveruseObserverProxy() {} |
| 81 | |
| 82 | virtual void OveruseDetected() OVERRIDE { |
pbos@webrtc.org | c476e64 | 2014-04-28 13:00:21 | [diff] [blame] | 83 | CriticalSectionScoped lock(crit_.get()); |
pbos@webrtc.org | d3e3c9b | 2014-10-03 11:25:45 | [diff] [blame] | 84 | overuse_callback_->OnLoadUpdate(LoadObserver::kOveruse); |
asapersson@webrtc.org | 8ef6548 | 2014-01-31 10:05:07 | [diff] [blame] | 85 | } |
| 86 | |
| 87 | virtual void NormalUsage() OVERRIDE { |
pbos@webrtc.org | c476e64 | 2014-04-28 13:00:21 | [diff] [blame] | 88 | CriticalSectionScoped lock(crit_.get()); |
pbos@webrtc.org | d3e3c9b | 2014-10-03 11:25:45 | [diff] [blame] | 89 | overuse_callback_->OnLoadUpdate(LoadObserver::kUnderuse); |
asapersson@webrtc.org | 8ef6548 | 2014-01-31 10:05:07 | [diff] [blame] | 90 | } |
| 91 | |
| 92 | private: |
pbos@webrtc.org | c476e64 | 2014-04-28 13:00:21 | [diff] [blame] | 93 | const scoped_ptr<CriticalSectionWrapper> crit_; |
pbos@webrtc.org | d3e3c9b | 2014-10-03 11:25:45 | [diff] [blame] | 94 | LoadObserver* overuse_callback_ GUARDED_BY(crit_); |
asapersson@webrtc.org | 8ef6548 | 2014-01-31 10:05:07 | [diff] [blame] | 95 | }; |
| 96 | |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 97 | class Call : public webrtc::Call, public PacketReceiver { |
| 98 | public: |
| 99 | Call(webrtc::VideoEngine* video_engine, const Call::Config& config); |
| 100 | virtual ~Call(); |
| 101 | |
| 102 | virtual PacketReceiver* Receiver() OVERRIDE; |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 103 | |
pbos@webrtc.org | 964d78e | 2013-11-20 10:40:25 | [diff] [blame] | 104 | virtual VideoSendStream* CreateVideoSendStream( |
pbos@webrtc.org | bdfcddf | 2014-06-06 10:49:19 | [diff] [blame] | 105 | const VideoSendStream::Config& config, |
pbos@webrtc.org | 58b5140 | 2014-09-19 12:30:25 | [diff] [blame] | 106 | const VideoEncoderConfig& encoder_config) OVERRIDE; |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 107 | |
pbos@webrtc.org | 12a93e0 | 2013-11-21 13:49:43 | [diff] [blame] | 108 | virtual void DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) |
| 109 | OVERRIDE; |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 110 | |
pbos@webrtc.org | 964d78e | 2013-11-20 10:40:25 | [diff] [blame] | 111 | virtual VideoReceiveStream* CreateVideoReceiveStream( |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 112 | const VideoReceiveStream::Config& config) OVERRIDE; |
| 113 | |
pbos@webrtc.org | 12a93e0 | 2013-11-21 13:49:43 | [diff] [blame] | 114 | virtual void DestroyVideoReceiveStream( |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 115 | webrtc::VideoReceiveStream* receive_stream) OVERRIDE; |
| 116 | |
stefan@webrtc.org | 5232267 | 2014-11-05 14:05:29 | [diff] [blame] | 117 | virtual Stats GetStats() const OVERRIDE; |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 118 | |
pbos@webrtc.org | bc57e0f | 2014-05-14 13:57:12 | [diff] [blame] | 119 | virtual DeliveryStatus DeliverPacket(const uint8_t* packet, |
| 120 | size_t length) OVERRIDE; |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 121 | |
pbos@webrtc.org | 5e3f6b4 | 2014-11-25 14:03:34 | [diff] [blame^] | 122 | virtual void SetBitrateConfig( |
| 123 | const webrtc::Call::Config::BitrateConfig& bitrate_config) OVERRIDE; |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 124 | virtual void SignalNetworkState(NetworkState state) OVERRIDE; |
| 125 | |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 126 | private: |
pbos@webrtc.org | bc57e0f | 2014-05-14 13:57:12 | [diff] [blame] | 127 | DeliveryStatus DeliverRtcp(const uint8_t* packet, size_t length); |
pbos@webrtc.org | f8be3d2 | 2014-07-08 07:38:12 | [diff] [blame] | 128 | DeliveryStatus DeliverRtp(const uint8_t* packet, size_t length); |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 129 | |
| 130 | Call::Config config_; |
| 131 | |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 132 | // Needs to be held while write-locking |receive_crit_| or |send_crit_|. This |
| 133 | // ensures that we have a consistent network state signalled to all senders |
| 134 | // and receivers. |
| 135 | scoped_ptr<CriticalSectionWrapper> network_enabled_crit_; |
| 136 | bool network_enabled_ GUARDED_BY(network_enabled_crit_); |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 137 | |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 138 | scoped_ptr<RWLockWrapper> receive_crit_; |
| 139 | std::map<uint32_t, VideoReceiveStream*> receive_ssrcs_ |
| 140 | GUARDED_BY(receive_crit_); |
| 141 | |
| 142 | scoped_ptr<RWLockWrapper> send_crit_; |
| 143 | std::map<uint32_t, VideoSendStream*> send_ssrcs_ GUARDED_BY(send_crit_); |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 144 | |
asapersson@webrtc.org | 8ef6548 | 2014-01-31 10:05:07 | [diff] [blame] | 145 | scoped_ptr<CpuOveruseObserverProxy> overuse_observer_proxy_; |
| 146 | |
pbos@webrtc.org | 2fd91bd | 2014-07-07 13:06:48 | [diff] [blame] | 147 | VideoSendStream::RtpStateMap suspended_send_ssrcs_; |
| 148 | |
mflodman@webrtc.org | dadfc9e | 2013-12-13 09:40:45 | [diff] [blame] | 149 | VideoEngine* video_engine_; |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 150 | ViERTP_RTCP* rtp_rtcp_; |
| 151 | ViECodec* codec_; |
mflodman@webrtc.org | dadfc9e | 2013-12-13 09:40:45 | [diff] [blame] | 152 | ViEBase* base_; |
| 153 | int base_channel_id_; |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 | [diff] [blame] | 154 | |
| 155 | DISALLOW_COPY_AND_ASSIGN(Call); |
| 156 | }; |
pbos@webrtc.org | d05597a | 2013-12-05 12:11:47 | [diff] [blame] | 157 | } // namespace internal |
pbos@webrtc.org | c2014fd | 2013-08-14 13:52:52 | [diff] [blame] | 158 | |
stefan@webrtc.org | 47f0c41 | 2013-12-04 10:24:26 | [diff] [blame] | 159 | Call* Call::Create(const Call::Config& config) { |
pbos@webrtc.org | c71929d | 2014-01-24 09:30:53 | [diff] [blame] | 160 | VideoEngine* video_engine = config.webrtc_config != NULL |
| 161 | ? VideoEngine::Create(*config.webrtc_config) |
| 162 | : VideoEngine::Create(); |
pbos@webrtc.org | c2014fd | 2013-08-14 13:52:52 | [diff] [blame] | 163 | assert(video_engine != NULL); |
| 164 | |
pbos@webrtc.org | bf6d572 | 2013-09-09 15:04:25 | [diff] [blame] | 165 | return new internal::Call(video_engine, config); |
pbos@webrtc.org | c2014fd | 2013-08-14 13:52:52 | [diff] [blame] | 166 | } |
pbos@webrtc.org | c2014fd | 2013-08-14 13:52:52 | [diff] [blame] | 167 | |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 168 | namespace internal { |
| 169 | |
pbos@webrtc.org | bf6d572 | 2013-09-09 15:04:25 | [diff] [blame] | 170 | Call::Call(webrtc::VideoEngine* video_engine, const Call::Config& config) |
mflodman@webrtc.org | bf76ae2 | 2013-07-23 11:35:00 | [diff] [blame] | 171 | : config_(config), |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 172 | network_enabled_crit_(CriticalSectionWrapper::CreateCriticalSection()), |
| 173 | network_enabled_(true), |
| 174 | receive_crit_(RWLockWrapper::CreateRWLock()), |
| 175 | send_crit_(RWLockWrapper::CreateRWLock()), |
mflodman@webrtc.org | dadfc9e | 2013-12-13 09:40:45 | [diff] [blame] | 176 | video_engine_(video_engine), |
| 177 | base_channel_id_(-1) { |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 178 | assert(video_engine != NULL); |
mflodman@webrtc.org | bf76ae2 | 2013-07-23 11:35:00 | [diff] [blame] | 179 | assert(config.send_transport != NULL); |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 180 | |
pbos@webrtc.org | 5e3f6b4 | 2014-11-25 14:03:34 | [diff] [blame^] | 181 | assert(config.stream_bitrates.min_bitrate_bps >= 0); |
| 182 | assert(config.stream_bitrates.start_bitrate_bps >= |
| 183 | config.stream_bitrates.min_bitrate_bps); |
| 184 | if (config.stream_bitrates.max_bitrate_bps != -1) { |
| 185 | assert(config.stream_bitrates.max_bitrate_bps >= |
| 186 | config.stream_bitrates.start_bitrate_bps); |
| 187 | } |
| 188 | |
asapersson@webrtc.org | 8ef6548 | 2014-01-31 10:05:07 | [diff] [blame] | 189 | if (config.overuse_callback) { |
| 190 | overuse_observer_proxy_.reset( |
| 191 | new CpuOveruseObserverProxy(config.overuse_callback)); |
| 192 | } |
| 193 | |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 194 | rtp_rtcp_ = ViERTP_RTCP::GetInterface(video_engine_); |
| 195 | assert(rtp_rtcp_ != NULL); |
| 196 | |
| 197 | codec_ = ViECodec::GetInterface(video_engine_); |
| 198 | assert(codec_ != NULL); |
mflodman@webrtc.org | dadfc9e | 2013-12-13 09:40:45 | [diff] [blame] | 199 | |
| 200 | // As a workaround for non-existing calls in the old API, create a base |
| 201 | // channel used as default channel when creating send and receive streams. |
| 202 | base_ = ViEBase::GetInterface(video_engine_); |
| 203 | assert(base_ != NULL); |
| 204 | |
| 205 | base_->CreateChannel(base_channel_id_); |
| 206 | assert(base_channel_id_ != -1); |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 207 | } |
| 208 | |
pbos@webrtc.org | bf6d572 | 2013-09-09 15:04:25 | [diff] [blame] | 209 | Call::~Call() { |
mflodman@webrtc.org | dadfc9e | 2013-12-13 09:40:45 | [diff] [blame] | 210 | base_->DeleteChannel(base_channel_id_); |
| 211 | base_->Release(); |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 212 | codec_->Release(); |
pbos@webrtc.org | c2014fd | 2013-08-14 13:52:52 | [diff] [blame] | 213 | rtp_rtcp_->Release(); |
| 214 | webrtc::VideoEngine::Delete(video_engine_); |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 215 | } |
| 216 | |
pbos@webrtc.org | bf6d572 | 2013-09-09 15:04:25 | [diff] [blame] | 217 | PacketReceiver* Call::Receiver() { return this; } |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 218 | |
pbos@webrtc.org | 964d78e | 2013-11-20 10:40:25 | [diff] [blame] | 219 | VideoSendStream* Call::CreateVideoSendStream( |
pbos@webrtc.org | bdfcddf | 2014-06-06 10:49:19 | [diff] [blame] | 220 | const VideoSendStream::Config& config, |
pbos@webrtc.org | 58b5140 | 2014-09-19 12:30:25 | [diff] [blame] | 221 | const VideoEncoderConfig& encoder_config) { |
pbos@webrtc.org | 63988b2 | 2013-06-10 13:48:26 | [diff] [blame] | 222 | assert(config.rtp.ssrcs.size() > 0); |
pbos@webrtc.org | 63988b2 | 2013-06-10 13:48:26 | [diff] [blame] | 223 | |
mflodman@webrtc.org | f89ce46 | 2014-06-16 08:57:39 | [diff] [blame] | 224 | // TODO(mflodman): Base the start bitrate on a current bandwidth estimate, if |
| 225 | // the call has already started. |
pbos@webrtc.org | 5e3f6b4 | 2014-11-25 14:03:34 | [diff] [blame^] | 226 | VideoSendStream* send_stream = new VideoSendStream( |
| 227 | config_.send_transport, overuse_observer_proxy_.get(), video_engine_, |
| 228 | config, encoder_config, suspended_send_ssrcs_, base_channel_id_, |
| 229 | config_.stream_bitrates); |
pbos@webrtc.org | 63988b2 | 2013-06-10 13:48:26 | [diff] [blame] | 230 | |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 231 | // This needs to be taken before send_crit_ as both locks need to be held |
| 232 | // while changing network state. |
| 233 | CriticalSectionScoped lock(network_enabled_crit_.get()); |
| 234 | WriteLockScoped write_lock(*send_crit_); |
pbos@webrtc.org | 63988b2 | 2013-06-10 13:48:26 | [diff] [blame] | 235 | for (size_t i = 0; i < config.rtp.ssrcs.size(); ++i) { |
| 236 | assert(send_ssrcs_.find(config.rtp.ssrcs[i]) == send_ssrcs_.end()); |
| 237 | send_ssrcs_[config.rtp.ssrcs[i]] = send_stream; |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 238 | } |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 239 | if (!network_enabled_) |
| 240 | send_stream->SignalNetworkState(kNetworkDown); |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 241 | return send_stream; |
| 242 | } |
| 243 | |
pbos@webrtc.org | 12a93e0 | 2013-11-21 13:49:43 | [diff] [blame] | 244 | void Call::DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) { |
pbos@webrtc.org | 0020858 | 2013-09-05 12:38:54 | [diff] [blame] | 245 | assert(send_stream != NULL); |
| 246 | |
pbos@webrtc.org | 2fd91bd | 2014-07-07 13:06:48 | [diff] [blame] | 247 | send_stream->Stop(); |
| 248 | |
pbos@webrtc.org | 0020858 | 2013-09-05 12:38:54 | [diff] [blame] | 249 | VideoSendStream* send_stream_impl = NULL; |
| 250 | { |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 251 | WriteLockScoped write_lock(*send_crit_); |
pbos@webrtc.org | 2fd91bd | 2014-07-07 13:06:48 | [diff] [blame] | 252 | std::map<uint32_t, VideoSendStream*>::iterator it = send_ssrcs_.begin(); |
| 253 | while (it != send_ssrcs_.end()) { |
pbos@webrtc.org | 0020858 | 2013-09-05 12:38:54 | [diff] [blame] | 254 | if (it->second == static_cast<VideoSendStream*>(send_stream)) { |
| 255 | send_stream_impl = it->second; |
pbos@webrtc.org | 2fd91bd | 2014-07-07 13:06:48 | [diff] [blame] | 256 | send_ssrcs_.erase(it++); |
| 257 | } else { |
| 258 | ++it; |
pbos@webrtc.org | 0020858 | 2013-09-05 12:38:54 | [diff] [blame] | 259 | } |
| 260 | } |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 261 | } |
pbos@webrtc.org | 0020858 | 2013-09-05 12:38:54 | [diff] [blame] | 262 | |
pbos@webrtc.org | 2fd91bd | 2014-07-07 13:06:48 | [diff] [blame] | 263 | VideoSendStream::RtpStateMap rtp_state = send_stream_impl->GetRtpStates(); |
| 264 | |
| 265 | for (VideoSendStream::RtpStateMap::iterator it = rtp_state.begin(); |
| 266 | it != rtp_state.end(); |
| 267 | ++it) { |
| 268 | suspended_send_ssrcs_[it->first] = it->second; |
| 269 | } |
| 270 | |
pbos@webrtc.org | 0020858 | 2013-09-05 12:38:54 | [diff] [blame] | 271 | assert(send_stream_impl != NULL); |
| 272 | delete send_stream_impl; |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 273 | } |
| 274 | |
pbos@webrtc.org | 964d78e | 2013-11-20 10:40:25 | [diff] [blame] | 275 | VideoReceiveStream* Call::CreateVideoReceiveStream( |
pbos@webrtc.org | c179706 | 2013-08-23 09:19:30 | [diff] [blame] | 276 | const VideoReceiveStream::Config& config) { |
mflodman@webrtc.org | dadfc9e | 2013-12-13 09:40:45 | [diff] [blame] | 277 | VideoReceiveStream* receive_stream = |
| 278 | new VideoReceiveStream(video_engine_, |
| 279 | config, |
| 280 | config_.send_transport, |
| 281 | config_.voice_engine, |
| 282 | base_channel_id_); |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 283 | |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 284 | // This needs to be taken before receive_crit_ as both locks need to be held |
| 285 | // while changing network state. |
| 286 | CriticalSectionScoped lock(network_enabled_crit_.get()); |
| 287 | WriteLockScoped write_lock(*receive_crit_); |
pbos@webrtc.org | 4b50db1 | 2013-12-03 10:13:04 | [diff] [blame] | 288 | assert(receive_ssrcs_.find(config.rtp.remote_ssrc) == receive_ssrcs_.end()); |
| 289 | receive_ssrcs_[config.rtp.remote_ssrc] = receive_stream; |
pbos@webrtc.org | c71929d | 2014-01-24 09:30:53 | [diff] [blame] | 290 | // TODO(pbos): Configure different RTX payloads per receive payload. |
| 291 | VideoReceiveStream::Config::Rtp::RtxMap::const_iterator it = |
| 292 | config.rtp.rtx.begin(); |
| 293 | if (it != config.rtp.rtx.end()) |
| 294 | receive_ssrcs_[it->second.ssrc] = receive_stream; |
| 295 | |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 296 | if (!network_enabled_) |
| 297 | receive_stream->SignalNetworkState(kNetworkDown); |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 298 | return receive_stream; |
| 299 | } |
| 300 | |
pbos@webrtc.org | 12a93e0 | 2013-11-21 13:49:43 | [diff] [blame] | 301 | void Call::DestroyVideoReceiveStream( |
| 302 | webrtc::VideoReceiveStream* receive_stream) { |
pbos@webrtc.org | 0020858 | 2013-09-05 12:38:54 | [diff] [blame] | 303 | assert(receive_stream != NULL); |
| 304 | |
| 305 | VideoReceiveStream* receive_stream_impl = NULL; |
| 306 | { |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 307 | WriteLockScoped write_lock(*receive_crit_); |
pbos@webrtc.org | c71929d | 2014-01-24 09:30:53 | [diff] [blame] | 308 | // Remove all ssrcs pointing to a receive stream. As RTX retransmits on a |
| 309 | // separate SSRC there can be either one or two. |
| 310 | std::map<uint32_t, VideoReceiveStream*>::iterator it = |
| 311 | receive_ssrcs_.begin(); |
| 312 | while (it != receive_ssrcs_.end()) { |
pbos@webrtc.org | 0020858 | 2013-09-05 12:38:54 | [diff] [blame] | 313 | if (it->second == static_cast<VideoReceiveStream*>(receive_stream)) { |
solenberg@webrtc.org | 2bb7ad5 | 2014-01-29 11:21:58 | [diff] [blame] | 314 | assert(receive_stream_impl == NULL || |
| 315 | receive_stream_impl == it->second); |
pbos@webrtc.org | 0020858 | 2013-09-05 12:38:54 | [diff] [blame] | 316 | receive_stream_impl = it->second; |
pbos@webrtc.org | c71929d | 2014-01-24 09:30:53 | [diff] [blame] | 317 | receive_ssrcs_.erase(it++); |
| 318 | } else { |
| 319 | ++it; |
pbos@webrtc.org | 0020858 | 2013-09-05 12:38:54 | [diff] [blame] | 320 | } |
| 321 | } |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 322 | } |
pbos@webrtc.org | 0020858 | 2013-09-05 12:38:54 | [diff] [blame] | 323 | |
| 324 | assert(receive_stream_impl != NULL); |
| 325 | delete receive_stream_impl; |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 326 | } |
| 327 | |
stefan@webrtc.org | 5232267 | 2014-11-05 14:05:29 | [diff] [blame] | 328 | Call::Stats Call::GetStats() const { |
| 329 | Stats stats; |
| 330 | // Ignoring return values. |
| 331 | uint32_t send_bandwidth = 0; |
| 332 | rtp_rtcp_->GetEstimatedSendBandwidth(base_channel_id_, &send_bandwidth); |
| 333 | stats.send_bandwidth_bps = send_bandwidth; |
| 334 | uint32_t recv_bandwidth = 0; |
| 335 | rtp_rtcp_->GetEstimatedReceiveBandwidth(base_channel_id_, &recv_bandwidth); |
| 336 | stats.recv_bandwidth_bps = recv_bandwidth; |
| 337 | { |
| 338 | ReadLockScoped read_lock(*send_crit_); |
| 339 | for (std::map<uint32_t, VideoSendStream*>::const_iterator it = |
| 340 | send_ssrcs_.begin(); |
| 341 | it != send_ssrcs_.end(); |
| 342 | ++it) { |
| 343 | stats.pacer_delay_ms = |
| 344 | std::max(it->second->GetPacerQueuingDelayMs(), stats.pacer_delay_ms); |
| 345 | } |
| 346 | } |
| 347 | return stats; |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 348 | } |
| 349 | |
pbos@webrtc.org | 5e3f6b4 | 2014-11-25 14:03:34 | [diff] [blame^] | 350 | void Call::SetBitrateConfig( |
| 351 | const webrtc::Call::Config::BitrateConfig& bitrate_config) { |
| 352 | assert(bitrate_config.min_bitrate_bps >= 0); |
| 353 | assert(bitrate_config.max_bitrate_bps == -1 || |
| 354 | bitrate_config.max_bitrate_bps > 0); |
| 355 | if (config_.stream_bitrates.min_bitrate_bps == |
| 356 | bitrate_config.min_bitrate_bps && |
| 357 | (bitrate_config.start_bitrate_bps <= 0 || |
| 358 | config_.stream_bitrates.start_bitrate_bps == |
| 359 | bitrate_config.start_bitrate_bps) && |
| 360 | config_.stream_bitrates.max_bitrate_bps == |
| 361 | bitrate_config.max_bitrate_bps) { |
| 362 | // Nothing new to set, early abort to avoid encoder reconfigurations. |
| 363 | return; |
| 364 | } |
| 365 | config_.stream_bitrates = bitrate_config; |
| 366 | ReadLockScoped read_lock(*send_crit_); |
| 367 | for (std::map<uint32_t, VideoSendStream*>::const_iterator it = |
| 368 | send_ssrcs_.begin(); |
| 369 | it != send_ssrcs_.end(); ++it) { |
| 370 | it->second->SetBitrateConfig(bitrate_config); |
| 371 | } |
| 372 | } |
| 373 | |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 374 | void Call::SignalNetworkState(NetworkState state) { |
| 375 | // Take crit for entire function, it needs to be held while updating streams |
| 376 | // to guarantee a consistent state across streams. |
| 377 | CriticalSectionScoped lock(network_enabled_crit_.get()); |
| 378 | network_enabled_ = state == kNetworkUp; |
| 379 | { |
| 380 | ReadLockScoped write_lock(*send_crit_); |
| 381 | for (std::map<uint32_t, VideoSendStream*>::iterator it = |
| 382 | send_ssrcs_.begin(); |
| 383 | it != send_ssrcs_.end(); |
| 384 | ++it) { |
| 385 | it->second->SignalNetworkState(state); |
| 386 | } |
| 387 | } |
| 388 | { |
| 389 | ReadLockScoped write_lock(*receive_crit_); |
| 390 | for (std::map<uint32_t, VideoReceiveStream*>::iterator it = |
| 391 | receive_ssrcs_.begin(); |
| 392 | it != receive_ssrcs_.end(); |
| 393 | ++it) { |
| 394 | it->second->SignalNetworkState(state); |
| 395 | } |
| 396 | } |
| 397 | } |
| 398 | |
pbos@webrtc.org | f8be3d2 | 2014-07-08 07:38:12 | [diff] [blame] | 399 | PacketReceiver::DeliveryStatus Call::DeliverRtcp(const uint8_t* packet, |
pbos@webrtc.org | bc57e0f | 2014-05-14 13:57:12 | [diff] [blame] | 400 | size_t length) { |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 401 | // TODO(pbos): Figure out what channel needs it actually. |
| 402 | // Do NOT broadcast! Also make sure it's a valid packet. |
pbos@webrtc.org | bc57e0f | 2014-05-14 13:57:12 | [diff] [blame] | 403 | // Return DELIVERY_UNKNOWN_SSRC if it can be determined that |
| 404 | // there's no receiver of the packet. |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 405 | bool rtcp_delivered = false; |
pbos@webrtc.org | 78ab511 | 2013-08-05 12:49:22 | [diff] [blame] | 406 | { |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 407 | ReadLockScoped read_lock(*receive_crit_); |
pbos@webrtc.org | 78ab511 | 2013-08-05 12:49:22 | [diff] [blame] | 408 | for (std::map<uint32_t, VideoReceiveStream*>::iterator it = |
| 409 | receive_ssrcs_.begin(); |
| 410 | it != receive_ssrcs_.end(); |
| 411 | ++it) { |
pbos@webrtc.org | 0011252 | 2013-09-20 11:56:26 | [diff] [blame] | 412 | if (it->second->DeliverRtcp(packet, length)) |
pbos@webrtc.org | 78ab511 | 2013-08-05 12:49:22 | [diff] [blame] | 413 | rtcp_delivered = true; |
pbos@webrtc.org | ce85109 | 2013-08-05 12:01:36 | [diff] [blame] | 414 | } |
| 415 | } |
| 416 | |
pbos@webrtc.org | 78ab511 | 2013-08-05 12:49:22 | [diff] [blame] | 417 | { |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 418 | ReadLockScoped read_lock(*send_crit_); |
pbos@webrtc.org | 78ab511 | 2013-08-05 12:49:22 | [diff] [blame] | 419 | for (std::map<uint32_t, VideoSendStream*>::iterator it = |
| 420 | send_ssrcs_.begin(); |
| 421 | it != send_ssrcs_.end(); |
| 422 | ++it) { |
pbos@webrtc.org | 0011252 | 2013-09-20 11:56:26 | [diff] [blame] | 423 | if (it->second->DeliverRtcp(packet, length)) |
pbos@webrtc.org | 78ab511 | 2013-08-05 12:49:22 | [diff] [blame] | 424 | rtcp_delivered = true; |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 425 | } |
| 426 | } |
pbos@webrtc.org | bc57e0f | 2014-05-14 13:57:12 | [diff] [blame] | 427 | return rtcp_delivered ? DELIVERY_OK : DELIVERY_PACKET_ERROR; |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 428 | } |
| 429 | |
pbos@webrtc.org | f8be3d2 | 2014-07-08 07:38:12 | [diff] [blame] | 430 | PacketReceiver::DeliveryStatus Call::DeliverRtp(const uint8_t* packet, |
| 431 | size_t length) { |
| 432 | // Minimum RTP header size. |
| 433 | if (length < 12) |
| 434 | return DELIVERY_PACKET_ERROR; |
| 435 | |
| 436 | const uint8_t* ptr = &packet[8]; |
pbos@webrtc.org | 6c0337d | 2014-08-05 23:35:43 | [diff] [blame] | 437 | uint32_t ssrc = ptr[0] << 24 | ptr[1] << 16 | ptr[2] << 8 | ptr[3]; |
pbos@webrtc.org | f8be3d2 | 2014-07-08 07:38:12 | [diff] [blame] | 438 | |
pbos@webrtc.org | 9b707ca | 2014-09-03 16:17:12 | [diff] [blame] | 439 | ReadLockScoped read_lock(*receive_crit_); |
solenberg@webrtc.org | 2bb7ad5 | 2014-01-29 11:21:58 | [diff] [blame] | 440 | std::map<uint32_t, VideoReceiveStream*>::iterator it = |
pbos@webrtc.org | f8be3d2 | 2014-07-08 07:38:12 | [diff] [blame] | 441 | receive_ssrcs_.find(ssrc); |
pbos@webrtc.org | bc57e0f | 2014-05-14 13:57:12 | [diff] [blame] | 442 | |
| 443 | if (it == receive_ssrcs_.end()) |
| 444 | return DELIVERY_UNKNOWN_SSRC; |
| 445 | |
pbos@webrtc.org | f8be3d2 | 2014-07-08 07:38:12 | [diff] [blame] | 446 | return it->second->DeliverRtp(packet, length) ? DELIVERY_OK |
| 447 | : DELIVERY_PACKET_ERROR; |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 448 | } |
| 449 | |
pbos@webrtc.org | f8be3d2 | 2014-07-08 07:38:12 | [diff] [blame] | 450 | PacketReceiver::DeliveryStatus Call::DeliverPacket(const uint8_t* packet, |
| 451 | size_t length) { |
pbos@webrtc.org | 6aae61c | 2014-07-08 12:10:51 | [diff] [blame] | 452 | if (RtpHeaderParser::IsRtcp(packet, length)) |
pbos@webrtc.org | 78ab511 | 2013-08-05 12:49:22 | [diff] [blame] | 453 | return DeliverRtcp(packet, length); |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 454 | |
pbos@webrtc.org | f8be3d2 | 2014-07-08 07:38:12 | [diff] [blame] | 455 | return DeliverRtp(packet, length); |
pbos@webrtc.org | 2a9108f | 2013-05-16 12:08:03 | [diff] [blame] | 456 | } |
| 457 | |
| 458 | } // namespace internal |
| 459 | } // namespace webrtc |