Move RTP timestamp calculation from BuildRTPheader to SendOutgoingData

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 127 matching lines @@
   if (frame_type == kAudioFrameCN) {
     inband_vad_active_ = true;
   } else if (inband_vad_active_) {
     inband_vad_active_ = false;
     marker_bit = true;
   }
   return marker_bit;
 }
 
 bool RTPSenderAudio::SendAudio(FrameType frame_type,
-                                  int8_t payload_type,
-                                  uint32_t capture_timestamp,
-                                  const uint8_t* payload_data,
-                                  size_t data_size,
-                                  const RTPFragmentationHeader* fragmentation) {
+                               int8_t payload_type,
+                               uint32_t rtp_timestamp,
+                               const uint8_t* payload_data,
+                               size_t data_size,
+                               const RTPFragmentationHeader* fragmentation) {
   // TODO(pwestin) Breakup function in smaller functions.
   size_t payload_size = data_size;
   size_t max_payload_length = rtp_sender_->MaxPayloadLength();
   uint16_t dtmf_length_ms = 0;
   uint8_t key = 0;
   uint8_t audio_level_dbov;
   int8_t dtmf_payload_type;
   uint16_t packet_size_samples;
   {
     rtc::CritScope cs(&send_audio_critsect_);
     audio_level_dbov = audio_level_dbov_;
     dtmf_payload_type = dtmf_payload_type_;
     packet_size_samples = packet_size_samples_;
   }
 
   // Check if we have pending DTMFs to send
   if (!dtmf_event_is_on_ && PendingDTMF()) {
     int64_t delaySinceLastDTMF =
         clock_->TimeInMilliseconds() - dtmf_time_last_sent_;
 
     if (delaySinceLastDTMF > 100) {
       // New tone to play
-      dtmf_timestamp_ = capture_timestamp;
+      dtmf_timestamp_ = rtp_timestamp;
       if (NextDTMF(&key, &dtmf_length_ms, &dtmf_level_) >= 0) {
         dtmf_event_first_packet_sent_ = false;
         dtmf_key_ = key;
         dtmf_length_samples_ = (kDtmfFrequencyHz / 1000) * dtmf_length_ms;
         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 >
-          (capture_timestamp - dtmf_timestamp_last_sent_)) {
+      if (packet_size_samples > (rtp_timestamp - dtmf_timestamp_last_sent_)) {
         // not time to send yet
         return true;
       }
     }
-    dtmf_timestamp_last_sent_ = capture_timestamp;
-    uint32_t dtmf_duration_samples = capture_timestamp - dtmf_timestamp_;
+    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) {
       if (dtmf_duration_samples <= 0) {
         // Skip send packet at start, since we shouldn't use duration 0
         send = false;
       }
     } else {
       ended = true;
       dtmf_event_is_on_ = false;
       dtmf_time_last_sent_ = clock_->TimeInMilliseconds();
     }
     if (send) {
       if (dtmf_duration_samples > 0xffff) {
         // RFC 4733 2.5.2.3 Long-Duration Events
         SendTelephoneEventPacket(ended, dtmf_payload_type, dtmf_timestamp_,
                                  static_cast<uint16_t>(0xffff), false);
 
         // set new timestap for this segment
-        dtmf_timestamp_ = capture_timestamp;
+        dtmf_timestamp_ = rtp_timestamp;
         dtmf_duration_samples -= 0xffff;
         dtmf_length_samples_ -= 0xffff;
 
         return SendTelephoneEventPacket(
             ended, dtmf_payload_type, dtmf_timestamp_,
             static_cast<uint16_t>(dtmf_duration_samples), false);
       } else {
         if (!SendTelephoneEventPacket(ended, dtmf_payload_type, dtmf_timestamp_,
                                       dtmf_duration_samples,
                                       !dtmf_event_first_packet_sent_)) {
@@ skipping 11 matching lines @@
       // no error since we use it to drive DTMF when we use VAD
       return true;
     }
     return false;
   }
   uint8_t data_buffer[IP_PACKET_SIZE];
   bool marker_bit = MarkerBit(frame_type, payload_type);
 
   int32_t rtpHeaderLength = 0;
 
-  rtpHeaderLength = rtp_sender_->BuildRtpHeader(data_buffer, payload_type,
-                                                marker_bit, capture_timestamp,
-                                                clock_->TimeInMilliseconds());
+  rtpHeaderLength =
+      rtp_sender_->BuildRtpHeader(data_buffer, payload_type, marker_bit,
+                                  rtp_timestamp, clock_->TimeInMilliseconds());
   if (rtpHeaderLength <= 0) {
     return false;
   }
   if (max_payload_length < (rtpHeaderLength + payload_size)) {
     // Too large payload buffer.
     return false;
   }
   if (fragmentation && fragmentation->fragmentationVectorSize > 0) {
     // use the fragment info if we have one
     data_buffer[rtpHeaderLength++] = fragmentation->fragmentationPlType[0];
@@ skipping 11 matching lines @@
     last_payload_type_ = payload_type;
   }
   // Update audio level extension, if included.
   size_t packetSize = payload_size + rtpHeaderLength;
   RtpUtility::RtpHeaderParser rtp_parser(data_buffer, packetSize);
   RTPHeader rtp_header;
   rtp_parser.Parse(&rtp_header);
   rtp_sender_->UpdateAudioLevel(data_buffer, packetSize, rtp_header,
                                 (frame_type == kAudioFrameSpeech),
                                 audio_level_dbov);
-  TRACE_EVENT_ASYNC_END2("webrtc", "Audio", capture_timestamp, "timestamp",
-                         rtp_sender_->Timestamp(), "seqnum",
+  TRACE_EVENT_ASYNC_END2("webrtc", "Audio", rtp_timestamp, "timestamp",
+                         rtp_timestamp, "seqnum",

[Sergey Ulanov, 2016/08/19 18:19:13]

Is it necessary to pass the same timestamp twice here?

[danilchap, 2016/08/20 11:50:47]

They have different meaning: first timestamp is a key to find matching
TRACE_EVENT_ASYNC_BEGIN (it is in rtp_sender.cc)
2nd timestamp is part of key-value pair with key="timestamp", something to
plot/use in stats.

                          rtp_sender_->SequenceNumber());
   bool send_result = rtp_sender_->SendToNetwork(
       data_buffer, payload_size, rtpHeaderLength, rtc::TimeMillis(),
       kAllowRetransmission, RtpPacketSender::kHighPriority);
   if (first_packet_sent_()) {
     LOG(LS_INFO) << "First audio RTP packet sent to pacer";
   }
   return send_result;
 }
 
@@ skipping 71 matching lines @@
         "timestamp", dtmf_timestamp, "seqnum", rtp_sender_->SequenceNumber());
     result = rtp_sender_->SendToNetwork(dtmfbuffer, 4, 12, rtc::TimeMillis(),
                                         kAllowRetransmission,
                                         RtpPacketSender::kHighPriority);
     send_count--;
   } while (send_count > 0 && result);
 
   return result;
 }
 }  // namespace webrtc