Lint enabled for webrtc/modules/video_coding folder.

webrtc/modules/video_coding/codec_database.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 200 matching lines @@
     max_payload_size_ = max_payload_size;
     reset_required = true;
   }
 
   VideoCodec new_send_codec;
   memcpy(&new_send_codec, send_codec, sizeof(new_send_codec));
 
   if (new_send_codec.maxBitrate == 0) {
     // max is one bit per pixel
     new_send_codec.maxBitrate = (static_cast<int>(send_codec->height) *
-        static_cast<int>(send_codec->width) *
-        static_cast<int>(send_codec->maxFramerate)) / 1000;
+                                 static_cast<int>(send_codec->width) *
+                                 static_cast<int>(send_codec->maxFramerate)) /
+                                1000;
     if (send_codec->startBitrate > new_send_codec.maxBitrate) {
       // But if the user tries to set a higher start bit rate we will
       // increase the max accordingly.
       new_send_codec.maxBitrate = send_codec->startBitrate;
     }
   }
 
   if (new_send_codec.startBitrate > new_send_codec.maxBitrate)
     new_send_codec.startBitrate = new_send_codec.maxBitrate;
 
@@ skipping 42 matching lines @@
   return true;
 }
 
 VideoCodecType VCMCodecDataBase::SendCodec() const {
   if (!ptr_encoder_) {
     return kVideoCodecUnknown;
   }
   return send_codec_.codecType;
 }
 
-bool VCMCodecDataBase::DeregisterExternalEncoder(
-    uint8_t payload_type, bool* was_send_codec) {
+bool VCMCodecDataBase::DeregisterExternalEncoder(uint8_t payload_type,
+                                                 bool* was_send_codec) {
   assert(was_send_codec);
   *was_send_codec = false;
   if (encoder_payload_type_ != payload_type) {
     return false;
   }
   if (send_codec_.plType == payload_type) {
     // De-register as send codec if needed.
     DeleteEncoder();
     memset(&send_codec_, 0, sizeof(VideoCodec));
     *was_send_codec = true;
   }
   encoder_payload_type_ = 0;
   external_encoder_ = nullptr;
   internal_source_ = false;
   return true;
 }
 
-void VCMCodecDataBase::RegisterExternalEncoder(
-    VideoEncoder* external_encoder,
-    uint8_t payload_type,
-    bool internal_source) {
+void VCMCodecDataBase::RegisterExternalEncoder(VideoEncoder* external_encoder,
+                                               uint8_t payload_type,
+                                               bool internal_source) {
   // Since only one encoder can be used at a given time, only one external
   // encoder can be registered/used.
   external_encoder_ = external_encoder;
   encoder_payload_type_ = payload_type;
   internal_source_ = internal_source;
   pending_encoder_reset_ = true;
 }
 
 bool VCMCodecDataBase::RequiresEncoderReset(const VideoCodec& new_send_codec) {
   if (!ptr_encoder_)
@@ skipping 47 matching lines @@
     // Unknown codec type, reset just to be sure.
     case kVideoCodecUnknown:
       return true;
   }
 
   if (new_send_codec.numberOfSimulcastStreams > 0) {
     for (unsigned char i = 0; i < new_send_codec.numberOfSimulcastStreams;
          ++i) {
       if (memcmp(&new_send_codec.simulcastStream[i],
                  &send_codec_.simulcastStream[i],
-                 sizeof(new_send_codec.simulcastStream[i])) !=
-          0) {
+                 sizeof(new_send_codec.simulcastStream[i])) != 0) {
         return true;
       }
     }
   }
   return false;
 }
 
 VCMGenericEncoder* VCMCodecDataBase::GetEncoder() {
   return ptr_encoder_.get();
 }
@@ skipping 35 matching lines @@
   VCMExtDecoderMapItem* ext_decoder =
       new VCMExtDecoderMapItem(external_decoder, payload_type);
   DeregisterExternalDecoder(payload_type);
   dec_external_map_[payload_type] = ext_decoder;
 }
 
 bool VCMCodecDataBase::DecoderRegistered() const {
   return !dec_map_.empty();
 }
 
-bool VCMCodecDataBase::RegisterReceiveCodec(
-    const VideoCodec* receive_codec,
-    int number_of_cores,
-    bool require_key_frame) {
+bool VCMCodecDataBase::RegisterReceiveCodec(const VideoCodec* receive_codec,
+                                            int number_of_cores,
+                                            bool require_key_frame) {
   if (number_of_cores < 0) {
     return false;
   }
   // Check if payload value already exists, if so  - erase old and insert new.
   DeregisterReceiveCodec(receive_codec->plType);
   if (receive_codec->codecType == kVideoCodecUnknown) {
     return false;
   }
   VideoCodec* new_receive_codec = new VideoCodec(*receive_codec);
-  dec_map_[receive_codec->plType] = new VCMDecoderMapItem(new_receive_codec,
-                                                          number_of_cores,
-                                                          require_key_frame);
+  dec_map_[receive_codec->plType] = new VCMDecoderMapItem(
+      new_receive_codec, number_of_cores, require_key_frame);
   return true;
 }
 
-bool VCMCodecDataBase::DeregisterReceiveCodec(
-    uint8_t payload_type) {
+bool VCMCodecDataBase::DeregisterReceiveCodec(uint8_t payload_type) {
   DecoderMap::iterator it = dec_map_.find(payload_type);
   if (it == dec_map_.end()) {
     return false;
   }
   delete it->second;
   dec_map_.erase(it);
   if (receive_codec_.plType == payload_type) {
     // This codec is currently in use.
     memset(&receive_codec_, 0, sizeof(VideoCodec));
   }
@@ skipping 27 matching lines @@
   if (ptr_decoder_) {
     ReleaseDecoder(ptr_decoder_);
     ptr_decoder_ = nullptr;
     memset(&receive_codec_, 0, sizeof(VideoCodec));
   }
   ptr_decoder_ = CreateAndInitDecoder(frame, &receive_codec_);
   if (!ptr_decoder_) {
     return nullptr;
   }
   VCMReceiveCallback* callback = decoded_frame_callback->UserReceiveCallback();
-  if (callback) callback->OnIncomingPayloadType(receive_codec_.plType);
-  if (ptr_decoder_->RegisterDecodeCompleteCallback(decoded_frame_callback)
-      < 0) {
+  if (callback)
+    callback->OnIncomingPayloadType(receive_codec_.plType);
+  if (ptr_decoder_->RegisterDecodeCompleteCallback(decoded_frame_callback) <
+      0) {
     ReleaseDecoder(ptr_decoder_);
     ptr_decoder_ = nullptr;
     memset(&receive_codec_, 0, sizeof(VideoCodec));
     return nullptr;
   }
   return ptr_decoder_;
 }
 
 void VCMCodecDataBase::ReleaseDecoder(VCMGenericDecoder* decoder) const {
   if (decoder) {
@@ skipping 97 matching lines @@
 
 const VCMExtDecoderMapItem* VCMCodecDataBase::FindExternalDecoderItem(
     uint8_t payload_type) const {
   ExternalDecoderMap::const_iterator it = dec_external_map_.find(payload_type);
   if (it != dec_external_map_.end()) {
     return (*it).second;
   }
   return nullptr;
 }
 }  // namespace webrtc