Implement GetDefaultOutputDeviceID, GetAssociatedOutputDeviceID and ...

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 17 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& input_params,
+    const AudioParameters& output_params,
     AudioDeviceID audio_device_id)
     : manager_(manager),
       sink_(NULL),
       audio_unit_(0),
       input_device_id_(audio_device_id),
       started_(false),
       hardware_latency_frames_(0),
       fifo_delay_bytes_(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_.mSampleRate = input_params.sample_rate();
   format_.mFormatID = kAudioFormatLinearPCM;
   format_.mFormatFlags = kLinearPCMFormatFlagIsPacked |
                          kLinearPCMFormatFlagIsSignedInteger;
-  format_.mBitsPerChannel = params.bits_per_sample();
-  format_.mChannelsPerFrame = params.channels();
+  format_.mBitsPerChannel = input_params.bits_per_sample();
+  format_.mChannelsPerFrame = input_params.channels();
   format_.mFramesPerPacket = 1;  // uncompressed audio
   format_.mBytesPerPacket = (format_.mBitsPerChannel *
-                             params.channels()) / 8;
+                             input_params.channels()) / 8;
   format_.mBytesPerFrame = format_.mBytesPerPacket;
   format_.mReserved = 0;
 
   DVLOG(1) << "Desired ouput format: " << format_;
 
   // Set number of sample frames per callback used by the internal audio layer.
   // An internal FIFO is then utilized to adapt the internal size to the size
   // requested by the client.
   // Note that we use the same native buffer size as for the output side here
   // since the AUHAL implementation requires that both capture and render side
   // use the same buffer size. See http://crbug.com/154352 for more details.
-  // TODO(xians): Get the audio parameters from the right device.
-  const AudioParameters parameters =
-      manager_->GetInputStreamParameters(AudioManagerBase::kDefaultDeviceId);
-  number_of_frames_ = parameters.frames_per_buffer();
+  number_of_frames_ = output_params.frames_per_buffer();
   DVLOG(1) << "Size of data buffer in frames : " << number_of_frames_;
 
   // Derive size (in bytes) of the buffers that we will render to.
   UInt32 data_byte_size = number_of_frames_ * format_.mBytesPerFrame;
   DVLOG(1) << "Size of data buffer in bytes : " << data_byte_size;
 
   // Allocate AudioBuffers to be used as storage for the received audio.
   // The AudioBufferList structure works as a placeholder for the
   // AudioBuffer structure, which holds a pointer to the actual data buffer.
   audio_data_buffer_.reset(new uint8[data_byte_size]);
   audio_buffer_list_.mNumberBuffers = 1;
 
   AudioBuffer* audio_buffer = audio_buffer_list_.mBuffers;
-  audio_buffer->mNumberChannels = params.channels();
+  audio_buffer->mNumberChannels = input_params.channels();
   audio_buffer->mDataByteSize = data_byte_size;
   audio_buffer->mData = audio_data_buffer_.get();
 
   // Set up an internal FIFO buffer that will accumulate recorded audio frames
   // until a requested size is ready to be sent to the client.
   // It is not possible to ask for less than |kAudioFramesPerCallback| number of
   // audio frames.
-  const size_t requested_size_frames =
-      params.GetBytesPerBuffer() / format_.mBytesPerPacket;
-  DCHECK_GE(requested_size_frames, number_of_frames_);
+  size_t requested_size_frames =
+      input_params.GetBytesPerBuffer() / format_.mBytesPerPacket;
+  if (requested_size_frames < number_of_frames_) {
+    // For devices that only support a low sample rate like 8kHz, we adjust the
+    // buffer size to match number_of_frames_.  The value of number_of_frames_
+    // in this case has not been calculated based on hardware settings but
+    // rather our hardcoded defaults (see ChooseBufferSize).
+    requested_size_frames = number_of_frames_;
+  }
+
   requested_size_bytes_ = requested_size_frames * format_.mBytesPerFrame;
   DVLOG(1) << "Requested buffer size in bytes : " << requested_size_bytes_;
   DLOG_IF(INFO, requested_size_frames > number_of_frames_) << "FIFO is used";
 
   const int number_of_bytes = number_of_frames_ * format_.mBytesPerFrame;
   fifo_delay_bytes_ = requested_size_bytes_ - number_of_bytes;
 
   // Allocate some extra memory to avoid memory reallocations.
   // Ensure that the size is an even multiple of |number_of_frames_ and
   // larger than |requested_size_frames|.
@@ skipping 546 matching lines @@
     kAudioDevicePropertyScopeInput,
     static_cast<UInt32>(channel)
   };
   OSStatus result = AudioObjectIsPropertySettable(input_device_id_,
                                                   &property_address,
                                                   &is_settable);
   return (result == noErr) ? is_settable : false;
 }
 
 }  // namespace media