Lint enabled for webrtc/modules/video_coding folder.

webrtc/modules/video_coding/generic_encoder.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/generic_encoder.h"
+
+#include <vector>
+
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/engine_configurations.h"
 #include "webrtc/modules/video_coding/encoded_frame.h"
-#include "webrtc/modules/video_coding/generic_encoder.h"
 #include "webrtc/modules/video_coding/media_optimization.h"
 #include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 
 namespace webrtc {
 namespace {
 // Map information from info into rtp. If no relevant information is found
 // in info, rtp is set to NULL.
 void CopyCodecSpecific(const CodecSpecificInfo* info, RTPVideoHeader* rtp) {
   RTC_DCHECK(info);
   switch (info->codecType) {
     case kVideoCodecVP8: {
       rtp->codec = kRtpVideoVp8;
       rtp->codecHeader.VP8.InitRTPVideoHeaderVP8();
       rtp->codecHeader.VP8.pictureId = info->codecSpecific.VP8.pictureId;
-      rtp->codecHeader.VP8.nonReference =
-          info->codecSpecific.VP8.nonReference;
+      rtp->codecHeader.VP8.nonReference = info->codecSpecific.VP8.nonReference;
       rtp->codecHeader.VP8.temporalIdx = info->codecSpecific.VP8.temporalIdx;
       rtp->codecHeader.VP8.layerSync = info->codecSpecific.VP8.layerSync;
       rtp->codecHeader.VP8.tl0PicIdx = info->codecSpecific.VP8.tl0PicIdx;
       rtp->codecHeader.VP8.keyIdx = info->codecSpecific.VP8.keyIdx;
       rtp->simulcastIdx = info->codecSpecific.VP8.simulcastIdx;
       return;
     }
     case kVideoCodecVP9: {
       rtp->codec = kRtpVideoVp9;
       rtp->codecHeader.VP9.InitRTPVideoHeaderVP9();
@@ skipping 39 matching lines @@
     case kVideoCodecGeneric:
       rtp->codec = kRtpVideoGeneric;
       rtp->simulcastIdx = info->codecSpecific.generic.simulcast_idx;
       return;
     default:
       return;
   }
 }
 }  // namespace
 
-//#define DEBUG_ENCODER_BIT_STREAM
+// #define DEBUG_ENCODER_BIT_STREAM
 
 VCMGenericEncoder::VCMGenericEncoder(
     VideoEncoder* encoder,
     VideoEncoderRateObserver* rate_observer,
     VCMEncodedFrameCallback* encoded_frame_callback,
     bool internalSource)
     : encoder_(encoder),
       rate_observer_(rate_observer),
       vcm_encoded_frame_callback_(encoded_frame_callback),
       internal_source_(internalSource),
@@ skipping 79 matching lines @@
                                  params.input_frame_rate);
     }
   }
 }
 
 EncoderParameters VCMGenericEncoder::GetEncoderParameters() const {
   rtc::CritScope lock(&params_lock_);
   return encoder_params_;
 }
 
-int32_t
-VCMGenericEncoder::SetPeriodicKeyFrames(bool enable)
-{
-    return encoder_->SetPeriodicKeyFrames(enable);
+int32_t VCMGenericEncoder::SetPeriodicKeyFrames(bool enable) {
+  return encoder_->SetPeriodicKeyFrames(enable);
 }
 
 int32_t VCMGenericEncoder::RequestFrame(
     const std::vector<FrameType>& frame_types) {
   VideoFrame image;
   return encoder_->Encode(image, NULL, &frame_types);
 }
 
-bool
-VCMGenericEncoder::InternalSource() const
-{
-    return internal_source_;
+bool VCMGenericEncoder::InternalSource() const {
+  return internal_source_;
 }
 
 void VCMGenericEncoder::OnDroppedFrame() {
   encoder_->OnDroppedFrame();
 }
 
 bool VCMGenericEncoder::SupportsNativeHandle() const {
   return encoder_->SupportsNativeHandle();
 }
 
 int VCMGenericEncoder::GetTargetFramerate() {
   return encoder_->GetTargetFramerate();
 }
 
- /***************************
-  * Callback Implementation
-  ***************************/
+/***************************
+ * Callback Implementation
+ ***************************/
 VCMEncodedFrameCallback::VCMEncodedFrameCallback(
     EncodedImageCallback* post_encode_callback)
     : _sendCallback(),
       _mediaOpt(NULL),
       _payloadType(0),
       _internalSource(false),
       _rotation(kVideoRotation_0),
       post_encode_callback_(post_encode_callback)
 #ifdef DEBUG_ENCODER_BIT_STREAM
       ,
       _bitStreamAfterEncoder(NULL)
 #endif
 {
 #ifdef DEBUG_ENCODER_BIT_STREAM
-    _bitStreamAfterEncoder = fopen("encoderBitStream.bit", "wb");
+  _bitStreamAfterEncoder = fopen("encoderBitStream.bit", "wb");
 #endif
 }
 
-VCMEncodedFrameCallback::~VCMEncodedFrameCallback()
-{
+VCMEncodedFrameCallback::~VCMEncodedFrameCallback() {
 #ifdef DEBUG_ENCODER_BIT_STREAM
-    fclose(_bitStreamAfterEncoder);
+  fclose(_bitStreamAfterEncoder);
 #endif
 }
 
-int32_t
-VCMEncodedFrameCallback::SetTransportCallback(VCMPacketizationCallback* transport)
-{
-    _sendCallback = transport;
-    return VCM_OK;
+int32_t VCMEncodedFrameCallback::SetTransportCallback(
+    VCMPacketizationCallback* transport) {
+  _sendCallback = transport;
+  return VCM_OK;
 }
 
 int32_t VCMEncodedFrameCallback::Encoded(
     const EncodedImage& encodedImage,
     const CodecSpecificInfo* codecSpecificInfo,
     const RTPFragmentationHeader* fragmentationHeader) {
   TRACE_EVENT_INSTANT1("webrtc", "VCMEncodedFrameCallback::Encoded",
                        "timestamp", encodedImage._timeStamp);
   RTC_DCHECK(encodedImage._frameType == kVideoFrameKey ||
              encodedImage._frameType == kVideoFrameDelta);
@@ skipping 25 matching lines @@
   }
 
   if (_mediaOpt != NULL) {
     _mediaOpt->UpdateWithEncodedData(encodedImage);
     if (_internalSource)
       return _mediaOpt->DropFrame();  // Signal to encoder to drop next frame.
   }
   return VCM_OK;
 }
 
-void
-VCMEncodedFrameCallback::SetMediaOpt(
-    media_optimization::MediaOptimization *mediaOpt)
-{
-    _mediaOpt = mediaOpt;
+void VCMEncodedFrameCallback::SetMediaOpt(
+    media_optimization::MediaOptimization* mediaOpt) {
+  _mediaOpt = mediaOpt;
 }
 
 }  // namespace webrtc