Adding getParameters/setParameters APIs to RtpReceiver.

webrtc/media/engine/webrtcvoiceengine.cc

 /*
  *  Copyright (c) 2004 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.
  */
 
@@ skipping 1405 matching lines @@
                           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;
 }
 
-webrtc::RtpParameters WebRtcVoiceMediaChannel::GetRtpParameters(
+webrtc::RtpParameters WebRtcVoiceMediaChannel::GetRtpSendParameters(
     uint32_t ssrc) const {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   auto it = send_streams_.find(ssrc);
   if (it == send_streams_.end()) {
-    LOG(LS_WARNING) << "Attempting to get RTP parameters for stream with ssrc "
-                    << ssrc << " which doesn't exist.";
+    LOG(LS_WARNING) << "Attempting to get RTP send parameters for stream "
+                    << "with ssrc " << ssrc << " which doesn't exist.";
     return webrtc::RtpParameters();
   }
 
   webrtc::RtpParameters rtp_params = it->second->rtp_parameters();
   // Need to add the common list of codecs to the send stream-specific
   // RTP parameters.
   for (const AudioCodec& codec : send_codecs_) {
     rtp_params.codecs.push_back(codec.ToCodecParameters());
   }
   return rtp_params;
 }
 
-bool WebRtcVoiceMediaChannel::SetRtpParameters(
+bool WebRtcVoiceMediaChannel::SetRtpSendParameters(
     uint32_t ssrc,
     const webrtc::RtpParameters& parameters) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   if (!ValidateRtpParameters(parameters)) {
     return false;
   }
   auto it = send_streams_.find(ssrc);
   if (it == send_streams_.end()) {
-    LOG(LS_WARNING) << "Attempting to set RTP parameters for stream with ssrc "
-                    << ssrc << " which doesn't exist.";
+    LOG(LS_WARNING) << "Attempting to set RTP send parameters for stream "
+                    << "with ssrc " << ssrc << " which doesn't exist.";
     return false;
   }
 
-  if (!SetChannelParameters(it->second->channel(), parameters)) {
-    LOG(LS_WARNING) << "Failed to set RtpParameters.";
+  // TODO(deadbeef): Handle setting parameters with a list of codecs in a
+  // different order (which should change the send codec).
+  webrtc::RtpParameters current_parameters = GetRtpSendParameters(ssrc);
+  if (current_parameters.codecs != parameters.codecs) {
+    LOG(LS_ERROR) << "Using SetParameters to change the set of codecs "
+                  << "is not currently supported.";
+    return false;
+  }
+
+  if (!SetChannelSendParameters(it->second->channel(), parameters)) {
+    LOG(LS_WARNING) << "Failed to set send RtpParameters.";
     return false;
   }
   // Codecs are handled at the WebRtcVoiceMediaChannel level.
   webrtc::RtpParameters reduced_params = parameters;
   reduced_params.codecs.clear();
   it->second->SetRtpParameters(reduced_params);
   return true;
 }
 
+webrtc::RtpParameters WebRtcVoiceMediaChannel::GetRtpReceiveParameters(
+    uint32_t ssrc) const {
+  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+  auto it = recv_streams_.find(ssrc);
+  if (it == recv_streams_.end()) {
+    LOG(LS_WARNING) << "Attempting to get RTP receive parameters for stream "
+                    << "with ssrc " << ssrc << " which doesn't exist.";
+    return webrtc::RtpParameters();
+  }
+
+  // TODO(deadbeef): Return stream-specific parameters.
+  webrtc::RtpParameters rtp_params = CreateRtpParametersWithOneEncoding();
+  for (const AudioCodec& codec : recv_codecs_) {
+    rtp_params.codecs.push_back(codec.ToCodecParameters());
+  }
+  return rtp_params;
+}
+
+bool WebRtcVoiceMediaChannel::SetRtpReceiveParameters(
+    uint32_t ssrc,
+    const webrtc::RtpParameters& parameters) {
+  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+  if (!ValidateRtpParameters(parameters)) {
+    return false;
+  }
+  auto it = recv_streams_.find(ssrc);
+  if (it == recv_streams_.end()) {
+    LOG(LS_WARNING) << "Attempting to set RTP receive parameters for stream "
+                    << "with ssrc " << ssrc << " which doesn't exist.";
+    return false;
+  }
+
+  webrtc::RtpParameters current_parameters = GetRtpReceiveParameters(ssrc);
+  if (current_parameters != parameters) {
+    LOG(LS_ERROR) << "Changing the RTP receive parameters is currently "
+                  << "unsupported.";
+    return false;
+  }
+  return true;
+}
+
 bool WebRtcVoiceMediaChannel::ValidateRtpParameters(
     const webrtc::RtpParameters& rtp_parameters) {
   if (rtp_parameters.encodings.size() != 1) {
     LOG(LS_ERROR)
         << "Attempted to set RtpParameters without exactly one encoding";
     return false;
   }
   return true;
 }
 
@@ skipping 282 matching lines @@
       if (engine()->voe()->codec()->SetOpusMaxPlaybackRate(
           channel, send_codec_spec_.opus_max_playback_rate) == -1) {
         LOG_RTCERR2(SetOpusMaxPlaybackRate, channel,
                     send_codec_spec_.opus_max_playback_rate);
         return false;
       }
     }
   }
   // TODO(solenberg): SetMaxSendBitrate() yields another call to SetSendCodec().
   // Check if it is possible to fuse with the previous call in this function.
-  SetChannelParameters(channel, rtp_parameters);
+  SetChannelSendParameters(channel, rtp_parameters);
 
   // Set the CN payloadtype and the VAD status.
   if (send_codec_spec_.cng_payload_type != -1) {
     // The CN payload type for 8000 Hz clockrate is fixed at 13.
     if (send_codec_spec_.cng_plfreq != 8000) {
       webrtc::PayloadFrequencies cn_freq;
       switch (send_codec_spec_.cng_plfreq) {
         case 16000:
           cn_freq = webrtc::kFreq16000Hz;
           break;
@@ skipping 579 matching lines @@
     ap->set_output_will_be_muted(all_muted);
   }
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::SetMaxSendBitrate(int bps) {
   LOG(LS_INFO) << "WebRtcVoiceMediaChannel::SetMaxSendBitrate.";
   max_send_bitrate_bps_ = bps;
 
   for (const auto& kv : send_streams_) {
-    if (!SetChannelParameters(kv.second->channel(),
-                              kv.second->rtp_parameters())) {
+    if (!SetChannelSendParameters(kv.second->channel(),
+                                  kv.second->rtp_parameters())) {
       return false;
     }
   }
   return true;
 }
 
-bool WebRtcVoiceMediaChannel::SetChannelParameters(
+bool WebRtcVoiceMediaChannel::SetChannelSendParameters(
     int channel,
     const webrtc::RtpParameters& parameters) {
   RTC_CHECK_EQ(1UL, parameters.encodings.size());
   // TODO(deadbeef): Handle setting parameters with a list of codecs in a
   // different order (which should change the send codec).
   return SetMaxSendBitrate(
       channel, MinPositive(max_send_bitrate_bps_,
                            parameters.encodings[0].max_bitrate_bps));
 }
 
@@ skipping 169 matching lines @@
     }
   } else {
     LOG(LS_INFO) << "Stopping playout for channel #" << channel;
     engine()->voe()->base()->StopPlayout(channel);
   }
   return true;
 }
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE