src/media/audio/android/opensles_input.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/android/opensles_input.h"
   6
   7 #include "base/debug/trace_event.h"
   8 #include "base/logging.h"
   9 #include "media/audio/android/audio_manager_android.h"
  10 #include "media/base/audio_bus.h"
  11
  12 #define LOG_ON_FAILURE_AND_RETURN(op, ...)      \
  13   do {                                          \
  14     SLresult err = (op);                        \
  15     if (err != SL_RESULT_SUCCESS) {             \
  16       DLOG(ERROR) << #op << " failed: " << err; \
  17       return __VA_ARGS__;                       \
  18     }                                           \
  19   } while (0)
  20
  21 namespace media {
  22
  23 OpenSLESInputStream::OpenSLESInputStream(AudioManagerAndroid* audio_manager,
  24                                          const AudioParameters& params)
  25     : audio_manager_(audio_manager),
  26       callback_(NULL),
  27       recorder_(NULL),
  28       simple_buffer_queue_(NULL),
  29       active_buffer_index_(0),
  30       buffer_size_bytes_(0),
  31       started_(false),
  32       audio_bus_(media::AudioBus::Create(params)) {
  33   DVLOG(2) << __PRETTY_FUNCTION__;
  34   format_.formatType = SL_DATAFORMAT_PCM;
  35   format_.numChannels = static_cast<SLuint32>(params.channels());
  36   // Provides sampling rate in milliHertz to OpenSLES.
  37   format_.samplesPerSec = static_cast<SLuint32>(params.sample_rate() * 1000);
  38   format_.bitsPerSample = params.bits_per_sample();
  39   format_.containerSize = params.bits_per_sample();
  40   format_.endianness = SL_BYTEORDER_LITTLEENDIAN;
  41   if (format_.numChannels == 1)
  42     format_.channelMask = SL_SPEAKER_FRONT_CENTER;
  43   else if (format_.numChannels == 2)
  44     format_.channelMask = SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT;
  45   else
  46     NOTREACHED() << "Unsupported number of channels: " << format_.numChannels;
  47
  48   buffer_size_bytes_ = params.GetBytesPerBuffer();
  49
  50   memset(&audio_data_, 0, sizeof(audio_data_));
  51 }
  52
  53 OpenSLESInputStream::~OpenSLESInputStream() {
  54   DVLOG(2) << __PRETTY_FUNCTION__;
  55   DCHECK(thread_checker_.CalledOnValidThread());
  56   DCHECK(!recorder_object_.Get());
  57   DCHECK(!engine_object_.Get());
  58   DCHECK(!recorder_);
  59   DCHECK(!simple_buffer_queue_);
  60   DCHECK(!audio_data_[0]);
  61 }
  62
  63 bool OpenSLESInputStream::Open() {
  64   DVLOG(2) << __PRETTY_FUNCTION__;
  65   DCHECK(thread_checker_.CalledOnValidThread());
  66   if (engine_object_.Get())
  67     return false;
  68
  69   if (!CreateRecorder())
  70     return false;
  71
  72   SetupAudioBuffer();
  73
  74   return true;
  75 }
  76
  77 void OpenSLESInputStream::Start(AudioInputCallback* callback) {
  78   DVLOG(2) << __PRETTY_FUNCTION__;
  79   DCHECK(thread_checker_.CalledOnValidThread());
  80   DCHECK(callback);
  81   DCHECK(recorder_);
  82   DCHECK(simple_buffer_queue_);
  83   if (started_)
  84     return;
  85
  86   base::AutoLock lock(lock_);
  87   DCHECK(callback_ == NULL || callback_ == callback);
  88   callback_ = callback;
  89   active_buffer_index_ = 0;
  90
  91   // Enqueues kMaxNumOfBuffersInQueue zero buffers to get the ball rolling.
  92   // TODO(henrika): add support for Start/Stop/Start sequences when we are
  93   // able to clear the buffer queue. There is currently a bug in the OpenSLES
  94   // implementation which forces us to always call Stop() and Close() before
  95   // calling Start() again.
  96   SLresult err = SL_RESULT_UNKNOWN_ERROR;
  97   for (int i = 0; i < kMaxNumOfBuffersInQueue; ++i) {
  98     err = (*simple_buffer_queue_)->Enqueue(
  99         simple_buffer_queue_, audio_data_[i], buffer_size_bytes_);
 100     if (SL_RESULT_SUCCESS != err) {
 101       HandleError(err);
 102       started_ = false;
 103       return;
 104     }
 105   }
 106
 107   // Start the recording by setting the state to SL_RECORDSTATE_RECORDING.
 108   // When the object is in the SL_RECORDSTATE_RECORDING state, adding buffers
 109   // will implicitly start the filling process.
 110   err = (*recorder_)->SetRecordState(recorder_, SL_RECORDSTATE_RECORDING);
 111   if (SL_RESULT_SUCCESS != err) {
 112     HandleError(err);
 113     started_ = false;
 114     return;
 115   }
 116
 117   started_ = true;
 118 }
 119
 120 void OpenSLESInputStream::Stop() {
 121   DVLOG(2) << __PRETTY_FUNCTION__;
 122   DCHECK(thread_checker_.CalledOnValidThread());
 123   if (!started_)
 124     return;
 125
 126   base::AutoLock lock(lock_);
 127
 128   // Stop recording by setting the record state to SL_RECORDSTATE_STOPPED.
 129   LOG_ON_FAILURE_AND_RETURN(
 130       (*recorder_)->SetRecordState(recorder_, SL_RECORDSTATE_STOPPED));
 131
 132   // Clear the buffer queue to get rid of old data when resuming recording.
 133   LOG_ON_FAILURE_AND_RETURN(
 134       (*simple_buffer_queue_)->Clear(simple_buffer_queue_));
 135
 136   started_ = false;
 137   callback_ = NULL;
 138 }
 139
 140 void OpenSLESInputStream::Close() {
 141   DVLOG(2) << __PRETTY_FUNCTION__;
 142   DCHECK(thread_checker_.CalledOnValidThread());
 143
 144   // Stop the stream if it is still recording.
 145   Stop();
 146   {
 147     // TODO(henrika): Do we need to hold the lock here?
 148     base::AutoLock lock(lock_);
 149
 150     // Destroy the buffer queue recorder object and invalidate all associated
 151     // interfaces.
 152     recorder_object_.Reset();
 153     simple_buffer_queue_ = NULL;
 154     recorder_ = NULL;
 155
 156     // Destroy the engine object. We don't store any associated interface for
 157     // this object.
 158     engine_object_.Reset();
 159     ReleaseAudioBuffer();
 160   }
 161
 162   audio_manager_->ReleaseInputStream(this);
 163 }
 164
 165 double OpenSLESInputStream::GetMaxVolume() {
 166   NOTIMPLEMENTED();
 167   return 0.0;
 168 }
 169
 170 void OpenSLESInputStream::SetVolume(double volume) {
 171   NOTIMPLEMENTED();
 172 }
 173
 174 double OpenSLESInputStream::GetVolume() {
 175   NOTIMPLEMENTED();
 176   return 0.0;
 177 }
 178
 179 void OpenSLESInputStream::SetAutomaticGainControl(bool enabled) {
 180   NOTIMPLEMENTED();
 181 }
 182
 183 bool OpenSLESInputStream::GetAutomaticGainControl() {
 184   NOTIMPLEMENTED();
 185   return false;
 186 }
 187
 188 bool OpenSLESInputStream::IsMuted() {
 189   NOTIMPLEMENTED();
 190   return false;
 191 }
 192
 193 bool OpenSLESInputStream::CreateRecorder() {
 194   DCHECK(thread_checker_.CalledOnValidThread());
 195   DCHECK(!engine_object_.Get());
 196   DCHECK(!recorder_object_.Get());
 197   DCHECK(!recorder_);
 198   DCHECK(!simple_buffer_queue_);
 199
 200   // Initializes the engine object with specific option. After working with the
 201   // object, we need to free the object and its resources.
 202   SLEngineOption option[] = {
 203       {SL_ENGINEOPTION_THREADSAFE, static_cast<SLuint32>(SL_BOOLEAN_TRUE)}};
 204   LOG_ON_FAILURE_AND_RETURN(
 205       slCreateEngine(engine_object_.Receive(), 1, option, 0, NULL, NULL),
 206       false);
 207
 208   // Realize the SL engine object in synchronous mode.
 209   LOG_ON_FAILURE_AND_RETURN(
 210       engine_object_->Realize(engine_object_.Get(), SL_BOOLEAN_FALSE), false);
 211
 212   // Get the SL engine interface which is implicit.
 213   SLEngineItf engine;
 214   LOG_ON_FAILURE_AND_RETURN(engine_object_->GetInterface(
 215                                 engine_object_.Get(), SL_IID_ENGINE, &engine),
 216                             false);
 217
 218   // Audio source configuration.
 219   SLDataLocator_IODevice mic_locator = {
 220       SL_DATALOCATOR_IODEVICE,       SL_IODEVICE_AUDIOINPUT,
 221       SL_DEFAULTDEVICEID_AUDIOINPUT, NULL};
 222   SLDataSource audio_source = {&mic_locator, NULL};
 223
 224   // Audio sink configuration.
 225   SLDataLocator_AndroidSimpleBufferQueue buffer_queue = {
 226       SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE,
 227       static_cast<SLuint32>(kMaxNumOfBuffersInQueue)};
 228   SLDataSink audio_sink = {&buffer_queue, &format_};
 229
 230   // Create an audio recorder.
 231   const SLInterfaceID interface_id[] = {SL_IID_ANDROIDSIMPLEBUFFERQUEUE,
 232                                         SL_IID_ANDROIDCONFIGURATION};
 233   const SLboolean interface_required[] = {SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE};
 234
 235   // Create AudioRecorder and specify SL_IID_ANDROIDCONFIGURATION.
 236   LOG_ON_FAILURE_AND_RETURN(
 237       (*engine)->CreateAudioRecorder(engine,
 238                                      recorder_object_.Receive(),
 239                                      &audio_source,
 240                                      &audio_sink,
 241                                      arraysize(interface_id),
 242                                      interface_id,
 243                                      interface_required),
 244       false);
 245
 246   SLAndroidConfigurationItf recorder_config;
 247   LOG_ON_FAILURE_AND_RETURN(
 248       recorder_object_->GetInterface(recorder_object_.Get(),
 249                                      SL_IID_ANDROIDCONFIGURATION,
 250                                      &recorder_config),
 251       false);
 252
 253   // Uses the main microphone tuned for audio communications.
 254   SLint32 stream_type = SL_ANDROID_RECORDING_PRESET_VOICE_COMMUNICATION;
 255   LOG_ON_FAILURE_AND_RETURN(
 256       (*recorder_config)->SetConfiguration(recorder_config,
 257                                            SL_ANDROID_KEY_RECORDING_PRESET,
 258                                            &stream_type,
 259                                            sizeof(SLint32)),
 260       false);
 261
 262   // Realize the recorder object in synchronous mode.
 263   LOG_ON_FAILURE_AND_RETURN(
 264       recorder_object_->Realize(recorder_object_.Get(), SL_BOOLEAN_FALSE),
 265       false);
 266
 267   // Get an implicit recorder interface.
 268   LOG_ON_FAILURE_AND_RETURN(
 269       recorder_object_->GetInterface(
 270           recorder_object_.Get(), SL_IID_RECORD, &recorder_),
 271       false);
 272
 273   // Get the simple buffer queue interface.
 274   LOG_ON_FAILURE_AND_RETURN(
 275       recorder_object_->GetInterface(recorder_object_.Get(),
 276                                      SL_IID_ANDROIDSIMPLEBUFFERQUEUE,
 277                                      &simple_buffer_queue_),
 278       false);
 279
 280   // Register the input callback for the simple buffer queue.
 281   // This callback will be called when receiving new data from the device.
 282   LOG_ON_FAILURE_AND_RETURN(
 283       (*simple_buffer_queue_)->RegisterCallback(
 284           simple_buffer_queue_, SimpleBufferQueueCallback, this),
 285       false);
 286
 287   return true;
 288 }
 289
 290 void OpenSLESInputStream::SimpleBufferQueueCallback(
 291     SLAndroidSimpleBufferQueueItf buffer_queue,
 292     void* instance) {
 293   OpenSLESInputStream* stream =
 294       reinterpret_cast<OpenSLESInputStream*>(instance);
 295   stream->ReadBufferQueue();
 296 }
 297
 298 void OpenSLESInputStream::ReadBufferQueue() {
 299   base::AutoLock lock(lock_);
 300   if (!started_)
 301     return;
 302
 303   TRACE_EVENT0("audio", "OpenSLESOutputStream::ReadBufferQueue");
 304
 305   // Convert from interleaved format to deinterleaved audio bus format.
 306   audio_bus_->FromInterleaved(audio_data_[active_buffer_index_],
 307                               audio_bus_->frames(),
 308                               format_.bitsPerSample / 8);
 309
 310   // TODO(henrika): Investigate if it is possible to get an accurate
 311   // delay estimation.
 312   callback_->OnData(this, audio_bus_.get(), buffer_size_bytes_, 0.0);
 313
 314   // Done with this buffer. Send it to device for recording.
 315   SLresult err =
 316       (*simple_buffer_queue_)->Enqueue(simple_buffer_queue_,
 317                                        audio_data_[active_buffer_index_],
 318                                        buffer_size_bytes_);
 319   if (SL_RESULT_SUCCESS != err)
 320     HandleError(err);
 321
 322   active_buffer_index_ = (active_buffer_index_ + 1) % kMaxNumOfBuffersInQueue;
 323 }
 324
 325 void OpenSLESInputStream::SetupAudioBuffer() {
 326   DCHECK(thread_checker_.CalledOnValidThread());
 327   DCHECK(!audio_data_[0]);
 328   for (int i = 0; i < kMaxNumOfBuffersInQueue; ++i) {
 329     audio_data_[i] = new uint8[buffer_size_bytes_];
 330   }
 331 }
 332
 333 void OpenSLESInputStream::ReleaseAudioBuffer() {
 334   DCHECK(thread_checker_.CalledOnValidThread());
 335   if (audio_data_[0]) {
 336     for (int i = 0; i < kMaxNumOfBuffersInQueue; ++i) {
 337       delete[] audio_data_[i];
 338       audio_data_[i] = NULL;
 339     }
 340   }
 341 }
 342
 343 void OpenSLESInputStream::HandleError(SLresult error) {
 344   DLOG(ERROR) << "OpenSLES Input error " << error;
 345   if (callback_)
 346     callback_->OnError(this);
 347 }
 348
 349 }  // namespace media