media/audio/mac/audio_input_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_input_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/audio_manager_base.h"
  13
  14
  15 namespace media {
  16
  17 PCMQueueInAudioInputStream::PCMQueueInAudioInputStream(
  18     AudioManagerBase* manager, const AudioParameters& params)
  19     : manager_(manager),
  20       callback_(NULL),
  21       audio_queue_(NULL),
  22       buffer_size_bytes_(0),
  23       started_(false) {
  24   // We must have a manager.
  25   DCHECK(manager_);
  26   // A frame is one sample across all channels. In interleaved audio the per
  27   // frame fields identify the set of n |channels|. In uncompressed audio, a
  28   // packet is always one frame.
  29   format_.mSampleRate = params.sample_rate();
  30   format_.mFormatID = kAudioFormatLinearPCM;
  31   format_.mFormatFlags = kLinearPCMFormatFlagIsPacked |
  32                          kLinearPCMFormatFlagIsSignedInteger;
  33   format_.mBitsPerChannel = params.bits_per_sample();
  34   format_.mChannelsPerFrame = params.channels();
  35   format_.mFramesPerPacket = 1;
  36   format_.mBytesPerPacket = (params.bits_per_sample() * params.channels()) / 8;
  37   format_.mBytesPerFrame = format_.mBytesPerPacket;
  38   format_.mReserved = 0;
  39
  40   buffer_size_bytes_ = params.GetBytesPerBuffer();
  41 }
  42
  43 PCMQueueInAudioInputStream::~PCMQueueInAudioInputStream() {
  44   DCHECK(!callback_);
  45   DCHECK(!audio_queue_);
  46 }
  47
  48 bool PCMQueueInAudioInputStream::Open() {
  49   OSStatus err = AudioQueueNewInput(&format_,
  50                                     &HandleInputBufferStatic,
  51                                     this,
  52                                     NULL,  // Use OS CFRunLoop for |callback|
  53                                     kCFRunLoopCommonModes,
  54                                     0,  // Reserved
  55                                     &audio_queue_);
  56   if (err != noErr) {
  57     HandleError(err);
  58     return false;
  59   }
  60   return SetupBuffers();
  61 }
  62
  63 void PCMQueueInAudioInputStream::Start(AudioInputCallback* callback) {
  64   DCHECK(callback);
  65   DLOG_IF(ERROR, !audio_queue_) << "Open() has not been called successfully";
  66   if (callback_ || !audio_queue_)
  67     return;
  68   callback_ = callback;
  69   OSStatus err = AudioQueueStart(audio_queue_, NULL);
  70   if (err != noErr) {
  71     HandleError(err);
  72   } else {
  73     started_ = true;
  74   }
  75 }
  76
  77 void PCMQueueInAudioInputStream::Stop() {
  78   if (!audio_queue_ || !started_)
  79     return;
  80
  81   // We request a synchronous stop, so the next call can take some time. In
  82   // the windows implementation we block here as well.
  83   OSStatus err = AudioQueueStop(audio_queue_, true);
  84   if (err != noErr)
  85     HandleError(err);
  86
  87   started_ = false;
  88 }
  89
  90 void PCMQueueInAudioInputStream::Close() {
  91   // It is valid to call Close() before calling Open() or Start(), thus
  92   // |audio_queue_| and |callback_| might be NULL.
  93   if (audio_queue_) {
  94     OSStatus err = AudioQueueDispose(audio_queue_, true);
  95     audio_queue_ = NULL;
  96     if (err != noErr)
  97       HandleError(err);
  98   }
  99   if (callback_) {
 100     callback_->OnClose(this);
 101     callback_ = NULL;
 102   }
 103   manager_->ReleaseInputStream(this);
 104   // CARE: This object may now be destroyed.
 105 }
 106
 107 double PCMQueueInAudioInputStream::GetMaxVolume() {
 108   NOTREACHED() << "Only supported for low-latency mode.";
 109   return 0.0;
 110 }
 111
 112 void PCMQueueInAudioInputStream::SetVolume(double volume) {
 113   NOTREACHED() << "Only supported for low-latency mode.";
 114 }
 115
 116 double PCMQueueInAudioInputStream::GetVolume() {
 117   NOTREACHED() << "Only supported for low-latency mode.";
 118   return 0.0;
 119 }
 120
 121 void PCMQueueInAudioInputStream::SetAutomaticGainControl(bool enabled) {
 122   NOTREACHED() << "Only supported for low-latency mode.";
 123 }
 124
 125 bool PCMQueueInAudioInputStream::GetAutomaticGainControl() {
 126   NOTREACHED() << "Only supported for low-latency mode.";
 127   return false;
 128 }
 129
 130 void PCMQueueInAudioInputStream::HandleError(OSStatus err) {
 131   if (callback_)
 132     callback_->OnError(this);
 133   // This point should never be reached.
 134   OSSTATUS_DCHECK(0, err);
 135 }
 136
 137 bool PCMQueueInAudioInputStream::SetupBuffers() {
 138   DCHECK(buffer_size_bytes_);
 139   for (int i = 0; i < kNumberBuffers; ++i) {
 140     AudioQueueBufferRef buffer;
 141     OSStatus err = AudioQueueAllocateBuffer(audio_queue_,
 142                                             buffer_size_bytes_,
 143                                             &buffer);
 144     if (err == noErr)
 145       err = QueueNextBuffer(buffer);
 146     if (err != noErr) {
 147       HandleError(err);
 148       return false;
 149     }
 150     // |buffer| will automatically be freed when |audio_queue_| is released.
 151   }
 152   return true;
 153 }
 154
 155 OSStatus PCMQueueInAudioInputStream::QueueNextBuffer(
 156     AudioQueueBufferRef audio_buffer) {
 157   // Only the first 2 params are needed for recording.
 158   return AudioQueueEnqueueBuffer(audio_queue_, audio_buffer, 0, NULL);
 159 }
 160
 161 // static
 162 void PCMQueueInAudioInputStream::HandleInputBufferStatic(
 163     void* data,
 164     AudioQueueRef audio_queue,
 165     AudioQueueBufferRef audio_buffer,
 166     const AudioTimeStamp* start_time,
 167     UInt32 num_packets,
 168     const AudioStreamPacketDescription* desc) {
 169   reinterpret_cast<PCMQueueInAudioInputStream*>(data)->
 170       HandleInputBuffer(audio_queue, audio_buffer, start_time,
 171                         num_packets, desc);
 172 }
 173
 174 void PCMQueueInAudioInputStream::HandleInputBuffer(
 175     AudioQueueRef audio_queue,
 176     AudioQueueBufferRef audio_buffer,
 177     const AudioTimeStamp* start_time,
 178     UInt32 num_packets,
 179     const AudioStreamPacketDescription* packet_desc) {
 180   DCHECK_EQ(audio_queue_, audio_queue);
 181   DCHECK(audio_buffer->mAudioData);
 182   if (!callback_) {
 183     // This can happen if Stop() was called without start.
 184     DCHECK_EQ(0U, audio_buffer->mAudioDataByteSize);
 185     return;
 186   }
 187
 188   if (audio_buffer->mAudioDataByteSize) {
 189     // The AudioQueue API may use a large internal buffer and repeatedly call us
 190     // back to back once that internal buffer is filled.  When this happens the
 191     // renderer client does not have enough time to read data back from the
 192     // shared memory before the next write comes along.  If HandleInputBuffer()
 193     // is called too frequently, Sleep() at least 5ms to ensure the shared
 194     // memory doesn't get trampled.
 195     // TODO(dalecurtis): This is a HACK.  Long term the AudioQueue path is going
 196     // away in favor of the AudioUnit based AUAudioInputStream().  Tracked by
 197     // http://crbug.com/161383.
 198     base::TimeDelta elapsed = base::TimeTicks::Now() - last_fill_;
 199     const base::TimeDelta kMinDelay = base::TimeDelta::FromMilliseconds(5);
 200     if (elapsed < kMinDelay)
 201       base::PlatformThread::Sleep(kMinDelay - elapsed);
 202
 203     callback_->OnData(this,
 204                       reinterpret_cast<const uint8*>(audio_buffer->mAudioData),
 205                       audio_buffer->mAudioDataByteSize,
 206                       audio_buffer->mAudioDataByteSize,
 207                       0.0);
 208
 209     last_fill_ = base::TimeTicks::Now();
 210   }
 211   // Recycle the buffer.
 212   OSStatus err = QueueNextBuffer(audio_buffer);
 213   if (err != noErr) {
 214     if (err == kAudioQueueErr_EnqueueDuringReset) {
 215       // This is the error you get if you try to enqueue a buffer and the
 216       // queue has been closed. Not really a problem if indeed the queue
 217       // has been closed.
 218       // TODO(joth): PCMQueueOutAudioOutputStream uses callback_ to provide an
 219       // extra guard for this situation, but it seems to introduce more
 220       // complications than it solves (memory barrier issues accessing it from
 221       // multiple threads, looses the means to indicate OnClosed to client).
 222       // Should determine if we need to do something equivalent here.
 223       return;
 224     }
 225     HandleError(err);
 226   }
 227 }
 228
 229 }  // namespace media