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

media/audio/mac/audio_auhal_mac.cc

 // Copyright 2013 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_auhal_mac.h"
 
 #include <CoreServices/CoreServices.h>
 
 #include <algorithm>
 #include <cstddef>
@@ skipping 42 matching lines @@
                            AudioBus* bus,
                            int frames) {
   DCHECK(buffer_list);
   DCHECK(bus);
   const int channels = bus->channels();
   const int buffer_list_channels = buffer_list->mNumberBuffers;
   CHECK_EQ(channels, buffer_list_channels);
 
   // Copy pointers from AudioBufferList.
   for (int i = 0; i < channels; ++i) {
-    bus->SetChannelData(
-        i, static_cast<float*>(buffer_list->mBuffers[i].mData));
+    bus->SetChannelData(i, static_cast<float*>(buffer_list->mBuffers[i].mData));
   }
 
   // Finally set the actual length.
   bus->set_frames(frames);
 }
 
 AUHALStream::AUHALStream(AudioManagerMac* manager,
                          const AudioParameters& params,
                          AudioDeviceID device,
                          const AudioManager::LogCallback& log_callback)
@@ skipping 76 matching lines @@
     return;
   }
 
   // Check if we should defer Start() for http://crbug.com/160920.
   if (manager_->ShouldDeferStreamStart()) {
     // 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(&AUHALStream::Start, base::Unretained(this), callback));
     manager_->GetTaskRunner()->PostDelayedTask(
-        FROM_HERE, deferred_start_cb_.callback(), base::TimeDelta::FromSeconds(
+        FROM_HERE, deferred_start_cb_.callback(),
+        base::TimeDelta::FromSeconds(
             AudioManagerMac::kStartDelayInSecsForPowerEvents));
     return;
   }
 
   stopped_ = false;
   audio_fifo_.reset();
   {
     base::AutoLock auto_lock(source_lock_);
     source_ = callback;
   }
@@ skipping 30 matching lines @@
 }
 
 void AUHALStream::GetVolume(double* volume) {
   *volume = volume_;
 }
 
 // Pulls on our provider to get rendered audio stream.
 // Note to future hackers of this function: Do not add locks which can
 // be contended in the middle of stream processing here (starting and stopping
 // the stream are ok) because this is running on a real-time thread.
-OSStatus AUHALStream::Render(
-    AudioUnitRenderActionFlags* flags,
-    const AudioTimeStamp* output_time_stamp,
-    UInt32 bus_number,
-    UInt32 number_of_frames,
-    AudioBufferList* data) {
+OSStatus AUHALStream::Render(AudioUnitRenderActionFlags* flags,
+                             const AudioTimeStamp* output_time_stamp,
+                             UInt32 bus_number,
+                             UInt32 number_of_frames,
+                             AudioBufferList* data) {
   TRACE_EVENT2("audio", "AUHALStream::Render", "input buffer size",
                number_of_frames_, "output buffer size", number_of_frames);
 
   UpdatePlayoutTimestamp(output_time_stamp);
 
   // If the stream parameters change for any reason, we need to insert a FIFO
   // since the OnMoreData() pipeline can't handle frame size changes.
   if (number_of_frames != number_of_frames_) {
     // Create a FIFO on the fly to handle any discrepancies in callback rates.
     if (!audio_fifo_) {
       // TODO(grunell): We'll only care about the first buffer size change,
       // any further changes will be ignored. It would be nice to have all
       // changes reflected in UMA stats.
       number_of_frames_requested_ = number_of_frames;
       DVLOG(1) << "Audio frame size changed from " << number_of_frames_
                << " to " << number_of_frames << " adding FIFO to compensate.";
       audio_fifo_.reset(new AudioPullFifo(
-          output_channels_,
-          number_of_frames_,
+          output_channels_, number_of_frames_,
           base::Bind(&AUHALStream::ProvideInput, base::Unretained(this))));
     }
   }
 
   // Make |output_bus_| wrap the output AudioBufferList.
   WrapBufferList(data, output_bus_.get(), number_of_frames);
 
   current_playout_time_ = GetPlayoutTime(output_time_stamp);
 
   if (audio_fifo_)
@@ skipping 19 matching lines @@
   const base::TimeTicks now = base::TimeTicks::Now();
   const base::TimeDelta delay = playout_time - now;
 
   // Supply the input data and render the output data.
   source_->OnMoreData(delay, now, current_lost_frames_, dest);
   dest->Scale(volume_);
   current_lost_frames_ = 0;
 }
 
 // AUHAL callback.
-OSStatus AUHALStream::InputProc(
-    void* user_data,
-    AudioUnitRenderActionFlags* flags,
-    const AudioTimeStamp* output_time_stamp,
-    UInt32 bus_number,
-    UInt32 number_of_frames,
-    AudioBufferList* io_data) {
+OSStatus AUHALStream::InputProc(void* user_data,
+                                AudioUnitRenderActionFlags* flags,
+                                const AudioTimeStamp* output_time_stamp,
+                                UInt32 bus_number,
+                                UInt32 number_of_frames,
+                                AudioBufferList* io_data) {
   // Dispatch to our class method.
-  AUHALStream* audio_output =
-      static_cast<AUHALStream*>(user_data);
+  AUHALStream* audio_output = static_cast<AUHALStream*>(user_data);
   if (!audio_output)
     return -1;
 
-  return audio_output->Render(
-      flags,
-      output_time_stamp,
-      bus_number,
-      number_of_frames,
-      io_data);
+  return audio_output->Render(flags, output_time_stamp, bus_number,
+                              number_of_frames, io_data);
 }
 
 base::TimeDelta AUHALStream::GetHardwareLatency() {
   if (!audio_unit_ || device_ == kAudioObjectUnknown) {
     DLOG(WARNING) << "AudioUnit is NULL or device ID is unknown";
     return base::TimeDelta();
   }
 
   // Get audio unit latency.
   Float64 audio_unit_latency_sec = 0.0;
   UInt32 size = sizeof(audio_unit_latency_sec);
   OSStatus result = AudioUnitGetProperty(
-      audio_unit_,
-      kAudioUnitProperty_Latency,
-      kAudioUnitScope_Global,
-      0,
-      &audio_unit_latency_sec,
-      &size);
+      audio_unit_, kAudioUnitProperty_Latency, kAudioUnitScope_Global, 0,
+      &audio_unit_latency_sec, &size);
   if (result != noErr) {
     OSSTATUS_DLOG(WARNING, result) << "Could not get AudioUnit latency";
     return base::TimeDelta();
   }
 
   // Get output audio device latency.
   static const AudioObjectPropertyAddress property_address = {
-    kAudioDevicePropertyLatency,
-    kAudioDevicePropertyScopeOutput,
-    kAudioObjectPropertyElementMaster
-  };
+      kAudioDevicePropertyLatency, kAudioDevicePropertyScopeOutput,
+      kAudioObjectPropertyElementMaster};
 
   UInt32 device_latency_frames = 0;
   size = sizeof(device_latency_frames);
-  result = AudioObjectGetPropertyData(
-      device_,
-      &property_address,
-      0,
-      NULL,
-      &size,
-      &device_latency_frames);
+  result = AudioObjectGetPropertyData(device_, &property_address, 0, NULL,
+                                      &size, &device_latency_frames);
   if (result != noErr) {
     OSSTATUS_DLOG(WARNING, result) << "Could not get audio device latency";
     return base::TimeDelta();
   }
 
   int latency_frames = audio_unit_latency_sec * output_format_.mSampleRate +
                        device_latency_frames;
 
   return AudioTimestampHelper::FramesToTime(latency_frames,
                                             params_.sample_rate());
@@ skipping 67 matching lines @@
   }
 
   number_of_frames_requested_ = 0;
   glitches_detected_ = 0;
   last_sample_time_ = 0;
   last_number_of_frames_ = 0;
   total_lost_frames_ = 0;
   largest_glitch_frames_ = 0;
 }
 
