Removed extended jitter report from RtcpSender

webrtc/modules/rtp_rtcp/source/rtcp_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 72 matching lines @@
               uint32_t buffer_size)
       : feedback_state(feedback_state),
         nack_size(nack_size),
         nack_list(nack_list),
         repeat(repeat),
         picture_id(picture_id),
         buffer(buffer),
         buffer_size(buffer_size),
         ntp_sec(0),
         ntp_frac(0),
-        jitter_transmission_offset(0),
         position(0) {}
 
   uint8_t* AllocateData(uint32_t bytes) {
     DCHECK_LE(position + bytes, buffer_size);
     uint8_t* ptr = &buffer[position];
     position += bytes;
     return ptr;
   }
 
   const FeedbackState& feedback_state;
   int32_t nack_size;
   const uint16_t* nack_list;
   bool repeat;
   uint64_t picture_id;
   uint8_t* buffer;
   uint32_t buffer_size;
   uint32_t ntp_sec;
   uint32_t ntp_frac;
-  uint32_t jitter_transmission_offset;
   uint32_t position;
 };
 
 // TODO(sprang): Once all builders use RtcpPacket, call SendToNetwork() here.
 class RTCPSender::PacketBuiltCallback
     : public rtcp::RtcpPacket::PacketReadyCallback {
  public:
   PacketBuiltCallback(RtcpContext* context) : context_(context) {}
   virtual ~PacketBuiltCallback() {}
   void OnPacketReady(uint8_t* data, size_t length) override {
@@ skipping 16 matching lines @@
       method_(kRtcpOff),
       critical_section_transport_(
           CriticalSectionWrapper::CreateCriticalSection()),
       cbTransport_(nullptr),
 
       critical_section_rtcp_sender_(
           CriticalSectionWrapper::CreateCriticalSection()),
       using_nack_(false),
       sending_(false),
       remb_enabled_(false),
-      extended_jitter_report_enabled_(false),
       next_time_to_send_rtcp_(0),
       start_timestamp_(0),
       last_rtp_timestamp_(0),
       last_frame_capture_time_ms_(-1),
       ssrc_(0),
       remote_ssrc_(0),
       receive_statistics_(receive_statistics),
 
       sequence_number_fir_(0),
 
       remb_bitrate_(0),
 
       tmmbr_help_(),
       tmmbr_send_(0),
       packet_oh_send_(0),
 
       app_sub_type_(0),
       app_name_(0),
       app_data_(nullptr),
       app_length_(0),
 
       xr_send_receiver_reference_time_enabled_(false),
       packet_type_counter_observer_(packet_type_counter_observer) {
   memset(last_send_report_, 0, sizeof(last_send_report_));
   memset(last_rtcp_time_, 0, sizeof(last_rtcp_time_));
 
   builders_[kRtcpSr] = &RTCPSender::BuildSR;
   builders_[kRtcpRr] = &RTCPSender::BuildRR;
   builders_[kRtcpSdes] = &RTCPSender::BuildSDES;
-  builders_[kRtcpTransmissionTimeOffset] =
-      &RTCPSender::BuildExtendedJitterReport;
   builders_[kRtcpPli] = &RTCPSender::BuildPLI;
   builders_[kRtcpFir] = &RTCPSender::BuildFIR;
   builders_[kRtcpSli] = &RTCPSender::BuildSLI;
   builders_[kRtcpRpsi] = &RTCPSender::BuildRPSI;
   builders_[kRtcpRemb] = &RTCPSender::BuildREMB;
   builders_[kRtcpBye] = &RTCPSender::BuildBYE;
   builders_[kRtcpApp] = &RTCPSender::BuildAPP;
   builders_[kRtcpTmmbr] = &RTCPSender::BuildTMMBR;
   builders_[kRtcpTmmbn] = &RTCPSender::BuildTMMBN;
   builders_[kRtcpNack] = &RTCPSender::BuildNACK;
@@ skipping 82 matching lines @@
 
 void RTCPSender::SetTMMBRStatus(bool enable) {
   CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
   if (enable) {
     SetFlag(RTCPPacketType::kRtcpTmmbr, false);
   } else {
     ConsumeFlag(RTCPPacketType::kRtcpTmmbr, true);
   }
 }
 
-bool RTCPSender::IJ() const {
-  CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
-  return extended_jitter_report_enabled_;
-}
-
-void RTCPSender::SetIJStatus(bool enable) {
-  CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
-  extended_jitter_report_enabled_ = enable;
-}
-
 void RTCPSender::SetStartTimestamp(uint32_t start_timestamp) {
   CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
   start_timestamp_ = start_timestamp;
 }
 
 void RTCPSender::SetLastRtpTime(uint32_t rtp_timestamp,
                                 int64_t capture_time_ms) {
   CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
   last_rtp_timestamp_ = rtp_timestamp;
   if (capture_time_ms < 0) {
@@ skipping 253 matching lines @@
                                   ctx->buffer_size - ctx->position,
                                   &callback)) {
     return BuildResult::kTruncated;
   }
 
   report_blocks_.clear();
 
   return BuildResult::kSuccess;
 }
 
-// From RFC 5450: Transmission Time Offsets in RTP Streams.
-//        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
-//       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-//   hdr |V=2|P|    RC   |   PT=IJ=195   |             length            |
-//       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-//       |                      inter-arrival jitter                     |
-//       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-//       .                                                               .
-//       .                                                               .
-//       .                                                               .
-//       |                      inter-arrival jitter                     |
-//       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-//
-//  If present, this RTCP packet must be placed after a receiver report
-//  (inside a compound RTCP packet), and MUST have the same value for RC
-//  (reception report count) as the receiver report.
-
-RTCPSender::BuildResult RTCPSender::BuildExtendedJitterReport(
-    RtcpContext* ctx) {
-  // sanity
-  if (ctx->position + 8 >= IP_PACKET_SIZE)
-    return BuildResult::kTruncated;
-
-  // add picture loss indicator
-  uint8_t RC = 1;
-  *ctx->AllocateData(1) = 0x80 + RC;
-  *ctx->AllocateData(1) = 195;
-
-  // Used fixed length of 2
-  *ctx->AllocateData(1) = 0;
-  *ctx->AllocateData(1) = 1;
-
-  // Add inter-arrival jitter
-  ByteWriter<uint32_t>::WriteBigEndian(ctx->AllocateData(4),
-                                       ctx->jitter_transmission_offset);
-  return BuildResult::kSuccess;
-}
-
 RTCPSender::BuildResult RTCPSender::BuildPLI(RtcpContext* ctx) {
   // sanity
   if (ctx->position + 12 >= IP_PACKET_SIZE)
     return BuildResult::kTruncated;
 
   // add picture loss indicator
   uint8_t FMT = 1;
   *ctx->AllocateData(1) = 0x80 + FMT;
   *ctx->AllocateData(1) = 206;
 
@@ skipping 764 matching lines @@
     StatisticianMap statisticians =
         receive_statistics_->GetActiveStatisticians();
     if (!statisticians.empty()) {
       for (auto it = statisticians.begin(); it != statisticians.end(); ++it) {
         RTCPReportBlock report_block;
         if (PrepareReport(feedback_state, it->first, it->second,
                           &report_block)) {
           AddReportBlock(report_block);
         }
       }
-      if (extended_jitter_report_enabled_)
-        SetFlag(kRtcpTransmissionTimeOffset, true);
     }
   }
 
   auto it = report_flags_.begin();
   while (it != report_flags_.end()) {
     auto builder = builders_.find(it->type);
     DCHECK(builder != builders_.end());
     if (it->is_volatile) {
       report_flags_.erase(it++);
     } else {
@@ skipping 157 matching lines @@
 
 bool RTCPSender::AllVolatileFlagsConsumed() const {
   for (const ReportFlag& flag : report_flags_) {
     if (flag.is_volatile)
       return false;
   }
   return true;
 }
 
 }  // namespace webrtc