Create AudioSendStreams in WVoE.

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 1295 matching lines @@
 }
 
 void WebRtcVoiceEngine::StopRtcEventLog() {
   voe_wrapper_->codec()->GetEventLog()->StopLogging();
 }
 
 int WebRtcVoiceEngine::CreateVoEChannel() {
   return voe_wrapper_->base()->CreateChannel(voe_config_);
 }
 
-class WebRtcVoiceMediaChannel::WebRtcVoiceChannelRenderer
+class WebRtcVoiceMediaChannel::WebRtcAudioSendStream
     : public AudioRenderer::Sink {
  public:
-  WebRtcVoiceChannelRenderer(int ch,
-                             webrtc::AudioTransport* voe_audio_transport)
+  WebRtcAudioSendStream(int ch, webrtc::AudioTransport* voe_audio_transport,
+                        uint32_t ssrc, webrtc::Call* call)
       : channel_(ch),
         voe_audio_transport_(voe_audio_transport),
-        renderer_(NULL) {}
-  ~WebRtcVoiceChannelRenderer() override { Stop(); }
+        call_(call) {
+    RTC_DCHECK(call);
+    webrtc::AudioSendStream::Config config(nullptr);
+    config.voe_channel_id = channel_;
+    config.rtp.ssrc = ssrc;
+    stream_ = call_->CreateAudioSendStream(config);
+    RTC_DCHECK(stream_);
+  }
+  ~WebRtcAudioSendStream() override {
+    Stop();
+    call_->DestroyAudioSendStream(stream_);
+    call_ = nullptr;
+    stream_ = nullptr;

[kwiberg-webrtc, 2015/10/21 14:04:40]

Setting these to null isn't necessary, is it?

[the sun, 2015/10/21 14:42:24]

No.

+  }
 
   // Starts the rendering by setting a sink to the renderer to get data
   // callback.
   // This method is called on the libjingle worker thread.
   // TODO(xians): Make sure Start() is called only once.
   void Start(AudioRenderer* renderer) {
     rtc::CritScope lock(&lock_);
-    RTC_DCHECK(renderer != NULL);
-    if (renderer_ != NULL) {
+    RTC_DCHECK(renderer != nullptr);
+    if (renderer_ != nullptr) {

[kwiberg-webrtc, 2015/10/21 14:04:40]

Pointers are false iff they're null.

[the sun, 2015/10/21 14:42:24]

Done.

       RTC_DCHECK(renderer_ == renderer);
       return;
     }
     renderer->SetSink(this);
     renderer_ = renderer;
   }
 
-  // Stops rendering by setting the sink of the renderer to NULL. No data
+  // Stops rendering by setting the sink of the renderer to nullptr. No data
   // callback will be received after this method.
   // This method is called on the libjingle worker thread.
   void Stop() {
     rtc::CritScope lock(&lock_);
-    if (renderer_ != NULL) {
-      renderer_->SetSink(NULL);
-      renderer_ = NULL;
+    if (renderer_ != nullptr) {
+      renderer_->SetSink(nullptr);
+      renderer_ = nullptr;
     }
   }
 
   // AudioRenderer::Sink implementation.
   // This method is called on the audio thread.
   void OnData(const void* audio_data,
               int bits_per_sample,
               int sample_rate,
               int number_of_channels,
               size_t number_of_frames) override {
+    RTC_DCHECK(voe_audio_transport_);
     voe_audio_transport_->OnData(channel_,
                                  audio_data,
                                  bits_per_sample,
                                  sample_rate,
                                  number_of_channels,
                                  number_of_frames);
   }
 
   // Callback from the |renderer_| when it is going away. In case Start() has
   // never been called, this callback won't be triggered.
   void OnClose() override {
     rtc::CritScope lock(&lock_);
-    // Set |renderer_| to NULL to make sure no more callback will get into
+    // Set |renderer_| to nullptr to make sure no more callback will get into
     // the renderer.
-    renderer_ = NULL;
+    renderer_ = nullptr;
   }
 
   // Accessor to the VoE channel ID.
   int channel() const { return channel_; }
 
  private:
-  const int channel_;
-  webrtc::AudioTransport* const voe_audio_transport_;
+  const int channel_ = -1;
+  webrtc::AudioTransport* const voe_audio_transport_ = nullptr;
+  webrtc::Call* call_ = nullptr;
+  webrtc::AudioSendStream* stream_ = nullptr;
 
   // Raw pointer to AudioRenderer owned by LocalAudioTrackHandler.
   // PeerConnection will make sure invalidating the pointer before the object
   // goes away.
-  AudioRenderer* renderer_;
+  AudioRenderer* renderer_ = nullptr;
 
   // Protects |renderer_| in Start(), Stop() and OnClose().
   rtc::CriticalSection lock_;
+
+  RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(WebRtcAudioSendStream);
+};
+
+class WebRtcVoiceMediaChannel::WebRtcAudioReceiveStream {
+ public:
+  explicit WebRtcAudioReceiveStream(int voe_channel_id)
+      : channel_(voe_channel_id) {}
+
+  int channel() { return channel_; }
+
+ private:
+  int channel_;
+
+  RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(WebRtcAudioReceiveStream);
 };
 
 // WebRtcVoiceMediaChannel
 WebRtcVoiceMediaChannel::WebRtcVoiceMediaChannel(WebRtcVoiceEngine* engine,
                                                  const AudioOptions& options,
                                                  webrtc::Call* call)
     : engine_(engine),
       send_bitrate_setting_(false),
       send_bitrate_bps_(0),
       options_(),
@@ skipping 10 matching lines @@
   RTC_DCHECK(nullptr != call);
   engine->RegisterChannel(this);
   SetOptions(options);
 }
 
 WebRtcVoiceMediaChannel::~WebRtcVoiceMediaChannel() {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   LOG(LS_VERBOSE) << "WebRtcVoiceMediaChannel::~WebRtcVoiceMediaChannel";
 
   // Remove any remaining send streams.
-  while (!send_channels_.empty()) {
-    RemoveSendStream(send_channels_.begin()->first);
+  while (!send_streams_.empty()) {
+    RemoveSendStream(send_streams_.begin()->first);
   }
 
   // Remove any remaining receive streams.
   while (!receive_channels_.empty()) {
     RemoveRecvStream(receive_channels_.begin()->first);
   }
   RTC_DCHECK(receive_streams_.empty());
 
   // Unregister ourselves from the engine.
   engine()->UnregisterChannel(this);
@@ skipping 42 matching lines @@
 
   if (dscp_option_changed) {
     rtc::DiffServCodePoint dscp = rtc::DSCP_DEFAULT;
     if (options_.dscp.GetWithDefaultIfUnset(false))
       dscp = kAudioDscpValue;
     if (MediaChannel::SetDscp(dscp) != 0) {
       LOG(LS_WARNING) << "Failed to set DSCP settings for audio channel";
     }
   }
 
+  // TODO(solenberg): Don't recreate unless options changed.
   RecreateAudioReceiveStreams();
 
   LOG(LS_INFO) << "Set voice channel options.  Current options: "
                << options_.ToString();
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::SetRecvCodecs(
     const std::vector<AudioCodec>& codecs) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 259 matching lines @@
   dtmf_allowed_ = false;
   for (const AudioCodec& codec : codecs) {
     // Find the DTMF telephone event "codec".
     if (IsCodec(codec, kDtmfCodecName)) {
       dtmf_allowed_ = true;
     }
   }
 
   // Cache the codecs in order to configure the channel created later.
   send_codecs_ = codecs;
-  for (const auto& ch : send_channels_) {
+  for (const auto& ch : send_streams_) {
     if (!SetSendCodecs(ch.second->channel(), codecs)) {
       return false;
     }
   }
 
   // Set nack status on receive channels and update |nack_enabled_|.
   for (const auto& ch : receive_channels_) {
     SetNack(ch.second->channel(), nack_enabled_);
   }
 
@@ skipping 90 matching lines @@
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::SetSendRtpHeaderExtensions(
     const std::vector<RtpHeaderExtension>& extensions) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (send_extensions_ == extensions) {
     return true;
   }
 
-  for (const auto& ch : send_channels_) {
+  for (const auto& ch : send_streams_) {
     if (!SetChannelSendRtpHeaderExtensions(ch.second->channel(), extensions)) {
       return false;
     }
   }
 
   send_extensions_ = extensions;
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::SetChannelSendRtpHeaderExtensions(
@@ skipping 43 matching lines @@
                     << ch.second->channel() << " failed";
       return false;
     }
   }
   playout_ = playout;
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::SetSend(SendFlags send) {
   desired_send_ = send;
-  if (!send_channels_.empty())
+  if (!send_streams_.empty()) {
     return ChangeSend(desired_send_);
+  }
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::PauseSend() {
   return ChangeSend(SEND_NOTHING);
 }
 
 bool WebRtcVoiceMediaChannel::ResumeSend() {
   return ChangeSend(desired_send_);
 }
 
 bool WebRtcVoiceMediaChannel::ChangeSend(SendFlags send) {
   if (send_ == send) {
     return true;
   }
 
   // Apply channel specific options.
   if (send == SEND_MICROPHONE) {
     engine()->ApplyOptions(options_);
   }
 
   // Change the settings on each send channel.
-  for (const auto& ch : send_channels_) {
+  for (const auto& ch : send_streams_) {
     if (!ChangeSend(ch.second->channel(), send)) {
       return false;
     }
   }
 
   // Clear up the options after stopping sending. Since we may previously have
   // applied the channel specific options, now apply the original options stored
   // in WebRtcVoiceEngine.
   if (send == SEND_NOTHING) {
     engine()->ApplyOptions(engine()->GetOptions());
@@ skipping 95 matching lines @@
     DeleteChannel(channel);
     return false;
   }
 
   if (engine()->voe()->rtp()->SetRTCP_CNAME(channel, sp.cname.c_str()) == -1) {
     LOG_RTCERR2(SetRTCP_CNAME, channel, sp.cname);
     DeleteChannel(channel);
     return false;
   }
 
-  // Save the channel to send_channels_, so that RemoveSendStream() can still
+  // Save the channel to send_streams_, so that RemoveSendStream() can still
   // delete the channel in case failure happens below.
   webrtc::AudioTransport* audio_transport =
       engine()->voe()->base()->audio_transport();
-  send_channels_.insert(
+  send_streams_.insert(
       std::make_pair(ssrc,
-                     new WebRtcVoiceChannelRenderer(channel, audio_transport)));
+          new WebRtcAudioSendStream(channel, audio_transport, ssrc, call_)));
 
   // Set the current codecs to be used for the new channel. We need to do this
   // after adding the channel to send_channels_, because of how max bitrate is
   // currently being configured by SetSendCodec().
   if (!send_codecs_.empty() && !SetSendCodecs(channel, send_codecs_)) {
     RemoveSendStream(ssrc);
     return false;
   }
 
   // At this point the channel's local SSRC has been updated. If the channel is
   // the first send channel make sure that all the receive channels are updated
   // with the same SSRC in order to send receiver reports.
-  if (send_channels_.size() == 1) {
+  if (send_streams_.size() == 1) {
     receiver_reports_ssrc_ = ssrc;
     for (const auto& ch : receive_channels_) {
       int recv_channel = ch.second->channel();
       if (engine()->voe()->rtp()->SetLocalSSRC(recv_channel, ssrc) != 0) {
         LOG_RTCERR2(SetLocalSSRC, ch.second->channel(), ssrc);
         return false;
       }
       engine()->voe()->base()->AssociateSendChannel(recv_channel, channel);
       LOG(LS_INFO) << "VoiceEngine channel #" << recv_channel
                    << " is associated with channel #" << channel << ".";
     }
   }
 
   return ChangeSend(channel, desired_send_);
 }
 
 bool WebRtcVoiceMediaChannel::RemoveSendStream(uint32_t ssrc) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  ChannelMap::iterator it = send_channels_.find(ssrc);
-  if (it == send_channels_.end()) {
+  auto it = send_streams_.find(ssrc);
+  if (it == send_streams_.end()) {
     LOG(LS_WARNING) << "Try to remove stream with ssrc " << ssrc
                     << " which doesn't exist.";
     return false;
   }
 
   int channel = it->second->channel();
   ChangeSend(channel, SEND_NOTHING);
 
   // Delete the WebRtcVoiceChannelRenderer object connected to the channel,
   // this will disconnect the audio renderer with the send channel.
   delete it->second;
-  send_channels_.erase(it);
+  send_streams_.erase(it);
 
   // Clean up and delete the send channel.
   LOG(LS_INFO) << "Removing audio send stream " << ssrc
                << " with VoiceEngine channel #" << channel << ".";
   if (!DeleteChannel(channel)) {
     return false;
   }
-  if (send_channels_.empty()) {
+  if (send_streams_.empty()) {
     ChangeSend(SEND_NOTHING);
   }
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::AddRecvStream(const StreamParams& sp) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   LOG(LS_INFO) << "AddRecvStream: " << sp.ToString();
 
   if (!ValidateStreamParams(sp)) {
@@ skipping 21 matching lines @@
   // Create a new channel for receiving audio data.
   int channel = CreateVoEChannel();
   if (channel == -1) {
     return false;
   }
   if (!ConfigureRecvChannel(channel)) {
     DeleteChannel(channel);
     return false;
   }
 
-  webrtc::AudioTransport* audio_transport =
-      engine()->voe()->base()->audio_transport();
-  WebRtcVoiceChannelRenderer* channel_renderer =
-      new WebRtcVoiceChannelRenderer(channel, audio_transport);
-  receive_channels_.insert(std::make_pair(ssrc, channel_renderer));
+  WebRtcAudioReceiveStream* stream = new WebRtcAudioReceiveStream(channel);
+  receive_channels_.insert(std::make_pair(ssrc, stream));
   receive_stream_params_[ssrc] = sp;
   AddAudioReceiveStream(ssrc);
 
   LOG(LS_INFO) << "New audio stream " << ssrc
                << " registered to VoiceEngine channel #"
                << channel << ".";
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::ConfigureRecvChannel(int channel) {
@@ skipping 48 matching lines @@
   }
 
   SetPlayout(channel, playout_);
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::RemoveRecvStream(uint32_t ssrc) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   LOG(LS_INFO) << "RemoveRecvStream: " << ssrc;
 
-  ChannelMap::iterator it = receive_channels_.find(ssrc);
+  auto it = receive_channels_.find(ssrc);
   if (it == receive_channels_.end()) {
     LOG(LS_WARNING) << "Try to remove stream with ssrc " << ssrc
                     << " which doesn't exist.";
     return false;
   }
 
   RemoveAudioReceiveStream(ssrc);
   receive_stream_params_.erase(ssrc);
 
-  // Delete the WebRtcVoiceChannelRenderer object connected to the channel, this
-  // will disconnect the audio renderer with the receive channel.
-  // Cache the channel before the deletion.
   const int channel = it->second->channel();
   delete it->second;
   receive_channels_.erase(it);
 
   // Deregister default channel, if that's the one being destroyed.
   if (IsDefaultRecvStream(ssrc)) {
     default_recv_ssrc_ = -1;
   }
 
   LOG(LS_INFO) << "Removing audio stream " << ssrc
                << " with VoiceEngine channel #" << channel << ".";
   return DeleteChannel(channel);
 }
 
 bool WebRtcVoiceMediaChannel::SetLocalRenderer(uint32_t ssrc,
                                                AudioRenderer* renderer) {
-  ChannelMap::iterator it = send_channels_.find(ssrc);
-  if (it == send_channels_.end()) {
+  auto it = send_streams_.find(ssrc);
+  if (it == send_streams_.end()) {
     if (renderer) {
       // Return an error if trying to set a valid renderer with an invalid ssrc.
       LOG(LS_ERROR) << "SetLocalRenderer failed with ssrc "<< ssrc;
       return false;
     }
 
     // The channel likely has gone away, do nothing.
     return true;
   }
 
@@ skipping 88 matching lines @@
                                          int flags) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (!dtmf_allowed_) {
     return false;
   }
 
   // Send the event.
   if (flags & cricket::DF_SEND) {
     int channel = -1;
     if (ssrc == 0) {
-      if (send_channels_.size() > 0) {
-        channel = send_channels_.begin()->second->channel();
+      if (send_streams_.size() > 0) {
+        channel = send_streams_.begin()->second->channel();
       }
     } else {
       channel = GetSendChannelId(ssrc);
     }
     if (channel == -1) {
       LOG(LS_WARNING) << "InsertDtmf - The specified ssrc "
                       << ssrc << " is not in use.";
       return false;
     }
     // Send DTMF using out-of-band DTMF. ("true", as 3rd arg)
@@ skipping 89 matching lines @@
     int recv_channel_id = GetReceiveChannelId(ssrc);
     if (recv_channel_id != -1) {
       engine()->voe()->network()->ReceivedRTCPPacket(
           recv_channel_id, packet->data(), packet->size());
     }
   }
 
   // SR may continue RR and any RR entry may correspond to any one of the send
   // channels. So all RTCP packets must be forwarded all send channels. VoE
   // will filter out RR internally.
-  for (const auto& ch : send_channels_) {
+  for (const auto& ch : send_streams_) {
     engine()->voe()->network()->ReceivedRTCPPacket(
         ch.second->channel(), packet->data(), packet->size());
   }
 }
 
 bool WebRtcVoiceMediaChannel::MuteStream(uint32_t ssrc, bool muted) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   int channel = GetSendChannelId(ssrc);
   if (channel == -1) {
     LOG(LS_WARNING) << "The specified ssrc " << ssrc << " is not in use.";
     return false;
   }
   if (engine()->voe()->volume()->SetInputMute(channel, muted) == -1) {
     LOG_RTCERR2(SetInputMute, channel, muted);
     return false;
   }
   // We set the AGC to mute state only when all the channels are muted.
   // This implementation is not ideal, instead we should signal the AGC when
   // the mic channel is muted/unmuted. We can't do it today because there
   // is no good way to know which stream is mapping to the mic channel.
   bool all_muted = muted;
-  for (const auto& ch : send_channels_) {
+  for (const auto& ch : send_streams_) {
     if (!all_muted) {
       break;
     }
     if (engine()->voe()->volume()->GetInputMute(ch.second->channel(),
                                                 all_muted)) {
       LOG_RTCERR1(GetInputMute, ch.second->channel());
       return false;
     }
   }
 
@@ skipping 28 matching lines @@
   // SetMaxSendBandwith(0), the second call removes the previous limit.
   if (bps <= 0)
     return true;
 
   webrtc::CodecInst codec = *send_codec_;
   bool is_multi_rate = IsCodecMultiRate(codec);
 
   if (is_multi_rate) {
     // If codec is multi-rate then just set the bitrate.
     codec.rate = bps;
-    for (const auto& ch : send_channels_) {
+    for (const auto& ch : send_streams_) {
       if (!SetSendCodec(ch.second->channel(), codec)) {
         LOG(LS_INFO) << "Failed to set codec " << codec.plname
                      << " to bitrate " << bps << " bps.";
         return false;
       }
     }
     return true;
   } else {
     // If codec is not multi-rate and |bps| is less than the fixed bitrate
     // then fail. If codec is not multi-rate and |bps| exceeds or equal the
@@ skipping 39 matching lines @@
       echo_delay_median_ms = median;
       echo_delay_std_ms = std;
     }
   }
 
   webrtc::CallStatistics cs;
   unsigned int ssrc;
   webrtc::CodecInst codec;
   unsigned int level;
 
-  for (const auto& ch : send_channels_) {
+  for (const auto& ch : send_streams_) {
     const int channel = ch.second->channel();
 
     // Fill in the sender info, based on what we know, and what the
     // remote side told us it got from its RTCP report.
     VoiceSenderInfo sinfo;
 
     if (engine()->voe()->rtp()->GetRTCPStatistics(channel, cs) == -1 ||
         engine()->voe()->rtp()->GetLocalSSRC(channel, ssrc) == -1) {
       continue;
     }
@@ skipping 140 matching lines @@
 }
 
 int WebRtcVoiceMediaChannel::GetOutputLevel(int channel) {
   unsigned int ulevel = 0;
   int ret = engine()->voe()->volume()->GetSpeechOutputLevel(channel, ulevel);
   return (ret == 0) ? static_cast<int>(ulevel) : -1;
 }
 
 int WebRtcVoiceMediaChannel::GetReceiveChannelId(uint32_t ssrc) const {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  ChannelMap::const_iterator it = receive_channels_.find(ssrc);
+  const auto it = receive_channels_.find(ssrc);
   if (it != receive_channels_.end()) {
     return it->second->channel();
   }
   return -1;
 }
 
 int WebRtcVoiceMediaChannel::GetSendChannelId(uint32_t ssrc) const {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  ChannelMap::const_iterator it = send_channels_.find(ssrc);
-  if (it != send_channels_.end()) {
+  const auto it = send_streams_.find(ssrc);
+  if (it != send_streams_.end()) {
     return it->second->channel();
   }
   return -1;
 }
 
 bool WebRtcVoiceMediaChannel::GetRedSendCodec(const AudioCodec& red_codec,
     const std::vector<AudioCodec>& all_codecs, webrtc::CodecInst* send_codec) {
   // Get the RED encodings from the parameter with no name. This may
   // change based on what is discussed on the Jingle list.
   // The encoding parameter is of the form "a/b"; we only support where
@@ skipping 105 matching lines @@
   for (const auto& it : receive_channels_) {
     RemoveAudioReceiveStream(it.first);
   }
   for (const auto& it : receive_channels_) {
     AddAudioReceiveStream(it.first);
   }
 }
 
 void WebRtcVoiceMediaChannel::AddAudioReceiveStream(uint32_t ssrc) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  WebRtcVoiceChannelRenderer* channel = receive_channels_[ssrc];
-  RTC_DCHECK(channel != nullptr);
+  WebRtcAudioReceiveStream* stream = receive_channels_[ssrc];
+  RTC_DCHECK(stream != nullptr);
   RTC_DCHECK(receive_streams_.find(ssrc) == receive_streams_.end());
   webrtc::AudioReceiveStream::Config config;
   config.rtp.remote_ssrc = ssrc;
   // Only add RTP extensions if we support combined A/V BWE.
   config.rtp.extensions = recv_rtp_extensions_;
   config.combined_audio_video_bwe =
       options_.combined_audio_video_bwe.GetWithDefaultIfUnset(false);
-  config.voe_channel_id = channel->channel();
+  config.voe_channel_id = stream->channel();
   config.sync_group = receive_stream_params_[ssrc].sync_label;
   webrtc::AudioReceiveStream* s = call_->CreateAudioReceiveStream(config);
   receive_streams_.insert(std::make_pair(ssrc, s));
 }
 
 void WebRtcVoiceMediaChannel::RemoveAudioReceiveStream(uint32_t ssrc) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   auto stream_it = receive_streams_.find(ssrc);
   if (stream_it != receive_streams_.end()) {
     call_->DestroyAudioReceiveStream(stream_it->second);
@@ skipping 21 matching lines @@
       LOG(LS_WARNING) << "Unknown codec " << ToString(codec);
       return false;
     }
   }
   return true;
 }
 
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE