Lint fix for webrtc/modules/video_coding PART 2!

webrtc/modules/video_coding/jitter_buffer.h

 /*
  *  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 12 matching lines @@
 #include "webrtc/modules/video_coding/include/video_coding_defines.h"
 #include "webrtc/modules/video_coding/decoding_state.h"
 #include "webrtc/modules/video_coding/inter_frame_delay.h"
 #include "webrtc/modules/video_coding/jitter_buffer_common.h"
 #include "webrtc/modules/video_coding/jitter_estimator.h"
 #include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/typedefs.h"
 
 namespace webrtc {
 
-enum VCMNackMode {
-  kNack,
-  kNoNack
-};
+enum VCMNackMode { kNack, kNoNack };
 
 // forward declarations
 class Clock;
 class EventFactory;
 class EventWrapper;
 class VCMFrameBuffer;
 class VCMPacket;
 class VCMEncodedFrame;
 
 typedef std::list<VCMFrameBuffer*> UnorderedFrameList;
 
 struct VCMJitterSample {
   VCMJitterSample() : timestamp(0), frame_size(0), latest_packet_time(-1) {}
   uint32_t timestamp;
   uint32_t frame_size;
   int64_t latest_packet_time;
 };
 
 class TimestampLessThan {
  public:
-  bool operator() (uint32_t timestamp1,
-                   uint32_t timestamp2) const {
+  bool operator()(uint32_t timestamp1, uint32_t timestamp2) const {
     return IsNewerTimestamp(timestamp2, timestamp1);
   }
 };
 
 class FrameList
     : public std::map<uint32_t, VCMFrameBuffer*, TimestampLessThan> {
  public:
   void InsertFrame(VCMFrameBuffer* frame);
   VCMFrameBuffer* PopFrame(uint32_t timestamp);
   VCMFrameBuffer* Front() const;
   VCMFrameBuffer* Back() const;
   int RecycleFramesUntilKeyFrame(FrameList::iterator* key_frame_it,
-      UnorderedFrameList* free_frames);
+                                 UnorderedFrameList* free_frames);
   void CleanUpOldOrEmptyFrames(VCMDecodingState* decoding_state,
                                UnorderedFrameList* free_frames);
   void Reset(UnorderedFrameList* free_frames);
 };
 
 class Vp9SsMap {
  public:
   typedef std::map<uint32_t, GofInfoVP9, TimestampLessThan> SsMap;
   bool Insert(const VCMPacket& packet);
   void Reset();
@@ skipping 52 matching lines @@
   // Gets number of packets received.
   int num_packets() const;
 
   // Gets number of duplicated packets received.
   int num_duplicated_packets() const;
 
   // Gets number of packets discarded by the jitter buffer.
   int num_discarded_packets() const;
 
   // Statistics, Calculate frame and bit rates.
-  void IncomingRateStatistics(unsigned int* framerate,
-                              unsigned int* bitrate);
+  void IncomingRateStatistics(unsigned int* framerate, unsigned int* bitrate);
 
   // Checks if the packet sequence will be complete if the next frame would be
   // grabbed for decoding. That is, if a frame has been lost between the
   // last decoded frame and the next, or if the next frame is missing one
   // or more packets.
   bool CompleteSequenceWithNextFrame();
 
   // Wait |max_wait_time_ms| for a complete frame to arrive.
   // The function returns true once such a frame is found, its corresponding
   // timestamp is returned. Otherwise, returns false.
@@ skipping 14 matching lines @@
 
   // Returns the time in ms when the latest packet was inserted into the frame.
   // Retransmitted is set to true if any of the packets belonging to the frame
   // has been retransmitted.
   int64_t LastPacketTime(const VCMEncodedFrame* frame,
                          bool* retransmitted) const;
 
   // Inserts a packet into a frame returned from GetFrame().
   // If the return value is <= 0, |frame| is invalidated and the pointer must
   // be dropped after this function returns.
-  VCMFrameBufferEnum InsertPacket(const VCMPacket& packet,
-                                  bool* retransmitted);
+  VCMFrameBufferEnum InsertPacket(const VCMPacket& packet, bool* retransmitted);
 
   // Returns the estimated jitter in milliseconds.
   uint32_t EstimatedJitterMs();
 
   // Updates the round-trip time estimate.
   void UpdateRtt(int64_t rtt_ms);
 
   // Set the NACK mode. |high_rtt_nack_threshold_ms| is an RTT threshold in ms
   // above which NACK will be disabled if the NACK mode is |kNack|, -1 meaning
   // that NACK is always enabled in the |kNack| mode.
   // |low_rtt_nack_threshold_ms| is an RTT threshold in ms below which we expect
   // to rely on NACK only, and therefore are using larger buffers to have time
   // to wait for retransmissions.
-  void SetNackMode(VCMNackMode mode, int64_t low_rtt_nack_threshold_ms,
+  void SetNackMode(VCMNackMode mode,
+                   int64_t low_rtt_nack_threshold_ms,
                    int64_t high_rtt_nack_threshold_ms);
 
   void SetNackSettings(size_t max_nack_list_size,
                        int max_packet_age_to_nack,
                        int max_incomplete_time_ms);
 
   // Returns the current NACK mode.
   VCMNackMode nack_mode() const;
 
   // Returns a list of the sequence numbers currently missing.
   std::vector<uint16_t> GetNackList(bool* request_key_frame);
 
   // Set decode error mode - Should not be changed in the middle of the
   // session. Changes will not influence frames already in the buffer.
   void SetDecodeErrorMode(VCMDecodeErrorMode error_mode);
   int64_t LastDecodedTimestamp() const;
-  VCMDecodeErrorMode decode_error_mode() const {return decode_error_mode_;}
+  VCMDecodeErrorMode decode_error_mode() const { return decode_error_mode_; }
 
   // Used to compute time of complete continuous frames. Returns the timestamps
   // corresponding to the start and end of the continuous complete buffer.
   void RenderBufferSize(uint32_t* timestamp_start, uint32_t* timestamp_end);
 
   void RegisterStatsCallback(VCMReceiveStatisticsCallback* callback);
 
  private:
   class SequenceNumberLessThan {
    public:
-    bool operator() (const uint16_t& sequence_number1,
-                     const uint16_t& sequence_number2) const {
+    bool operator()(const uint16_t& sequence_number1,
+                    const uint16_t& sequence_number2) const {
       return IsNewerSequenceNumber(sequence_number2, sequence_number1);
     }
   };
   typedef std::set<uint16_t, SequenceNumberLessThan> SequenceNumberSet;
 
   // Gets the frame assigned to the timestamp of the packet. May recycle
   // existing frames if no free frames are available. Returns an error code if
   // failing, or kNoError on success. |frame_list| contains which list the
   // packet was in, or NULL if it was not in a FrameList (a new frame).
   VCMFrameBufferEnum GetFrame(const VCMPacket& packet,
@@ skipping 150 matching lines @@
   // Estimated rolling average of packets per frame
   float average_packets_per_frame_;
   // average_packets_per_frame converges fast if we have fewer than this many
   // frames.
   int frame_counter_;
   RTC_DISALLOW_COPY_AND_ASSIGN(VCMJitterBuffer);
 };
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_VIDEO_CODING_JITTER_BUFFER_H_