Simplified AudioOutputStream interface.

media/audio/mac/audio_output_mac.cc

 // Copyright (c) 2010 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_output_mac.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "media/audio/audio_util.h"
 #include "media/audio/mac/audio_manager_mac.h"
@@ skipping 27 matching lines @@
 
 #if !defined(MAC_OS_X_VERSION_10_6) || \
     MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_6
 enum {
   kAudioQueueErr_EnqueueDuringReset = -66632
 };
 #endif
 
 PCMQueueOutAudioOutputStream::PCMQueueOutAudioOutputStream(
     AudioManagerMac* manager, AudioParameters params)
-        : format_(),
-          audio_queue_(NULL),
-          buffer_(),
-          source_(NULL),
-          manager_(manager),
-          silence_bytes_(0),
-          volume_(1),
-          pending_bytes_(0) {
+    : format_(),
+      audio_queue_(NULL),
+      buffer_(),
+      source_(NULL),
+      manager_(manager),
+      silence_bytes_(0),
+      volume_(1),
+      pending_bytes_(0) {
   // We must have a manager.
   DCHECK(manager_);
   // A frame is one sample across all channels. In interleaved audio the per
   // frame fields identify the set of n |channels|. In uncompressed audio, a
   // packet is always one frame.
   format_.mSampleRate = params.sample_rate;
   format_.mFormatID = kAudioFormatLinearPCM;
   format_.mFormatFlags = kLinearPCMFormatFlagIsPacked |
                          kLinearPCMFormatFlagIsSignedInteger;
   format_.mBitsPerChannel = params.bits_per_sample;
   format_.mChannelsPerFrame = params.channels;
   format_.mFramesPerPacket = 1;
   format_.mBytesPerPacket = (format_.mBitsPerChannel * params.channels) / 8;
   format_.mBytesPerFrame = format_.mBytesPerPacket;
 
+  packet_size_ = params.samples_per_packet * params.channels *

[scherkus (not reviewing), 2010/11/09 02:28:31]

this seems to be duplicated a bit... can packet_size_ be made a
function/computed property of AudioParameters?

[Sergey Ulanov, 2010/11/09 22:29:58]

Done.

+      params.bits_per_sample / 8;
+
   // Silence buffer has a duration of 6ms to simulate the behavior of Windows.
   // This value is choosen by experiments and macs cannot keep up with
   // anything less than 6ms.
   silence_bytes_ = format_.mBytesPerFrame * params.sample_rate * 6 / 1000;
 }
 
 PCMQueueOutAudioOutputStream::~PCMQueueOutAudioOutputStream() {
 }
 
 void PCMQueueOutAudioOutputStream::HandleError(OSStatus err) {
   // source_ can be set to NULL from another thread. We need to cache its
   // pointer while we operate here. Note that does not mean that the source
   // has been destroyed.
   AudioSourceCallback* source = source_;
   if (source)
     source->OnError(this, static_cast<int>(err));
   NOTREACHED() << "error code " << err;
 }
 
-bool PCMQueueOutAudioOutputStream::Open(uint32 packet_size) {
-  if (0 == packet_size) {
-    // TODO(cpu) : Impelement default buffer computation.
-    return false;
-  }
+bool PCMQueueOutAudioOutputStream::Open() {
   // Create the actual queue object and let the OS use its own thread to
   // run its CFRunLoop.
   OSStatus err = AudioQueueNewOutput(&format_, RenderCallback, this, NULL,
                                      kCFRunLoopCommonModes, 0, &audio_queue_);
   if (err != noErr) {
     HandleError(err);
     return false;
   }
   // Allocate the hardware-managed buffers.
   for (uint32 ix = 0; ix != kNumBuffers; ++ix) {
-    err = AudioQueueAllocateBuffer(audio_queue_, packet_size, &buffer_[ix]);
+    err = AudioQueueAllocateBuffer(audio_queue_, packet_size_, &buffer_[ix]);
     if (err != noErr) {
       HandleError(err);
       return false;
     }
     // Allocate memory for user data.
     buffer_[ix]->mUserData = new AudioQueueUserData();
   }
   // Set initial volume here.
   err = AudioQueueSetParameter(audio_queue_, kAudioQueueParam_Volume, 1.0);
   if (err != noErr) {
@@ skipping 172 matching lines @@
       HandleError(err);
       return;
     }
   }
   err  = AudioQueueStart(audio_queue_, NULL);
   if (err != noErr) {
     HandleError(err);
     return;
   }
 }