Have AudioSendStream register CNG payload types with the RtpRtcpModule.

webrtc/audio/audio_send_stream.cc

 /*
  *  Copyright (c) 2015 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 10 matching lines @@
 #include "webrtc/base/event.h"
 #include "webrtc/base/function_view.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/task_queue.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/call/rtp_transport_controller_send_interface.h"
 #include "webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng.h"
 #include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
 #include "webrtc/modules/congestion_controller/include/send_side_congestion_controller.h"
 #include "webrtc/modules/pacing/paced_sender.h"
-#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
+#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
 #include "webrtc/voice_engine/channel_proxy.h"
 #include "webrtc/voice_engine/include/voe_base.h"
 #include "webrtc/voice_engine/transmit_mixer.h"
 #include "webrtc/voice_engine/voice_engine_impl.h"
 
 namespace webrtc {
 
 namespace internal {
 // TODO(elad.alon): Subsequent CL will make these values experiment-dependent.
 constexpr size_t kPacketLossTrackerMaxWindowSizeMs = 15000;
@@ skipping 372 matching lines @@
   }
 
   // Wrap the encoder in a an AudioEncoderCNG, if VAD is enabled.
   if (spec.cng_payload_type) {
     AudioEncoderCng::Config cng_config;
     cng_config.num_channels = encoder->NumChannels();
     cng_config.payload_type = *spec.cng_payload_type;
     cng_config.speech_encoder = std::move(encoder);
     cng_config.vad_mode = Vad::kVadNormal;
     encoder.reset(new AudioEncoderCng(std::move(cng_config)));
+
+    stream->RegisterCngPayloadType(
+        *spec.cng_payload_type,
+        new_config.send_codec_spec->format.clockrate_hz);
   }
 
   stream->channel_proxy_->SetEncoder(new_config.send_codec_spec->payload_type,
                                      std::move(encoder));
   return true;
 }
 
 bool AudioSendStream::ReconfigureSendCodec(AudioSendStream* stream,
                                            const Config& new_config) {
   const auto& old_config = stream->config_;
@@ skipping 57 matching lines @@
   }
 }
 
 void AudioSendStream::ReconfigureCNG(AudioSendStream* stream,
                                      const Config& new_config) {
   if (new_config.send_codec_spec->cng_payload_type ==
       stream->config_.send_codec_spec->cng_payload_type) {
     return;
   }
 
+  // Register the CNG payload type if it's been added, don't do anything if CNG
+  // is removed. Payload types must not be redefined.
+  if (new_config.send_codec_spec->cng_payload_type) {
+    stream->RegisterCngPayloadType(
+        *new_config.send_codec_spec->cng_payload_type,
+        new_config.send_codec_spec->format.clockrate_hz);
+  }
+
   // Wrap or unwrap the encoder in an AudioEncoderCNG.
   stream->channel_proxy_->ModifyEncoder(
       [&](std::unique_ptr<AudioEncoder>* encoder_ptr) {
         std::unique_ptr<AudioEncoder> old_encoder(std::move(*encoder_ptr));
         auto sub_encoders = old_encoder->ReclaimContainedEncoders();
         if (!sub_encoders.empty()) {
           // Replace enc with its sub encoder. We need to put the sub
           // encoder in a temporary first, since otherwise the old value
           // of enc would be destroyed before the new value got assigned,
           // which would be bad since the new value is a part of the old
@@ skipping 54 matching lines @@
 void AudioSendStream::RemoveBitrateObserver() {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   rtc::Event thread_sync_event(false /* manual_reset */, false);
   worker_queue_->PostTask([this, &thread_sync_event] {
     bitrate_allocator_->RemoveObserver(this);
     thread_sync_event.Set();
   });
   thread_sync_event.Wait(rtc::Event::kForever);
 }
 
+void AudioSendStream::RegisterCngPayloadType(int payload_type,
+                                             int clockrate_hz) {
+  RtpRtcp* rtpRtcpModule = nullptr;
+  RtpReceiver* rtpReceiver = nullptr;  // Unused, but required for call.
+  channel_proxy_->GetRtpRtcp(&rtpRtcpModule, &rtpReceiver);
+  const CodecInst codec = {payload_type, "CN", clockrate_hz, 0, 1, 0};
+  if (rtpRtcpModule->RegisterSendPayload(codec) != 0) {
+    rtpRtcpModule->DeRegisterSendPayload(codec.pltype);
+    if (rtpRtcpModule->RegisterSendPayload(codec) != 0) {
+      LOG(LS_ERROR) << "RegisterCngPayloadType() failed to register CN to "
+                       "RTP/RTCP module";
+    }
+  }
+}
+
+
 }  // namespace internal
 }  // namespace webrtc