Remove default receive channel from WVoE; baby step 2.

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 1372 matching lines @@
 
   // Protects |renderer_| in Start(), Stop() and OnClose().
   rtc::CriticalSection lock_;
 };
 
 // WebRtcVoiceMediaChannel
 WebRtcVoiceMediaChannel::WebRtcVoiceMediaChannel(WebRtcVoiceEngine* engine,
                                                  const AudioOptions& options,
                                                  webrtc::Call* call)
     : engine_(engine),
-      voe_channel_(engine->CreateMediaVoiceChannel()),
+      default_send_channel_id_(engine->CreateMediaVoiceChannel()),
       send_bitrate_setting_(false),
       send_bitrate_bps_(0),
       options_(),
       dtmf_allowed_(false),
       desired_playout_(false),
       nack_enabled_(false),
       playout_(false),
       typing_noise_detected_(false),
       desired_send_(SEND_NOTHING),
       send_(SEND_NOTHING),
       call_(call),
       default_receive_ssrc_(0) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   engine->RegisterChannel(this);
   LOG(LS_VERBOSE) << "WebRtcVoiceMediaChannel::WebRtcVoiceMediaChannel "
-                  << voe_channel();
+                  << default_send_channel_id();
   RTC_DCHECK(nullptr != call);
-  ConfigureSendChannel(voe_channel());
+  ConfigureSendChannel(default_send_channel_id());
   SetOptions(options);
 }
 
 WebRtcVoiceMediaChannel::~WebRtcVoiceMediaChannel() {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   LOG(LS_VERBOSE) << "WebRtcVoiceMediaChannel::~WebRtcVoiceMediaChannel "
-                  << voe_channel();
+                  << default_send_channel_id();
 
   // Remove any remaining send streams, the default channel will be deleted
   // later.
   while (!send_channels_.empty()) {
     RemoveSendStream(send_channels_.begin()->first);
   }
 
   // Unregister ourselves from the engine.
   engine()->UnregisterChannel(this);
 
   // Remove any remaining streams.
   while (!receive_channels_.empty()) {
     RemoveRecvStream(receive_channels_.begin()->first);
   }
   RTC_DCHECK(receive_streams_.empty());
 
   // Delete the default channel.
-  DeleteChannel(voe_channel());
+  DeleteChannel(default_send_channel_id());
 }
 
 bool WebRtcVoiceMediaChannel::SetSendParameters(
     const AudioSendParameters& params) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   // TODO(pthatcher): Refactor this to be more clean now that we have
   // all the information at once.
   return (SetSendCodecs(params.codecs) &&
           SetSendRtpHeaderExtensions(params.extensions) &&
           SetMaxSendBandwidth(params.max_bandwidth_bps) &&
@@ skipping 31 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";
     }
   }
+
   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());
+
   // Set the payload types to be used for incoming media.
   LOG(LS_INFO) << "Setting receive voice codecs.";
-  RTC_DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!VerifyUniquePayloadTypes(codecs)) {
     LOG(LS_ERROR) << "Codec payload types overlap.";
     return false;
   }
 
   std::vector<AudioCodec> new_codecs;
   // Find all new codecs. We allow adding new codecs but don't allow changing
   // the payload type of codecs that is already configured since we might
   // already be receiving packets with that payload type.
@@ skipping 314 matching lines @@
 
 bool WebRtcVoiceMediaChannel::SetRecvRtpHeaderExtensions(
     const std::vector<RtpHeaderExtension>& extensions) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (receive_extensions_ == extensions) {
     return true;
   }
 
   // The default channel may or may not be in |receive_channels_|. Set the rtp
   // header extensions for default channel regardless.
