Moved ring-buffer related files from common_audio to audio_processing

webrtc/modules/audio_processing/utility/blocker.cc

 /*
  *  Copyright (c) 2014 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/common_audio/blocker.h"
+#include "webrtc/modules/audio_processing/utility/blocker.h"
 
 #include <string.h>
 
 #include "webrtc/base/checks.h"
 
 namespace {
 
 // Adds |a| and |b| frame by frame into |result| (basically matrix addition).
 void AddFrames(const float* const* a,
                size_t a_start_index,
@@ skipping 12 matching lines @@
 }
 
 // Copies |src| into |dst| channel by channel.
 void CopyFrames(const float* const* src,
                 size_t src_start_index,
                 size_t num_frames,
                 size_t num_channels,
                 float* const* dst,
                 size_t dst_start_index) {
   for (size_t i = 0; i < num_channels; ++i) {
-    memcpy(&dst[i][dst_start_index],
-           &src[i][src_start_index],
+    memcpy(&dst[i][dst_start_index], &src[i][src_start_index],
            num_frames * sizeof(dst[i][dst_start_index]));
   }
 }
 
 // Moves |src| into |dst| channel by channel.
 void MoveFrames(const float* const* src,
                 size_t src_start_index,
                 size_t num_frames,
                 size_t num_channels,
                 float* const* dst,
                 size_t dst_start_index) {
   for (size_t i = 0; i < num_channels; ++i) {
-    memmove(&dst[i][dst_start_index],
-            &src[i][src_start_index],
+    memmove(&dst[i][dst_start_index], &src[i][src_start_index],
             num_frames * sizeof(dst[i][dst_start_index]));
   }
 }
 
 void ZeroOut(float* const* buffer,
              size_t starting_idx,
              size_t num_frames,
              size_t num_channels) {
   for (size_t i = 0; i < num_channels; ++i) {
     memset(&buffer[i][starting_idx], 0,
@@ skipping 10 matching lines @@
   for (size_t i = 0; i < num_channels; ++i) {
     for (size_t j = 0; j < num_frames; ++j) {
       frames[i][j] = frames[i][j] * window[j];
     }
   }
 }
 
 size_t gcd(size_t a, size_t b) {
   size_t tmp;
   while (b) {
-     tmp = a;
-     a = b;
-     b = tmp % b;
+    tmp = a;
+    a = b;
+    b = tmp % b;
   }
   return a;
 }
 
 }  // namespace
 
 namespace webrtc {
 
 Blocker::Blocker(size_t chunk_size,
                  size_t block_size,
@@ skipping 72 matching lines @@
 
   input_buffer_.Write(input, num_input_channels, chunk_size_);
   size_t first_frame_in_block = frame_offset_;
 
   // Loop through blocks.
   while (first_frame_in_block < chunk_size_) {
     input_buffer_.Read(input_block_.channels(), num_input_channels,
                        block_size_);
     input_buffer_.MoveReadPositionBackward(block_size_ - shift_amount_);
 
-    ApplyWindow(window_.get(),
-                block_size_,
-                num_input_channels_,
+    ApplyWindow(window_.get(), block_size_, num_input_channels_,
                 input_block_.channels());
-    callback_->ProcessBlock(input_block_.channels(),
-                            block_size_,
-                            num_input_channels_,
-                            num_output_channels_,
+    callback_->ProcessBlock(input_block_.channels(), block_size_,
+                            num_input_channels_, num_output_channels_,
                             output_block_.channels());
-    ApplyWindow(window_.get(),
-                block_size_,
-                num_output_channels_,
+    ApplyWindow(window_.get(), block_size_, num_output_channels_,
                 output_block_.channels());
 
-    AddFrames(output_buffer_.channels(),
-              first_frame_in_block,
-              output_block_.channels(),
-              0,
-              block_size_,
-              num_output_channels_,
-              output_buffer_.channels(),
-              first_frame_in_block);
+    AddFrames(output_buffer_.channels(), first_frame_in_block,
+              output_block_.channels(), 0, block_size_, num_output_channels_,
+              output_buffer_.channels(), first_frame_in_block);
 
     first_frame_in_block += shift_amount_;
   }
 
   // Copy output buffer to output
-  CopyFrames(output_buffer_.channels(),
-             0,
-             chunk_size_,
-             num_output_channels_,
-             output,
-             0);
+  CopyFrames(output_buffer_.channels(), 0, chunk_size_, num_output_channels_,
+             output, 0);
 
   // Copy output buffer [chunk_size_, chunk_size_ + initial_delay]
   // to output buffer [0, initial_delay], zero the rest.
-  MoveFrames(output_buffer_.channels(),
-             chunk_size,
-             initial_delay_,
-             num_output_channels_,
-             output_buffer_.channels(),
-             0);
-  ZeroOut(output_buffer_.channels(),
-          initial_delay_,
-          chunk_size_,
+  MoveFrames(output_buffer_.channels(), chunk_size, initial_delay_,
+             num_output_channels_, output_buffer_.channels(), 0);
+  ZeroOut(output_buffer_.channels(), initial_delay_, chunk_size_,
           num_output_channels_);
 
   // Calculate new starting frames.
   frame_offset_ = first_frame_in_block - chunk_size_;
 }
 
 }  // namespace webrtc