Lint enabled for webrtc/modules/video_coding folder.

webrtc/modules/video_coding/test/rtp_player.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.
  */
 
 #include "webrtc/modules/video_coding/test/rtp_player.h"
 
 #include <stdio.h>
 
 #include <map>
 
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_payload_registry.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_receiver.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
 #include "webrtc/modules/video_coding/internal_defines.h"
 #include "webrtc/modules/video_coding/test/test_util.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/test/rtp_file_reader.h"
 
 #if 1
-# define DEBUG_LOG1(text, arg)
+#define DEBUG_LOG1(text, arg)
 #else
-# define DEBUG_LOG1(text, arg) (printf(text "\n", arg))
+#define DEBUG_LOG1(text, arg) (printf(text "\n", arg))
 #endif
 
 namespace webrtc {
 namespace rtpplayer {
 
 enum {
   kMaxPacketBufferSize = 4096,
   kDefaultTransmissionTimeOffsetExtensionId = 2
 };
 
 class RawRtpPacket {
  public:
-  RawRtpPacket(const uint8_t* data, size_t length, uint32_t ssrc,
+  RawRtpPacket(const uint8_t* data,
+               size_t length,
+               uint32_t ssrc,
                uint16_t seq_num)
       : data_(new uint8_t[length]),
         length_(length),
         resend_time_ms_(-1),
         ssrc_(ssrc),
         seq_num_(seq_num) {
     assert(data);
     memcpy(data_.get(), data, length_);
   }
 
@@ skipping 78 matching lines @@
         return packet;
       }
     }
     return NULL;
   }
 
   int NumberOfPacketsToResend() const {
     CriticalSectionScoped cs(crit_sect_.get());
     int count = 0;
     for (ConstRtpPacketIterator it = packets_.begin(); it != packets_.end();
-        ++it) {
+         ++it) {
       if ((*it)->resend_time_ms() >= 0) {
         count++;
       }
     }
     return count;
   }
 
   void LogPacketResent(RawRtpPacket* packet) {
     int64_t now_ms = clock_->TimeInMilliseconds();
     CriticalSectionScoped cs(crit_sect_.get());
     if (debug_file_) {
       fprintf(debug_file_, "Resent %u at %u\n", packet->seq_num(),
               MaskWord64ToUWord32(now_ms));
     }
   }
 
   void Print() const {
     CriticalSectionScoped cs(crit_sect_.get());
     printf("Lost packets: %u\n", loss_count_);
     printf("Packets waiting to be resent: %d\n", NumberOfPacketsToResend());
     printf("Packets still lost: %zd\n", packets_.size());
     printf("Sequence numbers:\n");
     for (ConstRtpPacketIterator it = packets_.begin(); it != packets_.end();
-        ++it) {
+         ++it) {
       printf("%u, ", (*it)->seq_num());
     }
     printf("\n");
   }
 
  private:
   typedef std::vector<RawRtpPacket*> RtpPacketList;
   typedef RtpPacketList::iterator RtpPacketIterator;
   typedef RtpPacketList::const_iterator ConstRtpPacketIterator;
 
@@ skipping 46 matching lines @@
     if (handler->rtp_module_.get() == NULL) {
       return -1;
     }
 
     handler->rtp_module_->SetNACKStatus(kNackOff);
     handler->rtp_header_parser_->RegisterRtpHeaderExtension(
         kRtpExtensionTransmissionTimeOffset,
         kDefaultTransmissionTimeOffsetExtensionId);
 
     for (PayloadTypesIterator it = payload_types_.begin();
-        it != payload_types_.end(); ++it) {
+         it != payload_types_.end(); ++it) {
       VideoCodec codec;
       memset(&codec, 0, sizeof(codec));
-      strncpy(codec.plName, it->name().c_str(), sizeof(codec.plName)-1);
+      strncpy(codec.plName, it->name().c_str(), sizeof(codec.plName) - 1);
       codec.plType = it->payload_type();
       codec.codecType = it->codec_type();
-      if (handler->rtp_module_->RegisterReceivePayload(codec.plName,
-                                                       codec.plType,
-                                                       90000,
-                                                       0,
-                                                       codec.maxBitrate) < 0) {
+      if (handler->rtp_module_->RegisterReceivePayload(
+              codec.plName, codec.plType, 90000, 0, codec.maxBitrate) < 0) {
         return -1;
       }
     }
 
     handlers_[ssrc] = handler.release();
     return 0;
   }
 
   void IncomingPacket(const uint8_t* data, size_t length) {
     for (HandlerMapIt it = handlers_.begin(); it != handlers_.end(); ++it) {
       if (!it->second->rtp_header_parser_->IsRtcp(data, length)) {
         RTPHeader header;
         it->second->rtp_header_parser_->Parse(data, length, &header);
         PayloadUnion payload_specific;
         it->second->rtp_payload_registry_->GetPayloadSpecifics(
             header.payloadType, &payload_specific);
         it->second->rtp_module_->IncomingRtpPacket(header, data, length,
                                                    payload_specific, true);
       }
     }
   }
 
  private:
   class Handler : public RtpStreamInterface {
    public:
-    Handler(uint32_t ssrc, const PayloadTypes& payload_types,
+    Handler(uint32_t ssrc,
+            const PayloadTypes& payload_types,
             LostPackets* lost_packets)
         : rtp_header_parser_(RtpHeaderParser::Create()),
           rtp_payload_registry_(new RTPPayloadRegistry(
               RTPPayloadStrategy::CreateStrategy(false))),
           rtp_module_(),
           payload_sink_(),
           ssrc_(ssrc),
           payload_types_(payload_types),
           lost_packets_(lost_packets) {
       assert(lost_packets);
     }
     virtual ~Handler() {}
 
     virtual void ResendPackets(const uint16_t* sequence_numbers,
                                uint16_t length) {
       assert(sequence_numbers);
       for (uint16_t i = 0; i < length; i++) {
         lost_packets_->SetResendTime(ssrc_, sequence_numbers[i]);
       }
     }
 
     virtual uint32_t ssrc() const { return ssrc_; }
-    virtual const PayloadTypes& payload_types() const {
-      return payload_types_;
-    }
+    virtual const PayloadTypes& payload_types() const { return payload_types_; }
 
     rtc::scoped_ptr<RtpHeaderParser> rtp_header_parser_;
     rtc::scoped_ptr<RTPPayloadRegistry> rtp_payload_registry_;
     rtc::scoped_ptr<RtpReceiver> rtp_module_;
     rtc::scoped_ptr<PayloadSinkInterface> payload_sink_;
 
    private:
     uint32_t ssrc_;
     const PayloadTypes& payload_types_;
     LostPackets* lost_packets_;
@@ skipping 38 matching lines @@
     assert(packet_source->get());
     packet_source_.swap(*packet_source);
     srand(321);
   }
 
   virtual ~RtpPlayerImpl() {}
 
   virtual int NextPacket(int64_t time_now) {
     // Send any packets ready to be resent.
     for (RawRtpPacket* packet = lost_packets_.NextPacketToResend(time_now);
-         packet != NULL;
-         packet = lost_packets_.NextPacketToResend(time_now)) {
+         packet != NULL; packet = lost_packets_.NextPacketToResend(time_now)) {
       int ret = SendPacket(packet->data(), packet->length());
       if (ret > 0) {
         printf("Resend: %08x:%u\n", packet->ssrc(), packet->seq_num());
         lost_packets_.LogPacketResent(packet);
         resend_packet_count_++;
       }
       delete packet;
       if (ret < 0) {
         return ret;
       }
@@ skipping 19 matching lines @@
         SendPacket(reorder_buffer_->data(), reorder_buffer_->length());
         reorder_buffer_.reset(NULL);
       }
       if (ret < 0) {
         return ret;
       }
 
       if (!packet_source_->NextPacket(&next_packet_)) {
         end_of_file_ = true;
         return 0;
-      }
-      else if (next_packet_.length == 0) {
+      } else if (next_packet_.length == 0) {
         return 0;
       }
     }
 
     if (end_of_file_ && lost_packets_.NumberOfPacketsToResend() == 0) {
       return 1;
     }
     return 0;
   }
 
   virtual uint32_t TimeUntilNextPacket() const {
     int64_t time_left = (next_rtp_time_ - first_packet_rtp_time_) -
-        (clock_->TimeInMilliseconds() - first_packet_time_ms_);
+                        (clock_->TimeInMilliseconds() - first_packet_time_ms_);
     if (time_left < 0) {
       return 0;
     }
     return static_cast<uint32_t>(time_left);
   }
 
   virtual void Print() const {
     printf("Resent packets: %u\n", resend_packet_count_);
     lost_packets_.Print();
   }
@@ skipping 11 matching lines @@
         return -1;
       }
       uint32_t ssrc = header.ssrc;
       if (ssrc_handlers_.RegisterSsrc(ssrc, &lost_packets_, clock_) < 0) {
         DEBUG_LOG1("Unable to register ssrc: %d", ssrc);
         return -1;
       }
 
       if (no_loss_startup_ > 0) {
         no_loss_startup_--;
-      } else if ((rand() + 1.0)/(RAND_MAX + 1.0) < loss_rate_) {
+      } else if ((rand() + 1.0) / (RAND_MAX + 1.0) < loss_rate_) {  // NOLINT
         uint16_t seq_num = header.sequenceNumber;
         lost_packets_.AddPacket(new RawRtpPacket(data, length, ssrc, seq_num));
         DEBUG_LOG1("Dropped packet: %d!", header.header.sequenceNumber);
         return 0;
       }
     }
 
     ssrc_handlers_.IncomingPacket(data, length);
     return 1;
   }
