Storing raw audio sink for default audio track.

talk/media/webrtc/webrtcvoiceengine.cc

 /*
  * libjingle
  * Copyright 2004 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 2168 matching lines @@
   if (default_recv_ssrc_ == -1 && GetReceiveChannelId(ssrc) == -1) {
     StreamParams sp;
     sp.ssrcs.push_back(ssrc);
     LOG(LS_INFO) << "Creating default receive stream for SSRC=" << ssrc << ".";
     if (!AddRecvStream(sp)) {
       LOG(LS_WARNING) << "Could not create default receive stream.";
       return;
     }
     default_recv_ssrc_ = ssrc;
     SetOutputVolume(default_recv_ssrc_, default_recv_volume_);
+    if (default_sink_) {
+      SetRawAudioSink(default_recv_ssrc_, std::move(default_sink_));

[pthatcher1, 2015/12/30 16:31:50]

This looks different than default_recv_volume_ in that default_recv_volume_
continues to be set even after the default stream is added, so that if the
default stream is removed and re-added, the new default stream can get the same
volume.  But this is moving ownership of the audio sink, so if the default
stream were removed, the default sink would be destroyed.

There are a couple of solution to this, but I don't really like any of them:
- When the default stream is removed, transfer ownership back, and comment when
default_sink_ is set and when it is not in the header file.
- Use refcounting
- Always retain owernship of sinks in this class instead of lower below.
- Never destroy the default receive stream once created.  Instead, just remove
it from the map.


Out of them all, the first looks the best to me right now.  What do you think?

[Taylor Brandstetter, 2016/01/05 18:47:21]

The first solution seems a little fragile. And it means we'd need to have a
"GetSink"/"ReleaseSink" method through all the layers. Personally I don't see
any problem with using a scoped_refptr, other than that it's a little
unintuitive at first glance.

+    }
   }
 
   // Forward packet to Call. If the SSRC is unknown we'll return after this.
   const webrtc::PacketTime webrtc_packet_time(packet_time.timestamp,
                                               packet_time.not_before);
   webrtc::PacketReceiver::DeliveryStatus delivery_result =
       call_->Receiver()->DeliverPacket(webrtc::MediaType::AUDIO,
           reinterpret_cast<const uint8_t*>(packet->data()), packet->size(),
           webrtc_packet_time);
   if (webrtc::PacketReceiver::DELIVERY_OK != delivery_result) {
@@ skipping 209 matching lines @@
   }
 
   return true;
 }
 
 void WebRtcVoiceMediaChannel::SetRawAudioSink(
     uint32_t ssrc,
     rtc::scoped_ptr<webrtc::AudioSinkInterface> sink) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   LOG(LS_VERBOSE) << "WebRtcVoiceMediaChannel::SetRawAudioSink";
+  if (ssrc == 0) {
+    if (default_recv_ssrc_ == -1) {
+      default_sink_ = std::move(sink);
+    } else {
+      SetRawAudioSink(default_recv_ssrc_, std::move(sink));
+    }
+    return;
+  }
   const auto it = recv_streams_.find(ssrc);
   if (it == recv_streams_.end()) {
     LOG(LS_WARNING) << "SetRawAudioSink: no recv stream" << ssrc;
     return;
   }
   it->second->SetRawAudioSink(std::move(sink));
 }
 
 int WebRtcVoiceMediaChannel::GetOutputLevel(int channel) {
   unsigned int ulevel = 0;
@@ skipping 72 matching lines @@
     }
   } else {
     LOG(LS_INFO) << "Stopping playout for channel #" << channel;
     engine()->voe()->base()->StopPlayout(channel);
   }
   return true;
 }
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE