media/audio/audio_input_device.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/audio_input_device.h"
   6
   7 #include "base/bind.h"
   8 #include "base/memory/scoped_vector.h"
   9 #include "base/threading/thread_restrictions.h"
  10 #include "base/time/time.h"
  11 #include "media/audio/audio_manager_base.h"
  12 #include "media/base/audio_bus.h"
  13
  14 namespace media {
  15
  16 // The number of shared memory buffer segments indicated to browser process
  17 // in order to avoid data overwriting. This number can be any positive number,
  18 // dependent how fast the renderer process can pick up captured data from
  19 // shared memory.
  20 static const int kRequestedSharedMemoryCount = 10;
  21
  22 // Takes care of invoking the capture callback on the audio thread.
  23 // An instance of this class is created for each capture stream in
  24 // OnLowLatencyCreated().
  25 class AudioInputDevice::AudioThreadCallback
  26     : public AudioDeviceThread::Callback {
  27  public:
  28   AudioThreadCallback(const AudioParameters& audio_parameters,
  29                       base::SharedMemoryHandle memory,
  30                       int memory_length,
  31                       int total_segments,
  32                       CaptureCallback* capture_callback);
  33   ~AudioThreadCallback() override;
  34
  35   void MapSharedMemory() override;
  36
  37   // Called whenever we receive notifications about pending data.
  38   void Process(uint32 pending_data) override;
  39
  40  private:
  41   int current_segment_id_;
  42   uint32 last_buffer_id_;
  43   ScopedVector<media::AudioBus> audio_buses_;
  44   CaptureCallback* capture_callback_;
  45
  46   DISALLOW_COPY_AND_ASSIGN(AudioThreadCallback);
  47 };
  48
  49 AudioInputDevice::AudioInputDevice(
  50     scoped_ptr<AudioInputIPC> ipc,
  51     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner)
  52     : ScopedTaskRunnerObserver(io_task_runner),
  53       callback_(NULL),
  54       ipc_(ipc.Pass()),
  55       state_(IDLE),
  56       session_id_(0),
  57       agc_is_enabled_(false),
  58       stopping_hack_(false) {
  59   CHECK(ipc_);
  60
  61   // The correctness of the code depends on the relative values assigned in the
  62   // State enum.
  63   static_assert(IPC_CLOSED < IDLE, "invalid enum value assignment 0");
  64   static_assert(IDLE < CREATING_STREAM, "invalid enum value assignment 1");
  65   static_assert(CREATING_STREAM < RECORDING, "invalid enum value assignment 2");
  66 }
  67
  68 void AudioInputDevice::Initialize(const AudioParameters& params,
  69                                   CaptureCallback* callback,
  70                                   int session_id) {
  71   DCHECK(params.IsValid());
  72   DCHECK(!callback_);
  73   DCHECK_EQ(0, session_id_);
  74   audio_parameters_ = params;
  75   callback_ = callback;
  76   session_id_ = session_id;
  77 }
  78
  79 void AudioInputDevice::Start() {
  80   DCHECK(callback_) << "Initialize hasn't been called";
  81   DVLOG(1) << "Start()";
  82   task_runner()->PostTask(FROM_HERE,
  83       base::Bind(&AudioInputDevice::StartUpOnIOThread, this));
  84 }
  85
  86 void AudioInputDevice::Stop() {
  87   DVLOG(1) << "Stop()";
  88
  89   {
  90     base::AutoLock auto_lock(audio_thread_lock_);
  91     audio_thread_.Stop(base::MessageLoop::current());
  92     stopping_hack_ = true;
  93   }
  94
  95   task_runner()->PostTask(FROM_HERE,
  96       base::Bind(&AudioInputDevice::ShutDownOnIOThread, this));
  97 }
  98
  99 void AudioInputDevice::SetVolume(double volume) {
 100   if (volume < 0 || volume > 1.0) {
 101     DLOG(ERROR) << "Invalid volume value specified";
 102     return;
 103   }
 104
 105   task_runner()->PostTask(FROM_HERE,
 106       base::Bind(&AudioInputDevice::SetVolumeOnIOThread, this, volume));
 107 }
 108
 109 void AudioInputDevice::SetAutomaticGainControl(bool enabled) {
 110   DVLOG(1) << "SetAutomaticGainControl(enabled=" << enabled << ")";
 111   task_runner()->PostTask(FROM_HERE,
 112       base::Bind(&AudioInputDevice::SetAutomaticGainControlOnIOThread,
 113           this, enabled));
 114 }
 115
 116 void AudioInputDevice::OnStreamCreated(
 117     base::SharedMemoryHandle handle,
 118     base::SyncSocket::Handle socket_handle,
 119     int length,
 120     int total_segments) {
 121   DCHECK(task_runner()->BelongsToCurrentThread());
 122   DCHECK(base::SharedMemory::IsHandleValid(handle));
 123 #if defined(OS_WIN)
 124   DCHECK(socket_handle);
 125 #else
 126   DCHECK_GE(socket_handle, 0);
 127 #endif
 128   DCHECK_GT(length, 0);
 129
 130   if (state_ != CREATING_STREAM)
 131     return;
 132
 133   base::AutoLock auto_lock(audio_thread_lock_);
 134   // TODO(miu): See TODO in OnStreamCreated method for AudioOutputDevice.
 135   // Interface changes need to be made; likely, after AudioInputDevice is merged
 136   // into AudioOutputDevice (http://crbug.com/179597).
 137   if (stopping_hack_)
 138     return;
 139
 140   DCHECK(audio_thread_.IsStopped());
 141   audio_callback_.reset(new AudioInputDevice::AudioThreadCallback(
 142       audio_parameters_, handle, length, total_segments, callback_));
 143   audio_thread_.Start(
 144       audio_callback_.get(), socket_handle, "AudioInputDevice", false);
 145
 146   state_ = RECORDING;
 147   ipc_->RecordStream();
 148 }
 149
 150 void AudioInputDevice::OnVolume(double volume) {
 151   NOTIMPLEMENTED();
 152 }
 153
 154 void AudioInputDevice::OnStateChanged(
 155     AudioInputIPCDelegateState state) {
 156   DCHECK(task_runner()->BelongsToCurrentThread());
 157
 158   // Do nothing if the stream has been closed.
 159   if (state_ < CREATING_STREAM)
 160     return;
 161
 162   // TODO(miu): Clean-up inconsistent and incomplete handling here.
 163   // http://crbug.com/180640
 164   switch (state) {
 165     case AUDIO_INPUT_IPC_DELEGATE_STATE_STOPPED:
 166       ShutDownOnIOThread();
 167       break;
 168     case AUDIO_INPUT_IPC_DELEGATE_STATE_RECORDING:
 169       NOTIMPLEMENTED();
 170       break;
 171     case AUDIO_INPUT_IPC_DELEGATE_STATE_ERROR:
 172       DLOG(WARNING) << "AudioInputDevice::OnStateChanged(ERROR)";
 173       // Don't dereference the callback object if the audio thread
 174       // is stopped or stopping.  That could mean that the callback
 175       // object has been deleted.
 176       // TODO(tommi): Add an explicit contract for clearing the callback
 177       // object.  Possibly require calling Initialize again or provide
 178       // a callback object via Start() and clear it in Stop().
 179       if (!audio_thread_.IsStopped())
 180         callback_->OnCaptureError();
 181       break;
 182     default:
 183       NOTREACHED();
 184       break;
 185   }
 186 }
 187
 188 void AudioInputDevice::OnIPCClosed() {
 189   DCHECK(task_runner()->BelongsToCurrentThread());
 190   state_ = IPC_CLOSED;
 191   ipc_.reset();
 192 }
 193
 194 AudioInputDevice::~AudioInputDevice() {
 195   // TODO(henrika): The current design requires that the user calls
 196   // Stop before deleting this class.
 197   DCHECK(audio_thread_.IsStopped());
 198 }
 199
 200 void AudioInputDevice::StartUpOnIOThread() {
 201   DCHECK(task_runner()->BelongsToCurrentThread());
 202
 203   // Make sure we don't call Start() more than once.
 204   if (state_ != IDLE)
 205     return;
 206
 207   if (session_id_ <= 0) {
 208     DLOG(WARNING) << "Invalid session id for the input stream " << session_id_;
 209     return;
 210   }
 211
 212   state_ = CREATING_STREAM;
 213   ipc_->CreateStream(this, session_id_, audio_parameters_,
 214                      agc_is_enabled_, kRequestedSharedMemoryCount);
 215 }
 216
 217 void AudioInputDevice::ShutDownOnIOThread() {
 218   DCHECK(task_runner()->BelongsToCurrentThread());
 219
 220   // Close the stream, if we haven't already.
 221   if (state_ >= CREATING_STREAM) {
 222     ipc_->CloseStream();
 223     state_ = IDLE;
 224     agc_is_enabled_ = false;
 225   }
 226
 227   // We can run into an issue where ShutDownOnIOThread is called right after
 228   // OnStreamCreated is called in cases where Start/Stop are called before we
 229   // get the OnStreamCreated callback.  To handle that corner case, we call
 230   // Stop(). In most cases, the thread will already be stopped.
 231   //
 232   // Another situation is when the IO thread goes away before Stop() is called
 233   // in which case, we cannot use the message loop to close the thread handle
 234   // and can't not rely on the main thread existing either.
 235   base::AutoLock auto_lock_(audio_thread_lock_);
 236   base::ThreadRestrictions::ScopedAllowIO allow_io;
 237   audio_thread_.Stop(NULL);
 238   audio_callback_.reset();
 239   stopping_hack_ = false;
 240 }
 241
 242 void AudioInputDevice::SetVolumeOnIOThread(double volume) {
 243   DCHECK(task_runner()->BelongsToCurrentThread());
 244   if (state_ >= CREATING_STREAM)
 245     ipc_->SetVolume(volume);
 246 }
 247
 248 void AudioInputDevice::SetAutomaticGainControlOnIOThread(bool enabled) {
 249   DCHECK(task_runner()->BelongsToCurrentThread());
 250
 251   if (state_ >= CREATING_STREAM) {
 252     DLOG(WARNING) << "The AGC state can not be modified after starting.";
 253     return;
 254   }
 255
 256   // We simply store the new AGC setting here. This value will be used when
 257   // a new stream is initialized and by GetAutomaticGainControl().
 258   agc_is_enabled_ = enabled;
 259 }
 260
 261 void AudioInputDevice::WillDestroyCurrentMessageLoop() {
 262   LOG(ERROR) << "IO loop going away before the input device has been stopped";
 263   ShutDownOnIOThread();
 264 }
 265
 266 // AudioInputDevice::AudioThreadCallback
 267 AudioInputDevice::AudioThreadCallback::AudioThreadCallback(
 268     const AudioParameters& audio_parameters,
 269     base::SharedMemoryHandle memory,
 270     int memory_length,
 271     int total_segments,
 272     CaptureCallback* capture_callback)
 273     : AudioDeviceThread::Callback(audio_parameters, memory, memory_length,
 274                                   total_segments),
 275       current_segment_id_(0),
 276       last_buffer_id_(UINT32_MAX),
 277       capture_callback_(capture_callback) {
 278 }
 279
 280 AudioInputDevice::AudioThreadCallback::~AudioThreadCallback() {
 281 }
 282
 283 void AudioInputDevice::AudioThreadCallback::MapSharedMemory() {
 284   shared_memory_.Map(memory_length_);
 285
 286   // Create vector of audio buses by wrapping existing blocks of memory.
 287   uint8* ptr = static_cast<uint8*>(shared_memory_.memory());
 288   for (int i = 0; i < total_segments_; ++i) {
 289     media::AudioInputBuffer* buffer =
 290         reinterpret_cast<media::AudioInputBuffer*>(ptr);
 291     scoped_ptr<media::AudioBus> audio_bus =
 292         media::AudioBus::WrapMemory(audio_parameters_, buffer->audio);
 293     audio_buses_.push_back(audio_bus.Pass());
 294     ptr += segment_length_;
 295   }
 296 }
 297
 298 void AudioInputDevice::AudioThreadCallback::Process(uint32 pending_data) {
 299   CHECK_EQ(current_segment_id_, static_cast<int>(pending_data));
 300
 301   // The shared memory represents parameters, size of the data buffer and the
 302   // actual data buffer containing audio data. Map the memory into this
 303   // structure and parse out parameters and the data area.
 304   uint8* ptr = static_cast<uint8*>(shared_memory_.memory());
 305   ptr += current_segment_id_ * segment_length_;
 306   AudioInputBuffer* buffer = reinterpret_cast<AudioInputBuffer*>(ptr);
 307
 308   // Usually this will be equal but in the case of low sample rate (e.g. 8kHz,
 309   // the buffer may be bigger (on mac at least)).
 310   DCHECK_GE(buffer->params.size,
 311             segment_length_ - sizeof(AudioInputBufferParameters));
 312
 313   // Verify correct sequence.
 314   CHECK_EQ(last_buffer_id_ + 1, buffer->params.id);
 315   last_buffer_id_ = buffer->params.id;
 316
 317   // Use pre-allocated audio bus wrapping existing block of shared memory.
 318   media::AudioBus* audio_bus = audio_buses_[current_segment_id_];
 319
 320   // Deliver captured data to the client in floating point format and update
 321   // the audio delay measurement.
 322   capture_callback_->Capture(
 323       audio_bus,
 324       buffer->params.hardware_delay_bytes / bytes_per_ms_,  // Delay in ms
 325       buffer->params.volume,
 326       buffer->params.key_pressed);
 327
 328   if (++current_segment_id_ >= total_segments_)
 329     current_segment_id_ = 0;
 330 }
 331
 332 }  // namespace media