[rtp_rtcp] lint whitespace warning removed from most source/ files

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 17 matching lines @@
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h"
 #include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 
 namespace webrtc {
 
 using RTCPUtility::RTCPCnameInformation;
 
 NACKStringBuilder::NACKStringBuilder()
-    : stream_(""), count_(0), prevNack_(0), consecutive_(false) {
-}
+    : stream_(""), count_(0), prevNack_(0), consecutive_(false) {}
 
 NACKStringBuilder::~NACKStringBuilder() {}
 
-void NACKStringBuilder::PushNACK(uint16_t nack)
-{
+void NACKStringBuilder::PushNACK(uint16_t nack) {
   if (count_ == 0) {
     stream_ << nack;
   } else if (nack == prevNack_ + 1) {
     consecutive_ = true;
   } else {
     if (consecutive_) {
       stream_ << "-" << prevNack_;
       consecutive_ = false;
     }
     stream_ << "," << nack;
@@ skipping 13 matching lines @@
 RTCPSender::FeedbackState::FeedbackState()
     : send_payload_type(0),
       frequency_hz(0),
       packets_sent(0),
       media_bytes_sent(0),
       send_bitrate(0),
       last_rr_ntp_secs(0),
       last_rr_ntp_frac(0),
       remote_sr(0),
       has_last_xr_rr(false),
-      module(nullptr) {
-}
+      module(nullptr) {}
 
 class PacketContainer : public rtcp::Empty,
                         public rtcp::RtcpPacket::PacketReadyCallback {
  public:
   explicit PacketContainer(Transport* transport)
       : transport_(transport), bytes_sent_(0) {}
   virtual ~PacketContainer() {
     for (RtcpPacket* packet : appended_packets_)
       delete packet;
   }
@@ skipping 100 matching lines @@
   builders_[kRtcpApp] = &RTCPSender::BuildAPP;
   builders_[kRtcpTmmbr] = &RTCPSender::BuildTMMBR;
   builders_[kRtcpTmmbn] = &RTCPSender::BuildTMMBN;
   builders_[kRtcpNack] = &RTCPSender::BuildNACK;
   builders_[kRtcpXrVoipMetric] = &RTCPSender::BuildVoIPMetric;
   builders_[kRtcpXrReceiverReferenceTime] =
       &RTCPSender::BuildReceiverReferenceTime;
   builders_[kRtcpXrDlrrReportBlock] = &RTCPSender::BuildDlrr;
 }
 
-RTCPSender::~RTCPSender() {
-}
+RTCPSender::~RTCPSender() {}
 
 RtcpMode RTCPSender::Status() const {
   CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
   return method_;
 }
 
 void RTCPSender::SetRTCPStatus(RtcpMode method) {
   CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
   method_ = method;
 
@@ skipping 125 matching lines @@
   auto it = csrc_cnames_.find(SSRC);
 
   if (it == csrc_cnames_.end())
     return -1;
 
   csrc_cnames_.erase(it);
   return 0;
 }
 
 bool RTCPSender::TimeToSendRTCPReport(bool sendKeyframeBeforeRTP) const {
-/*
-    For audio we use a fix 5 sec interval
+  /*
+      For audio we use a fix 5 sec interval
 
-    For video we use 1 sec interval fo a BW smaller than 360 kbit/s,
-        technicaly we break the max 5% RTCP BW for video below 10 kbit/s but
-        that should be extremely rare
+      For video we use 1 sec interval fo a BW smaller than 360 kbit/s,
+          technicaly we break the max 5% RTCP BW for video below 10 kbit/s but
+          that should be extremely rare
 
 
-From RFC 3550
+  From RFC 3550
 
-    MAX RTCP BW is 5% if the session BW
-        A send report is approximately 65 bytes inc CNAME
-        A receiver report is approximately 28 bytes
+      MAX RTCP BW is 5% if the session BW
+          A send report is approximately 65 bytes inc CNAME
+          A receiver report is approximately 28 bytes
 
-    The RECOMMENDED value for the reduced minimum in seconds is 360
-      divided by the session bandwidth in kilobits/second.  This minimum
-      is smaller than 5 seconds for bandwidths greater than 72 kb/s.
+      The RECOMMENDED value for the reduced minimum in seconds is 360
+        divided by the session bandwidth in kilobits/second.  This minimum
+        is smaller than 5 seconds for bandwidths greater than 72 kb/s.
 
-    If the participant has not yet sent an RTCP packet (the variable
-      initial is true), the constant Tmin is set to 2.5 seconds, else it
-      is set to 5 seconds.
+      If the participant has not yet sent an RTCP packet (the variable
+        initial is true), the constant Tmin is set to 2.5 seconds, else it
+        is set to 5 seconds.
 
-    The interval between RTCP packets is varied randomly over the
-      range [0.5,1.5] times the calculated interval to avoid unintended
-      synchronization of all participants
+      The interval between RTCP packets is varied randomly over the
+        range [0.5,1.5] times the calculated interval to avoid unintended
+        synchronization of all participants
 
-    if we send
-    If the participant is a sender (we_sent true), the constant C is
-      set to the average RTCP packet size (avg_rtcp_size) divided by 25%
-      of the RTCP bandwidth (rtcp_bw), and the constant n is set to the
-      number of senders.
+      if we send
+      If the participant is a sender (we_sent true), the constant C is
+        set to the average RTCP packet size (avg_rtcp_size) divided by 25%
+        of the RTCP bandwidth (rtcp_bw), and the constant n is set to the
+        number of senders.
 
-    if we receive only
-      If we_sent is not true, the constant C is set
-      to the average RTCP packet size divided by 75% of the RTCP
-      bandwidth.  The constant n is set to the number of receivers
-      (members - senders).  If the number of senders is greater than
-      25%, senders and receivers are treated together.
+      if we receive only
+        If we_sent is not true, the constant C is set
+        to the average RTCP packet size divided by 75% of the RTCP
+        bandwidth.  The constant n is set to the number of receivers
+        (members - senders).  If the number of senders is greater than
+        25%, senders and receivers are treated together.
 
-    reconsideration NOT required for peer-to-peer
-      "timer reconsideration" is
-      employed.  This algorithm implements a simple back-off mechanism
-      which causes users to hold back RTCP packet transmission if the
-      group sizes are increasing.
+      reconsideration NOT required for peer-to-peer
+        "timer reconsideration" is
+        employed.  This algorithm implements a simple back-off mechanism
+        which causes users to hold back RTCP packet transmission if the
+        group sizes are increasing.
 
-      n = number of members
-      C = avg_size/(rtcpBW/4)
+        n = number of members
+        C = avg_size/(rtcpBW/4)
 
-   3. The deterministic calculated interval Td is set to max(Tmin, n*C).
+     3. The deterministic calculated interval Td is set to max(Tmin, n*C).
 
-   4. The calculated interval T is set to a number uniformly distributed
-      between 0.5 and 1.5 times the deterministic calculated interval.
+     4. The calculated interval T is set to a number uniformly distributed
+        between 0.5 and 1.5 times the deterministic calculated interval.
 
-   5. The resulting value of T is divided by e-3/2=1.21828 to compensate
-      for the fact that the timer reconsideration algorithm converges to
-      a value of the RTCP bandwidth below the intended average
-*/
+     5. The resulting value of T is divided by e-3/2=1.21828 to compensate
+        for the fact that the timer reconsideration algorithm converges to
+        a value of the RTCP bandwidth below the intended average
+  */
 
   int64_t now = clock_->TimeInMilliseconds();
 
   CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
 
   if (method_ == RtcpMode::kOff)
     return false;
 
   if (!audio_ && sendKeyframeBeforeRTP) {
     // for video key-frames we want to send the RTCP before the large key-frame
@@ skipping 543 matching lines @@
 bool RTCPSender::PrepareReportBlock(const FeedbackState& feedback_state,
                                     uint32_t ssrc,
                                     StreamStatistician* statistician,
                                     RTCPReportBlock* report_block) {
   // Do we have receive statistics to send?
   RtcpStatistics stats;
   if (!statistician->GetStatistics(&stats, true))
     return false;
   report_block->fractionLost = stats.fraction_lost;
   report_block->cumulativeLost = stats.cumulative_lost;
-  report_block->extendedHighSeqNum =
-      stats.extended_max_sequence_number;
+  report_block->extendedHighSeqNum = stats.extended_max_sequence_number;
   report_block->jitter = stats.jitter;
   report_block->remoteSSRC = ssrc;
 
   // TODO(sprang): Do we really need separate time stamps for each report?
   // Get our NTP as late as possible to avoid a race.
   uint32_t ntp_secs;
   uint32_t ntp_frac;
   clock_->CurrentNtp(ntp_secs, ntp_frac);
 
   // Delay since last received report.
   uint32_t delaySinceLastReceivedSR = 0;
   if ((feedback_state.last_rr_ntp_secs != 0) ||
       (feedback_state.last_rr_ntp_frac != 0)) {
     // Get the 16 lowest bits of seconds and the 16 highest bits of fractions.
     uint32_t now = ntp_secs & 0x0000FFFF;
     now <<= 16;
     now += (ntp_frac & 0xffff0000) >> 16;
 
     uint32_t receiveTime = feedback_state.last_rr_ntp_secs & 0x0000FFFF;
     receiveTime <<= 16;
     receiveTime += (feedback_state.last_rr_ntp_frac & 0xffff0000) >> 16;
 
-    delaySinceLastReceivedSR = now-receiveTime;
+    delaySinceLastReceivedSR = now - receiveTime;
   }
   report_block->delaySinceLastSR = delaySinceLastReceivedSR;
   report_block->lastSR = feedback_state.remote_sr;
   return true;
 }
 
 void RTCPSender::SetCsrcs(const std::vector<uint32_t>& csrcs) {
   assert(csrcs.size() <= kRtpCsrcSize);
   CriticalSectionScoped lock(critical_section_rtcp_sender_.get());
   csrcs_ = csrcs;
@@ skipping 93 matching lines @@
     Transport* const transport_;
     bool send_failure_;
   } sender(transport_);
 
   uint8_t buffer[IP_PACKET_SIZE];
   return packet.BuildExternalBuffer(buffer, IP_PACKET_SIZE, &sender) &&
          !sender.send_failure_;
 }
 
 }  // namespace webrtc