@@ skipping 11 matching lines @@
   uint32_t resend_packet_count_;
   uint32_t no_loss_startup_;
   bool end_of_file_;
   bool reordering_;
   rtc::scoped_ptr<RawRtpPacket> reorder_buffer_;
 
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(RtpPlayerImpl);
 };
 
 RtpPlayerInterface* Create(const std::string& input_filename,
-    PayloadSinkFactoryInterface* payload_sink_factory, Clock* clock,
-    const PayloadTypes& payload_types, float loss_rate, int64_t rtt_ms,
-    bool reordering) {
+                           PayloadSinkFactoryInterface* payload_sink_factory,
+                           Clock* clock,
+                           const PayloadTypes& payload_types,
+                           float loss_rate,
+                           int64_t rtt_ms,
+                           bool reordering) {
   rtc::scoped_ptr<test::RtpFileReader> packet_source(
       test::RtpFileReader::Create(test::RtpFileReader::kRtpDump,
                                   input_filename));
   if (packet_source.get() == NULL) {
     packet_source.reset(test::RtpFileReader::Create(test::RtpFileReader::kPcap,
                                                     input_filename));
     if (packet_source.get() == NULL) {
       return NULL;
     }
   }
 
   rtc::scoped_ptr<RtpPlayerImpl> impl(
       new RtpPlayerImpl(payload_sink_factory, payload_types, clock,
                         &packet_source, loss_rate, rtt_ms, reordering));
   return impl.release();
 }
 }  // namespace rtpplayer
 }  // namespace webrtc