-  if (!SetChannelRecvRtpHeaderExtensions(voe_channel(), extensions)) {
+  if (!SetChannelRecvRtpHeaderExtensions(default_send_channel_id(),
+                                         extensions)) {
     return false;
   }
 
   // Loop through all receive channels and enable/disable the extensions.
   for (const auto& ch : receive_channels_) {
     if (!SetChannelRecvRtpHeaderExtensions(ch.second->channel(), extensions)) {
       return false;
     }
   }
 
@@ skipping 48 matching lines @@
 bool WebRtcVoiceMediaChannel::SetSendRtpHeaderExtensions(
     const std::vector<RtpHeaderExtension>& extensions) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (send_extensions_ == extensions) {
     return true;
   }
 
   // The default channel may or may not be in |send_channels_|. Set the rtp
   // header extensions for default channel regardless.
 
-  if (!SetChannelSendRtpHeaderExtensions(voe_channel(), extensions)) {
+  if (!SetChannelSendRtpHeaderExtensions(default_send_channel_id(),
+                                         extensions)) {
     return false;
   }
 
   // Loop through all send channels and enable/disable the extensions.
   for (const auto& ch : send_channels_) {
     if (!SetChannelSendRtpHeaderExtensions(ch.second->channel(), extensions)) {
       return false;
     }
   }
 
@@ skipping 39 matching lines @@
 bool WebRtcVoiceMediaChannel::ChangePlayout(bool playout) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (playout_ == playout) {
     return true;
   }
 
   // Change the playout of all channels to the new state.
   bool result = true;
   if (receive_channels_.empty()) {
     // Only toggle the default channel if we don't have any other channels.
-    result = SetPlayout(voe_channel(), playout);
+    result = SetPlayout(default_send_channel_id(), playout);
   }
   for (const auto& ch : receive_channels_) {
     if (!SetPlayout(ch.second->channel(), playout)) {
       LOG(LS_ERROR) << "SetPlayout " << playout << " on channel "
                     << ch.second->channel() << " failed";
       result = false;
       break;
     }
   }
 
@@ skipping 123 matching lines @@
   }
 
   bool default_channel_is_available = true;
   for (const auto& ch : send_channels_) {
     if (IsDefaultChannel(ch.second->channel())) {
       default_channel_is_available = false;
       break;
     }
   }
   if (default_channel_is_available) {
-    channel = voe_channel();
+    channel = default_send_channel_id();
   } else {
     // Create a new channel for sending audio data.
     channel = engine()->CreateMediaVoiceChannel();
     if (channel == -1) {
       LOG_RTCERR0(CreateChannel);
       return false;
     }
 
     ConfigureSendChannel(channel);
   }
@@ skipping 102 matching lines @@
   RTC_DCHECK(receive_stream_params_.find(ssrc) == receive_stream_params_.end());
 
   // Reuse default channel for recv stream in non-conference mode call
   // when the default channel is not being used.
   webrtc::AudioTransport* audio_transport =
       engine()->voe()->base()->audio_transport();
   if (!InConferenceMode() && default_receive_ssrc_ == 0) {
     LOG(LS_INFO) << "Recv stream " << ssrc << " reuse default channel";
     default_receive_ssrc_ = ssrc;
     WebRtcVoiceChannelRenderer* channel_renderer =
-        new WebRtcVoiceChannelRenderer(voe_channel(), audio_transport);
+        new WebRtcVoiceChannelRenderer(default_send_channel_id(),
+                                       audio_transport);
     receive_channels_.insert(std::make_pair(ssrc, channel_renderer));
     receive_stream_params_[ssrc] = sp;
     AddAudioReceiveStream(ssrc);
-    return SetPlayout(voe_channel(), playout_);
+    return SetPlayout(default_send_channel_id(), playout_);
   }
 
   // Create a new channel for receiving audio data.
   int channel = engine()->CreateMediaVoiceChannel();
   if (channel == -1) {
     LOG_RTCERR0(CreateChannel);
     return false;
   }
-
   if (!ConfigureRecvChannel(channel)) {
     DeleteChannel(channel);
     return false;
   }
 
   WebRtcVoiceChannelRenderer* channel_renderer =
       new WebRtcVoiceChannelRenderer(channel, audio_transport);
   receive_channels_.insert(std::make_pair(ssrc, channel_renderer));
   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) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  // Configure to use external transport, like our default channel.
+  // Configure to use external transport.
   if (engine()->voe()->network()->RegisterExternalTransport(
           channel, *this) == -1) {
     LOG_RTCERR2(SetExternalTransport, channel, this);
     return false;
   }
 
-  // Use the same SSRC as our default channel (so the RTCP reports are correct).
+  // Use the same SSRC as our default send channel, so the RTCP reports are
+  // correct.
   unsigned int send_ssrc = 0;
   webrtc::VoERTP_RTCP* rtp = engine()->voe()->rtp();
