media/audio/mac/audio_synchronized_mac.cc

   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_synchronized_mac.h"
   6
   7 #include <CoreServices/CoreServices.h>
   8 #include <algorithm>
   9
  10 #include "base/basictypes.h"
  11 #include "base/debug/trace_event.h"
  12 #include "base/logging.h"
  13 #include "base/mac/mac_logging.h"
  14 #include "media/audio/mac/audio_manager_mac.h"
  15 #include "media/base/channel_mixer.h"
  16
  17 namespace media {
  18
  19 static const int kHardwareBufferSize = 128;
  20 static const int kFifoSize = 16384;
  21
  22 // TODO(crogers): handle the non-stereo case.
  23 static const int kChannels = 2;
  24
  25 // This value was determined empirically for minimum latency while still
  26 // guarding against FIFO under-runs.
  27 static const int kBaseTargetFifoFrames = 256 + 64;
  28
  29 // If the input and output sample-rate don't match, then we need to maintain
  30 // an additional safety margin due to the callback timing jitter and the
  31 // varispeed buffering.  This value was empirically tuned.
  32 static const int kAdditionalTargetFifoFrames = 128;
  33
  34 static void ZeroBufferList(AudioBufferList* buffer_list) {
  35   for (size_t i = 0; i < buffer_list->mNumberBuffers; ++i)
  36     memset(buffer_list->mBuffers[i].mData,
  37            0,
  38            buffer_list->mBuffers[i].mDataByteSize);
  39 }
  40
  41 static void WrapBufferList(AudioBufferList* buffer_list,
  42                            AudioBus* bus,
  43                            int frames) {
  44   DCHECK(buffer_list);
  45   DCHECK(bus);
  46   int channels = bus->channels();
  47   int buffer_list_channels = buffer_list->mNumberBuffers;
  48
  49   // Copy pointers from AudioBufferList.
  50   int source_idx = 0;
  51   for (int i = 0; i < channels; ++i) {
  52     bus->SetChannelData(
  53         i, static_cast<float*>(buffer_list->mBuffers[source_idx].mData));
  54
  55     // It's ok to pass in a |buffer_list| with fewer channels, in which
  56     // case we just duplicate the last channel.
  57     if (source_idx < buffer_list_channels - 1)
  58       ++source_idx;
  59   }
  60
  61   // Finally set the actual length.
  62   bus->set_frames(frames);
  63 }
  64
  65 AudioSynchronizedStream::AudioSynchronizedStream(
  66     AudioManagerMac* manager,
  67     const AudioParameters& params,
  68     AudioDeviceID input_id,
  69     AudioDeviceID output_id)
  70     : manager_(manager),
  71       params_(params),
  72       input_sample_rate_(0),
  73       output_sample_rate_(0),
  74       input_id_(input_id),
  75       output_id_(output_id),
  76       input_buffer_list_(NULL),
  77       fifo_(kChannels, kFifoSize),
  78       target_fifo_frames_(kBaseTargetFifoFrames),
  79       average_delta_(0.0),
  80       fifo_rate_compensation_(1.0),
  81       input_unit_(0),
  82       varispeed_unit_(0),
  83       output_unit_(0),
  84       first_input_time_(-1),
  85       is_running_(false),
  86       hardware_buffer_size_(kHardwareBufferSize),
  87       channels_(kChannels) {
  88   VLOG(1) << "AudioSynchronizedStream::AudioSynchronizedStream()";
  89 }
  90
  91 AudioSynchronizedStream::~AudioSynchronizedStream() {
  92   DCHECK(!input_unit_);
  93   DCHECK(!output_unit_);
  94   DCHECK(!varispeed_unit_);
  95 }
  96
  97 bool AudioSynchronizedStream::Open() {
  98   if (params_.channels() != kChannels) {
  99     LOG(ERROR) << "Only stereo output is currently supported.";
 100     return false;
 101   }
 102
 103   // Create the input, output, and varispeed AudioUnits.
 104   OSStatus result = CreateAudioUnits();
 105   if (result != noErr) {
 106     LOG(ERROR) << "Cannot create AudioUnits.";
 107     return false;
 108   }
 109
 110   result = SetupInput(input_id_);
 111   if (result != noErr) {
 112     LOG(ERROR) << "Error configuring input AudioUnit.";
 113     return false;
 114   }
 115
 116   result = SetupOutput(output_id_);
 117   if (result != noErr) {
 118     LOG(ERROR) << "Error configuring output AudioUnit.";
 119     return false;
 120   }
 121
 122   result = SetupCallbacks();
 123   if (result != noErr) {
 124     LOG(ERROR) << "Error setting up callbacks on AudioUnits.";
 125     return false;
 126   }
 127
 128   result = SetupStreamFormats();
 129   if (result != noErr) {
 130     LOG(ERROR) << "Error configuring stream formats on AudioUnits.";
 131     return false;
 132   }
 133
 134   AllocateInputData();
 135
 136   // Final initialization of the AudioUnits.
 137   result = AudioUnitInitialize(input_unit_);
 138   if (result != noErr) {
 139     LOG(ERROR) << "Error initializing input AudioUnit.";
 140     return false;
 141   }
 142
 143   result = AudioUnitInitialize(output_unit_);
 144   if (result != noErr) {
 145     LOG(ERROR) << "Error initializing output AudioUnit.";
 146     return false;
 147   }
 148
 149   result = AudioUnitInitialize(varispeed_unit_);
 150   if (result != noErr) {
 151     LOG(ERROR) << "Error initializing varispeed AudioUnit.";
 152     return false;
 153   }
 154
 155   if (input_sample_rate_ != output_sample_rate_) {
 156     // Add extra safety margin.
 157     target_fifo_frames_ += kAdditionalTargetFifoFrames;
 158   }
 159
 160   // Buffer initial silence corresponding to target I/O buffering.
 161   fifo_.Clear();
 162   scoped_ptr<AudioBus> silence =
 163       AudioBus::Create(channels_, target_fifo_frames_);
 164   silence->Zero();
 165   fifo_.Push(silence.get());
 166
 167   return true;
 168 }
 169
 170 void AudioSynchronizedStream::Close() {
 171   DCHECK(!is_running_);
 172
 173   if (input_buffer_list_) {
 174     free(input_buffer_list_);
 175     input_buffer_list_ = 0;
 176     input_bus_.reset(NULL);
 177     wrapper_bus_.reset(NULL);
 178   }
 179
 180   if (input_unit_) {
 181     AudioUnitUninitialize(input_unit_);
 182     CloseComponent(input_unit_);
 183   }
 184
 185   if (output_unit_) {
 186     AudioUnitUninitialize(output_unit_);
 187     CloseComponent(output_unit_);
 188   }
 189
 190   if (varispeed_unit_) {
 191     AudioUnitUninitialize(varispeed_unit_);
 192     CloseComponent(varispeed_unit_);
 193   }
 194
 195   input_unit_ = NULL;
 196   output_unit_ = NULL;
 197   varispeed_unit_ = NULL;
 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 AudioSynchronizedStream::Start(AudioSourceCallback* callback) {
 205   DCHECK(callback);
 206   DCHECK(input_unit_);
 207   DCHECK(output_unit_);
 208   DCHECK(varispeed_unit_);
 209
 210   if (is_running_ || !input_unit_ || !output_unit_ || !varispeed_unit_)
 211     return;
 212
 213   source_ = callback;
 214
 215   // Reset state variables each time we Start().
 216   fifo_rate_compensation_ = 1.0;
 217   average_delta_ = 0.0;
 218
 219   OSStatus result = noErr;
 220
 221   if (!is_running_) {
 222     first_input_time_ = -1;
 223
 224     result = AudioOutputUnitStart(input_unit_);
 225     OSSTATUS_DCHECK(result == noErr, result);
 226
 227     if (result == noErr) {
 228       result = AudioOutputUnitStart(output_unit_);
 229       OSSTATUS_DCHECK(result == noErr, result);
 230     }
 231   }
 232
 233   is_running_ = true;
 234 }
 235
 236 void AudioSynchronizedStream::Stop() {
 237   OSStatus result = noErr;
 238   if (is_running_) {
 239     result = AudioOutputUnitStop(input_unit_);
 240     OSSTATUS_DCHECK(result == noErr, result);
 241
 242     if (result == noErr) {
 243       result = AudioOutputUnitStop(output_unit_);
 244       OSSTATUS_DCHECK(result == noErr, result);
 245     }
 246   }
 247
 248   if (result == noErr)
 249     is_running_ = false;
 250 }
 251
 252 bool AudioSynchronizedStream::IsRunning() {
 253   return is_running_;
 254 }
 255
 256 // TODO(crogers): implement - or remove from AudioOutputStream.
 257 void AudioSynchronizedStream::SetVolume(double volume) {}
 258 void AudioSynchronizedStream::GetVolume(double* volume) {}
 259
 260 OSStatus AudioSynchronizedStream::SetOutputDeviceAsCurrent(
 261     AudioDeviceID output_id) {
 262   OSStatus result = noErr;
 263
 264   // Get the default output device if device is unknown.
 265   if (output_id == kAudioDeviceUnknown) {
 266     AudioObjectPropertyAddress pa;
 267     pa.mSelector = kAudioHardwarePropertyDefaultOutputDevice;
 268     pa.mScope = kAudioObjectPropertyScopeGlobal;
 269     pa.mElement = kAudioObjectPropertyElementMaster;
 270     UInt32 size = sizeof(output_id);
 271
 272     result = AudioObjectGetPropertyData(
 273         kAudioObjectSystemObject,
 274         &pa,
 275         0,
 276         0,
 277         &size,
 278         &output_id);
 279
 280     OSSTATUS_DCHECK(result == noErr, result);
 281     if (result != noErr)
 282       return result;
 283   }
 284
 285   // Set the render frame size.
 286   UInt32 frame_size = hardware_buffer_size_;
 287   AudioObjectPropertyAddress pa;
 288   pa.mSelector = kAudioDevicePropertyBufferFrameSize;
 289   pa.mScope = kAudioDevicePropertyScopeInput;
 290   pa.mElement = kAudioObjectPropertyElementMaster;
 291   result = AudioObjectSetPropertyData(
 292       output_id,
 293       &pa,
 294       0,
 295       0,
 296       sizeof(frame_size),
 297       &frame_size);
 298
 299   OSSTATUS_DCHECK(result == noErr, result);
 300   if (result != noErr)
 301     return result;
 302
 303   output_info_.Initialize(output_id, false);
 304
 305   // Set the Current Device to the Default Output Unit.
 306   result = AudioUnitSetProperty(
 307       output_unit_,
 308       kAudioOutputUnitProperty_CurrentDevice,
 309       kAudioUnitScope_Global,
 310       0,
 311       &output_info_.id_,
 312       sizeof(output_info_.id_));
 313
 314   OSSTATUS_DCHECK(result == noErr, result);
 315   return result;
 316 }
 317
 318 OSStatus AudioSynchronizedStream::SetInputDeviceAsCurrent(
 319     AudioDeviceID input_id) {
 320   OSStatus result = noErr;
 321
 322   // Get the default input device if device is unknown.
 323   if (input_id == kAudioDeviceUnknown) {
 324     AudioObjectPropertyAddress pa;
 325     pa.mSelector = kAudioHardwarePropertyDefaultInputDevice;
 326     pa.mScope = kAudioObjectPropertyScopeGlobal;
 327     pa.mElement = kAudioObjectPropertyElementMaster;
 328     UInt32 size = sizeof(input_id);
 329
 330     result = AudioObjectGetPropertyData(
 331         kAudioObjectSystemObject,
 332         &pa,
 333         0,
 334         0,
 335         &size,
 336         &input_id);
 337
 338     OSSTATUS_DCHECK(result == noErr, result);
 339     if (result != noErr)
 340       return result;
 341   }
 342
 343   // Set the render frame size.
 344   UInt32 frame_size = hardware_buffer_size_;
 345   AudioObjectPropertyAddress pa;
 346   pa.mSelector = kAudioDevicePropertyBufferFrameSize;
 347   pa.mScope = kAudioDevicePropertyScopeInput;
 348   pa.mElement = kAudioObjectPropertyElementMaster;
 349   result = AudioObjectSetPropertyData(
 350       input_id,
 351       &pa,
 352       0,
 353       0,
 354       sizeof(frame_size),
 355       &frame_size);
 356
 357   OSSTATUS_DCHECK(result == noErr, result);
 358   if (result != noErr)
 359     return result;
 360
 361   input_info_.Initialize(input_id, true);
 362
 363   // Set the Current Device to the AUHAL.
 364   // This should be done only after I/O has been enabled on the AUHAL.
 365   result = AudioUnitSetProperty(
 366       input_unit_,
 367       kAudioOutputUnitProperty_CurrentDevice,
 368       kAudioUnitScope_Global,
 369       0,
 370       &input_info_.id_,
 371       sizeof(input_info_.id_));
 372
 373   OSSTATUS_DCHECK(result == noErr, result);
 374   return result;
 375 }
 376
 377 OSStatus AudioSynchronizedStream::CreateAudioUnits() {
 378   // Q: Why do we need a varispeed unit?
 379   // A: If the input device and the output device are running at
 380   // different sample rates and/or on different clocks, we will need
 381   // to compensate to avoid a pitch change and
 382   // to avoid buffer under and over runs.
 383   ComponentDescription varispeed_desc;
 384   varispeed_desc.componentType = kAudioUnitType_FormatConverter;
 385   varispeed_desc.componentSubType = kAudioUnitSubType_Varispeed;
 386   varispeed_desc.componentManufacturer = kAudioUnitManufacturer_Apple;
 387   varispeed_desc.componentFlags = 0;
 388   varispeed_desc.componentFlagsMask = 0;
 389
 390   Component varispeed_comp = FindNextComponent(NULL, &varispeed_desc);
 391   if (varispeed_comp == NULL)
 392     return -1;
 393
 394   OSStatus result = OpenAComponent(varispeed_comp, &varispeed_unit_);
 395   OSSTATUS_DCHECK(result == noErr, result);
 396   if (result != noErr)
 397     return result;
 398
 399   // Open input AudioUnit.
 400   ComponentDescription input_desc;
 401   input_desc.componentType = kAudioUnitType_Output;
 402   input_desc.componentSubType = kAudioUnitSubType_HALOutput;
 403   input_desc.componentManufacturer = kAudioUnitManufacturer_Apple;
 404   input_desc.componentFlags = 0;
 405   input_desc.componentFlagsMask = 0;
 406
 407   Component input_comp = FindNextComponent(NULL, &input_desc);
 408   if (input_comp == NULL)
 409     return -1;
 410
 411   result = OpenAComponent(input_comp, &input_unit_);
 412   OSSTATUS_DCHECK(result == noErr, result);
 413   if (result != noErr)
 414     return result;
 415
 416   // Open output AudioUnit.
 417   ComponentDescription output_desc;
 418   output_desc.componentType = kAudioUnitType_Output;
 419   output_desc.componentSubType = kAudioUnitSubType_DefaultOutput;
 420   output_desc.componentManufacturer = kAudioUnitManufacturer_Apple;
 421   output_desc.componentFlags = 0;
 422   output_desc.componentFlagsMask = 0;
 423
 424   Component output_comp = FindNextComponent(NULL, &output_desc);
 425   if (output_comp == NULL)
 426     return -1;
 427
 428   result = OpenAComponent(output_comp, &output_unit_);
 429   OSSTATUS_DCHECK(result == noErr, result);
 430   if (result != noErr)
 431     return result;
 432
 433   return noErr;
 434 }
 435
 436 OSStatus AudioSynchronizedStream::SetupInput(AudioDeviceID input_id) {
 437   // The AUHAL used for input needs to be initialized
 438   // before anything is done to it.
 439   OSStatus result = AudioUnitInitialize(input_unit_);
 440   OSSTATUS_DCHECK(result == noErr, result);
 441   if (result != noErr)
 442     return result;
 443
 444   // We must enable the Audio Unit (AUHAL) for input and disable output
 445   // BEFORE setting the AUHAL's current device.
 446   result = EnableIO();
 447   OSSTATUS_DCHECK(result == noErr, result);
 448   if (result != noErr)
 449     return result;
 450
 451   result = SetInputDeviceAsCurrent(input_id);
 452   OSSTATUS_DCHECK(result == noErr, result);
 453
 454   return result;
 455 }
 456
 457 OSStatus AudioSynchronizedStream::EnableIO() {
 458   // Enable input on the AUHAL.
 459   UInt32 enable_io = 1;
 460   OSStatus result = AudioUnitSetProperty(
 461       input_unit_,
 462       kAudioOutputUnitProperty_EnableIO,
 463       kAudioUnitScope_Input,
 464       1,  // input element
 465       &enable_io,
 466       sizeof(enable_io));
 467
 468   OSSTATUS_DCHECK(result == noErr, result);
 469   if (result != noErr)
 470     return result;
 471
 472   // Disable Output on the AUHAL.
 473   enable_io = 0;
 474   result = AudioUnitSetProperty(
 475       input_unit_,
 476       kAudioOutputUnitProperty_EnableIO,
 477       kAudioUnitScope_Output,
 478       0,  // output element
 479       &enable_io,
 480       sizeof(enable_io));
 481
 482   OSSTATUS_DCHECK(result == noErr, result);
 483   return result;
 484 }
 485
 486 OSStatus AudioSynchronizedStream::SetupOutput(AudioDeviceID output_id) {
 487   OSStatus result = noErr;
 488
 489   result = SetOutputDeviceAsCurrent(output_id);
 490   OSSTATUS_DCHECK(result == noErr, result);
 491   if (result != noErr)
 492     return result;
 493
 494   // Tell the output unit not to reset timestamps.
 495   // Otherwise sample rate changes will cause sync loss.
 496   UInt32 start_at_zero = 0;
 497   result = AudioUnitSetProperty(
 498       output_unit_,
 499       kAudioOutputUnitProperty_StartTimestampsAtZero,
 500       kAudioUnitScope_Global,
 501       0,
 502       &start_at_zero,
 503       sizeof(start_at_zero));
 504
 505   OSSTATUS_DCHECK(result == noErr, result);
 506
 507   return result;
 508 }
 509
 510 OSStatus AudioSynchronizedStream::SetupCallbacks() {
 511   // Set the input callback.
 512   AURenderCallbackStruct callback;
 513   callback.inputProc = InputProc;
 514   callback.inputProcRefCon = this;
 515   OSStatus result = AudioUnitSetProperty(
 516       input_unit_,
 517       kAudioOutputUnitProperty_SetInputCallback,
 518       kAudioUnitScope_Global,
 519       0,
 520       &callback,
 521       sizeof(callback));
 522
 523   OSSTATUS_DCHECK(result == noErr, result);
 524   if (result != noErr)
 525     return result;
 526
 527   // Set the output callback.
 528   callback.inputProc = OutputProc;
 529   callback.inputProcRefCon = this;
 530   result = AudioUnitSetProperty(
 531       output_unit_,
 532       kAudioUnitProperty_SetRenderCallback,
 533       kAudioUnitScope_Input,
 534       0,
 535       &callback,
 536       sizeof(callback));
 537
 538   OSSTATUS_DCHECK(result == noErr, result);
 539   if (result != noErr)
 540     return result;
 541
 542   // Set the varispeed callback.
 543   callback.inputProc = VarispeedProc;
 544   callback.inputProcRefCon = this;
 545   result = AudioUnitSetProperty(
 546       varispeed_unit_,
 547       kAudioUnitProperty_SetRenderCallback,
 548       kAudioUnitScope_Input,
 549       0,
 550       &callback,
 551       sizeof(callback));
 552
 553   OSSTATUS_DCHECK(result == noErr, result);
 554
 555   return result;
 556 }
 557
 558 OSStatus AudioSynchronizedStream::SetupStreamFormats() {
 559   AudioStreamBasicDescription asbd, asbd_dev1_in, asbd_dev2_out;
 560
 561   // Get the Stream Format (Output client side).
 562   UInt32 property_size = sizeof(asbd_dev1_in);
 563   OSStatus result = AudioUnitGetProperty(
 564       input_unit_,
 565       kAudioUnitProperty_StreamFormat,
 566       kAudioUnitScope_Input,
 567       1,
 568       &asbd_dev1_in,
 569       &property_size);
 570
 571   OSSTATUS_DCHECK(result == noErr, result);
 572   if (result != noErr)
 573     return result;
 574
 575   // Get the Stream Format (client side).
 576   property_size = sizeof(asbd);
 577   result = AudioUnitGetProperty(
 578       input_unit_,
 579       kAudioUnitProperty_StreamFormat,
 580       kAudioUnitScope_Output,
 581       1,
 582       &asbd,
 583       &property_size);
 584
 585   OSSTATUS_DCHECK(result == noErr, result);
 586   if (result != noErr)
 587     return result;
 588
 589   // Get the Stream Format (Output client side).
 590   property_size = sizeof(asbd_dev2_out);
 591   result = AudioUnitGetProperty(
 592       output_unit_,
 593       kAudioUnitProperty_StreamFormat,
 594       kAudioUnitScope_Output,
 595       0,
 596       &asbd_dev2_out,
 597       &property_size);
 598
 599   OSSTATUS_DCHECK(result == noErr, result);
 600   if (result != noErr)
 601     return result;
 602
 603   // Set the format of all the AUs to the input/output devices channel count.
 604   // For a simple case, you want to set this to
 605   // the lower of count of the channels in the input device vs output device.
 606   asbd.mChannelsPerFrame = std::min(asbd_dev1_in.mChannelsPerFrame,
 607                                     asbd_dev2_out.mChannelsPerFrame);
 608
 609   // We must get the sample rate of the input device and set it to the
 610   // stream format of AUHAL.
 611   Float64 rate = 0;
 612   property_size = sizeof(rate);
 613
 614   AudioObjectPropertyAddress pa;
 615   pa.mSelector = kAudioDevicePropertyNominalSampleRate;
 616   pa.mScope = kAudioObjectPropertyScopeWildcard;
 617   pa.mElement = kAudioObjectPropertyElementMaster;
 618   result = AudioObjectGetPropertyData(
 619       input_info_.id_,
 620       &pa,
 621       0,
 622       0,
 623       &property_size,
 624       &rate);
 625
 626   OSSTATUS_DCHECK(result == noErr, result);
 627   if (result != noErr)
 628     return result;
 629
 630   input_sample_rate_ = rate;
 631
 632   asbd.mSampleRate = rate;
 633   property_size = sizeof(asbd);
 634
 635   // Set the new formats to the AUs...
 636   result = AudioUnitSetProperty(
 637       input_unit_,
 638       kAudioUnitProperty_StreamFormat,
 639       kAudioUnitScope_Output,
 640       1,
 641       &asbd,
 642       property_size);
 643
 644   OSSTATUS_DCHECK(result == noErr, result);
 645   if (result != noErr)
 646     return result;
 647
 648   result = AudioUnitSetProperty(
 649       varispeed_unit_,
 650       kAudioUnitProperty_StreamFormat,
 651       kAudioUnitScope_Input,
 652       0,
 653       &asbd,
 654       property_size);
 655
 656   OSSTATUS_DCHECK(result == noErr, result);
 657   if (result != noErr)
 658     return result;
 659
 660   // Set the correct sample rate for the output device,
 661   // but keep the channel count the same.
 662   property_size = sizeof(rate);
 663
 664   pa.mSelector = kAudioDevicePropertyNominalSampleRate;
 665   pa.mScope = kAudioObjectPropertyScopeWildcard;
 666   pa.mElement = kAudioObjectPropertyElementMaster;
 667   result = AudioObjectGetPropertyData(
 668       output_info_.id_,
 669       &pa,
 670       0,
 671       0,
 672       &property_size,
 673       &rate);
 674
 675   OSSTATUS_DCHECK(result == noErr, result);
 676   if (result != noErr)
 677     return result;
 678
 679   output_sample_rate_ = rate;
 680
 681   // The requested sample-rate must match the hardware sample-rate.
 682   if (output_sample_rate_ != params_.sample_rate()) {
 683     LOG(ERROR) << "Requested sample-rate: " << params_.sample_rate()
 684         <<  " must match the hardware sample-rate: " << output_sample_rate_;
 685     return kAudioDeviceUnsupportedFormatError;
 686   }
 687
 688   asbd.mSampleRate = rate;
 689   property_size = sizeof(asbd);
 690
 691   // Set the new audio stream formats for the rest of the AUs...
 692   result = AudioUnitSetProperty(
 693       varispeed_unit_,
 694       kAudioUnitProperty_StreamFormat,
 695       kAudioUnitScope_Output,
 696       0,
 697       &asbd,
 698       property_size);
 699
 700   OSSTATUS_DCHECK(result == noErr, result);
 701   if (result != noErr)
 702     return result;
 703
 704   result = AudioUnitSetProperty(
 705       output_unit_,
 706       kAudioUnitProperty_StreamFormat,
 707       kAudioUnitScope_Input,
 708       0,
 709       &asbd,
 710       property_size);
 711
 712   OSSTATUS_DCHECK(result == noErr, result);
 713   return result;
 714 }
 715
 716 void AudioSynchronizedStream::AllocateInputData() {
 717   // Get the native number of input channels that the hardware supports.
 718   int hardware_channels = 0;
 719   bool got_hardware_channels = AudioManagerMac::GetDeviceChannels(
 720       input_id_, kAudioDevicePropertyScopeInput, &hardware_channels);
 721   if (!got_hardware_channels || hardware_channels > 2) {
 722     // Only mono and stereo are supported on the input side. When it fails to
 723     // get the native channel number or the native channel number is bigger
 724     // than 2, we open the device in stereo mode.
 725     hardware_channels = 2;
 726   }
 727
 728   // Allocate storage for the AudioBufferList used for the
 729   // input data from the input AudioUnit.
 730   // We allocate enough space for with one AudioBuffer per channel.
 731   size_t malloc_size = offsetof(AudioBufferList, mBuffers[0]) +
 732       (sizeof(AudioBuffer) * hardware_channels);
 733
 734   input_buffer_list_ = static_cast<AudioBufferList*>(malloc(malloc_size));
 735   input_buffer_list_->mNumberBuffers = hardware_channels;
 736
 737   input_bus_ = AudioBus::Create(hardware_channels, hardware_buffer_size_);
 738   wrapper_bus_ = AudioBus::CreateWrapper(channels_);
 739   if (hardware_channels != params_.input_channels()) {
 740     ChannelLayout hardware_channel_layout =
 741         GuessChannelLayout(hardware_channels);
 742     ChannelLayout requested_channel_layout =
 743         GuessChannelLayout(params_.input_channels());
 744     channel_mixer_.reset(new ChannelMixer(hardware_channel_layout,
 745                                           requested_channel_layout));
 746     mixer_bus_ = AudioBus::Create(params_.input_channels(),
 747                                   hardware_buffer_size_);
 748   }
 749
 750   // Allocate buffers for AudioBufferList.
 751   UInt32 buffer_size_bytes = input_bus_->frames() * sizeof(Float32);
 752   for (size_t i = 0; i < input_buffer_list_->mNumberBuffers; ++i) {
 753     input_buffer_list_->mBuffers[i].mNumberChannels = 1;
 754     input_buffer_list_->mBuffers[i].mDataByteSize = buffer_size_bytes;
 755     input_buffer_list_->mBuffers[i].mData = input_bus_->channel(i);
 756   }
 757 }
 758
 759 OSStatus AudioSynchronizedStream::HandleInputCallback(
 760     AudioUnitRenderActionFlags* io_action_flags,
 761     const AudioTimeStamp* time_stamp,
 762     UInt32 bus_number,
 763     UInt32 number_of_frames,
 764     AudioBufferList* io_data) {
 765   TRACE_EVENT0("audio", "AudioSynchronizedStream::HandleInputCallback");
 766
 767   if (first_input_time_ < 0.0)
 768     first_input_time_ = time_stamp->mSampleTime;
 769
 770   // Get the new audio input data.
 771   OSStatus result = AudioUnitRender(
 772       input_unit_,
 773       io_action_flags,
 774       time_stamp,
 775       bus_number,
 776       number_of_frames,
 777       input_buffer_list_);
 778
 779   // TODO(xians): Add back the DCHECK after synchronize IO supports all
 780   // combination of input and output params. See http://issue/246521.
 781   if (result != noErr)
 782     return result;
 783
 784   // Buffer input into FIFO.
 785   int available_frames = fifo_.max_frames() - fifo_.frames();
 786   if (input_bus_->frames() <= available_frames) {
 787     if (channel_mixer_) {
 788       channel_mixer_->Transform(input_bus_.get(), mixer_bus_.get());
 789       fifo_.Push(mixer_bus_.get());
 790     } else {
 791       fifo_.Push(input_bus_.get());
 792     }
 793   }
 794
 795   return result;
 796 }
 797
 798 OSStatus AudioSynchronizedStream::HandleVarispeedCallback(
 799     AudioUnitRenderActionFlags* io_action_flags,
 800     const AudioTimeStamp* time_stamp,
 801     UInt32 bus_number,
 802     UInt32 number_of_frames,
 803     AudioBufferList* io_data) {
 804   // Create a wrapper bus on the AudioBufferList.
 805   WrapBufferList(io_data, wrapper_bus_.get(), number_of_frames);
 806
 807   if (fifo_.frames() < static_cast<int>(number_of_frames)) {
 808     // We don't DCHECK here, since this is a possible run-time condition
 809     // if the machine is bogged down.
 810     wrapper_bus_->Zero();
 811     return noErr;
 812   }
 813
 814   // Read from the FIFO to feed the varispeed.
 815   fifo_.Consume(wrapper_bus_.get(), 0, number_of_frames);
 816
 817   return noErr;
 818 }
 819
 820 OSStatus AudioSynchronizedStream::HandleOutputCallback(
 821     AudioUnitRenderActionFlags* io_action_flags,
 822     const AudioTimeStamp* time_stamp,
 823     UInt32 bus_number,
 824     UInt32 number_of_frames,
 825     AudioBufferList* io_data) {
 826   // Input callback hasn't run yet or we've suddenly changed sample-rates
 827   // -> silence.
 828   if (first_input_time_ < 0.0 ||
 829       static_cast<int>(number_of_frames) != params_.frames_per_buffer()) {
 830     ZeroBufferList(io_data);
 831     return noErr;
 832   }
 833
 834   // Use the varispeed playback rate to offset small discrepancies
 835   // in hardware clocks, and also any differences in sample-rate
 836   // between input and output devices.
 837
 838   // Calculate a varispeed rate scalar factor to compensate for drift between
 839   // input and output.  We use the actual number of frames still in the FIFO
 840   // compared with the ideal value of |target_fifo_frames_|.
 841   int delta = fifo_.frames() - target_fifo_frames_;
 842
 843   // Average |delta| because it can jitter back/forth quite frequently
 844   // by +/- the hardware buffer-size *if* the input and output callbacks are
 845   // happening at almost exactly the same time.  Also, if the input and output
 846   // sample-rates are different then |delta| will jitter quite a bit due to
 847   // the rate conversion happening in the varispeed, plus the jittering of
 848   // the callbacks.  The average value is what's important here.
 849   average_delta_ += (delta - average_delta_) * 0.1;
 850
 851   // Compute a rate compensation which always attracts us back to the
 852   // |target_fifo_frames_| over a period of kCorrectionTimeSeconds.
 853   const double kCorrectionTimeSeconds = 0.1;
 854   double correction_time_frames = kCorrectionTimeSeconds * output_sample_rate_;
 855   fifo_rate_compensation_ =
 856       (correction_time_frames + average_delta_) / correction_time_frames;
 857
 858   // Adjust for FIFO drift.
 859   OSStatus result = AudioUnitSetParameter(
 860       varispeed_unit_,
 861       kVarispeedParam_PlaybackRate,
 862       kAudioUnitScope_Global,
 863       0,
 864       fifo_rate_compensation_,
 865       0);
 866
 867   OSSTATUS_DCHECK(result == noErr, result);
 868   if (result != noErr)
 869     return result;
 870
 871   // Render to the output using the varispeed.
 872   result = AudioUnitRender(
 873       varispeed_unit_,
 874       io_action_flags,
 875       time_stamp,
 876       0,
 877       number_of_frames,
 878       io_data);
 879
 880   OSSTATUS_DCHECK(result == noErr, result);
 881   if (result != noErr)
 882     return result;
 883
 884   // Create a wrapper bus on the AudioBufferList.
 885   WrapBufferList(io_data, wrapper_bus_.get(), number_of_frames);
 886
 887   // Process in-place!
 888   source_->OnMoreIOData(wrapper_bus_.get(),
 889                         wrapper_bus_.get(),
 890                         AudioBuffersState(0, 0));
 891
 892   return noErr;
 893 }
 894
 895 OSStatus AudioSynchronizedStream::InputProc(
 896     void* user_data,
 897     AudioUnitRenderActionFlags* io_action_flags,
 898     const AudioTimeStamp* time_stamp,
 899     UInt32 bus_number,
 900     UInt32 number_of_frames,
 901     AudioBufferList* io_data) {
 902   AudioSynchronizedStream* stream =
 903       static_cast<AudioSynchronizedStream*>(user_data);
 904   DCHECK(stream);
 905
 906   return stream->HandleInputCallback(
 907       io_action_flags,
 908       time_stamp,
 909       bus_number,
 910       number_of_frames,
 911       io_data);
 912 }
 913
 914 OSStatus AudioSynchronizedStream::VarispeedProc(
 915     void* user_data,
 916     AudioUnitRenderActionFlags* io_action_flags,
 917     const AudioTimeStamp* time_stamp,
 918     UInt32 bus_number,
 919     UInt32 number_of_frames,
 920     AudioBufferList* io_data) {
 921   AudioSynchronizedStream* stream =
 922       static_cast<AudioSynchronizedStream*>(user_data);
 923   DCHECK(stream);
 924
 925   return stream->HandleVarispeedCallback(
 926       io_action_flags,
 927       time_stamp,
 928       bus_number,
 929       number_of_frames,
 930       io_data);
 931 }
 932
 933 OSStatus AudioSynchronizedStream::OutputProc(
 934     void* user_data,
 935     AudioUnitRenderActionFlags* io_action_flags,
 936     const AudioTimeStamp* time_stamp,
 937     UInt32 bus_number,
 938     UInt32 number_of_frames,
 939     AudioBufferList* io_data) {
 940   AudioSynchronizedStream* stream =
 941       static_cast<AudioSynchronizedStream*>(user_data);
 942   DCHECK(stream);
 943
 944   return stream->HandleOutputCallback(
 945       io_action_flags,
 946       time_stamp,
 947       bus_number,
 948       number_of_frames,
 949       io_data);
 950 }
 951
 952 void AudioSynchronizedStream::AudioDeviceInfo::Initialize(
 953     AudioDeviceID id, bool is_input) {
 954   id_ = id;
 955   is_input_ = is_input;
 956   if (id_ == kAudioDeviceUnknown)
 957     return;
 958
 959   UInt32 property_size = sizeof(buffer_size_frames_);
 960
 961   AudioObjectPropertyAddress pa;
 962   pa.mSelector = kAudioDevicePropertyBufferFrameSize;
 963   pa.mScope = kAudioObjectPropertyScopeWildcard;
 964   pa.mElement = kAudioObjectPropertyElementMaster;
 965   OSStatus result = AudioObjectGetPropertyData(
 966       id_,
 967       &pa,
 968       0,
 969       0,
 970       &property_size,
 971       &buffer_size_frames_);
 972
 973   OSSTATUS_DCHECK(result == noErr, result);
 974 }
 975
 976 }  // namespace media