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);
 
+  timestamp_offset_ = random_.Rand<uint32_t>();

[terelius, 2016/08/15 14:56:03]

Note that this PRNG is not cryptographic strength. It is also not seeded with
enough entropy for cryptographic purposes. In fact, it has even less entropy
than what is suggested in the RFC 3550.

[danilchap, 2016/08/15 15:23:17]

Done. Simple note added.

   // 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_ = start_timestamp_ + capture_timestamp;
+  timestamp_ = timestamp_offset_ + 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) {
-    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 {
+  if (!enabled) {
     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::SetStartTimestamp(uint32_t timestamp, bool force) {
+void RTPSender::SetTimestampOffset(uint32_t timestamp) {
   rtc::CritScope lock(&send_critsect_);
-  if (force) {
-    start_timestamp_forced_ = true;
-    start_timestamp_ = timestamp;
-  } else {
-    if (!start_timestamp_forced_) {
-      start_timestamp_ = timestamp;
-    }
-  }
+  timestamp_offset_ = timestamp;
 }
 
-uint32_t RTPSender::StartTimestamp() const {
+uint32_t RTPSender::TimestampOffset() const {
   rtc::CritScope lock(&send_critsect_);
-  return start_timestamp_;
+  return timestamp_offset_;
 }
 
 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;

[terelius, 2016/08/15 14:56:03]

Rename start_timestamp in the state struct too?

[danilchap, 2016/08/15 15:23:17]

Prefer to avoid modifying structure in the /include/ subfolder.

   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 = start_timestamp_;
+  state.start_timestamp = timestamp_offset_;
   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 = start_timestamp_;
+  state.start_timestamp = timestamp_offset_;
 
   return state;
 }
 
 }  // namespace webrtc