Deprecated SetAudioPacketSize from RTPSender and removed calls to it.

webrtc/modules/rtp_rtcp/source/rtp_sender_audio.cc

 /*
  *  Copyright (c) 2012 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 13 matching lines @@
 #include "webrtc/modules/rtp_rtcp/source/rtp_packet_to_send.h"
 
 namespace webrtc {
 
 RTPSenderAudio::RTPSenderAudio(Clock* clock, RTPSender* rtp_sender)
     : clock_(clock),
       rtp_sender_(rtp_sender) {}
 
 RTPSenderAudio::~RTPSenderAudio() {}
 
-// set audio packet size, used to determine when it's time to send a DTMF packet
-// in silence (CNG)
-int32_t RTPSenderAudio::SetAudioPacketSize(uint16_t packet_size_samples) {
-  rtc::CritScope cs(&send_audio_critsect_);
-  packet_size_samples_ = packet_size_samples;
-  return 0;
-}
-
 int32_t RTPSenderAudio::RegisterAudioPayload(
     const char payloadName[RTP_PAYLOAD_NAME_SIZE],
     const int8_t payload_type,
     const uint32_t frequency,
     const size_t channels,
     const uint32_t rate,
     RtpUtility::Payload** payload) {
   if (RtpUtility::StringCompare(payloadName, "cn", 2)) {
     rtc::CritScope cs(&send_audio_critsect_);
     //  we can have multiple CNG payload types
@@ skipping 73 matching lines @@
   }
   return marker_bit;
 }
 
 bool RTPSenderAudio::SendAudio(FrameType frame_type,
                                int8_t payload_type,
                                uint32_t rtp_timestamp,
                                const uint8_t* payload_data,
                                size_t payload_size,
                                const RTPFragmentationHeader* fragmentation) {
+  // From RFC 4733:
+  // A source has wide latitude as to how often it sends event updates. A
+  // natural interval is the spacing between non-event audio packets. [...]
+  // Alternatively, a source MAY decide to use a different spacing for event
+  // updates, with a value of 50 ms RECOMMENDED.
+  constexpr int kDtmfIntervalTimeMs = 50;
   uint8_t audio_level_dbov = 0;
-  uint16_t packet_size_samples = 0;
   uint32_t dtmf_payload_freq = 0;
   {
     rtc::CritScope cs(&send_audio_critsect_);
     audio_level_dbov = audio_level_dbov_;
-    packet_size_samples = packet_size_samples_;
     dtmf_payload_freq = dtmf_payload_freq_;
   }
 
   // Check if we have pending DTMFs to send
   if (!dtmf_event_is_on_ && dtmf_queue_.PendingDtmf()) {
-    if ((clock_->TimeInMilliseconds() - dtmf_time_last_sent_) > 50) {
+    if ((clock_->TimeInMilliseconds() - dtmf_time_last_sent_) >
+        kDtmfIntervalTimeMs) {
       // New tone to play
       dtmf_timestamp_ = rtp_timestamp;
       if (dtmf_queue_.NextDtmf(&dtmf_current_event_)) {
         dtmf_event_first_packet_sent_ = false;
         dtmf_length_samples_ =
             dtmf_current_event_.duration_ms * (dtmf_payload_freq / 1000);
         dtmf_event_is_on_ = true;
       }
     }
   }
 
   // A source MAY send events and coded audio packets for the same time
   // but we don't support it
   if (dtmf_event_is_on_) {
     if (frame_type == kEmptyFrame) {
       // kEmptyFrame is used to drive the DTMF when in CN mode
       // it can be triggered more frequently than we want to send the
       // DTMF packets.
-      if (packet_size_samples > (rtp_timestamp - dtmf_timestamp_last_sent_)) {
+      const unsigned int dtmf_interval_time_rtp =
+          dtmf_payload_freq * kDtmfIntervalTimeMs / 1000;
+      if ((rtp_timestamp - dtmf_timestamp_last_sent_) <
+          dtmf_interval_time_rtp) {
         // not time to send yet
         return true;
       }
     }
     dtmf_timestamp_last_sent_ = rtp_timestamp;
     uint32_t dtmf_duration_samples = rtp_timestamp - dtmf_timestamp_;
     bool ended = false;
     bool send = true;
 
     if (dtmf_length_samples_ > dtmf_duration_samples) {
@@ skipping 163 matching lines @@
         TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "Audio::SendTelephoneEvent",
         "timestamp", packet->Timestamp(), "seqnum", packet->SequenceNumber());
     result = rtp_sender_->SendToNetwork(std::move(packet), kAllowRetransmission,
                                         RtpPacketSender::kHighPriority);
     send_count--;
   } while (send_count > 0 && result);
 
   return result;
 }
 }  // namespace webrtc