Reformat existing code. There should be no functional effects.

webrtc/modules/audio_device/test/func_test_manager.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 349 matching lines @@
             {
                 int ret(0);
                 int lenOut(0);
                 int16_t tmpBuf_96kHz[80 * 12];
                 int16_t* ptr16In = NULL;
                 int16_t* ptr16Out = NULL;
 
                 const uint16_t nSamplesIn = packet->nSamples;
                 const uint8_t nChannelsIn = packet->nChannels;
                 const uint32_t samplesPerSecIn = packet->samplesPerSec;
-                const uint16_t nBytesPerSampleIn =
-                    packet->nBytesPerSample;
+                const uint16_t nBytesPerSampleIn = packet->nBytesPerSample;
 
                 int32_t fsInHz(samplesPerSecIn);
                 int32_t fsOutHz(samplesPerSec);
 
                 if (fsInHz == 44100)
                     fsInHz = 44000;
 
                 if (fsOutHz == 44100)
                     fsOutHz = 44000;
 
                 if (nChannelsIn == 2 && nBytesPerSampleIn == 4)
                 {
                     // input is stereo => we will resample in stereo
                     ret = _resampler.ResetIfNeeded(fsInHz, fsOutHz, 2);
                     if (ret == 0)
                     {
                         if (nChannels == 2)
                         {
                             _resampler.Push(
                                 (const int16_t*) packet->dataBuffer,
-                                2 * nSamplesIn,
-                                (int16_t*) audioSamples, 2
-                                * nSamples, lenOut);
+                                2 * nSamplesIn, (int16_t*) audioSamples,
+                                2 * nSamples, lenOut);
                         } else
                         {
                             _resampler.Push(
                                 (const int16_t*) packet->dataBuffer,
-                                2 * nSamplesIn, tmpBuf_96kHz, 2
-                                * nSamples, lenOut);
+                                2 * nSamplesIn, tmpBuf_96kHz, 2 * nSamples,
+                                lenOut);
 
                             ptr16In = &tmpBuf_96kHz[0];
                             ptr16Out = (int16_t*) audioSamples;
 
                             // do stereo -> mono
                             for (unsigned int i = 0; i < nSamples; i++)
                             {
                                 *ptr16Out = *ptr16In; // use left channel
                                 ptr16Out++;
                                 ptr16In++;
@@ skipping 11 matching lines @@
                 } else
                 {
                     // input is mono (can be "reduced from stereo" as well) =>
                     // we will resample in mono
                     ret = _resampler.ResetIfNeeded(fsInHz, fsOutHz, 1);
                     if (ret == 0)
                     {
                         if (nChannels == 1)
                         {
                             _resampler.Push(
-                                (const int16_t*) packet->dataBuffer,
-                                nSamplesIn,
-                                (int16_t*) audioSamples,
-                                nSamples, lenOut);
+                                (const int16_t*) packet->dataBuffer, nSamplesIn,
+                                (int16_t*) audioSamples, nSamples, lenOut);
                         } else
                         {
                             _resampler.Push(
-                                (const int16_t*) packet->dataBuffer,
-                                nSamplesIn, tmpBuf_96kHz, nSamples,
-                                lenOut);
+                                (const int16_t*) packet->dataBuffer, nSamplesIn,
+                                tmpBuf_96kHz, nSamples, lenOut);
 
                             ptr16In = &tmpBuf_96kHz[0];
                             ptr16Out = (int16_t*) audioSamples;
 
                             // do mono -> stereo
                             for (unsigned int i = 0; i < nSamples; i++)
                             {
                                 *ptr16Out = *ptr16In; // left
                                 ptr16Out++;
                                 *ptr16Out = *ptr16In; // right (same as left sample)
@@ skipping 13 matching lines @@
                 delete packet;
             }
         }
     }  // if (_fullDuplex)
 
     if (_playFromFile && _playFile.Open())
     {
         int16_t fileBuf[480];
 
         // read mono-file
-        int32_t len = _playFile.Read((int8_t*) fileBuf, 2
-            * nSamples);
+        int32_t len = _playFile.Read((int8_t*) fileBuf, 2 * nSamples);
         if (len != 2 * (int32_t) nSamples)
         {
             _playFile.Rewind();
             _playFile.Read((int8_t*) fileBuf, 2 * nSamples);
         }
 
         // convert to stero if required
         if (nChannels == 1)
         {
             memcpy(audioSamples, fileBuf, 2 * nSamples);
@@ skipping 2281 matching lines @@
 
     TEST_LOG("\n");
     PRINT_TEST_RESULTS;
 
     return 0;
 }
 
 }  // namespace webrtc
 
 // EOF