-  if (rtp->GetLocalSSRC(voe_channel(), send_ssrc) == -1) {
+  if (rtp->GetLocalSSRC(default_send_channel_id(), send_ssrc) == -1) {
     LOG_RTCERR1(GetSendSSRC, channel);
     return false;
   }
   if (rtp->SetLocalSSRC(channel, send_ssrc) == -1) {
     LOG_RTCERR1(SetSendSSRC, channel);
     return false;
   }
 
-  // Associate receive channel to default channel (so the receive channel can
-  // obtain RTT from the send channel)
-  engine()->voe()->base()->AssociateSendChannel(channel, voe_channel());
+  // Associate receive channel to default send channel (so the receive channel
+  // can obtain RTT from the send channel).
+  engine()->voe()->base()->AssociateSendChannel(channel,
+                                                default_send_channel_id());
   LOG(LS_INFO) << "VoiceEngine channel #"
                << channel << " is associated with channel #"
-               << voe_channel() << ".";
+               << default_send_channel_id() << ".";
 
   // Use the same recv payload types as our default channel.
   ResetRecvCodecs(channel);
   if (!recv_codecs_.empty()) {
     for (const auto& codec : recv_codecs_) {
       webrtc::CodecInst voe_codec;
       if (engine()->FindWebRtcCodec(codec, &voe_codec)) {
         voe_codec.pltype = codec.id;
         voe_codec.rate = 0;  // Needed to make GetRecPayloadType work for ISAC
         if (engine()->voe()->codec()->GetRecPayloadType(
-            voe_channel(), voe_codec) != -1) {
+            default_send_channel_id(), voe_codec) != -1) {
           if (engine()->voe()->codec()->SetRecPayloadType(
               channel, voe_codec) == -1) {
             LOG_RTCERR2(SetRecPayloadType, channel, ToString(voe_codec));
             return false;
           }
         }
       }
     }
   }
 
   if (InConferenceMode()) {
-    // To be in par with the video, voe_channel() is not used for receiving in
-    // a conference call.
+    // To be in par with the video, default_send_channel_id() is not used for
+    // receiving in a conference call.
     if (receive_channels_.empty() && default_receive_ssrc_ == 0 && playout_) {
       // This is the first stream in a multi user meeting. We can now
       // disable playback of the default stream. This since the default
       // stream will probably have received some initial packets before
       // the new stream was added. This will mean that the CN state from
       // the default channel will be mixed in with the other streams
       // throughout the whole meeting, which might be disturbing.
       LOG(LS_INFO) << "Disabling playback on the default voice channel";
-      SetPlayout(voe_channel(), false);
+      SetPlayout(default_send_channel_id(), false);
     }
   }
+
   SetNack(channel, nack_enabled_);
 
   // Set RTP header extension for the new channel.
   if (!SetChannelRecvRtpHeaderExtensions(channel, receive_extensions_)) {
     return false;
   }
 
   return SetPlayout(channel, playout_);
 }
 
