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