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_low_latency_output_mac.h"
      6 
      7 #include <CoreServices/CoreServices.h>
      8 
      9 #include "base/basictypes.h"
     10 #include "base/command_line.h"
     11 #include "base/logging.h"
     12 #include "base/mac/mac_logging.h"
     13 #include "media/audio/mac/audio_manager_mac.h"
     14 #include "media/base/media_switches.h"
     15 
     16 namespace media {
     17 
     18 static std::ostream& operator<<(std::ostream& os,
     19                                 const AudioStreamBasicDescription& format) {
     20   os << "sample rate       : " << format.mSampleRate << std::endl
     21      << "format ID         : " << format.mFormatID << std::endl
     22      << "format flags      : " << format.mFormatFlags << std::endl
     23      << "bytes per packet  : " << format.mBytesPerPacket << std::endl
     24      << "frames per packet : " << format.mFramesPerPacket << std::endl
     25      << "bytes per frame   : " << format.mBytesPerFrame << std::endl
     26      << "channels per frame: " << format.mChannelsPerFrame << std::endl
     27      << "bits per channel  : " << format.mBitsPerChannel;
     28   return os;
     29 }
     30 
     31 static AudioObjectPropertyAddress kDefaultOutputDeviceAddress = {
     32   kAudioHardwarePropertyDefaultOutputDevice,
     33   kAudioObjectPropertyScopeGlobal,
     34   kAudioObjectPropertyElementMaster
     35 };
     36 
     37 // Overview of operation:
     38 // 1) An object of AUAudioOutputStream is created by the AudioManager
     39 // factory: audio_man->MakeAudioStream().
     40 // 2) Next some thread will call Open(), at that point the underlying
     41 // default output Audio Unit is created and configured.
     42 // 3) Then some thread will call Start(source).
     43 // Then the Audio Unit is started which creates its own thread which
     44 // periodically will call the source for more data as buffers are being
     45 // consumed.
     46 // 4) At some point some thread will call Stop(), which we handle by directly
     47 // stopping the default output Audio Unit.
     48 // 6) The same thread that called stop will call Close() where we cleanup
     49 // and notify the audio manager, which likely will destroy this object.
     50 
     51 AUAudioOutputStream::AUAudioOutputStream(
     52     AudioManagerMac* manager, const AudioParameters& params)
     53     : manager_(manager),
     54       source_(NULL),
     55       output_unit_(0),
     56       output_device_id_(kAudioObjectUnknown),
     57       volume_(1),
     58       hardware_latency_frames_(0),
     59       stopped_(false),
     60       audio_bus_(AudioBus::Create(params)) {
     61   // We must have a manager.
     62   DCHECK(manager_);
     63 
     64   // A frame is one sample across all channels. In interleaved audio the per
     65   // frame fields identify the set of n |channels|. In uncompressed audio, a
     66   // packet is always one frame.
     67   format_.mSampleRate = params.sample_rate();
     68   format_.mFormatID = kAudioFormatLinearPCM;
     69   format_.mFormatFlags = kLinearPCMFormatFlagIsPacked |
     70                          kLinearPCMFormatFlagIsSignedInteger;
     71   format_.mBitsPerChannel = params.bits_per_sample();
     72   format_.mChannelsPerFrame = params.channels();
     73   format_.mFramesPerPacket = 1;
     74   format_.mBytesPerPacket = (format_.mBitsPerChannel * params.channels()) / 8;
     75   format_.mBytesPerFrame = format_.mBytesPerPacket;
     76   format_.mReserved = 0;
     77 
     78   DVLOG(1) << "Desired ouput format: " << format_;
     79 
     80   // Calculate the number of sample frames per callback.
     81   number_of_frames_ = params.frames_per_buffer();
     82   DVLOG(1) << "Number of frames per callback: " << number_of_frames_;
     83 }
     84 
     85 AUAudioOutputStream::~AUAudioOutputStream() {
     86 }
     87 
     88 bool AUAudioOutputStream::Open() {
     89   // Obtain the current input device selected by the user.
     90   UInt32 size = sizeof(output_device_id_);
     91   OSStatus result = AudioObjectGetPropertyData(kAudioObjectSystemObject,
     92                                                &kDefaultOutputDeviceAddress,
     93                                                0,
     94                                                0,
     95                                                &size,
     96                                                &output_device_id_);
     97   if (result != noErr || output_device_id_ == kAudioObjectUnknown) {
     98     OSSTATUS_DLOG(ERROR, result)
     99         << "Could not get default audio output device.";
    100     return false;
    101   }
    102 
    103   // Open and initialize the DefaultOutputUnit.
    104   AudioComponent comp;
    105   AudioComponentDescription desc;
    106 
    107   desc.componentType = kAudioUnitType_Output;
    108   desc.componentSubType = kAudioUnitSubType_DefaultOutput;
    109   desc.componentManufacturer = kAudioUnitManufacturer_Apple;
    110   desc.componentFlags = 0;
    111   desc.componentFlagsMask = 0;
    112   comp = AudioComponentFindNext(0, &desc);
    113   if (!comp)
    114     return false;
    115 
    116   result = AudioComponentInstanceNew(comp, &output_unit_);
    117   if (result != noErr) {
    118     OSSTATUS_DLOG(ERROR, result) << "AudioComponentInstanceNew() failed.";
    119     return false;
    120   }
    121 
    122   result = AudioUnitInitialize(output_unit_);
    123   if (result != noErr) {
    124     OSSTATUS_DLOG(ERROR, result) << "AudioUnitInitialize() failed.";
    125     return false;
    126   }
    127 
    128   hardware_latency_frames_ = GetHardwareLatency();
    129 
    130   return Configure();
    131 }
    132 
    133 bool AUAudioOutputStream::Configure() {
    134   // Set the render callback.
    135   AURenderCallbackStruct input;
    136   input.inputProc = InputProc;
    137   input.inputProcRefCon = this;
    138   OSStatus result = AudioUnitSetProperty(
    139       output_unit_,
    140       kAudioUnitProperty_SetRenderCallback,
    141       kAudioUnitScope_Global,
    142       0,
    143       &input,
    144       sizeof(input));
    145   if (result != noErr) {
    146     OSSTATUS_DLOG(ERROR, result)
    147       << "AudioUnitSetProperty(kAudioUnitProperty_SetRenderCallback) failed.";
    148     return false;
    149   }
    150 
    151   // Set the stream format.
    152   result = AudioUnitSetProperty(
    153       output_unit_,
    154       kAudioUnitProperty_StreamFormat,
    155       kAudioUnitScope_Input,
    156       0,
    157       &format_,
    158       sizeof(format_));
    159   if (result != noErr) {
    160     OSSTATUS_DLOG(ERROR, result)
    161         << "AudioUnitSetProperty(kAudioUnitProperty_StreamFormat) failed.";
    162     return false;
    163   }
    164 
    165   // Set the buffer frame size.
    166   // WARNING: Setting this value changes the frame size for all audio units in
    167   // the current process.  It's imperative that the input and output frame sizes
    168   // be the same as the frames_per_buffer() returned by
    169   // GetDefaultOutputStreamParameters.
    170   // See http://crbug.com/154352 for details.
    171   const AudioParameters hw_params =
    172       manager_->GetDefaultOutputStreamParameters();
    173   if (number_of_frames_ != static_cast<size_t>(hw_params.frames_per_buffer())) {
    174     DLOG(ERROR) << "Audio buffer size does not match hardware buffer size.";
    175     return false;
    176   }
    177 
    178   UInt32 buffer_size = number_of_frames_;
    179   result = AudioUnitSetProperty(
    180       output_unit_,
    181       kAudioDevicePropertyBufferFrameSize,
    182       kAudioUnitScope_Output,
    183       0,
    184       &buffer_size,
    185       sizeof(buffer_size));
    186   if (result != noErr) {
    187     OSSTATUS_DLOG(ERROR, result)
    188         << "AudioUnitSetProperty(kAudioDevicePropertyBufferFrameSize) failed.";
    189     return false;
    190   }
    191 
    192   return true;
    193 }
    194 
    195 void AUAudioOutputStream::Close() {
    196   if (output_unit_)
    197     AudioComponentInstanceDispose(output_unit_);
    198 
    199   // Inform the audio manager that we have been closed. This can cause our
    200   // destruction.
    201   manager_->ReleaseOutputStream(this);
    202 }
    203 
    204 void AUAudioOutputStream::Start(AudioSourceCallback* callback) {
    205   DCHECK(callback);
    206   if (!output_unit_) {
    207     DLOG(ERROR) << "Open() has not been called successfully";
    208     return;
    209   }
    210 
    211   stopped_ = false;
    212   {
    213     base::AutoLock auto_lock(source_lock_);
    214     source_ = callback;
    215   }
    216 
    217   AudioOutputUnitStart(output_unit_);
    218 }
    219 
    220 void AUAudioOutputStream::Stop() {
    221   if (stopped_)
    222     return;
    223 
    224   AudioOutputUnitStop(output_unit_);
    225 
    226   base::AutoLock auto_lock(source_lock_);
    227   source_ = NULL;
    228   stopped_ = true;
    229 }
    230 
    231 void AUAudioOutputStream::SetVolume(double volume) {
    232   if (!output_unit_)
    233     return;
    234   volume_ = static_cast<float>(volume);
    235 
    236   // TODO(crogers): set volume property
    237 }
    238 
    239 void AUAudioOutputStream::GetVolume(double* volume) {
    240   if (!output_unit_)
    241     return;
    242   *volume = volume_;
    243 }
    244 
    245 // Pulls on our provider to get rendered audio stream.
    246 // Note to future hackers of this function: Do not add locks here because this
    247 // is running on a real-time thread (for low-latency).
    248 OSStatus AUAudioOutputStream::Render(UInt32 number_of_frames,
    249                                      AudioBufferList* io_data,
    250                                      const AudioTimeStamp* output_time_stamp) {
    251   // Update the playout latency.
    252   double playout_latency_frames = GetPlayoutLatency(output_time_stamp);
    253 
    254   AudioBuffer& buffer = io_data->mBuffers[0];
    255   uint8* audio_data = reinterpret_cast<uint8*>(buffer.mData);
    256   uint32 hardware_pending_bytes = static_cast<uint32>
    257       ((playout_latency_frames + 0.5) * format_.mBytesPerFrame);
    258 
    259   // Unfortunately AUAudioInputStream and AUAudioOutputStream share the frame
    260   // size set by kAudioDevicePropertyBufferFrameSize above on a per process
    261   // basis.  What this means is that the |number_of_frames| value may be larger
    262   // or smaller than the value set during Configure().  In this case either
    263   // audio input or audio output will be broken, so just output silence.
    264   // TODO(crogers): Figure out what can trigger a change in |number_of_frames|.
    265   // See http://crbug.com/154352 for details.
    266   if (number_of_frames != static_cast<UInt32>(audio_bus_->frames())) {
    267     memset(audio_data, 0, number_of_frames * format_.mBytesPerFrame);
    268     return noErr;
    269   }
    270 
    271   int frames_filled = 0;
    272   {
    273     // Render() shouldn't be called except between AudioOutputUnitStart() and
    274     // AudioOutputUnitStop() calls, but crash reports have shown otherwise:
    275     // http://crbug.com/178765.  We use |source_lock_| to prevent races and
    276     // crashes in Render() when |source_| is cleared.
    277     base::AutoLock auto_lock(source_lock_);
    278     if (!source_) {
    279       memset(audio_data, 0, number_of_frames * format_.mBytesPerFrame);
    280       return noErr;
    281     }
    282 
    283     frames_filled = source_->OnMoreData(
    284         audio_bus_.get(), AudioBuffersState(0, hardware_pending_bytes));
    285   }
    286 
    287   // Note: If this ever changes to output raw float the data must be clipped and
    288   // sanitized since it may come from an untrusted source such as NaCl.
    289   audio_bus_->Scale(volume_);
    290   audio_bus_->ToInterleaved(
    291       frames_filled, format_.mBitsPerChannel / 8, audio_data);
    292 
    293   return noErr;
    294 }
    295 
    296 // DefaultOutputUnit callback
    297 OSStatus AUAudioOutputStream::InputProc(void* user_data,
    298                                         AudioUnitRenderActionFlags*,
    299                                         const AudioTimeStamp* output_time_stamp,
    300                                         UInt32,
    301                                         UInt32 number_of_frames,
    302                                         AudioBufferList* io_data) {
    303   AUAudioOutputStream* audio_output =
    304       static_cast<AUAudioOutputStream*>(user_data);
    305   if (!audio_output)
    306     return -1;
    307 
    308   return audio_output->Render(number_of_frames, io_data, output_time_stamp);
    309 }
    310 
    311 int AUAudioOutputStream::HardwareSampleRate() {
    312   // Determine the default output device's sample-rate.
    313   AudioDeviceID device_id = kAudioObjectUnknown;
    314   UInt32 info_size = sizeof(device_id);
    315   OSStatus result = AudioObjectGetPropertyData(kAudioObjectSystemObject,
    316                                                &kDefaultOutputDeviceAddress,
    317                                                0,
    318                                                0,
    319                                                &info_size,
    320                                                &device_id);
    321   if (result != noErr || device_id == kAudioObjectUnknown) {
    322     OSSTATUS_DLOG(WARNING, result)
    323         << "Could not get default audio output device.";
    324     return 0;
    325   }
    326 
    327   Float64 nominal_sample_rate;
    328   info_size = sizeof(nominal_sample_rate);
    329 
    330   AudioObjectPropertyAddress nominal_sample_rate_address = {
    331       kAudioDevicePropertyNominalSampleRate,
    332       kAudioObjectPropertyScopeGlobal,
    333       kAudioObjectPropertyElementMaster
    334   };
    335   result = AudioObjectGetPropertyData(device_id,
    336                                       &nominal_sample_rate_address,
    337                                       0,
    338                                       0,
    339                                       &info_size,
    340                                       &nominal_sample_rate);
    341   if (result != noErr) {
    342     OSSTATUS_DLOG(WARNING, result)
    343         << "Could not get default sample rate for device: " << device_id;
    344     return 0;
    345   }
    346 
    347   return static_cast<int>(nominal_sample_rate);
    348 }
    349 
    350 double AUAudioOutputStream::GetHardwareLatency() {
    351   if (!output_unit_ || output_device_id_ == kAudioObjectUnknown) {
    352     DLOG(WARNING) << "Audio unit object is NULL or device ID is unknown";
    353     return 0.0;
    354   }
    355 
    356   // Get audio unit latency.
    357   Float64 audio_unit_latency_sec = 0.0;
    358   UInt32 size = sizeof(audio_unit_latency_sec);
    359   OSStatus result = AudioUnitGetProperty(output_unit_,
    360                                          kAudioUnitProperty_Latency,
    361                                          kAudioUnitScope_Global,
    362                                          0,
    363                                          &audio_unit_latency_sec,
    364                                          &size);
    365   if (result != noErr) {
    366     OSSTATUS_DLOG(WARNING, result) << "Could not get audio unit latency";
    367     return 0.0;
    368   }
    369 
    370   // Get output audio device latency.
    371   AudioObjectPropertyAddress property_address = {
    372     kAudioDevicePropertyLatency,
    373     kAudioDevicePropertyScopeOutput,
    374     kAudioObjectPropertyElementMaster
    375   };
    376   UInt32 device_latency_frames = 0;
    377   size = sizeof(device_latency_frames);
    378   result = AudioObjectGetPropertyData(output_device_id_,
    379                                       &property_address,
    380                                       0,
    381                                       NULL,
    382                                       &size,
    383                                       &device_latency_frames);
    384   if (result != noErr) {
    385     OSSTATUS_DLOG(WARNING, result) << "Could not get audio unit latency";
    386     return 0.0;
    387   }
    388 
    389   return static_cast<double>((audio_unit_latency_sec *
    390       format_.mSampleRate) + device_latency_frames);
    391 }
    392 
    393 double AUAudioOutputStream::GetPlayoutLatency(
    394     const AudioTimeStamp* output_time_stamp) {
    395   // Ensure mHostTime is valid.
    396   if ((output_time_stamp->mFlags & kAudioTimeStampHostTimeValid) == 0)
    397     return 0;
    398 
    399   // Get the delay between the moment getting the callback and the scheduled
    400   // time stamp that tells when the data is going to be played out.
    401   UInt64 output_time_ns = AudioConvertHostTimeToNanos(
    402       output_time_stamp->mHostTime);
    403   UInt64 now_ns = AudioConvertHostTimeToNanos(AudioGetCurrentHostTime());
    404 
    405   // Prevent overflow leading to huge delay information; occurs regularly on
    406   // the bots, probably less so in the wild.
    407   if (now_ns > output_time_ns)
    408     return 0;
    409 
    410   double delay_frames = static_cast<double>
    411       (1e-9 * (output_time_ns - now_ns) * format_.mSampleRate);
    412 
    413   return (delay_frames + hardware_latency_frames_);
    414 }
    415 
    416 }  // namespace media
    417