Home | History | Annotate | Download | only in mac 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "media/audio/mac/audio_unified_mac.h"
      6 
      7 #include <CoreServices/CoreServices.h>
      8 
      9 #include "base/basictypes.h"
     10 #include "base/logging.h"
     11 #include "base/mac/mac_logging.h"
     12 #include "media/audio/mac/audio_manager_mac.h"
     13 
     14 namespace media {
     15 
     16 // TODO(crogers): support more than hard-coded stereo input.
     17 // Ideally we would like to receive this value as a constructor argument.
     18 static const int kDefaultInputChannels = 2;
     19 
     20 AudioHardwareUnifiedStream::AudioHardwareUnifiedStream(
     21     AudioManagerMac* manager, const AudioParameters& params)
     22     : manager_(manager),
     23       source_(NULL),
     24       client_input_channels_(kDefaultInputChannels),
     25       volume_(1.0f),
     26       input_channels_(0),
     27       output_channels_(0),
     28       input_channels_per_frame_(0),
     29       output_channels_per_frame_(0),
     30       io_proc_id_(0),
     31       device_(kAudioObjectUnknown),
     32       is_playing_(false) {
     33   DCHECK(manager_);
     34 
     35   // A frame is one sample across all channels. In interleaved audio the per
     36   // frame fields identify the set of n |channels|. In uncompressed audio, a
     37   // packet is always one frame.
     38   format_.mSampleRate = params.sample_rate();
     39   format_.mFormatID = kAudioFormatLinearPCM;
     40   format_.mFormatFlags = kLinearPCMFormatFlagIsPacked |
     41                          kLinearPCMFormatFlagIsSignedInteger;
     42   format_.mBitsPerChannel = params.bits_per_sample();
     43   format_.mChannelsPerFrame = params.channels();
     44   format_.mFramesPerPacket = 1;
     45   format_.mBytesPerPacket = (format_.mBitsPerChannel * params.channels()) / 8;
     46   format_.mBytesPerFrame = format_.mBytesPerPacket;
     47   format_.mReserved = 0;
     48 
     49   // Calculate the number of sample frames per callback.
     50   number_of_frames_ = params.GetBytesPerBuffer() / format_.mBytesPerPacket;
     51 
     52   input_bus_ = AudioBus::Create(client_input_channels_,
     53                                 params.frames_per_buffer());
     54   output_bus_ = AudioBus::Create(params);
     55 }
     56 
     57 AudioHardwareUnifiedStream::~AudioHardwareUnifiedStream() {
     58   DCHECK_EQ(device_, kAudioObjectUnknown);
     59 }
     60 
     61 bool AudioHardwareUnifiedStream::Open() {
     62   // Obtain the current output device selected by the user.
     63   AudioObjectPropertyAddress pa;
     64   pa.mSelector = kAudioHardwarePropertyDefaultOutputDevice;
     65   pa.mScope = kAudioObjectPropertyScopeGlobal;
     66   pa.mElement = kAudioObjectPropertyElementMaster;
     67 
     68   UInt32 size = sizeof(device_);
     69 
     70   OSStatus result = AudioObjectGetPropertyData(
     71       kAudioObjectSystemObject,
     72       &pa,
     73       0,
     74       0,
     75       &size,
     76       &device_);
     77 
     78   if ((result != kAudioHardwareNoError) || (device_ == kAudioDeviceUnknown)) {
     79     LOG(ERROR) << "Cannot open unified AudioDevice.";
     80     return false;
     81   }
     82 
     83   // The requested sample-rate must match the hardware sample-rate.
     84   Float64 sample_rate = 0.0;
     85   size = sizeof(sample_rate);
     86 
     87   pa.mSelector = kAudioDevicePropertyNominalSampleRate;
     88   pa.mScope = kAudioObjectPropertyScopeWildcard;
     89   pa.mElement = kAudioObjectPropertyElementMaster;
     90 
     91   result = AudioObjectGetPropertyData(
     92       device_,
     93       &pa,
     94       0,
     95       0,
     96       &size,
     97       &sample_rate);
     98 
     99   if (result != noErr || sample_rate != format_.mSampleRate) {
    100     LOG(ERROR) << "Requested sample-rate: " << format_.mSampleRate
    101         <<  " must match the hardware sample-rate: " << sample_rate;
    102     return false;
    103   }
    104 
    105   // Configure buffer frame size.
    106   UInt32 frame_size = number_of_frames_;
    107 
    108   pa.mSelector = kAudioDevicePropertyBufferFrameSize;
    109   pa.mScope = kAudioDevicePropertyScopeInput;
    110   pa.mElement = kAudioObjectPropertyElementMaster;
    111   result = AudioObjectSetPropertyData(
    112       device_,
    113       &pa,
    114       0,
    115       0,
    116       sizeof(frame_size),
    117       &frame_size);
    118 
    119   if (result != noErr) {
    120     LOG(ERROR) << "Unable to set input buffer frame size: "  << frame_size;
    121     return false;
    122   }
    123 
    124   pa.mScope = kAudioDevicePropertyScopeOutput;
    125   result = AudioObjectSetPropertyData(
    126       device_,
    127       &pa,
    128       0,
    129       0,
    130       sizeof(frame_size),
    131       &frame_size);
    132 
    133   if (result != noErr) {
    134     LOG(ERROR) << "Unable to set output buffer frame size: "  << frame_size;
    135     return false;
    136   }
    137 
    138   DVLOG(1) << "Sample rate: " << sample_rate;
    139   DVLOG(1) << "Frame size: " << frame_size;
    140 
    141   // Determine the number of input and output channels.
    142   // We handle both the interleaved and non-interleaved cases.
    143 
    144   // Get input stream configuration.
    145   pa.mSelector = kAudioDevicePropertyStreamConfiguration;
    146   pa.mScope = kAudioDevicePropertyScopeInput;
    147   pa.mElement = kAudioObjectPropertyElementMaster;
    148 
    149   result = AudioObjectGetPropertyDataSize(device_, &pa, 0, 0, &size);
    150   OSSTATUS_DCHECK(result == noErr, result);
    151 
    152   if (result == noErr && size > 0) {
    153     // Allocate storage.
    154     scoped_ptr<uint8[]> input_list_storage(new uint8[size]);
    155     AudioBufferList& input_list =
    156         *reinterpret_cast<AudioBufferList*>(input_list_storage.get());
    157 
    158     result = AudioObjectGetPropertyData(
    159         device_,
    160         &pa,
    161         0,
    162         0,
    163         &size,
    164         &input_list);
    165     OSSTATUS_DCHECK(result == noErr, result);
    166 
    167     if (result == noErr) {
    168       // Determine number of input channels.
    169       input_channels_per_frame_ = input_list.mNumberBuffers > 0 ?
    170           input_list.mBuffers[0].mNumberChannels : 0;
    171       if (input_channels_per_frame_ == 1 && input_list.mNumberBuffers > 1) {
    172         // Non-interleaved.
    173         input_channels_ = input_list.mNumberBuffers;
    174       } else {
    175         // Interleaved.
    176         input_channels_ = input_channels_per_frame_;
    177       }
    178     }
    179   }
    180 
    181   DVLOG(1) << "Input channels: " << input_channels_;
    182   DVLOG(1) << "Input channels per frame: " << input_channels_per_frame_;
    183 
    184   // The hardware must have at least the requested input channels.
    185   if (result != noErr || client_input_channels_ > input_channels_) {
    186     LOG(ERROR) << "AudioDevice does not support requested input channels.";
    187     return false;
    188   }
    189 
    190   // Get output stream configuration.
    191   pa.mSelector = kAudioDevicePropertyStreamConfiguration;
    192   pa.mScope = kAudioDevicePropertyScopeOutput;
    193   pa.mElement = kAudioObjectPropertyElementMaster;
    194 
    195   result = AudioObjectGetPropertyDataSize(device_, &pa, 0, 0, &size);
    196   OSSTATUS_DCHECK(result == noErr, result);
    197 
    198   if (result == noErr && size > 0) {
    199     // Allocate storage.
    200     scoped_ptr<uint8[]> output_list_storage(new uint8[size]);
    201     AudioBufferList& output_list =
    202         *reinterpret_cast<AudioBufferList*>(output_list_storage.get());
    203 
    204     result = AudioObjectGetPropertyData(
    205         device_,
    206         &pa,
    207         0,
    208         0,
    209         &size,
    210         &output_list);
    211     OSSTATUS_DCHECK(result == noErr, result);
    212 
    213     if (result == noErr) {
    214       // Determine number of output channels.
    215       output_channels_per_frame_ = output_list.mBuffers[0].mNumberChannels;
    216       if (output_channels_per_frame_ == 1 && output_list.mNumberBuffers > 1) {
    217         // Non-interleaved.
    218         output_channels_ = output_list.mNumberBuffers;
    219       } else {
    220         // Interleaved.
    221         output_channels_ = output_channels_per_frame_;
    222       }
    223     }
    224   }
    225 
    226   DVLOG(1) << "Output channels: " << output_channels_;
    227   DVLOG(1) << "Output channels per frame: " << output_channels_per_frame_;
    228 
    229   // The hardware must have at least the requested output channels.
    230   if (result != noErr ||
    231       output_channels_ < static_cast<int>(format_.mChannelsPerFrame)) {
    232     LOG(ERROR) << "AudioDevice does not support requested output channels.";
    233     return false;
    234   }
    235 
    236   // Setup the I/O proc.
    237   result = AudioDeviceCreateIOProcID(device_, RenderProc, this, &io_proc_id_);
    238   if (result != noErr) {
    239     LOG(ERROR) << "Error creating IOProc.";
    240     return false;
    241   }
    242 
    243   return true;
    244 }
    245 
    246 void AudioHardwareUnifiedStream::Close() {
    247   DCHECK(!is_playing_);
    248 
    249   OSStatus result = AudioDeviceDestroyIOProcID(device_, io_proc_id_);
    250   OSSTATUS_DCHECK(result == noErr, result);
    251 
    252   io_proc_id_ = 0;
    253   device_ = kAudioObjectUnknown;
    254 
    255   // Inform the audio manager that we have been closed. This can cause our
    256   // destruction.
    257   manager_->ReleaseOutputStream(this);
    258 }
    259 
    260 void AudioHardwareUnifiedStream::Start(AudioSourceCallback* callback) {
    261   DCHECK(callback);
    262   DCHECK_NE(device_, kAudioObjectUnknown);
    263   DCHECK(!is_playing_);
    264   if (device_ == kAudioObjectUnknown || is_playing_)
    265     return;
    266 
    267   source_ = callback;
    268 
    269   OSStatus result = AudioDeviceStart(device_, io_proc_id_);
    270   OSSTATUS_DCHECK(result == noErr, result);
    271 
    272   if (result == noErr)
    273     is_playing_ = true;
    274 }
    275 
    276 void AudioHardwareUnifiedStream::Stop() {
    277   if (!is_playing_)
    278     return;
    279 
    280   if (device_ != kAudioObjectUnknown) {
    281     OSStatus result = AudioDeviceStop(device_, io_proc_id_);
    282     OSSTATUS_DCHECK(result == noErr, result);
    283   }
    284 
    285   is_playing_ = false;
    286   source_ = NULL;
    287 }
    288 
    289 void AudioHardwareUnifiedStream::SetVolume(double volume) {
    290   volume_ = static_cast<float>(volume);
    291   // TODO(crogers): set volume property
    292 }
    293 
    294 void AudioHardwareUnifiedStream::GetVolume(double* volume) {
    295   *volume = volume_;
    296 }
    297 
    298 // Pulls on our provider with optional input, asking it to render output.
    299 // Note to future hackers of this function: Do not add locks here because this
    300 // is running on a real-time thread (for low-latency).
    301 OSStatus AudioHardwareUnifiedStream::Render(
    302     AudioDeviceID device,
    303     const AudioTimeStamp* now,
    304     const AudioBufferList* input_data,
    305     const AudioTimeStamp* input_time,
    306     AudioBufferList* output_data,
    307     const AudioTimeStamp* output_time) {
    308   // Convert the input data accounting for possible interleaving.
    309   // TODO(crogers): it's better to simply memcpy() if source is already planar.
    310   if (input_channels_ >= client_input_channels_) {
    311     for (int channel_index = 0; channel_index < client_input_channels_;
    312          ++channel_index) {
    313       float* source;
    314 
    315       int source_channel_index = channel_index;
    316 
    317       if (input_channels_per_frame_ > 1) {
    318         // Interleaved.
    319         source = static_cast<float*>(input_data->mBuffers[0].mData) +
    320             source_channel_index;
    321       } else {
    322         // Non-interleaved.
    323         source = static_cast<float*>(
    324             input_data->mBuffers[source_channel_index].mData);
    325       }
    326 
    327       float* p = input_bus_->channel(channel_index);
    328       for (int i = 0; i < number_of_frames_; ++i) {
    329         p[i] = *source;
    330         source += input_channels_per_frame_;
    331       }
    332     }
    333   } else if (input_channels_) {
    334     input_bus_->Zero();
    335   }
    336 
    337   // Give the client optional input data and have it render the output data.
    338   source_->OnMoreIOData(input_bus_.get(),
    339                         output_bus_.get(),
    340                         AudioBuffersState(0, 0));
    341 
    342   // TODO(crogers): handle final Core Audio 5.1 layout for 5.1 audio.
    343 
    344   // Handle interleaving as necessary.
    345   // TODO(crogers): it's better to simply memcpy() if dest is already planar.
    346 
    347   for (int channel_index = 0;
    348        channel_index < static_cast<int>(format_.mChannelsPerFrame);
    349        ++channel_index) {
    350     float* dest;
    351 
    352     int dest_channel_index = channel_index;
    353 
    354     if (output_channels_per_frame_ > 1) {
    355       // Interleaved.
    356       dest = static_cast<float*>(output_data->mBuffers[0].mData) +
    357           dest_channel_index;
    358     } else {
    359       // Non-interleaved.
    360       dest = static_cast<float*>(
    361           output_data->mBuffers[dest_channel_index].mData);
    362     }
    363 
    364     float* p = output_bus_->channel(channel_index);
    365     for (int i = 0; i < number_of_frames_; ++i) {
    366       *dest = p[i];
    367       dest += output_channels_per_frame_;
    368     }
    369   }
    370 
    371   return noErr;
    372 }
    373 
    374 OSStatus AudioHardwareUnifiedStream::RenderProc(
    375     AudioDeviceID device,
    376     const AudioTimeStamp* now,
    377     const AudioBufferList* input_data,
    378     const AudioTimeStamp* input_time,
    379     AudioBufferList* output_data,
    380     const AudioTimeStamp* output_time,
    381     void* user_data) {
    382   AudioHardwareUnifiedStream* audio_output =
    383       static_cast<AudioHardwareUnifiedStream*>(user_data);
    384   DCHECK(audio_output);
    385   if (!audio_output)
    386     return -1;
    387 
    388   return audio_output->Render(
    389       device,
    390       now,
    391       input_data,
    392       input_time,
    393       output_data,
    394       output_time);
    395 }
    396 
    397 }  // namespace media
    398