Run clang-format over macOS audio I/O implementations.

media/audio/mac/audio_low_latency_input_mac.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
+#include "media/audio/mac/audio_low_latency_input_mac.h"
 
-#include "media/audio/mac/audio_low_latency_input_mac.h"
 #include <CoreServices/CoreServices.h>
 #include <mach/mach.h>
 #include <string>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/mac/mac_logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/strings/stringprintf.h"
@@ skipping 253 matching lines @@
       number_of_restart_attempts_(0),
       total_number_of_restart_attempts_(0),
       log_callback_(log_callback),
       weak_factory_(this) {
   DCHECK(manager_);
   CHECK(!log_callback_.Equals(AudioManager::LogCallback()));
 
   // Set up the desired (output) format specified by the client.
   format_.mSampleRate = input_params.sample_rate();
   format_.mFormatID = kAudioFormatLinearPCM;
-  format_.mFormatFlags = kLinearPCMFormatFlagIsPacked |
-                         kLinearPCMFormatFlagIsSignedInteger;
+  format_.mFormatFlags =
+      kLinearPCMFormatFlagIsPacked | kLinearPCMFormatFlagIsSignedInteger;
   DCHECK(FormatIsInterleaved(format_.mFormatFlags));
   format_.mBitsPerChannel = input_params.bits_per_sample();
   format_.mChannelsPerFrame = input_params.channels();
   format_.mFramesPerPacket = 1;  // uncompressed audio
-  format_.mBytesPerPacket = (format_.mBitsPerChannel *
-                             input_params.channels()) / 8;
+  format_.mBytesPerPacket =
+      (format_.mBitsPerChannel * input_params.channels()) / 8;
   format_.mBytesPerFrame = format_.mBytesPerPacket;
   format_.mReserved = 0;
 
   DVLOG(1) << "ctor";
   DVLOG(1) << "device ID: 0x" << std::hex << audio_device_id;
   DVLOG(1) << "buffer size : " << number_of_frames_;
   DVLOG(1) << "channels : " << input_params.channels();
   DVLOG(1) << "desired output format: " << format_;
 
   // Derive size (in bytes) of the buffers that we will render to.
@@ skipping 41 matching lines @@
       AudioManagerMac::HardwareSampleRateForDevice(input_device_id_);
   DCHECK_EQ(sample_rate, format_.mSampleRate);
 
   // Start by obtaining an AudioOuputUnit using an AUHAL component description.
 
   // Description for the Audio Unit we want to use (AUHAL in this case).
   // The kAudioUnitSubType_HALOutput audio unit interfaces to any audio device.
   // The user specifies which audio device to track. The audio unit can do
   // input from the device as well as output to the device. Bus 0 is used for
   // the output side, bus 1 is used to get audio input from the device.
-  AudioComponentDescription desc = {
-      kAudioUnitType_Output,
-      kAudioUnitSubType_HALOutput,
-      kAudioUnitManufacturer_Apple,
-      0,
-      0
-  };
+  AudioComponentDescription desc = {kAudioUnitType_Output,
+                                    kAudioUnitSubType_HALOutput,
+                                    kAudioUnitManufacturer_Apple, 0, 0};
 
   // Find a component that meets the description in |desc|.
   AudioComponent comp = AudioComponentFindNext(nullptr, &desc);
   DCHECK(comp);
   if (!comp) {
     HandleError(kAudioUnitErr_NoConnection);
     return false;
   }
 
   // Get access to the service provided by the specified Audio Unit.
@@ skipping 22 matching lines @@
 
   // After creating the AUHAL object, we must enable IO on the input scope
   // of the Audio Unit to obtain the device input. Input must be explicitly
   // enabled with the kAudioOutputUnitProperty_EnableIO property on Element 1
   // of the AUHAL. Because the AUHAL can be used for both input and output,
   // we must also disable IO on the output scope.
 
   UInt32 enableIO = 1;
 
   // Enable input on the AUHAL.
-  result = AudioUnitSetProperty(audio_unit_,
-                                kAudioOutputUnitProperty_EnableIO,
+  result = AudioUnitSetProperty(audio_unit_, kAudioOutputUnitProperty_EnableIO,
                                 kAudioUnitScope_Input,
                                 1,          // input element 1
                                 &enableIO,  // enable
                                 sizeof(enableIO));
   if (result != noErr) {
     HandleError(result);
     return false;
   }
 
   // Disable output on the AUHAL.
   enableIO = 0;
-  result = AudioUnitSetProperty(audio_unit_,
-                                kAudioOutputUnitProperty_EnableIO,
+  result = AudioUnitSetProperty(audio_unit_, kAudioOutputUnitProperty_EnableIO,
                                 kAudioUnitScope_Output,
                                 0,          // output element 0
                                 &enableIO,  // disable
                                 sizeof(enableIO));
   if (result != noErr) {
     HandleError(result);
     return false;
   }
 
   // Next, set the audio device to be the Audio Unit's current device.
   // Note that, devices can only be set to the AUHAL after enabling IO.
-  result = AudioUnitSetProperty(audio_unit_,
-                                kAudioOutputUnitProperty_CurrentDevice,
-                                kAudioUnitScope_Global,
-                                0,
-                                &input_device_id_,
-                                sizeof(input_device_id_));
+  result = AudioUnitSetProperty(
+      audio_unit_, kAudioOutputUnitProperty_CurrentDevice,
+      kAudioUnitScope_Global, 0, &input_device_id_, sizeof(input_device_id_));
   if (result != noErr) {
     HandleError(result);
     return false;
   }
 
   // Register the input procedure for the AUHAL. This procedure will be called
   // when the AUHAL has received new data from the input device.
   AURenderCallbackStruct callback;
   callback.inputProc = &DataIsAvailable;
   callback.inputProcRefCon = this;
@@ skipping 95 matching lines @@
   DLOG_IF(ERROR, !audio_unit_) << "Open() has not been called successfully";
   if (IsRunning())
     return;
 
   // Check if we should defer Start() for http://crbug.com/160920.
   if (manager_->ShouldDeferStreamStart()) {
     LOG(WARNING) << "Start of input audio is deferred";
     start_was_deferred_ = true;
     // Use a cancellable closure so that if Stop() is called before Start()
     // actually runs, we can cancel the pending start.
-    deferred_start_cb_.Reset(base::Bind(
-        &AUAudioInputStream::Start, base::Unretained(this), callback));
+    deferred_start_cb_.Reset(base::Bind(&AUAudioInputStream::Start,
+                                        base::Unretained(this), callback));
     manager_->GetTaskRunner()->PostDelayedTask(
         FROM_HERE, deferred_start_cb_.callback(),
         base::TimeDelta::FromSeconds(
             AudioManagerMac::kStartDelayInSecsForPowerEvents));
     return;
   }
 
   sink_ = callback;
   last_success_time_ = base::TimeTicks::Now();
   last_callback_time_ = base::TimeTicks::Now();
@@ skipping 128 matching lines @@
   DCHECK_LE(volume, 1.0);
 
   // Verify that we have a valid device.
   if (input_device_id_ == kAudioObjectUnknown) {
     NOTREACHED() << "Device ID is unknown";
     return;
   }
 
   Float32 volume_float32 = static_cast<Float32>(volume);
   AudioObjectPropertyAddress property_address = {
-    kAudioDevicePropertyVolumeScalar,
-    kAudioDevicePropertyScopeInput,
-    kAudioObjectPropertyElementMaster
-  };
+      kAudioDevicePropertyVolumeScalar, kAudioDevicePropertyScopeInput,
+      kAudioObjectPropertyElementMaster};
 
   // Try to set the volume for master volume channel.
   if (IsVolumeSettableOnChannel(kAudioObjectPropertyElementMaster)) {
     OSStatus result = AudioObjectSetPropertyData(
         input_device_id_, &property_address, 0, nullptr, sizeof(volume_float32),
         &volume_float32);
     if (result != noErr) {
       DLOG(WARNING) << "Failed to set volume to " << volume_float32;
     }
     return;
@@ skipping 24 matching lines @@
 }
 
 double AUAudioInputStream::GetVolume() {
   // Verify that we have a valid device.
   if (input_device_id_ == kAudioObjectUnknown) {
     NOTREACHED() << "Device ID is unknown";
     return 0.0;
   }
 
   AudioObjectPropertyAddress property_address = {
-    kAudioDevicePropertyVolumeScalar,
-    kAudioDevicePropertyScopeInput,
-    kAudioObjectPropertyElementMaster
-  };
+      kAudioDevicePropertyVolumeScalar, kAudioDevicePropertyScopeInput,
+      kAudioObjectPropertyElementMaster};
 
   if (AudioObjectHasProperty(input_device_id_, &property_address)) {
     // The device supports master volume control, get the volume from the
     // master channel.
     Float32 volume_float32 = 0.0;
     UInt32 size = sizeof(volume_float32);
     OSStatus result =
         AudioObjectGetPropertyData(input_device_id_, &property_address, 0,
                                    nullptr, &size, &volume_float32);
     if (result == noErr)
@@ skipping 25 matching lines @@
 
   DLOG(WARNING) << "Failed to get volume";
   return 0.0;
 }
 
 bool AUAudioInputStream::IsMuted() {
   // Verify that we have a valid device.
   DCHECK_NE(input_device_id_, kAudioObjectUnknown) << "Device ID is unknown";
 
   AudioObjectPropertyAddress property_address = {
-    kAudioDevicePropertyMute,
-    kAudioDevicePropertyScopeInput,
-    kAudioObjectPropertyElementMaster
-  };
+      kAudioDevicePropertyMute, kAudioDevicePropertyScopeInput,
+      kAudioObjectPropertyElementMaster};
 
   if (!AudioObjectHasProperty(input_device_id_, &property_address)) {
     DLOG(ERROR) << "Device does not support checking master mute state";
     return false;
   }
 
   UInt32 muted = 0;
   UInt32 size = sizeof(muted);
   OSStatus result = AudioObjectGetPropertyData(
       input_device_id_, &property_address, 0, nullptr, &size, &muted);
@@ skipping 174 matching lines @@
   // Dynamically increase capacity of the FIFO to handle larger buffers from
   // CoreAudio. This can happen in combination with Apple Thunderbolt Displays
   // when the Display Audio is used as capture source and the cable is first
   // remove and then inserted again.
   // See http://www.crbug.com/434681 for details.
   if (static_cast<int>(number_of_frames) > fifo_.GetUnfilledFrames()) {
     // Derive required increase in number of FIFO blocks. The increase is
     // typically one block.
     const int blocks =
         static_cast<int>((number_of_frames - fifo_.GetUnfilledFrames()) /
-                         number_of_frames_) + 1;
+                         number_of_frames_) +
+        1;
     DLOG(WARNING) << "Increasing FIFO capacity by " << blocks << " blocks";
     TRACE_EVENT_INSTANT1("audio", "Increasing FIFO capacity",
                          TRACE_EVENT_SCOPE_THREAD, "increased by", blocks);
     fifo_.IncreaseCapacity(blocks);
   }
 
   // Copy captured (and interleaved) data into FIFO.
   fifo_.Push(audio_data, number_of_frames, format_.mBitsPerChannel / 8);
 
   // Consume and deliver the data when the FIFO has a block of available data.
@@ skipping 681 matching lines @@
 
   number_of_frames_provided_ = 0;
   glitches_detected_ = 0;
   last_sample_time_ = 0;
   last_number_of_frames_ = 0;
   total_lost_frames_ = 0;
   largest_glitch_frames_ = 0;
 }
 
 }  // namespace media