Fix a couple bugs with OSX audio buffer size selection.

media/audio/mac/audio_low_latency_output_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_output_mac.h"
 
 #include <CoreServices/CoreServices.h>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
@@ skipping 61 matching lines @@
   format_.mBitsPerChannel = params.bits_per_sample();
   format_.mChannelsPerFrame = params.channels();
   format_.mFramesPerPacket = 1;
   format_.mBytesPerPacket = (format_.mBitsPerChannel * params.channels()) / 8;
   format_.mBytesPerFrame = format_.mBytesPerPacket;
   format_.mReserved = 0;
 
   DVLOG(1) << "Desired ouput format: " << format_;
 
   // Calculate the number of sample frames per callback.
-  number_of_frames_ = params.GetBytesPerBuffer() / format_.mBytesPerPacket;
+  number_of_frames_ = params.frames_per_buffer();
   DVLOG(1) << "Number of frames per callback: " << number_of_frames_;
-  const AudioParameters parameters =
-      manager_->GetDefaultOutputStreamParameters();
-  CHECK_EQ(number_of_frames_,
-           static_cast<size_t>(parameters.frames_per_buffer()));
 }
 
 AUAudioOutputStream::~AUAudioOutputStream() {
 }
 
 bool AUAudioOutputStream::Open() {
   // Obtain the current input device selected by the user.
   UInt32 size = sizeof(output_device_id_);
   OSStatus result = AudioObjectGetPropertyData(kAudioObjectSystemObject,
                                                &kDefaultOutputDeviceAddress,
                                                0,
                                                0,
                                                &size,
                                                &output_device_id_);
   if (result != noErr || output_device_id_ == kAudioObjectUnknown) {
-    OSSTATUS_DLOG(WARNING, result)
+    OSSTATUS_DLOG(ERROR, result)
         << "Could not get default audio output device.";
     return false;
   }
 
   // Open and initialize the DefaultOutputUnit.
   AudioComponent comp;
   AudioComponentDescription desc;
 
   desc.componentType = kAudioUnitType_Output;
   desc.componentSubType = kAudioUnitSubType_DefaultOutput;
   desc.componentManufacturer = kAudioUnitManufacturer_Apple;
   desc.componentFlags = 0;
   desc.componentFlagsMask = 0;
   comp = AudioComponentFindNext(0, &desc);
   if (!comp)
     return false;
 
   result = AudioComponentInstanceNew(comp, &output_unit_);
   if (result != noErr) {
-    OSSTATUS_DLOG(WARNING, result) << "AudioComponentInstanceNew() failed.";
+    OSSTATUS_DLOG(ERROR, result) << "AudioComponentInstanceNew() failed.";
     return false;
   }
 
   result = AudioUnitInitialize(output_unit_);
   if (result != noErr) {
-    OSSTATUS_DLOG(WARNING, result) << "AudioUnitInitialize() failed.";
+    OSSTATUS_DLOG(ERROR, result) << "AudioUnitInitialize() failed.";
     return false;
   }
 
   hardware_latency_frames_ = GetHardwareLatency();
 
   return Configure();
 }
 
 bool AUAudioOutputStream::Configure() {
   // Set the render callback.
   AURenderCallbackStruct input;
   input.inputProc = InputProc;
   input.inputProcRefCon = this;
   OSStatus result = AudioUnitSetProperty(
       output_unit_,
       kAudioUnitProperty_SetRenderCallback,
       kAudioUnitScope_Global,
       0,
       &input,
       sizeof(input));
   if (result != noErr) {
-    OSSTATUS_DLOG(WARNING, result)
+    OSSTATUS_DLOG(ERROR, result)
       << "AudioUnitSetProperty(kAudioUnitProperty_SetRenderCallback) failed.";
     return false;
   }
 
   // Set the stream format.
   result = AudioUnitSetProperty(
       output_unit_,
       kAudioUnitProperty_StreamFormat,
       kAudioUnitScope_Input,
       0,
       &format_,
       sizeof(format_));
   if (result != noErr) {
-    OSSTATUS_DLOG(WARNING, result)
+    OSSTATUS_DLOG(ERROR, result)
         << "AudioUnitSetProperty(kAudioUnitProperty_StreamFormat) failed.";
     return false;
   }
 
   // Set the buffer frame size.
   // WARNING: Setting this value changes the frame size for all audio units in
   // the current process.  It's imperative that the input and output frame sizes
   // be the same as the frames_per_buffer() returned by
   // GetDefaultOutputStreamParameters.
   // See http://crbug.com/154352 for details.
+  const AudioParameters hw_params =
+      manager_->GetDefaultOutputStreamParameters();
+  if (number_of_frames_ != static_cast<size_t>(hw_params.frames_per_buffer())) {
+    DLOG(ERROR) << "Audio buffer size does not match hardware buffer size.";
+    return false;
+  }
+
   UInt32 buffer_size = number_of_frames_;
   result = AudioUnitSetProperty(
       output_unit_,
       kAudioDevicePropertyBufferFrameSize,
       kAudioUnitScope_Output,
       0,
       &buffer_size,
       sizeof(buffer_size));
   if (result != noErr) {
-    OSSTATUS_DLOG(WARNING, result)
+    OSSTATUS_DLOG(ERROR, result)
         << "AudioUnitSetProperty(kAudioDevicePropertyBufferFrameSize) failed.";
     return false;
   }
 
   return true;
 }
 
 void AUAudioOutputStream::Close() {
   if (output_unit_)
     AudioComponentInstanceDispose(output_unit_);
@@ skipping 216 matching lines @@
   if (now_ns > output_time_ns)
     return 0;
 
   double delay_frames = static_cast<double>
       (1e-9 * (output_time_ns - now_ns) * format_.mSampleRate);
 
   return (delay_frames + hardware_latency_frames_);
 }
 
 }  // namespace media