Add send-side BWE to WebRtcVoiceEngine under a finch experiment.

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 186 matching lines @@
   }
   std::vector<int> payload_types;
   for (const AudioCodec& codec : codecs) {
     payload_types.push_back(codec.id);
   }
   std::sort(payload_types.begin(), payload_types.end());
   auto it = std::unique(payload_types.begin(), payload_types.end());
   return it == payload_types.end();
 }
 
-bool IsNackEnabled(const AudioCodec& codec) {
-  return codec.HasFeedbackParam(FeedbackParam(kRtcpFbParamNack,
-                                              kParamValueEmpty));
-}
-
 // Return true if codec.params[feature] == "1", false otherwise.
 bool IsCodecFeatureEnabled(const AudioCodec& codec, const char* feature) {
   int value;
   return codec.GetParam(feature, &value) && value == 1;
 }
 
 // Use params[kCodecParamMaxAverageBitrate] if it is defined, use codec.bitrate
 // otherwise. If the value (either from params or codec.bitrate) <=0, use the
 // default configuration. If the value is beyond feasible bit rate of Opus,
 // clamp it. Returns the Opus bit rate for operation.
@@ skipping 102 matching lines @@
           // Only add fmtp parameters that differ from the spec.
           if (kPreferredMinPTime != kOpusDefaultMinPTime) {
             codec.params[kCodecParamMinPTime] =
                 rtc::ToString(kPreferredMinPTime);
           }
           if (kPreferredMaxPTime != kOpusDefaultMaxPTime) {
             codec.params[kCodecParamMaxPTime] =
                 rtc::ToString(kPreferredMaxPTime);
           }
           codec.SetParam(kCodecParamUseInbandFec, 1);
+          codec.AddFeedbackParam(
+              FeedbackParam(kRtcpFbParamTransportCc, kParamValueEmpty));
 
           // TODO(hellner): Add ptime, sprop-stereo, and stereo
           // when they can be set to values other than the default.
         }
         result.push_back(codec);
       } else {
         LOG(LS_WARNING) << "Unexpected codec: " << ToString(voe_codec);
       }
     }
     // Make sure they are in local preference order.
@@ skipping 64 matching lines @@
         if (packet_size_ms) {
           // Convert unit from milli-seconds to samples.
           codec->pacsize = (codec->plfreq / 1000) * packet_size_ms;
           return true;
         }
       }
     }
     return false;
   }
 
+  static const AudioCodec* GetPreferredCodec(
+      const std::vector<AudioCodec>& codecs,
+      webrtc::CodecInst* voe_codec,
+      int* red_payload_type) {
+    // Set send codec (the first non-telephone-event/CN codec)
+    for (const AudioCodec& codec : codecs) {
+      *red_payload_type = -1;
+      if (IsCodec(codec, kDtmfCodecName) || IsCodec(codec, kCnCodecName)) {
+        // Skip telephone-event/CN codec, which will be handled later.
+        continue;
+      }
+
+      // We'll use the first codec in the list to actually send audio data.
+      // Be sure to use the payload type requested by the remote side.
+      // "red", for RED audio, is a special case where the actual codec to be
+      // used is specified in params.
+      const AudioCodec* found_codec = &codec;
+      if (IsCodec(*found_codec, kRedCodecName)) {
+        // Parse out the RED parameters. If we fail, just ignore RED;
+        // we don't support all possible params/usage scenarios.
+        *red_payload_type = codec.id;
+        found_codec = GetRedSendCodec(*found_codec, codecs);
+        if (!found_codec) {
+          continue;
+        }
+      }
+      // Ignore codecs we don't know about. The negotiation step should prevent
+      // this, but double-check to be sure.
+      if (!WebRtcVoiceEngine::ToCodecInst(*found_codec, voe_codec)) {
+        LOG(LS_WARNING) << "Unknown codec " << ToString(*found_codec);
+        continue;
+      }
+      return found_codec;
+    }
+    return nullptr;
+  }
+
  private:
   static const int kMaxNumPacketSize = 6;
   struct CodecPref {
     const char* name;
     int clockrate;
     size_t channels;
     int payload_type;
     bool is_multi_rate;
     int packet_sizes_ms[kMaxNumPacketSize];
   };
@@ skipping 14 matching lines @@
   // which says that G722 should be advertised as 8 kHz although it is a 16 kHz
   // codec.
   static void MaybeFixupG722(webrtc::CodecInst* voe_codec, int new_plfreq) {
     if (IsCodec(*voe_codec, kG722CodecName)) {
       // If the ASSERT triggers, the codec definition in WebRTC VoiceEngine
       // has changed, and this special case is no longer needed.
       RTC_DCHECK(voe_codec->plfreq != new_plfreq);
       voe_codec->plfreq = new_plfreq;
     }
   }
