Revert of StartTimestamp generated randomly in RtpSender constructor

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 91 matching lines @@
       rtp_stats_callback_(nullptr),
       total_bitrate_sent_(kBitrateStatisticsWindowMs,
                           RateStatistics::kBpsScale),
       nack_bitrate_sent_(kBitrateStatisticsWindowMs, RateStatistics::kBpsScale),
       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
+      start_timestamp_forced_(false),
+      start_timestamp_(0),
       ssrc_db_(SSRCDatabase::GetSSRCDatabase()),
       remote_ssrc_(0),
       sequence_number_forced_(false),
       ssrc_forced_(false),
       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();
   RTC_DCHECK(ssrc_rtx_ != 0);
 
-  // This random initialization is not intended to be cryptographic strong.
-  timestamp_offset_ = random_.Rand<uint32_t>();
   // Random start, 16 bits. Can't be 0.
   sequence_number_rtx_ = random_.Rand(1, kMaxInitRtpSeqNumber);
   sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber);
 }
 
 RTPSender::~RTPSender() {
   // TODO(tommi): Use a thread checker to ensure the object is created and
   // deleted on the same thread.  At the moment this isn't possible due to
   // voe::ChannelOwner in voice engine.  To reproduce, run:
   // voe_auto_test --automated --gtest_filter=*MixManyChannelsForStressOpus
@@ skipping 951 matching lines @@
 int32_t RTPSender::BuildRtpHeader(uint8_t* data_buffer,
                                   int8_t payload_type,
                                   bool marker_bit,
                                   uint32_t capture_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;
+  timestamp_ = start_timestamp_ + capture_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_);
 }
 
 uint16_t RTPSender::BuildRtpHeaderExtension(uint8_t* data_buffer,
                                             bool marker_bit) const {
@@ skipping 379 matching lines @@
 
   *packet_id = transport_sequence_number_allocator_->AllocateSequenceNumber();
 
   if (!packet->SetExtension<TransportSequenceNumber>(*packet_id))
     return false;
 
   return true;
 }
 
 void RTPSender::SetSendingStatus(bool enabled) {
-  if (!enabled) {
+  if (enabled) {
+    uint32_t frequency_hz = SendPayloadFrequency();
+    uint32_t RTPtime = CurrentRtp(*clock_, frequency_hz);
+
+    // Will be ignored if it's already configured via API.
+    SetStartTimestamp(RTPtime, false);
+  } else {
     rtc::CritScope lock(&send_critsect_);
     if (!ssrc_forced_) {
       // Generate a new SSRC.
       ssrc_db_->ReturnSSRC(ssrc_);
       ssrc_ = ssrc_db_->CreateSSRC();
       RTC_DCHECK(ssrc_ != 0);
     }
     // Don't initialize seq number if SSRC passed externally.
     if (!sequence_number_forced_ && !ssrc_forced_) {
       // Generate a new sequence number.
@@ skipping 10 matching lines @@
 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) {
+void RTPSender::SetStartTimestamp(uint32_t timestamp, bool force) {
   rtc::CritScope lock(&send_critsect_);
-  timestamp_offset_ = timestamp;
+  if (force) {
+    start_timestamp_forced_ = true;
+    start_timestamp_ = timestamp;
+  } else {
+    if (!start_timestamp_forced_) {
+      start_timestamp_ = timestamp;
+    }
+  }
 }
 
-uint32_t RTPSender::TimestampOffset() const {
+uint32_t RTPSender::StartTimestamp() const {
   rtc::CritScope lock(&send_critsect_);
-  return timestamp_offset_;
+  return start_timestamp_;
 }
 
 uint32_t RTPSender::GenerateNewSSRC() {
   // If configured via API, return 0.
   rtc::CritScope lock(&send_critsect_);
 
   if (ssrc_forced_) {
     return 0;
   }
   ssrc_ = ssrc_db_->CreateSSRC();
@@ skipping 158 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;
   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.start_timestamp = start_timestamp_;
   state.timestamp = 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_;
+  state.start_timestamp = start_timestamp_;
 
   return state;
 }
 
 }  // namespace webrtc