@@ skipping 16 matching lines @@
   // 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);
 
   if (ssrc == default_receive_ssrc_) {
     RTC_DCHECK(IsDefaultChannel(channel));
     // Recycle the default channel is for recv stream.
     if (playout_)
-      SetPlayout(voe_channel(), false);
+      SetPlayout(default_send_channel_id(), false);
 
     default_receive_ssrc_ = 0;
     return true;
   }
 
   LOG(LS_INFO) << "Removing audio stream " << ssrc
                << " with VoiceEngine channel #" << channel << ".";
   if (!DeleteChannel(channel))
     return false;
 
   bool enable_default_channel_playout = false;
   if (receive_channels_.empty()) {
     // The last stream was removed. We can now enable the default
     // channel for new channels to be played out immediately without
     // waiting for AddStream messages.
     // We do this for both conference mode and non-conference mode.
     // TODO(oja): Does the default channel still have it's CN state?
     enable_default_channel_playout = true;
   }
   if (!InConferenceMode() && receive_channels_.size() == 1 &&
       default_receive_ssrc_ != 0) {
     // Only the default channel is active, enable the playout on default
     // channel.
     enable_default_channel_playout = true;
   }
   if (enable_default_channel_playout && playout_) {
     LOG(LS_INFO) << "Enabling playback on the default voice channel";
-    SetPlayout(voe_channel(), true);
+    SetPlayout(default_send_channel_id(), true);
   }
 
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::SetLocalRenderer(uint32_t ssrc,
                                                AudioRenderer* renderer) {
   ChannelMap::iterator it = send_channels_.find(ssrc);
   if (it == send_channels_.end()) {
     if (renderer) {
@@ skipping 25 matching lines @@
     if (level > 0) {
       actives->push_back(std::make_pair(ch.first, level));
     }
   }
   return true;
 }
 
 int WebRtcVoiceMediaChannel::GetOutputLevel() {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   // return the highest output level of all streams
-  int highest = GetOutputLevel(voe_channel());
+  int highest = GetOutputLevel(default_send_channel_id());
   for (const auto& ch : receive_channels_) {
-    int level = GetOutputLevel(ch.second->channel());
-    highest = std::max(level, highest);
+    highest = std::max(GetOutputLevel(ch.second->channel()), highest);
   }
   return highest;
 }
 
 int WebRtcVoiceMediaChannel::GetTimeSinceLastTyping() {
   int ret;
   if (engine()->voe()->processing()->TimeSinceLastTyping(ret) == -1) {
     // In case of error, log the info and continue
     LOG_RTCERR0(TimeSinceLastTyping);
     ret = -1;
@@ skipping 18 matching lines @@
 
 bool WebRtcVoiceMediaChannel::SetOutputVolume(uint32_t ssrc, double volume) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   rtc::CritScope lock(&receive_channels_cs_);
   // Collect the channels to scale the output volume.
   std::vector<int> channels;
   if (0 == ssrc) {  // Collect all channels, including the default one.
     // Default channel is not in receive_channels_ if it is not being used for
     // playout.
     if (default_receive_ssrc_ == 0)
-      channels.push_back(voe_channel());
+      channels.push_back(default_send_channel_id());
     for (const auto& ch : receive_channels_) {
       channels.push_back(ch.second->channel());
     }
   } else {  // Collect only the channel of the specified ssrc.
     int channel = GetReceiveChannelId(ssrc);
     if (-1 == channel) {
       LOG(LS_WARNING) << "Cannot find channel for ssrc:" << ssrc;
       return false;
     }
     channels.push_back(channel);
@@ skipping 28 matching lines @@
     int channel = -1;
     if (ssrc == 0) {
       bool default_channel_is_inuse = false;
       for (const auto& ch : send_channels_) {
         if (IsDefaultChannel(ch.second->channel())) {
           default_channel_is_inuse = true;
           break;
         }
       }
       if (default_channel_is_inuse) {
-        channel = voe_channel();
+        channel = default_send_channel_id();
       } else if (!send_channels_.empty()) {
         channel = send_channels_.begin()->second->channel();
       }
     } else {
       channel = GetSendChannelId(ssrc);
     }
     if (channel == -1) {
       LOG(LS_WARNING) << "InsertDtmf - The specified ssrc "
                       << ssrc << " is not in use.";
       return false;
@@ skipping 28 matching lines @@
   call_->Receiver()->DeliverPacket(webrtc::MediaType::AUDIO,
       reinterpret_cast<const uint8_t*>(packet->data()), packet->size(),
       webrtc_packet_time);
 
   // Pick which channel to send this packet to. If this packet doesn't match
   // any multiplexed streams, just send it to the default channel. Otherwise,
   // send it to the specific decoder instance for that stream.
   int which_channel =
       GetReceiveChannelId(ParseSsrc(packet->data(), packet->size(), false));
   if (which_channel == -1) {
-    which_channel = voe_channel();
+    which_channel = default_send_channel_id();
   }
 
   // Pass it off to the decoder.
   engine()->voe()->network()->ReceivedRTPPacket(
       which_channel, packet->data(), packet->size(),
       webrtc::PacketTime(packet_time.timestamp, packet_time.not_before));
 }
 
 void WebRtcVoiceMediaChannel::OnRtcpReceived(
     rtc::Buffer* packet, const rtc::PacketTime& packet_time) {
@@ skipping 41 matching lines @@
     if (IsDefaultChannel(ch.second->channel()) &&
         has_sent_to_default_channel)
       continue;
 
     engine()->voe()->network()->ReceivedRTCPPacket(
         ch.second->channel(), packet->data(), packet->size());
   }
 }
 
 bool WebRtcVoiceMediaChannel::MuteStream(uint32_t ssrc, bool muted) {
-  int channel = (ssrc == 0) ? voe_channel() : GetSendChannelId(ssrc);
+  int channel =
+      (ssrc == 0) ? default_send_channel_id() : 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
@@ skipping 173 matching lines @@
     info->senders.push_back(sinfo);
   }
 
   // Build the list of receivers, one for each receiving channel, or 1 in
   // a 1:1 call.
   std::vector<int> channels;
   for (const auto& ch : receive_channels_) {
     channels.push_back(ch.second->channel());
   }
   if (channels.empty()) {
-    channels.push_back(voe_channel());
+    channels.push_back(default_send_channel_id());
   }
 
   // Get the SSRC and stats for each receiver, based on our own calculations.
   for (int ch_id : channels) {
     memset(&cs, 0, sizeof(cs));
     if (engine()->voe()->rtp()->GetRemoteSSRC(ch_id, ssrc) != -1 &&
         engine()->voe()->rtp()->GetRTCPStatistics(ch_id, cs) != -1 &&
         engine()->voe()->codec()->GetRecCodec(ch_id, codec) != -1) {
       VoiceReceiverInfo rinfo;
       rinfo.add_ssrc(ssrc);
@@ skipping 77 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);
-  if (it != receive_channels_.end())
+  if (it != receive_channels_.end()) {
     return it->second->channel();
-  return (ssrc == default_receive_ssrc_) ? voe_channel() : -1;
+  }
+  return (ssrc == default_receive_ssrc_) ? default_send_channel_id() : -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())
+  if (it != send_channels_.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
   // a == b. Verify this and parse out the value into red_pt.
   // If the parameter value is absent (as it will be until we wire up the
@@ skipping 34 matching lines @@
   return false;
 }
 
 bool WebRtcVoiceMediaChannel::EnableRtcp(int channel) {
   if (engine()->voe()->rtp()->SetRTCPStatus(channel, true) == -1) {
     LOG_RTCERR2(SetRTCPStatus, channel, 1);
     return false;
   }
   // TODO(juberti): Enable VQMon and RTCP XR reports, once we know what
   // what we want to do with them.
-  // engine()->voe().EnableVQMon(voe_channel(), true);
-  // engine()->voe().EnableRTCP_XR(voe_channel(), true);
+  // engine()->voe().EnableVQMon(default_send_channel_id(), true);
+  // engine()->voe().EnableRTCP_XR(default_send_channel_id(), true);
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::ResetRecvCodecs(int channel) {
   int ncodecs = engine()->voe()->codec()->NumOfCodecs();
   for (int i = 0; i < ncodecs; ++i) {
     webrtc::CodecInst voe_codec;
     if (engine()->voe()->codec()->GetCodec(i, voe_codec) != -1) {
       voe_codec.pltype = -1;
       if (engine()->voe()->codec()->SetRecPayloadType(
@@ skipping 126 matching lines @@
       LOG(LS_INFO) << ToString(codec);
       voe_codec.pltype = codec.id;
       if (default_receive_ssrc_ == 0) {
         // Set the receive codecs on the default channel explicitly if the
         // default channel is not used by |receive_channels_|, this happens in
         // conference mode or in non-conference mode when there is no playout
         // channel.
         // TODO(xians): Figure out how we use the default channel in conference
         // mode.
         if (engine()->voe()->codec()->SetRecPayloadType(
-            voe_channel(), voe_codec) == -1) {
-          LOG_RTCERR2(SetRecPayloadType, voe_channel(), ToString(voe_codec));
+            default_send_channel_id(), voe_codec) == -1) {
+          LOG_RTCERR2(SetRecPayloadType, default_send_channel_id(),
+                      ToString(voe_codec));
           return false;
         }
       }
 
       // Set the receive codecs on all receiving channels.
       for (const auto& ch : receive_channels_) {
         if (engine()->voe()->codec()->SetRecPayloadType(
                 ch.second->channel(), voe_codec) == -1) {
           LOG_RTCERR2(SetRecPayloadType, ch.second->channel(),
                       ToString(voe_codec));
           return false;
         }
       }
     } else {
       LOG(LS_WARNING) << "Unknown codec " << ToString(codec);
       return false;
     }
   }
   return true;
 }
 
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE