Adds Analog Gain Control (AGC) to the WebRTC client.

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 <CoreServices/CoreServices.h>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/mac/mac_logging.h"
 #include "media/audio/audio_util.h"
 #include "media/audio/mac/audio_manager_mac.h"
 
+static const int kMinIntervalBetweenVolumeUpdatesMs = 1000;
+
 static std::ostream& operator<<(std::ostream& os,
                                 const AudioStreamBasicDescription& format) {
   os << "sample rate       : " << format.mSampleRate << std::endl
      << "format ID         : " << format.mFormatID << std::endl
      << "format flags      : " << format.mFormatFlags << std::endl
      << "bytes per packet  : " << format.mBytesPerPacket << std::endl
      << "frames per packet : " << format.mFramesPerPacket << std::endl
      << "bytes per frame   : " << format.mBytesPerFrame << std::endl
      << "channels per frame: " << format.mChannelsPerFrame << std::endl
      << "bits per channel  : " << format.mBitsPerChannel;
   return os;
 }
 
 // See "Technical Note TN2091 - Device input using the HAL Output Audio Unit"
 // http://developer.apple.com/library/mac/#technotes/tn2091/_index.html
 // for more details and background regarding this implementation.
 
 AUAudioInputStream::AUAudioInputStream(
     AudioManagerMac* manager, const AudioParameters& params,
     AudioDeviceID audio_device_id)
     : manager_(manager),
       sink_(NULL),
       audio_unit_(0),
       input_device_id_(audio_device_id),
       started_(false),
       hardware_latency_frames_(0),
-      number_of_channels_in_frame_(0) {
+      number_of_channels_in_frame_(0),
+      volume_(0.0),
+      agc_is_enabled_(0) {
   DCHECK(manager_);
 
   // Set up the desired (output) format specified by the client.
   format_.mSampleRate = params.sample_rate;
   format_.mFormatID = kAudioFormatLinearPCM;
   format_.mFormatFlags = kLinearPCMFormatFlagIsPacked |
                          kLinearPCMFormatFlagIsSignedInteger;
   format_.mBitsPerChannel = params.bits_per_sample;
   format_.mChannelsPerFrame = params.channels;
   format_.mFramesPerPacket = 1;  // uncompressed audio
@@ skipping 230 matching lines @@
     // If the volume is settable, the  valid volume range is [0.0, 1.0].
     if (IsVolumeSettableOnChannel(i))
       return 1.0;
   }
 
   // Volume control is not available for the audio stream.
   return 0.0;
 }
 
 void AUAudioInputStream::SetVolume(double volume) {
-  DCHECK(volume <= 1.0 && volume >= 0.0);
+  DCHECK_GE(volume, 0.0);
+  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,
@@ skipping 26 matching lines @@
                                                    NULL,
                                                    sizeof(volume_float32),
                                                    &volume_float32);
       if (result == noErr)
         ++successful_channels;
     }
   }
 
   DLOG_IF(WARNING, successful_channels == 0)
       << "Failed to set volume to " << volume_float32;
+
+  // We take new volume samples once every second when the AGC is enabled.
+  // To ensure that a new setting has an immediate effect, the new volume
+  // setting is cached here. It will ensure that the next OnData() callback
+  // will contain a new valid volume level. If this approach was not taken,
+  // we could report invalid volume levels to the client for a time period
+  // of up to one second.
+  if (GetAutomaticGainControl()) {
+    volume_ = GetVolume();
+  }
 }
 
 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 = {
@@ skipping 40 matching lines @@
 
     // Get the average volume of the channels.
     if (successful_channels != 0)
       return static_cast<double>(volume_float32 / successful_channels);
   }
 
   DLOG(WARNING) << "Failed to get volume";
   return 0.0;
 }
 
+void AUAudioInputStream::SetAutomaticGainControl(bool enabled) {
+  base::subtle::Release_Store(&agc_is_enabled_, enabled);
+}
+
+bool AUAudioInputStream::GetAutomaticGainControl() {
+  return (base::subtle::Acquire_Load(&agc_is_enabled_) == 1);
+}
+
 // AUHAL AudioDeviceOutput unit callback
 OSStatus AUAudioInputStream::InputProc(void* user_data,
                                        AudioUnitRenderActionFlags* flags,
                                        const AudioTimeStamp* time_stamp,
                                        UInt32 bus_number,
                                        UInt32 number_of_frames,
                                        AudioBufferList* io_data) {
   // Verify that the correct bus is used (Input bus/Element 1)
   DCHECK_EQ(bus_number, static_cast<UInt32>(1));
   AUAudioInputStream* audio_input =
@@ skipping 25 matching lines @@
   double capture_latency_frames = GetCaptureLatency(time_stamp);
 
   AudioBuffer& buffer = io_data->mBuffers[0];
   uint8* audio_data = reinterpret_cast<uint8*>(buffer.mData);
   uint32 capture_delay_bytes = static_cast<uint32>
       ((capture_latency_frames + 0.5) * format_.mBytesPerFrame);
   DCHECK(audio_data);
   if (!audio_data)
     return kAudioUnitErr_InvalidElement;
 
-  sink_->OnData(this, audio_data, buffer.mDataByteSize, capture_delay_bytes);
+  // Query a new volume level if AGC is enabled and if it is time to update
+  // the old value.
+  if (GetAutomaticGainControl()) {
+    base::Time now = base::Time::Now();
+    if ((now - last_volume_update_time_).InMilliseconds() >
+        kMinIntervalBetweenVolumeUpdatesMs) {
+      // Retrieve the current volume level. Range is [0.0,1.0].
+      volume_ = static_cast<double>(GetVolume());
+      last_volume_update_time_ = now;
+    }
+  }
+
+  // Deliver data packet, delay estimation and volume level to the user.
+  sink_->OnData(this,
+                audio_data,
+                buffer.mDataByteSize,
+                capture_delay_bytes,
+                volume_);
 
   return noErr;
 }
 
 double AUAudioInputStream::HardwareSampleRate() {
   // Determine the default input device's sample-rate.
   AudioDeviceID device_id = kAudioObjectUnknown;
   UInt32 info_size = sizeof(device_id);
 
   AudioObjectPropertyAddress default_input_device_address = {
@@ skipping 120 matching lines @@
   AudioObjectPropertyAddress property_address = {
     kAudioDevicePropertyVolumeScalar,
     kAudioDevicePropertyScopeInput,
     static_cast<UInt32>(channel)
   };
   OSStatus result = AudioObjectIsPropertySettable(input_device_id_,
                                                   &property_address,
                                                   &is_settable);
   return (result == noErr) ? is_settable : false;
 }