src/third_party/webrtc/video/call.cc

   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
  11 #include <assert.h>
  12 #include <string.h>
  13
  14 #include <map>
  15 #include <vector>
  16
  17 #include "webrtc/call.h"
  18 #include "webrtc/common.h"
  19 #include "webrtc/config.h"
  20 #include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h"
  21 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
  22 #include "webrtc/system_wrappers/interface/rw_lock_wrapper.h"
  23 #include "webrtc/system_wrappers/interface/scoped_ptr.h"
  24 #include "webrtc/system_wrappers/interface/trace.h"
  25 #include "webrtc/video/video_receive_stream.h"
  26 #include "webrtc/video/video_send_stream.h"
  27 #include "webrtc/video_engine/include/vie_base.h"
  28 #include "webrtc/video_engine/include/vie_codec.h"
  29 #include "webrtc/video_engine/include/vie_rtp_rtcp.h"
  30
  31 namespace webrtc {
  32 const char* RtpExtension::kTOffset = "urn:ietf:params:rtp-hdrext:toffset";
  33 const char* RtpExtension::kAbsSendTime =
  34     "http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time";
  35 namespace internal {
  36
  37 class CpuOveruseObserverProxy : public webrtc::CpuOveruseObserver {
  38  public:
  39   CpuOveruseObserverProxy(OveruseCallback* overuse_callback)
  40       : crit_(CriticalSectionWrapper::CreateCriticalSection()),
  41         overuse_callback_(overuse_callback) {
  42     assert(overuse_callback != NULL);
  43   }
  44
  45   virtual ~CpuOveruseObserverProxy() {}
  46
  47   virtual void OveruseDetected() OVERRIDE {
  48     CriticalSectionScoped cs(crit_.get());
  49     overuse_callback_->OnOveruse();
  50   }
  51
  52   virtual void NormalUsage() OVERRIDE {
  53     CriticalSectionScoped cs(crit_.get());
  54     overuse_callback_->OnNormalUse();
  55   }
  56
  57  private:
  58   scoped_ptr<CriticalSectionWrapper> crit_;
  59   OveruseCallback* overuse_callback_;
  60 };
  61
  62 class Call : public webrtc::Call, public PacketReceiver {
  63  public:
  64   Call(webrtc::VideoEngine* video_engine, const Call::Config& config);
  65   virtual ~Call();
  66
  67   virtual PacketReceiver* Receiver() OVERRIDE;
  68   virtual std::vector<VideoCodec> GetVideoCodecs() OVERRIDE;
  69
  70   virtual VideoSendStream::Config GetDefaultSendConfig() OVERRIDE;
  71
  72   virtual VideoSendStream* CreateVideoSendStream(
  73       const VideoSendStream::Config& config) OVERRIDE;
  74
  75   virtual void DestroyVideoSendStream(webrtc::VideoSendStream* send_stream)
  76       OVERRIDE;
  77
  78   virtual VideoReceiveStream::Config GetDefaultReceiveConfig() OVERRIDE;
  79
  80   virtual VideoReceiveStream* CreateVideoReceiveStream(
  81       const VideoReceiveStream::Config& config) OVERRIDE;
  82
  83   virtual void DestroyVideoReceiveStream(
  84       webrtc::VideoReceiveStream* receive_stream) OVERRIDE;
  85
  86   virtual uint32_t SendBitrateEstimate() OVERRIDE;
  87   virtual uint32_t ReceiveBitrateEstimate() OVERRIDE;
  88
  89   virtual bool DeliverPacket(const uint8_t* packet, size_t length) OVERRIDE;
  90
  91  private:
  92   bool DeliverRtcp(const uint8_t* packet, size_t length);
  93   bool DeliverRtp(const RTPHeader& header,
  94                   const uint8_t* packet,
  95                   size_t length);
  96
  97   Call::Config config_;
  98
  99   std::map<uint32_t, VideoReceiveStream*> receive_ssrcs_;
 100   scoped_ptr<RWLockWrapper> receive_lock_;
 101
 102   std::map<uint32_t, VideoSendStream*> send_ssrcs_;
 103   scoped_ptr<RWLockWrapper> send_lock_;
 104
 105   scoped_ptr<RtpHeaderParser> rtp_header_parser_;
 106
 107   scoped_ptr<CpuOveruseObserverProxy> overuse_observer_proxy_;
 108
 109   VideoEngine* video_engine_;
 110   ViERTP_RTCP* rtp_rtcp_;
 111   ViECodec* codec_;
 112   ViEBase* base_;
 113   int base_channel_id_;
 114
 115   DISALLOW_COPY_AND_ASSIGN(Call);
 116 };
 117 }  // namespace internal
 118
 119 class TraceDispatcher : public TraceCallback {
 120  public:
 121   TraceDispatcher()
 122       : lock_(CriticalSectionWrapper::CreateCriticalSection()),
 123         filter_(kTraceNone) {
 124     Trace::CreateTrace();
 125     VideoEngine::SetTraceCallback(this);
 126     VideoEngine::SetTraceFilter(kTraceNone);
 127   }
 128
 129   ~TraceDispatcher() {
 130     Trace::ReturnTrace();
 131     VideoEngine::SetTraceCallback(NULL);
 132   }
 133
 134   virtual void Print(TraceLevel level,
 135                      const char* message,
 136                      int length) OVERRIDE {
 137     CriticalSectionScoped crit(lock_.get());
 138     for (std::map<Call*, Call::Config*>::iterator it = callbacks_.begin();
 139          it != callbacks_.end();
 140          ++it) {
 141       if ((level & it->second->trace_filter) != kTraceNone)
 142         it->second->trace_callback->Print(level, message, length);
 143     }
 144   }
 145
 146   void RegisterCallback(Call* call, Call::Config* config) {
 147     if (config->trace_callback == NULL)
 148       return;
 149
 150     CriticalSectionScoped crit(lock_.get());
 151     callbacks_[call] = config;
 152
 153     filter_ |= config->trace_filter;
 154     VideoEngine::SetTraceFilter(filter_);
 155   }
 156
 157   void DeregisterCallback(Call* call) {
 158     CriticalSectionScoped crit(lock_.get());
 159     callbacks_.erase(call);
 160
 161     filter_ = kTraceNone;
 162     for (std::map<Call*, Call::Config*>::iterator it = callbacks_.begin();
 163          it != callbacks_.end();
 164          ++it) {
 165       filter_ |= it->second->trace_filter;
 166     }
 167
 168     VideoEngine::SetTraceFilter(filter_);
 169   }
 170
 171  private:
 172   scoped_ptr<CriticalSectionWrapper> lock_;
 173   unsigned int filter_;
 174   std::map<Call*, Call::Config*> callbacks_;
 175 };
 176
 177 namespace internal {
 178 TraceDispatcher* global_trace_dispatcher = NULL;
 179 }  // internal
 180
 181 void CreateTraceDispatcher() {
 182   if (internal::global_trace_dispatcher == NULL) {
 183     TraceDispatcher* dispatcher = new TraceDispatcher();
 184     // TODO(pbos): Atomic compare and exchange.
 185     if (internal::global_trace_dispatcher == NULL) {
 186       internal::global_trace_dispatcher = dispatcher;
 187     } else {
 188       delete dispatcher;
 189     }
 190   }
 191 }
 192
 193 Call* Call::Create(const Call::Config& config) {
 194   CreateTraceDispatcher();
 195
 196   VideoEngine* video_engine = config.webrtc_config != NULL
 197                                   ? VideoEngine::Create(*config.webrtc_config)
 198                                   : VideoEngine::Create();
 199   assert(video_engine != NULL);
 200
 201   return new internal::Call(video_engine, config);
 202 }
 203
 204 namespace internal {
 205
 206 Call::Call(webrtc::VideoEngine* video_engine, const Call::Config& config)
 207     : config_(config),
 208       receive_lock_(RWLockWrapper::CreateRWLock()),
 209       send_lock_(RWLockWrapper::CreateRWLock()),
 210       rtp_header_parser_(RtpHeaderParser::Create()),
 211       video_engine_(video_engine),
 212       base_channel_id_(-1) {
 213   assert(video_engine != NULL);
 214   assert(config.send_transport != NULL);
 215
 216   if (config.overuse_callback) {
 217     overuse_observer_proxy_.reset(
 218         new CpuOveruseObserverProxy(config.overuse_callback));
 219   }
 220
 221   global_trace_dispatcher->RegisterCallback(this, &config_);
 222
 223   rtp_rtcp_ = ViERTP_RTCP::GetInterface(video_engine_);
 224   assert(rtp_rtcp_ != NULL);
 225
 226   codec_ = ViECodec::GetInterface(video_engine_);
 227   assert(codec_ != NULL);
 228
 229   // As a workaround for non-existing calls in the old API, create a base
 230   // channel used as default channel when creating send and receive streams.
 231   base_ = ViEBase::GetInterface(video_engine_);
 232   assert(base_ != NULL);
 233
 234   base_->CreateChannel(base_channel_id_);
 235   assert(base_channel_id_ != -1);
 236 }
 237
 238 Call::~Call() {
 239   global_trace_dispatcher->DeregisterCallback(this);
 240   base_->DeleteChannel(base_channel_id_);
 241   base_->Release();
 242   codec_->Release();
 243   rtp_rtcp_->Release();
 244   webrtc::VideoEngine::Delete(video_engine_);
 245 }
 246
 247 PacketReceiver* Call::Receiver() { return this; }
 248
 249 std::vector<VideoCodec> Call::GetVideoCodecs() {
 250   std::vector<VideoCodec> codecs;
 251
 252   VideoCodec codec;
 253   for (size_t i = 0; i < static_cast<size_t>(codec_->NumberOfCodecs()); ++i) {
 254     if (codec_->GetCodec(static_cast<unsigned char>(i), codec) == 0) {
 255       codecs.push_back(codec);
 256     }
 257   }
 258   return codecs;
 259 }
 260
 261 VideoSendStream::Config Call::GetDefaultSendConfig() {
 262   VideoSendStream::Config config;
 263   codec_->GetCodec(0, config.codec);
 264   return config;
 265 }
 266
 267 VideoSendStream* Call::CreateVideoSendStream(
 268     const VideoSendStream::Config& config) {
 269   assert(config.rtp.ssrcs.size() > 0);
 270   assert(config.rtp.ssrcs.size() >= config.codec.numberOfSimulcastStreams);
 271
 272   VideoSendStream* send_stream = new VideoSendStream(
 273       config_.send_transport,
 274       overuse_observer_proxy_.get(),
 275       video_engine_,
 276       config,
 277       base_channel_id_);
 278
 279   WriteLockScoped write_lock(*send_lock_);
 280   for (size_t i = 0; i < config.rtp.ssrcs.size(); ++i) {
 281     assert(send_ssrcs_.find(config.rtp.ssrcs[i]) == send_ssrcs_.end());
 282     send_ssrcs_[config.rtp.ssrcs[i]] = send_stream;
 283   }
 284   return send_stream;
 285 }
 286
 287 void Call::DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) {
 288   assert(send_stream != NULL);
 289
 290   VideoSendStream* send_stream_impl = NULL;
 291   {
 292     WriteLockScoped write_lock(*send_lock_);
 293     for (std::map<uint32_t, VideoSendStream*>::iterator it =
 294              send_ssrcs_.begin();
 295          it != send_ssrcs_.end();
 296          ++it) {
 297       if (it->second == static_cast<VideoSendStream*>(send_stream)) {
 298         send_stream_impl = it->second;
 299         send_ssrcs_.erase(it);
 300         break;
 301       }
 302     }
 303   }
 304
 305   assert(send_stream_impl != NULL);
 306   delete send_stream_impl;
 307 }
 308
 309 VideoReceiveStream::Config Call::GetDefaultReceiveConfig() {
 310   VideoReceiveStream::Config config;
 311   config.rtp.remb = true;
 312   return config;
 313 }
 314
 315 VideoReceiveStream* Call::CreateVideoReceiveStream(
 316     const VideoReceiveStream::Config& config) {
 317   VideoReceiveStream* receive_stream =
 318       new VideoReceiveStream(video_engine_,
 319                              config,
 320                              config_.send_transport,
 321                              config_.voice_engine,
 322                              base_channel_id_);
 323
 324   WriteLockScoped write_lock(*receive_lock_);
 325   assert(receive_ssrcs_.find(config.rtp.remote_ssrc) == receive_ssrcs_.end());
 326   receive_ssrcs_[config.rtp.remote_ssrc] = receive_stream;
 327   // TODO(pbos): Configure different RTX payloads per receive payload.
 328   VideoReceiveStream::Config::Rtp::RtxMap::const_iterator it =
 329       config.rtp.rtx.begin();
 330   if (it != config.rtp.rtx.end())
 331     receive_ssrcs_[it->second.ssrc] = receive_stream;
 332
 333   return receive_stream;
 334 }
 335
 336 void Call::DestroyVideoReceiveStream(
 337     webrtc::VideoReceiveStream* receive_stream) {
 338   assert(receive_stream != NULL);
 339
 340   VideoReceiveStream* receive_stream_impl = NULL;
 341   {
 342     WriteLockScoped write_lock(*receive_lock_);
 343     // Remove all ssrcs pointing to a receive stream. As RTX retransmits on a
 344     // separate SSRC there can be either one or two.
 345     std::map<uint32_t, VideoReceiveStream*>::iterator it =
 346         receive_ssrcs_.begin();
 347     while (it != receive_ssrcs_.end()) {
 348       if (it->second == static_cast<VideoReceiveStream*>(receive_stream)) {
 349         assert(receive_stream_impl == NULL ||
 350             receive_stream_impl == it->second);
 351         receive_stream_impl = it->second;
 352         receive_ssrcs_.erase(it++);
 353       } else {
 354         ++it;
 355       }
 356     }
 357   }
 358
 359   assert(receive_stream_impl != NULL);
 360   delete receive_stream_impl;
 361 }
 362
 363 uint32_t Call::SendBitrateEstimate() {
 364   // TODO(pbos): Return send-bitrate estimate
 365   return 0;
 366 }
 367
 368 uint32_t Call::ReceiveBitrateEstimate() {
 369   // TODO(pbos): Return receive-bitrate estimate
 370   return 0;
 371 }
 372
 373 bool Call::DeliverRtcp(const uint8_t* packet, size_t length) {
 374   // TODO(pbos): Figure out what channel needs it actually.
 375   //             Do NOT broadcast! Also make sure it's a valid packet.
 376   bool rtcp_delivered = false;
 377   {
 378     ReadLockScoped read_lock(*receive_lock_);
 379     for (std::map<uint32_t, VideoReceiveStream*>::iterator it =
 380              receive_ssrcs_.begin();
 381          it != receive_ssrcs_.end();
 382          ++it) {
 383       if (it->second->DeliverRtcp(packet, length))
 384         rtcp_delivered = true;
 385     }
 386   }
 387
 388   {
 389     ReadLockScoped read_lock(*send_lock_);
 390     for (std::map<uint32_t, VideoSendStream*>::iterator it =
 391              send_ssrcs_.begin();
 392          it != send_ssrcs_.end();
 393          ++it) {
 394       if (it->second->DeliverRtcp(packet, length))
 395         rtcp_delivered = true;
 396     }
 397   }
 398   return rtcp_delivered;
 399 }
 400
 401 bool Call::DeliverRtp(const RTPHeader& header,
 402                       const uint8_t* packet,
 403                       size_t length) {
 404   ReadLockScoped read_lock(*receive_lock_);
 405   std::map<uint32_t, VideoReceiveStream*>::iterator it =
 406       receive_ssrcs_.find(header.ssrc);
 407   if (it == receive_ssrcs_.end()) {
 408     // TODO(pbos): Log some warning, SSRC without receiver.
 409     return false;
 410   }
 411   return it->second->DeliverRtp(static_cast<const uint8_t*>(packet), length);
 412 }
 413
 414 bool Call::DeliverPacket(const uint8_t* packet, size_t length) {
 415   // TODO(pbos): ExtensionMap if there are extensions.
 416   if (RtpHeaderParser::IsRtcp(packet, static_cast<int>(length)))
 417     return DeliverRtcp(packet, length);
 418
 419   RTPHeader rtp_header;
 420   if (!rtp_header_parser_->Parse(packet, static_cast<int>(length), &rtp_header))
 421     return false;
 422
 423   return DeliverRtp(rtp_header, packet, length);
 424 }
 425
 426 }  // namespace internal
 427 }  // namespace webrtc