+
+  static const AudioCodec* GetRedSendCodec(
+      const AudioCodec& red_codec,
+      const std::vector<AudioCodec>& all_codecs) {
+    // 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
+    // signaling of this message), use the second codec specified (i.e. the
+    // one after "red") as the encoding parameter.
+    int red_pt = -1;
+    std::string red_params;
+    CodecParameterMap::const_iterator it = red_codec.params.find("");
+    if (it != red_codec.params.end()) {
+      red_params = it->second;
+      std::vector<std::string> red_pts;
+      if (rtc::split(red_params, '/', &red_pts) != 2 ||
+          red_pts[0] != red_pts[1] || !rtc::FromString(red_pts[0], &red_pt)) {
+        LOG(LS_WARNING) << "RED params " << red_params << " not supported.";
+        return nullptr;
+      }
+    } else if (red_codec.params.empty()) {
+      LOG(LS_WARNING) << "RED params not present, using defaults";
+      if (all_codecs.size() > 1) {
+        red_pt = all_codecs[1].id;
+      }
+    }
+
+    // Try to find red_pt in |codecs|.
+    for (const AudioCodec& codec : all_codecs) {
+      if (codec.id == red_pt) {
+        return &codec;
+      }
+    }
+    LOG(LS_WARNING) << "RED params " << red_params << " are invalid.";
+    return nullptr;
+  }
 };
 
 const WebRtcVoiceCodecs::CodecPref WebRtcVoiceCodecs::kCodecPrefs[12] = {
   { kOpusCodecName,   48000, 2, 111, true,  { 10, 20, 40, 60 } },
   { kIsacCodecName,   16000, 1, 103, true,  { 30, 60 } },
   { kIsacCodecName,   32000, 1, 104, true,  { 30 } },
   // G722 should be advertised as 8000 Hz because of the RFC "bug".
   { kG722CodecName,   8000,  1, 9,   false, { 10, 20, 30, 40, 50, 60 } },
   { kIlbcCodecName,   8000,  1, 102, false, { 20, 30, 40, 60 } },
   { kPcmuCodecName,   8000,  1, 0,   false, { 10, 20, 30, 40, 50, 60 } },
@@ skipping 474 matching lines @@
 }
 
 RtpCapabilities WebRtcVoiceEngine::GetCapabilities() const {
   RTC_DCHECK(signal_thread_checker_.CalledOnValidThread());
   RtpCapabilities capabilities;
   capabilities.header_extensions.push_back(RtpHeaderExtension(
       kRtpAudioLevelHeaderExtension, kRtpAudioLevelHeaderExtensionDefaultId));
   capabilities.header_extensions.push_back(
       RtpHeaderExtension(kRtpAbsoluteSenderTimeHeaderExtension,
                          kRtpAbsoluteSenderTimeHeaderExtensionDefaultId));
+  if (webrtc::field_trial::FindFullName("WebRTC-Audio-SendSideBwe") ==
+      "Enabled") {
+    capabilities.header_extensions.push_back(RtpHeaderExtension(
+        kRtpTransportSequenceNumberHeaderExtension,
+        kRtpTransportSequenceNumberHeaderExtensionDefaultId));
+  }
   return capabilities;
 }
 
 int WebRtcVoiceEngine::GetLastEngineError() {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   return voe_wrapper_->error();
 }
 
 void WebRtcVoiceEngine::Print(webrtc::TraceLevel level, const char* trace,
                               int length) {
@@ skipping 255 matching lines @@
   // Raw pointer to AudioRenderer owned by LocalAudioTrackHandler.
   // PeerConnection will make sure invalidating the pointer before the object
   // goes away.
   AudioRenderer* renderer_ = nullptr;
 
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(WebRtcAudioSendStream);
 };
 
 class WebRtcVoiceMediaChannel::WebRtcAudioReceiveStream {
  public:
-  WebRtcAudioReceiveStream(int ch, uint32_t remote_ssrc, uint32_t local_ssrc,
-                           bool use_combined_bwe, const std::string& sync_group,
+  WebRtcAudioReceiveStream(int ch,
+                           uint32_t remote_ssrc,
+                           uint32_t local_ssrc,
+                           bool use_transport_cc,
+                           const std::string& sync_group,
                            const std::vector<webrtc::RtpExtension>& extensions,
                            webrtc::Call* call)
-      : call_(call),
-        config_() {
+      : call_(call), config_() {
     RTC_DCHECK_GE(ch, 0);
     RTC_DCHECK(call);
     config_.rtp.remote_ssrc = remote_ssrc;
     config_.rtp.local_ssrc = local_ssrc;
     config_.voe_channel_id = ch;
     config_.sync_group = sync_group;
-    RecreateAudioReceiveStream(use_combined_bwe, extensions);
+    RecreateAudioReceiveStream(use_transport_cc, extensions);
   }
 
   ~WebRtcAudioReceiveStream() {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     call_->DestroyAudioReceiveStream(stream_);
   }
 
+  void RecreateAudioReceiveStream() {
+    RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+    RecreateAudioReceiveStream(config_.rtp.transport_cc,
+                               config_.rtp.extensions);
+  }
   void RecreateAudioReceiveStream(
       const std::vector<webrtc::RtpExtension>& extensions) {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
-    RecreateAudioReceiveStream(config_.combined_audio_video_bwe, extensions);
+    RecreateAudioReceiveStream(config_.rtp.transport_cc, extensions);
   }
-  void RecreateAudioReceiveStream(bool use_combined_bwe) {
+  void RecreateAudioReceiveStream(bool use_transport_cc) {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
-    RecreateAudioReceiveStream(use_combined_bwe, config_.rtp.extensions);
+    RecreateAudioReceiveStream(use_transport_cc, config_.rtp.extensions);
   }
 
   webrtc::AudioReceiveStream::Stats GetStats() const {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     RTC_DCHECK(stream_);
     return stream_->GetStats();
   }
 
   int channel() const {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     return config_.voe_channel_id;
   }
 
   void SetRawAudioSink(rtc::scoped_ptr<webrtc::AudioSinkInterface> sink) {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     stream_->SetSink(std::move(sink));
   }
 
  private:
-  void RecreateAudioReceiveStream(bool use_combined_bwe,
+  void RecreateAudioReceiveStream(
+      bool use_transport_cc,
       const std::vector<webrtc::RtpExtension>& extensions) {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     if (stream_) {
       call_->DestroyAudioReceiveStream(stream_);
       stream_ = nullptr;
     }
     config_.rtp.extensions = extensions;
-    config_.combined_audio_video_bwe = use_combined_bwe;
+    config_.rtp.transport_cc = use_transport_cc;
     RTC_DCHECK(!stream_);
     stream_ = call_->CreateAudioReceiveStream(config_);
     RTC_CHECK(stream_);
   }
 
   rtc::ThreadChecker worker_thread_checker_;
   webrtc::Call* call_ = nullptr;
   webrtc::AudioReceiveStream::Config config_;
   // The stream is owned by WebRtcAudioReceiveStream and may be reallocated if
   // configuration changes.
@@ skipping 75 matching lines @@
   }
   std::vector<webrtc::RtpExtension> filtered_extensions =
       FilterRtpExtensions(params.extensions,
                           webrtc::RtpExtension::IsSupportedForAudio, false);
   if (recv_rtp_extensions_ != filtered_extensions) {
     recv_rtp_extensions_.swap(filtered_extensions);
     for (auto& it : recv_streams_) {
       it.second->RecreateAudioReceiveStream(recv_rtp_extensions_);
     }
   }
-
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::SetOptions(const AudioOptions& options) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   LOG(LS_INFO) << "Setting voice channel options: "
                << options.ToString();
 
   // Check if DSCP value is changed from previous.
   bool dscp_option_changed = (options_.dscp != options.dscp);
@@ skipping 13 matching lines @@
     if (options_.dscp.value_or(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.
   for (auto& it : recv_streams_) {
-    it.second->RecreateAudioReceiveStream(
-        options_.combined_audio_video_bwe.value_or(false));
+    it.second->RecreateAudioReceiveStream();
   }
 
   LOG(LS_INFO) << "Set voice channel options.  Current options: "
                << options_.ToString();
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::SetRecvCodecs(
     const std::vector<AudioCodec>& codecs) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
@@ skipping 66 matching lines @@
 bool WebRtcVoiceMediaChannel::SetSendCodecs(
     int channel, const std::vector<AudioCodec>& codecs) {
   // Disable VAD, FEC, and RED unless we know the other side wants them.
   engine()->voe()->codec()->SetVADStatus(channel, false);
   engine()->voe()->rtp()->SetNACKStatus(channel, false, 0);
   engine()->voe()->rtp()->SetREDStatus(channel, false);
   engine()->voe()->codec()->SetFECStatus(channel, false);
 
   // Scan through the list to figure out the codec to use for sending, along
   // with the proper configuration for VAD.
-  bool found_send_codec = false;
   webrtc::CodecInst send_codec;
   memset(&send_codec, 0, sizeof(send_codec));
 
   bool nack_enabled = nack_enabled_;
   bool enable_codec_fec = false;
   bool enable_opus_dtx = false;
   int opus_max_playback_rate = 0;
+  int red_payload_type = -1;
 
   // Set send codec (the first non-telephone-event/CN codec)
-  for (const AudioCodec& codec : codecs) {
-    // Ignore codecs we don't know about. The negotiation step should prevent
-    // this, but double-check to be sure.
-    webrtc::CodecInst voe_codec;
-    if (!WebRtcVoiceEngine::ToCodecInst(codec, &voe_codec)) {
-      LOG(LS_WARNING) << "Unknown codec " << ToString(codec);
-      continue;
-    }
-
-    if (IsCodec(codec, kDtmfCodecName) || IsCodec(codec, kCnCodecName)) {
-      // Skip telephone-event/CN codec, which will be handled later.
-      continue;
-    }
-
-    // We'll use the first codec in the list to actually send audio data.
-    // Be sure to use the payload type requested by the remote side.
-    // "red", for RED audio, is a special case where the actual codec to be
-    // used is specified in params.
-    if (IsCodec(codec, kRedCodecName)) {
-      // Parse out the RED parameters. If we fail, just ignore RED;
-      // we don't support all possible params/usage scenarios.
-      if (!GetRedSendCodec(codec, codecs, &send_codec)) {
-        continue;
-      }
-
+  const AudioCodec* codec = WebRtcVoiceCodecs::GetPreferredCodec(
+      codecs, &send_codec, &red_payload_type);
+  if (codec) {
+    if (red_payload_type != -1) {
       // Enable redundant encoding of the specified codec. Treat any
       // failure as a fatal internal error.
       LOG(LS_INFO) << "Enabling RED on channel " << channel;
-      if (engine()->voe()->rtp()->SetREDStatus(channel, true, codec.id) == -1) {
-        LOG_RTCERR3(SetREDStatus, channel, true, codec.id);
+      if (engine()->voe()->rtp()->SetREDStatus(channel, true,
+                                               red_payload_type) == -1) {
+        LOG_RTCERR3(SetREDStatus, channel, true, red_payload_type);
         return false;
       }
     } else {
-      send_codec = voe_codec;
-      nack_enabled = IsNackEnabled(codec);
+      nack_enabled = HasNack(*codec);
       // For Opus as the send codec, we are to determine inband FEC, maximum
       // playback rate, and opus internal dtx.
-      if (IsCodec(codec, kOpusCodecName)) {
-        GetOpusConfig(codec, &send_codec, &enable_codec_fec,
+      if (IsCodec(*codec, kOpusCodecName)) {
+        GetOpusConfig(*codec, &send_codec, &enable_codec_fec,
                       &opus_max_playback_rate, &enable_opus_dtx);
       }
 
       // Set packet size if the AudioCodec param kCodecParamPTime is set.
       int ptime_ms = 0;
-      if (codec.GetParam(kCodecParamPTime, &ptime_ms)) {
+      if (codec->GetParam(kCodecParamPTime, &ptime_ms)) {
         if (!WebRtcVoiceCodecs::SetPTimeAsPacketSize(&send_codec, ptime_ms)) {
           LOG(LS_WARNING) << "Failed to set packet size for codec "
                           << send_codec.plname;
           return false;
         }
       }
     }
-    found_send_codec = true;
-    break;
   }
 
   if (nack_enabled_ != nack_enabled) {
     SetNack(channel, nack_enabled);
     nack_enabled_ = nack_enabled;
   }
-
-  if (!found_send_codec) {
+  if (!codec) {
     LOG(LS_WARNING) << "Received empty list of codecs.";
     return false;
   }
 
   // Set the codec immediately, since SetVADStatus() depends on whether
   // the current codec is mono or stereo.
   if (!SetSendCodec(channel, send_codec))
     return false;
 
   // FEC should be enabled after SetSendCodec.
@@ skipping 127 matching lines @@
     if (!SetSendCodecs(ch.second->channel(), codecs)) {
       return false;
     }
   }
 
   // Set nack status on receive channels and update |nack_enabled_|.
   for (const auto& ch : recv_streams_) {
     SetNack(ch.second->channel(), nack_enabled_);
   }
 
+  // Check if the transport cc feedback has changed on the preferred send codec,
+  // and in that case reconfigure all receive streams.
+  webrtc::CodecInst voe_codec;
+  int red_payload_type;
+  const AudioCodec* send_codec = WebRtcVoiceCodecs::GetPreferredCodec(
+      send_codecs_, &voe_codec, &red_payload_type);
+  if (send_codec) {
+    bool transport_cc = HasTransportCc(*send_codec);
+    if (transport_cc_enabled_ != transport_cc) {
+      LOG(LS_INFO) << "Recreate all the receive streams because the send "
+                      "codec has changed.";
+      transport_cc_enabled_ = transport_cc;
+      for (auto& kv : recv_streams_) {
+        RTC_DCHECK(kv.second != nullptr);
+        kv.second->RecreateAudioReceiveStream(transport_cc_enabled_);
+      }
+    }
+  }
+
   return true;
 }
 
 void WebRtcVoiceMediaChannel::SetNack(int channel, bool nack_enabled) {
   if (nack_enabled) {
     LOG(LS_INFO) << "Enabling NACK for channel " << channel;
     engine()->voe()->rtp()->SetNACKStatus(channel, true, kNackMaxPackets);
   } else {
     LOG(LS_INFO) << "Disabling NACK for channel " << channel;
     engine()->voe()->rtp()->SetNACKStatus(channel, false, 0);
@@ skipping 286 matching lines @@
 
   const int send_channel = GetSendChannelId(receiver_reports_ssrc_);
   if (send_channel != -1) {
     // Associate receive channel with first send channel (so the receive channel
     // can obtain RTT from the send channel)
     engine()->voe()->base()->AssociateSendChannel(channel, send_channel);
     LOG(LS_INFO) << "VoiceEngine channel #" << channel
                  << " is associated with channel #" << send_channel << ".";
   }
 
-  recv_streams_.insert(std::make_pair(ssrc, new WebRtcAudioReceiveStream(
-      channel, ssrc, receiver_reports_ssrc_,
-      options_.combined_audio_video_bwe.value_or(false), sp.sync_label,
-      recv_rtp_extensions_, call_)));
+  transport_cc_enabled_ =
+      !send_codecs_.empty() ? HasTransportCc(send_codecs_[0]) : false;
+
+  recv_streams_.insert(std::make_pair(
+      ssrc, new WebRtcAudioReceiveStream(channel, ssrc, receiver_reports_ssrc_,
+                                         transport_cc_enabled_, sp.sync_label,
+                                         recv_rtp_extensions_, call_)));
 
   SetNack(channel, nack_enabled_);
   SetPlayout(channel, playout_);
 
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::RemoveRecvStream(uint32_t ssrc) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   LOG(LS_INFO) << "RemoveRecvStream: " << ssrc;
@@ skipping 437 matching lines @@
 
 int WebRtcVoiceMediaChannel::GetSendChannelId(uint32_t ssrc) const {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   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
-  // 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
-  // signaling of this message), use the second codec specified (i.e. the
-  // one after "red") as the encoding parameter.
-  int red_pt = -1;
-  std::string red_params;
-  CodecParameterMap::const_iterator it = red_codec.params.find("");
-  if (it != red_codec.params.end()) {
-    red_params = it->second;
-    std::vector<std::string> red_pts;
-    if (rtc::split(red_params, '/', &red_pts) != 2 ||
-        red_pts[0] != red_pts[1] ||
-        !rtc::FromString(red_pts[0], &red_pt)) {
-      LOG(LS_WARNING) << "RED params " << red_params << " not supported.";
-      return false;
-    }
-  } else if (red_codec.params.empty()) {
-    LOG(LS_WARNING) << "RED params not present, using defaults";
-    if (all_codecs.size() > 1) {
-      red_pt = all_codecs[1].id;
-    }
-  }
-
-  // Try to find red_pt in |codecs|.
-  for (const AudioCodec& codec : all_codecs) {
-    if (codec.id == red_pt) {
-      // If we find the right codec, that will be the codec we pass to
-      // SetSendCodec, with the desired payload type.
-      if (WebRtcVoiceEngine::ToCodecInst(codec, send_codec)) {
-        return true;
-      } else {
-        break;
-      }
-    }
-  }
-  LOG(LS_WARNING) << "RED params " << red_params << " are invalid.";
-  return false;
-}
-
 bool WebRtcVoiceMediaChannel::SetPlayout(int channel, bool playout) {
   if (playout) {
     LOG(LS_INFO) << "Starting playout for channel #" << channel;
     if (engine()->voe()->base()->StartPlayout(channel) == -1) {
       LOG_RTCERR1(StartPlayout, channel);
       return false;
     }
   } else {
     LOG(LS_INFO) << "Stopping playout for channel #" << channel;
     engine()->voe()->base()->StopPlayout(channel);
   }
   return true;
 }
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE