Renamed fields in rtp_rtcp_defines.h/RTCPReportBlock

webrtc/voice_engine/channel.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 355 matching lines @@
     int total_number_of_packets = 0;
 
     // If receiving multiple report blocks, calculate the weighted average based
     // on the number of packets a report refers to.
     for (ReportBlockList::const_iterator block_it = report_blocks.begin();
          block_it != report_blocks.end(); ++block_it) {
       // Find the previous extended high sequence number for this remote SSRC,
       // to calculate the number of RTP packets this report refers to. Ignore if
       // we haven't seen this SSRC before.
       std::map<uint32_t, uint32_t>::iterator seq_num_it =
-          extended_max_sequence_number_.find(block_it->sourceSSRC);
+          extended_max_sequence_number_.find(block_it->source_ssrc);
       int number_of_packets = 0;
       if (seq_num_it != extended_max_sequence_number_.end()) {
-        number_of_packets = block_it->extendedHighSeqNum - seq_num_it->second;
+        number_of_packets =
+            block_it->extended_highest_sequence_number - seq_num_it->second;
       }
-      fraction_lost_aggregate += number_of_packets * block_it->fractionLost;
+      fraction_lost_aggregate += number_of_packets * block_it->fraction_lost;
       total_number_of_packets += number_of_packets;
 
-      extended_max_sequence_number_[block_it->sourceSSRC] =
-          block_it->extendedHighSeqNum;
+      extended_max_sequence_number_[block_it->source_ssrc] =
+          block_it->extended_highest_sequence_number;
     }
     int weighted_fraction_lost = 0;
     if (total_number_of_packets > 0) {
       weighted_fraction_lost =
           (fraction_lost_aggregate + total_number_of_packets / 2) /
           total_number_of_packets;
     }
     owner_->OnUplinkPacketLossRate(weighted_fraction_lost / 255.0f);
   }
 
@@ skipping 2245 matching lines @@
   if (_rtpRtcpModule->RemoteRTCPStat(&rtcp_report_blocks) != 0) {
     return -1;
   }
 
   if (rtcp_report_blocks.empty())
     return 0;
 
   std::vector<RTCPReportBlock>::const_iterator it = rtcp_report_blocks.begin();
   for (; it != rtcp_report_blocks.end(); ++it) {
     ReportBlock report_block;
-    report_block.sender_SSRC = it->remoteSSRC;
-    report_block.source_SSRC = it->sourceSSRC;
-    report_block.fraction_lost = it->fractionLost;
-    report_block.cumulative_num_packets_lost = it->cumulativeLost;
-    report_block.extended_highest_sequence_number = it->extendedHighSeqNum;
+    report_block.sender_SSRC = it->sender_ssrc;
+    report_block.source_SSRC = it->source_ssrc;
+    report_block.fraction_lost = it->fraction_lost;
+    report_block.cumulative_num_packets_lost = it->packets_lost;
+    report_block.extended_highest_sequence_number =
+        it->extended_highest_sequence_number;
     report_block.interarrival_jitter = it->jitter;
-    report_block.last_SR_timestamp = it->lastSR;
-    report_block.delay_since_last_SR = it->delaySinceLastSR;
+    report_block.last_SR_timestamp = it->last_sender_report_timestamp;
+    report_block.delay_since_last_SR = it->delay_since_last_sender_report;
     report_blocks->push_back(report_block);
   }
   return 0;
 }
 
 int Channel::GetRTPStatistics(CallStatistics& stats) {
   // --- RtcpStatistics
 
   // The jitter statistics is updated for each received RTP packet and is
   // based on received packets.
@@ skipping 466 matching lines @@
       if (channel) {
         // To prevent infinite recursion and deadlock, calling GetRTT of
         // associate channel should always use "false" for argument:
         // |allow_associate_channel|.
         rtt = channel->GetRTT(false);
       }
     }
     return rtt;
   }
 
   uint32_t remoteSSRC = rtp_receiver_->SSRC();

[stefan-webrtc, 2017/08/07 10:43:24]

Would be nice to also change this to sender_ssrc.

[srte, 2017/08/07 12:17:30]

While that would not be wrong, I'm not sure it'd actually provide any
improvement, as it actually makes some sense in that context to call it the
remote ssrc as it is the remote ssrc reported by the RTP Receiver. Maybe worth
it to call it remote_ssrc to follow the naming convetion.

I've tried to make the changeset minimal to make it easier to follow and
understand.

   std::vector<RTCPReportBlock>::const_iterator it = report_blocks.begin();
   for (; it != report_blocks.end(); ++it) {
-    if (it->remoteSSRC == remoteSSRC)
+    if (it->sender_ssrc == remoteSSRC)
       break;
   }
   if (it == report_blocks.end()) {
     // We have not received packets with SSRC matching the report blocks.
     // To calculate RTT we try with the SSRC of the first report block.
     // This is very important for send-only channels where we don't know
     // the SSRC of the other end.
-    remoteSSRC = report_blocks[0].remoteSSRC;
+    remoteSSRC = report_blocks[0].sender_ssrc;
   }
 
   int64_t avg_rtt = 0;
   int64_t max_rtt = 0;
   int64_t min_rtt = 0;
   if (_rtpRtcpModule->RTT(remoteSSRC, &rtt, &avg_rtt, &min_rtt, &max_rtt) !=
       0) {
     return 0;
   }
   return rtt;
 }
 
 }  // namespace voe
 }  // namespace webrtc