Adding microphone volume support to chrome.

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"
@@ skipping 19 matching lines @@
 // 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) {
+      hardware_latency_frames_(0),
+      number_of_channels_in_frame_(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 26 matching lines @@
 
 AUAudioInputStream::~AUAudioInputStream() {}
 
 // Obtain and open the AUHAL AudioOutputUnit for recording.
 bool AUAudioInputStream::Open() {
   // Verify that we are not already opened.
   if (audio_unit_)
     return false;
 
   // Verify that we have a valid device.
-  if (input_device_id_ == kAudioObjectUnknown)
+  if (input_device_id_ == kAudioObjectUnknown) {
+    NOTREACHED() << "Device ID is unknown";
     return false;
+  }
 
   // Start by obtaining an AudioOuputUnit using an AUHAL component description.
 
   Component comp;
   ComponentDescription desc;
 
   // Description for the Audio Unit we want to use (AUHAL in this case).
   desc.componentType = kAudioUnitType_Output;
   desc.componentSubType = kAudioUnitSubType_HALOutput;
   desc.componentManufacturer = kAudioUnitManufacturer_Apple;
@@ skipping 105 matching lines @@
   // it can produce in response to a single render call.
   result = AudioUnitInitialize(audio_unit_);
   if (result) {
     HandleError(result);
     return false;
   }
 
   // The hardware latency is fixed and will not change during the call.
   hardware_latency_frames_ = GetHardwareLatency();
 
+  // The master channel is 0, Left and right are channels 1 and 2.
+  // And the master channel is not counted in |number_of_channels_in_frame_|.
+  number_of_channels_in_frame_ = GetNumberOfChannelsFromStream();
+
   return true;
 }
 
 void AUAudioInputStream::Start(AudioInputCallback* callback) {
   DCHECK(callback);
   DLOG_IF(ERROR, !audio_unit_) << "Open() has not been called successfully";
   if (started_ || !audio_unit_)
     return;
   sink_ = callback;
   OSStatus result = AudioOutputUnitStart(audio_unit_);
@@ skipping 32 matching lines @@
   if (sink_) {
     sink_->OnClose(this);
     sink_ = NULL;
   }
 
   // Inform the audio manager that we have been closed. This can cause our
   // destruction.
   manager_->ReleaseInputStream(this);
 }
 
+double AUAudioInputStream::GetMaxVolume() {
+  // Verify that we have a valid device.
+  if (input_device_id_ == kAudioObjectUnknown) {
+    NOTREACHED() << "Device ID is unknown";
+    return 0.0;
+  }
+
+  // Query if any of the master, left or right channels has volume control.
+  for (int i = 0; i <= number_of_channels_in_frame_; ++i) {
+    // 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);
+
+  // 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
+  };
+
+  // Try to set the volume for master volume channel.
+  if (IsVolumeSettableOnChannel(kAudioObjectPropertyElementMaster)) {
+    OSStatus result = AudioObjectSetPropertyData(input_device_id_,
+                                                 &property_address,
+                                                 0,
+                                                 NULL,
+                                                 sizeof(volume_float32),
+                                                 &volume_float32);
+    if (result != noErr) {
+      DLOG(WARNING) << "Failed to set volume to " << volume_float32;
+    }
+    return;
+  }
+
+  // There is no master volume control, try to set volume for each channel.
+  int successful_channels = 0;
+  for (int i = 1; i <= number_of_channels_in_frame_; ++i) {
+    property_address.mElement = static_cast<UInt32>(i);
+    if (IsVolumeSettableOnChannel(i)) {
+      OSStatus result = AudioObjectSetPropertyData(input_device_id_,
+                                                   &property_address,
+                                                   0,
+                                                   NULL,
+                                                   sizeof(volume_float32),
+                                                   &volume_float32);
+      if (result == noErr)
+        ++successful_channels;
+    }
+  }
+
+  DLOG_IF(WARNING, successful_channels == 0)
+      << "Failed to set volume to " << volume_float32;
+}
+
+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
+  };
+
+  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,
+                                                 NULL,
+                                                 &size,
+                                                 &volume_float32);
+    if (result == noErr)
+      return static_cast<double>(volume_float32);
+  } else {
+    // There is no master volume control, try to get the average volume of
+    // all the channels.
+    Float32 volume_float32 = 0.0;
+    int successful_channels = 0;
+    for (int i = 1; i <= number_of_channels_in_frame_; ++i) {
+      property_address.mElement = static_cast<UInt32>(i);
+      if (AudioObjectHasProperty(input_device_id_, &property_address)) {
+        Float32 channel_volume = 0;
+        UInt32 size = sizeof(channel_volume);
+        OSStatus result = AudioObjectGetPropertyData(input_device_id_,
+                                                     &property_address,
+                                                     0,
+                                                     NULL,
+                                                     &size,
+                                                     &channel_volume);
+        if (result == noErr) {
+          volume_float32 += channel_volume;
+          ++successful_channels;
+        }
+      }
+    }
+
+    // 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;
+}
+
 // 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 124 matching lines @@
       input_time_stamp->mHostTime);
   UInt64 now_ns = AudioConvertHostTimeToNanos(AudioGetCurrentHostTime());
   double delay_frames = static_cast<double>
       (1e-9 * (now_ns - capture_time_ns) * format_.mSampleRate);
 
   // Total latency is composed by the dynamic latency and the fixed
   // hardware latency.
   return (delay_frames + hardware_latency_frames_);
 }
 
+int AUAudioInputStream::GetNumberOfChannelsFromStream() {
+  // Get the stream format, to be able to read the number of channels.
+  AudioObjectPropertyAddress property_address = {
+    kAudioDevicePropertyStreamFormat,
+    kAudioDevicePropertyScopeInput,
+    kAudioObjectPropertyElementMaster
+  };
+  AudioStreamBasicDescription stream_format;
+  UInt32 size = sizeof(stream_format);
+  OSStatus result = AudioObjectGetPropertyData(input_device_id_,
+                                               &property_address,
+                                               0,
+                                               NULL,
+                                               &size,
+                                               &stream_format);
+  if (result != noErr) {
+    DLOG(WARNING) << "Could not get stream format";
+    return 0;
+  }
+
+  return static_cast<int>(stream_format.mChannelsPerFrame);
+}
+
 void AUAudioInputStream::HandleError(OSStatus err) {
   NOTREACHED() << "error " << GetMacOSStatusErrorString(err)
                << " (" << err << ")";
   if (sink_)
     sink_->OnError(this, static_cast<int>(err));
 }
+
+bool AUAudioInputStream::IsVolumeSettableOnChannel(int channel) {
+  Boolean is_settable = false;
+  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;
+}