Add AudioSendStream to Call.

webrtc/call/call.cc

 /*
  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include <string.h>
 
 #include <map>
 #include <vector>
 
 #include "webrtc/audio/audio_receive_stream.h"
+#include "webrtc/audio/audio_send_stream.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/thread_annotations.h"
 #include "webrtc/call.h"
 #include "webrtc/call/rtc_event_log.h"
 #include "webrtc/common.h"
 #include "webrtc/config.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/modules/utility/interface/process_thread.h"
@@ skipping 69 matching lines @@
   volatile int next_channel_id_;
   Call::Config config_;
 
   // Needs to be held while write-locking |receive_crit_| or |send_crit_|. This
   // ensures that we have a consistent network state signalled to all senders
   // and receivers.
   rtc::CriticalSection network_enabled_crit_;
   bool network_enabled_ GUARDED_BY(network_enabled_crit_);
 
   rtc::scoped_ptr<RWLockWrapper> receive_crit_;
+  // Audio and Video receive streams are owned by the client that creates them.
   std::map<uint32_t, AudioReceiveStream*> audio_receive_ssrcs_
       GUARDED_BY(receive_crit_);
   std::map<uint32_t, VideoReceiveStream*> video_receive_ssrcs_
       GUARDED_BY(receive_crit_);
   std::set<VideoReceiveStream*> video_receive_streams_
       GUARDED_BY(receive_crit_);
   std::map<std::string, AudioReceiveStream*> sync_stream_mapping_
       GUARDED_BY(receive_crit_);
 
   rtc::scoped_ptr<RWLockWrapper> send_crit_;
+  // Audio and Video send streams are owned by the client that creates them.
+  std::map<uint32_t, AudioSendStream*> audio_send_ssrcs_ GUARDED_BY(send_crit_);
   std::map<uint32_t, VideoSendStream*> video_send_ssrcs_ GUARDED_BY(send_crit_);
   std::set<VideoSendStream*> video_send_streams_ GUARDED_BY(send_crit_);
 
   VideoSendStream::RtpStateMap suspended_video_send_ssrcs_;
 
   RtcEventLog* event_log_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(Call);
 };
 }  // namespace internal
@@ skipping 31 matching lines @@
 
   Trace::CreateTrace();
   module_process_thread_->Start();
 
   channel_group_->SetBweBitrates(config_.bitrate_config.min_bitrate_bps,
                                  config_.bitrate_config.start_bitrate_bps,
                                  config_.bitrate_config.max_bitrate_bps);
 }
 
 Call::~Call() {
-  RTC_CHECK_EQ(0u, video_send_ssrcs_.size());
-  RTC_CHECK_EQ(0u, video_send_streams_.size());
-  RTC_CHECK_EQ(0u, audio_receive_ssrcs_.size());
-  RTC_CHECK_EQ(0u, video_receive_ssrcs_.size());
-  RTC_CHECK_EQ(0u, video_receive_streams_.size());
+  RTC_CHECK(audio_send_ssrcs_.empty());
+  RTC_CHECK(video_send_ssrcs_.empty());
+  RTC_CHECK(video_send_streams_.empty());
+  RTC_CHECK(audio_receive_ssrcs_.empty());
+  RTC_CHECK(video_receive_ssrcs_.empty());
+  RTC_CHECK(video_receive_streams_.empty());
 
   module_process_thread_->Stop();
   Trace::ReturnTrace();
 }
 
 PacketReceiver* Call::Receiver() { return this; }
 
 webrtc::AudioSendStream* Call::CreateAudioSendStream(
     const webrtc::AudioSendStream::Config& config) {
-  // TODO(pbos): When adding AudioSendStream, add both TRACE_EVENT0 and config
-  // logging to AudioSendStream constructor.
-  return nullptr;
+  TRACE_EVENT0("webrtc", "Call::CreateAudioSendStream");
+  AudioSendStream* send_stream = new AudioSendStream(config);
+  {
+    rtc::CritScope lock(&network_enabled_crit_);
+    WriteLockScoped write_lock(*send_crit_);
+    RTC_DCHECK(audio_send_ssrcs_.find(config.rtp.ssrc) ==
+               audio_send_ssrcs_.end());
+    audio_send_ssrcs_[config.rtp.ssrc] = send_stream;
+
+    if (!network_enabled_)
+      send_stream->SignalNetworkState(kNetworkDown);
+  }
+  return send_stream;
 }
 
 void Call::DestroyAudioSendStream(webrtc::AudioSendStream* send_stream) {
-  // TODO(pbos): When adding AudioSendStream, add both TRACE_EVENT0 and config
-  // logging to AudioSendStream destructor.
+  TRACE_EVENT0("webrtc", "Call::DestroyAudioSendStream");
+  RTC_DCHECK(send_stream != nullptr);
+
+  send_stream->Stop();
+
+  webrtc::internal::AudioSendStream* audio_send_stream =
+      static_cast<webrtc::internal::AudioSendStream*>(send_stream);
+  {
+    WriteLockScoped write_lock(*send_crit_);
+    size_t num_deleted = audio_send_ssrcs_.erase(
+        audio_send_stream->config().rtp.ssrc);
+    RTC_DCHECK(num_deleted == 1);
+  }
+  delete audio_send_stream;
 }
 
 webrtc::AudioReceiveStream* Call::CreateAudioReceiveStream(
     const webrtc::AudioReceiveStream::Config& config) {
   TRACE_EVENT0("webrtc", "Call::CreateAudioReceiveStream");
   AudioReceiveStream* receive_stream = new AudioReceiveStream(
       channel_group_->GetRemoteBitrateEstimator(), config);
   {
     WriteLockScoped write_lock(*receive_crit_);
     RTC_DCHECK(audio_receive_ssrcs_.find(config.rtp.remote_ssrc) ==
                audio_receive_ssrcs_.end());
     audio_receive_ssrcs_[config.rtp.remote_ssrc] = receive_stream;
     ConfigureSync(config.sync_group);
   }
   return receive_stream;
 }
 
 void Call::DestroyAudioReceiveStream(
     webrtc::AudioReceiveStream* receive_stream) {
   TRACE_EVENT0("webrtc", "Call::DestroyAudioReceiveStream");
   RTC_DCHECK(receive_stream != nullptr);
-  AudioReceiveStream* audio_receive_stream =
-      static_cast<AudioReceiveStream*>(receive_stream);
+  webrtc::internal::AudioReceiveStream* audio_receive_stream =
+      static_cast<webrtc::internal::AudioReceiveStream*>(receive_stream);
   {
     WriteLockScoped write_lock(*receive_crit_);
     size_t num_deleted = audio_receive_ssrcs_.erase(
         audio_receive_stream->config().rtp.remote_ssrc);
     RTC_DCHECK(num_deleted == 1);
     const std::string& sync_group = audio_receive_stream->config().sync_group;
     const auto it = sync_stream_mapping_.find(sync_group);
     if (it != sync_stream_mapping_.end() &&
         it->second == audio_receive_stream) {
       sync_stream_mapping_.erase(it);
@@ skipping 133 matching lines @@
   channel_group_->GetBitrateController()->AvailableBandwidth(&send_bandwidth);
   std::vector<unsigned int> ssrcs;
   uint32_t recv_bandwidth = 0;
   channel_group_->GetRemoteBitrateEstimator()->LatestEstimate(&ssrcs,
                                                               &recv_bandwidth);
   stats.send_bandwidth_bps = send_bandwidth;
   stats.recv_bandwidth_bps = recv_bandwidth;
   stats.pacer_delay_ms = channel_group_->GetPacerQueuingDelayMs();
   {
     ReadLockScoped read_lock(*send_crit_);
+    // TODO(solenberg): Add audio send streams.
     for (const auto& kv : video_send_ssrcs_) {
       int rtt_ms = kv.second->GetRtt();
       if (rtt_ms > 0)
         stats.rtt_ms = rtt_ms;
     }
   }
   return stats;
 }
 
 void Call::SetBitrateConfig(
@@ skipping 19 matching lines @@
 }
 
 void Call::SignalNetworkState(NetworkState state) {
   // Take crit for entire function, it needs to be held while updating streams
   // to guarantee a consistent state across streams.
   rtc::CritScope lock(&network_enabled_crit_);
   network_enabled_ = state == kNetworkUp;
   channel_group_->SignalNetworkState(state);
   {
     ReadLockScoped write_lock(*send_crit_);
+    for (auto& kv : audio_send_ssrcs_) {
+      kv.second->SignalNetworkState(state);
+    }
     for (auto& kv : video_send_ssrcs_) {
       kv.second->SignalNetworkState(state);
     }
   }
   {
     ReadLockScoped write_lock(*receive_crit_);
     for (auto& kv : video_receive_ssrcs_) {
       kv.second->SignalNetworkState(state);
     }
   }
@@ skipping 124 matching lines @@
     size_t length,
     const PacketTime& packet_time) {
   if (RtpHeaderParser::IsRtcp(packet, length))
     return DeliverRtcp(media_type, packet, length);
 
   return DeliverRtp(media_type, packet, length, packet_time);
 }
 
 }  // namespace internal
 }  // namespace webrtc