Link things together and enable the device selection for linux and mac.

media/audio/mac/audio_low_latency_input_mac.cc

 // Copyright (c) 2011 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 11 matching lines @@
      << "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)
+    AudioManagerMac* manager, const AudioParameters& params,
+    AudioDeviceID audio_device_id)
     : manager_(manager),
       sink_(NULL),
       audio_unit_(0),
-      input_device_id_(kAudioObjectUnknown),
+      input_device_id_(audio_device_id),
       started_(false),
       hardware_latency_frames_(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;
@@ skipping 27 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)
+    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;
   desc.componentFlags = 0;
@@ skipping 36 matching lines @@
                                 kAudioOutputUnitProperty_EnableIO,
                                 kAudioUnitScope_Output,
                                 0,          // output element 0
                                 &enableIO,  // disable
                                 sizeof(enableIO));
   if (result) {
     HandleError(result);
     return false;
   }
 
-  // Set the current device of the AudioOuputUnit to default input device.
-
-  // First, obtain the current input device selected by the user.
-  AudioObjectPropertyAddress default_intput_device_address = {
-    kAudioHardwarePropertyDefaultInputDevice,
-    kAudioObjectPropertyScopeGlobal,
-    kAudioObjectPropertyElementMaster
-  };
-  AudioDeviceID input_device = kAudioObjectUnknown;
-  UInt32 size = sizeof(input_device);
-  result = AudioObjectGetPropertyData(kAudioObjectSystemObject,
-                                      &default_intput_device_address,
-                                      0,
-                                      0,
-                                      &size,
-                                      &input_device);
-  if (result) {
-    HandleError(result);
-    return false;
-  }
-
-  input_device_id_ = input_device;
-
   // 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));
+                                sizeof(input_device_id_));
   if (result) {
     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 = InputProc;
@@ skipping 269 matching lines @@
   // Total latency is composed by the dynamic latency and the fixed
   // hardware latency.
   return (delay_frames + hardware_latency_frames_);
 }
 
 void AUAudioInputStream::HandleError(OSStatus err) {
   NOTREACHED() << "error code: " << err;
   if (sink_)
     sink_->OnError(this, static_cast<int>(err));
 }