-bool AUHALStream::SetStreamFormat(
-    AudioStreamBasicDescription* desc,
-    int channels,
-    UInt32 scope,
-    UInt32 element) {
+bool AUHALStream::SetStreamFormat(AudioStreamBasicDescription* desc,
+                                  int channels,
+                                  UInt32 scope,
+                                  UInt32 element) {
   DCHECK(desc);
   AudioStreamBasicDescription& format = *desc;
 
   format.mSampleRate = params_.sample_rate();
   format.mFormatID = kAudioFormatLinearPCM;
-  format.mFormatFlags = kAudioFormatFlagsNativeFloatPacked |
-      kLinearPCMFormatFlagIsNonInterleaved;
+  format.mFormatFlags =
+      kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;
   format.mBytesPerPacket = sizeof(Float32);
   format.mFramesPerPacket = 1;
   format.mBytesPerFrame = sizeof(Float32);
   format.mChannelsPerFrame = channels;
   format.mBitsPerChannel = 32;
   format.mReserved = 0;
 
-  OSStatus result = AudioUnitSetProperty(
-      audio_unit_,
-      kAudioUnitProperty_StreamFormat,
-      scope,
-      element,
-      &format,
-      sizeof(format));
+  OSStatus result =
+      AudioUnitSetProperty(audio_unit_, kAudioUnitProperty_StreamFormat, scope,
+                           element, &format, sizeof(format));
   return (result == noErr);
 }
 
 bool AUHALStream::ConfigureAUHAL() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (device_ == kAudioObjectUnknown || output_channels_ == 0)
     return false;
 
-  AudioComponentDescription desc = {
-      kAudioUnitType_Output,
-      kAudioUnitSubType_HALOutput,
-      kAudioUnitManufacturer_Apple,
-      0,
-      0
-  };
+  AudioComponentDescription desc = {kAudioUnitType_Output,
+                                    kAudioUnitSubType_HALOutput,
+                                    kAudioUnitManufacturer_Apple, 0, 0};
   AudioComponent comp = AudioComponentFindNext(0, &desc);
   if (!comp)
     return false;
 
   OSStatus result = AudioComponentInstanceNew(comp, &audio_unit_);
   if (result != noErr) {
     OSSTATUS_DLOG(ERROR, result) << "AudioComponentInstanceNew() failed.";
     return false;
   }
 
   // Enable output as appropriate.
   // See Apple technote for details about the EnableIO property.
   // Note that we use bus 1 for input and bus 0 for output:
   // http://developer.apple.com/library/mac/#technotes/tn2091/_index.html
   UInt32 enable_IO = 1;
-  result = AudioUnitSetProperty(
-      audio_unit_,
-      kAudioOutputUnitProperty_EnableIO,
-      kAudioUnitScope_Output,
-      0,
-      &enable_IO,
-      sizeof(enable_IO));
+  result = AudioUnitSetProperty(audio_unit_, kAudioOutputUnitProperty_EnableIO,
+                                kAudioUnitScope_Output, 0, &enable_IO,
+                                sizeof(enable_IO));
   if (result != noErr) {
     CloseAudioUnit();
     return false;
   }
 
   // Set the device to be used with the AUHAL AudioUnit.
   result = AudioUnitSetProperty(
-      audio_unit_,
-      kAudioOutputUnitProperty_CurrentDevice,
-      kAudioUnitScope_Global,
-      0,
-      &device_,
-      sizeof(AudioDeviceID));
+      audio_unit_, kAudioOutputUnitProperty_CurrentDevice,
+      kAudioUnitScope_Global, 0, &device_, sizeof(AudioDeviceID));
   if (result != noErr) {
     CloseAudioUnit();
     return false;
   }
 
   // Set stream formats.
   // See Apple's tech note for details on the peculiar way that
   // inputs and outputs are handled in the AUHAL concerning scope and bus
   // (element) numbers:
   // http://developer.apple.com/library/mac/#technotes/tn2091/_index.html
 
-  if (!SetStreamFormat(&output_format_,
-                       output_channels_,
-                       kAudioUnitScope_Input,
+  if (!SetStreamFormat(&output_format_, output_channels_, kAudioUnitScope_Input,
                        0)) {
     CloseAudioUnit();
     return false;
   }
 
   bool size_was_changed = false;
   size_t io_buffer_frame_size = 0;
   if (!manager_->MaybeChangeBufferSize(device_, audio_unit_, 0,
                                        number_of_frames_, &size_was_changed,
                                        &io_buffer_frame_size)) {
     CloseAudioUnit();
     return false;
   }
 
   // Setup callback.
   AURenderCallbackStruct callback;
   callback.inputProc = InputProc;
   callback.inputProcRefCon = this;
   result = AudioUnitSetProperty(
-      audio_unit_,
-      kAudioUnitProperty_SetRenderCallback,
-      kAudioUnitScope_Input,
-      0,
-      &callback,
-      sizeof(callback));
+      audio_unit_, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input,
+      0, &callback, sizeof(callback));
   if (result != noErr) {
     CloseAudioUnit();
     return false;
   }
 
   SetAudioChannelLayout();
 
   result = AudioUnitInitialize(audio_unit_);
   if (result != noErr) {
     OSSTATUS_DLOG(ERROR, result) << "AudioUnitInitialize() failed.";
@@ skipping 67 matching lines @@
   OSStatus result = AudioUnitSetProperty(
       audio_unit_, kAudioUnitProperty_AudioChannelLayout, kAudioUnitScope_Input,
       0, channel_layout, layout_size);
   if (result != noErr) {
     OSSTATUS_DLOG(ERROR, result)
         << "Failed to set audio channel layout. Using default layout.";
   }
 }
 
 }  // namespace media