Move RTP timestamp calculation from BuildRTPheader to SendOutgoingData

webrtc/modules/rtp_rtcp/source/rtp_sender.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 95 matching lines @@
       frame_count_observer_(frame_count_observer),
       send_side_delay_observer_(send_side_delay_observer),
       event_log_(event_log),
       send_packet_observer_(send_packet_observer),
       bitrate_callback_(bitrate_callback),
       // RTP variables
       ssrc_db_(SSRCDatabase::GetSSRCDatabase()),
       remote_ssrc_(0),
       sequence_number_forced_(false),
       ssrc_forced_(false),
-      timestamp_(0),
+      last_rtp_timestamp_(0),
       capture_time_ms_(0),
       last_timestamp_time_ms_(0),
       media_has_been_sent_(false),
       last_packet_marker_bit_(false),
       csrcs_(),
       rtx_(kRtxOff),
       retransmission_rate_limiter_(retransmission_rate_limiter) {
   ssrc_ = ssrc_db_->CreateSSRC();
   RTC_DCHECK(ssrc_ != 0);
   ssrc_rtx_ = ssrc_db_->CreateSSRC();
@@ skipping 302 matching lines @@
                                  int8_t payload_type,
                                  uint32_t capture_timestamp,
                                  int64_t capture_time_ms,
                                  const uint8_t* payload_data,
                                  size_t payload_size,
                                  const RTPFragmentationHeader* fragmentation,
                                  const RTPVideoHeader* rtp_header,
                                  uint32_t* transport_frame_id_out) {
   uint32_t ssrc;
   uint16_t sequence_number;
+  uint32_t rtp_timestamp;
   {
     // Drop this packet if we're not sending media packets.
     rtc::CritScope lock(&send_critsect_);
     ssrc = ssrc_;
     sequence_number = sequence_number_;
+    rtp_timestamp = timestamp_offset_ + capture_timestamp;
+    if (transport_frame_id_out)
+      *transport_frame_id_out = rtp_timestamp;
     if (!sending_media_)
       return true;
   }
   RtpVideoCodecTypes video_type = kRtpVideoGeneric;
   if (CheckPayloadType(payload_type, &video_type) != 0) {
     LOG(LS_ERROR) << "Don't send data with unknown payload type: "
                   << static_cast<int>(payload_type) << ".";
     return false;
   }
 
   bool result;
   if (audio_configured_) {
-    TRACE_EVENT_ASYNC_STEP1("webrtc", "Audio", capture_timestamp,
-                            "Send", "type", FrameTypeToString(frame_type));
+    TRACE_EVENT_ASYNC_STEP1("webrtc", "Audio", rtp_timestamp, "Send", "type",
+                            FrameTypeToString(frame_type));
     assert(frame_type == kAudioFrameSpeech || frame_type == kAudioFrameCN ||
            frame_type == kEmptyFrame);
 
-    result = audio_->SendAudio(frame_type, payload_type, capture_timestamp,
+    result = audio_->SendAudio(frame_type, payload_type, rtp_timestamp,
                                payload_data, payload_size, fragmentation);
   } else {
     TRACE_EVENT_ASYNC_STEP1("webrtc", "Video", capture_time_ms,
                             "Send", "type", FrameTypeToString(frame_type));
     assert(frame_type != kAudioFrameSpeech && frame_type != kAudioFrameCN);
 
     if (frame_type == kEmptyFrame)
       return true;
 
     if (rtp_header) {
       playout_delay_oracle_.UpdateRequest(ssrc, rtp_header->playout_delay,
                                           sequence_number);
     }
 
     // Update the active/inactive status of playout delay extension based
     // on what the oracle indicates.
     {
       rtc::CritScope lock(&send_critsect_);
       if (playout_delay_active_ != playout_delay_oracle_.send_playout_delay()) {
         playout_delay_active_ = playout_delay_oracle_.send_playout_delay();
         rtp_header_extension_map_.SetActive(kRtpExtensionPlayoutDelay,
                                             playout_delay_active_);
       }
     }
 
     result = video_->SendVideo(video_type, frame_type, payload_type,
-                               capture_timestamp, capture_time_ms, payload_data,
+                               rtp_timestamp, capture_time_ms, payload_data,
                                payload_size, fragmentation, rtp_header);
   }
 
-  if (transport_frame_id_out) {
-    rtc::CritScope lock(&send_critsect_);
-    // TODO(sergeyu): Move RTP timestamp calculation from BuildRTPheader() to
-    // SendOutgoingData() and pass it to SendVideo()/SendAudio() calls.
-    *transport_frame_id_out = timestamp_;
-  }
-
   rtc::CritScope cs(&statistics_crit_);
   // Note: This is currently only counting for video.
   if (frame_type == kVideoFrameKey) {
     ++frame_counts_.key_frames;
   } else if (frame_type == kVideoFrameDelta) {
     ++frame_counts_.delta_frames;
   }
   if (frame_count_observer_) {
     frame_count_observer_->FrameCountUpdated(frame_counts_, ssrc);
   }
@@ skipping 54 matching lines @@
 
     uint32_t ssrc;
     uint16_t sequence_number;
     int payload_type;
     bool over_rtx;
     {
       rtc::CritScope lock(&send_critsect_);
       if (!sending_media_)
         return bytes_sent;
       if (!timestamp_provided) {
-        timestamp = timestamp_;
+        timestamp = last_rtp_timestamp_;
         capture_time_ms = capture_time_ms_;
       }
       if (rtx_ == kRtxOff) {
         // Without RTX we can't send padding in the middle of frames.
         if (!last_packet_marker_bit_)
           return 0;
         ssrc = ssrc_;
         sequence_number = sequence_number_;
         ++sequence_number_;
         payload_type = payload_type_;
@@ skipping 491 matching lines @@
                                   int64_t capture_time_ms,
                                   bool timestamp_provided,
                                   bool inc_sequence_number) {
   return BuildRtpHeader(data_buffer, payload_type, marker_bit,
                         capture_timestamp, capture_time_ms);
 }
 
 int32_t RTPSender::BuildRtpHeader(uint8_t* data_buffer,
                                   int8_t payload_type,
                                   bool marker_bit,
-                                  uint32_t capture_timestamp,
+                                  uint32_t rtp_timestamp,
                                   int64_t capture_time_ms) {
   assert(payload_type >= 0);
   rtc::CritScope lock(&send_critsect_);
   if (!sending_media_)
     return -1;
 
-  timestamp_ = timestamp_offset_ + capture_timestamp;
+  last_rtp_timestamp_ = rtp_timestamp;
   last_timestamp_time_ms_ = clock_->TimeInMilliseconds();
   uint32_t sequence_number = sequence_number_++;
   capture_time_ms_ = capture_time_ms;
   last_packet_marker_bit_ = marker_bit;
   return CreateRtpHeader(data_buffer, payload_type, ssrc_, marker_bit,
-                         timestamp_, sequence_number, csrcs_);
+                         rtp_timestamp, sequence_number, csrcs_);
 }
 
 uint16_t RTPSender::BuildRtpHeaderExtension(uint8_t* data_buffer,
                                             bool marker_bit) const {
   if (rtp_header_extension_map_.Size() <= 0) {
     return 0;
   }
   // RTP header extension, RFC 3550.
   //   0                   1                   2                   3
   //   0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
@@ skipping 399 matching lines @@
 void RTPSender::SetSendingMediaStatus(bool enabled) {
   rtc::CritScope lock(&send_critsect_);
   sending_media_ = enabled;
 }
 
 bool RTPSender::SendingMedia() const {
   rtc::CritScope lock(&send_critsect_);
   return sending_media_;
 }
 
-uint32_t RTPSender::Timestamp() const {
-  rtc::CritScope lock(&send_critsect_);
-  return timestamp_;
-}
-
 void RTPSender::SetTimestampOffset(uint32_t timestamp) {
   rtc::CritScope lock(&send_critsect_);
   timestamp_offset_ = timestamp;
 }
 
 uint32_t RTPSender::TimestampOffset() const {
   rtc::CritScope lock(&send_critsect_);
   return timestamp_offset_;
 }
 
@@ skipping 153 matching lines @@
 uint32_t RTPSender::BitrateSent() const {
   rtc::CritScope cs(&statistics_crit_);
   return total_bitrate_sent_.Rate(clock_->TimeInMilliseconds()).value_or(0);
 }
 
 void RTPSender::SetRtpState(const RtpState& rtp_state) {
   rtc::CritScope lock(&send_critsect_);
   sequence_number_ = rtp_state.sequence_number;
   sequence_number_forced_ = true;
   timestamp_offset_ = rtp_state.start_timestamp;
-  timestamp_ = rtp_state.timestamp;
+  last_rtp_timestamp_ = rtp_state.timestamp;
   capture_time_ms_ = rtp_state.capture_time_ms;
   last_timestamp_time_ms_ = rtp_state.last_timestamp_time_ms;
   media_has_been_sent_ = rtp_state.media_has_been_sent;
 }
 
 RtpState RTPSender::GetRtpState() const {
   rtc::CritScope lock(&send_critsect_);
 
   RtpState state;
   state.sequence_number = sequence_number_;
   state.start_timestamp = timestamp_offset_;
-  state.timestamp = timestamp_;
+  state.timestamp = last_rtp_timestamp_;
   state.capture_time_ms = capture_time_ms_;
   state.last_timestamp_time_ms = last_timestamp_time_ms_;
   state.media_has_been_sent = media_has_been_sent_;
 
   return state;
 }
 
 void RTPSender::SetRtxRtpState(const RtpState& rtp_state) {
   rtc::CritScope lock(&send_critsect_);
   sequence_number_rtx_ = rtp_state.sequence_number;
 }
 
 RtpState RTPSender::GetRtxRtpState() const {
   rtc::CritScope lock(&send_critsect_);
 
   RtpState state;
   state.sequence_number = sequence_number_rtx_;
   state.start_timestamp = timestamp_offset_;
 
   return state;
 }
 
 }  // namespace webrtc