Fix issues with RestartingSendStreamPreservesRtpStatesWithRtx

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 832 matching lines @@
     TRACE_EVENT_ASYNC_END0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "PacedSend",
                            capture_time_ms);
   }
 
   TRACE_EVENT_INSTANT2(
       TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "PrepareAndSendPacket",
       "timestamp", rtp_header.timestamp, "seqnum", rtp_header.sequenceNumber);
 
   uint8_t data_buffer_rtx[IP_PACKET_SIZE];
   if (send_over_rtx) {
-    BuildRtxPacket(buffer, &length, data_buffer_rtx);
+    if (!BuildRtxPacket(buffer, &length, data_buffer_rtx))
+      return false;
     buffer_to_send_ptr = data_buffer_rtx;
   }
 
   int64_t now_ms = clock_->TimeInMilliseconds();
   int64_t diff_ms = now_ms - capture_time_ms;
   UpdateTransmissionTimeOffset(buffer_to_send_ptr, length, rtp_header,
                                diff_ms);
   UpdateAbsoluteSendTime(buffer_to_send_ptr, length, rtp_header, now_ms);
 
   PacketOptions options;
@@ skipping 283 matching lines @@
                         capture_timestamp, capture_time_ms);
 }
 
 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;
   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_);
 }
 
@@ skipping 619 matching lines @@
 int32_t RTPSender::SetFecParameters(
     const FecProtectionParams *delta_params,
     const FecProtectionParams *key_params) {
   if (audio_configured_) {
     return -1;
   }
   video_->SetFecParameters(delta_params, key_params);
   return 0;
 }
 
-void RTPSender::BuildRtxPacket(uint8_t* buffer, size_t* length,
+bool RTPSender::BuildRtxPacket(uint8_t* buffer,
+                               size_t* length,
                                uint8_t* buffer_rtx) {
   rtc::CritScope lock(&send_critsect_);
+  if (!sending_media_)
+    return false;
   uint8_t* data_buffer_rtx = buffer_rtx;
   // Add RTX header.
   RtpUtility::RtpHeaderParser rtp_parser(
       reinterpret_cast<const uint8_t*>(buffer), *length);
 
   RTPHeader rtp_header;
   rtp_parser.Parse(&rtp_header);
 
   // Add original RTP header.
   memcpy(data_buffer_rtx, buffer, rtp_header.headerLength);
@@ skipping 20 matching lines @@
 
   // Add OSN (original sequence number).
   ptr = data_buffer_rtx + rtp_header.headerLength;
   ByteWriter<uint16_t>::WriteBigEndian(ptr, rtp_header.sequenceNumber);
   ptr += 2;
 
   // Add original payload data.
   memcpy(ptr, buffer + rtp_header.headerLength,
          *length - rtp_header.headerLength);
   *length += 2;
+  return true;
 }
 
 void RTPSender::RegisterRtpStatisticsCallback(
     StreamDataCountersCallback* callback) {
   rtc::CritScope cs(&statistics_crit_);
   rtp_stats_callback_ = callback;
 }
 
 StreamDataCountersCallback* RTPSender::GetRtpStatisticsCallback() const {
   rtc::CritScope cs(&statistics_crit_);
@@ skipping 38 matching lines @@
   rtc::CritScope lock(&send_critsect_);
 
   RtpState state;
   state.sequence_number = sequence_number_rtx_;
   state.start_timestamp = start_timestamp_;
 
   return state;
 }
 
 }  // namespace webrtc