Clang format of video_processing folder.

webrtc/modules/video_processing/video_processing_impl.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_processing/video_processing_impl.h"
 
 #include <assert.h>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 
-
 namespace webrtc {
 
 namespace {
 
 int GetSubSamplingFactor(int width, int height) {
   if (width * height >= 640 * 480) {
     return 3;
   } else if (width * height >= 352 * 288) {
     return 2;
   } else if (width * height >= 176 * 144) {
@@ skipping 25 matching lines @@
   const uint8_t* buffer = frame.buffer(kYPlane);
   // Compute histogram and sum of frame
   for (int i = 0; i < height; i += (1 << stats->sub_sampling_factor)) {
     int k = i * width;
     for (int j = 0; j < width; j += (1 << stats->sub_sampling_factor)) {
       stats->hist[buffer[k + j]]++;
       stats->sum += buffer[k + j];
     }
   }
 
-  stats->num_pixels = (width * height) /
-      ((1 << stats->sub_sampling_factor) * (1 << stats->sub_sampling_factor));
+  stats->num_pixels = (width * height) / ((1 << stats->sub_sampling_factor) *
+                                          (1 << stats->sub_sampling_factor));
   assert(stats->num_pixels > 0);
 
   // Compute mean value of frame
   stats->mean = stats->sum / stats->num_pixels;
 }
 
 bool VideoProcessing::ValidFrameStats(const FrameStats& stats) {
   if (stats.num_pixels == 0) {
     LOG(LS_WARNING) << "Invalid frame stats.";
     return false;
@@ skipping 28 matching lines @@
     temp_ptr++;
   }
 }
 
 int32_t VideoProcessingImpl::Deflickering(VideoFrame* frame,
                                           FrameStats* stats) {
   rtc::CritScope mutex(&mutex_);
   return deflickering_.ProcessFrame(frame, stats);
 }
 
-int32_t VideoProcessingImpl::BrightnessDetection(
-    const VideoFrame& frame,
-    const FrameStats& stats) {
+int32_t VideoProcessingImpl::BrightnessDetection(const VideoFrame& frame,
+                                                 const FrameStats& stats) {
   rtc::CritScope mutex(&mutex_);
   return brightness_detection_.ProcessFrame(frame, stats);
 }
 
-
 void VideoProcessingImpl::EnableTemporalDecimation(bool enable) {
   rtc::CritScope mutex(&mutex_);
   frame_pre_processor_.EnableTemporalDecimation(enable);
 }
 
-
-void VideoProcessingImpl::SetInputFrameResampleMode(VideoFrameResampling
-                                                    resampling_mode) {
+void VideoProcessingImpl::SetInputFrameResampleMode(
+    VideoFrameResampling resampling_mode) {
   rtc::CritScope cs(&mutex_);
   frame_pre_processor_.SetInputFrameResampleMode(resampling_mode);
 }
 
 int32_t VideoProcessingImpl::SetTargetResolution(uint32_t width,
                                                  uint32_t height,
                                                  uint32_t frame_rate) {
   rtc::CritScope cs(&mutex_);
   return frame_pre_processor_.SetTargetResolution(width, height, frame_rate);
 }
 
 void VideoProcessingImpl::SetTargetFramerate(int frame_rate) {
   rtc::CritScope cs(&mutex_);
   frame_pre_processor_.SetTargetFramerate(frame_rate);
 }
 
 uint32_t VideoProcessingImpl::GetDecimatedFrameRate() {
   rtc::CritScope cs(&mutex_);
-  return  frame_pre_processor_.GetDecimatedFrameRate();
+  return frame_pre_processor_.GetDecimatedFrameRate();
 }
 
 uint32_t VideoProcessingImpl::GetDecimatedWidth() const {
   rtc::CritScope cs(&mutex_);
   return frame_pre_processor_.GetDecimatedWidth();
 }
 
 uint32_t VideoProcessingImpl::GetDecimatedHeight() const {
   rtc::CritScope cs(&mutex_);
   return frame_pre_processor_.GetDecimatedHeight();
@@ skipping 14 matching lines @@
   rtc::CritScope mutex(&mutex_);
   return frame_pre_processor_.GetContentMetrics();
 }
 
 void VideoProcessingImpl::EnableContentAnalysis(bool enable) {
   rtc::CritScope mutex(&mutex_);
   frame_pre_processor_.EnableContentAnalysis(enable);
 }
 
 }  // namespace webrtc