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