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::CreateRecorder() {
 189   DCHECK(thread_checker_.CalledOnValidThread());
 190   DCHECK(!engine_object_.Get());
 191   DCHECK(!recorder_object_.Get());
 192   DCHECK(!recorder_);
 193   DCHECK(!simple_buffer_queue_);
 194
 195   // Initializes the engine object with specific option. After working with the
 196   // object, we need to free the object and its resources.
 197   SLEngineOption option[] = {
 198       {SL_ENGINEOPTION_THREADSAFE, static_cast<SLuint32>(SL_BOOLEAN_TRUE)}};
 199   LOG_ON_FAILURE_AND_RETURN(
 200       slCreateEngine(engine_object_.Receive(), 1, option, 0, NULL, NULL),
 201       false);
 202
 203   // Realize the SL engine object in synchronous mode.
 204   LOG_ON_FAILURE_AND_RETURN(
 205       engine_object_->Realize(engine_object_.Get(), SL_BOOLEAN_FALSE), false);
 206
 207   // Get the SL engine interface which is implicit.
 208   SLEngineItf engine;
 209   LOG_ON_FAILURE_AND_RETURN(engine_object_->GetInterface(
 210                                 engine_object_.Get(), SL_IID_ENGINE, &engine),
 211                             false);
 212
 213   // Audio source configuration.
 214   SLDataLocator_IODevice mic_locator = {
 215       SL_DATALOCATOR_IODEVICE,       SL_IODEVICE_AUDIOINPUT,
 216       SL_DEFAULTDEVICEID_AUDIOINPUT, NULL};
 217   SLDataSource audio_source = {&mic_locator, NULL};
 218
 219   // Audio sink configuration.
 220   SLDataLocator_AndroidSimpleBufferQueue buffer_queue = {
 221       SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE,
 222       static_cast<SLuint32>(kMaxNumOfBuffersInQueue)};
 223   SLDataSink audio_sink = {&buffer_queue, &format_};
 224
 225   // Create an audio recorder.
 226   const SLInterfaceID interface_id[] = {SL_IID_ANDROIDSIMPLEBUFFERQUEUE,
 227                                         SL_IID_ANDROIDCONFIGURATION};
 228   const SLboolean interface_required[] = {SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE};
 229
 230   // Create AudioRecorder and specify SL_IID_ANDROIDCONFIGURATION.
 231   LOG_ON_FAILURE_AND_RETURN(
 232       (*engine)->CreateAudioRecorder(engine,
 233                                      recorder_object_.Receive(),
 234                                      &audio_source,
 235                                      &audio_sink,
 236                                      arraysize(interface_id),
 237                                      interface_id,
 238                                      interface_required),
 239       false);
 240
 241   SLAndroidConfigurationItf recorder_config;
 242   LOG_ON_FAILURE_AND_RETURN(
 243       recorder_object_->GetInterface(recorder_object_.Get(),
 244                                      SL_IID_ANDROIDCONFIGURATION,
 245                                      &recorder_config),
 246       false);
 247
 248   // Uses the main microphone tuned for audio communications.
 249   SLint32 stream_type = SL_ANDROID_RECORDING_PRESET_VOICE_COMMUNICATION;
 250   LOG_ON_FAILURE_AND_RETURN(
 251       (*recorder_config)->SetConfiguration(recorder_config,
 252                                            SL_ANDROID_KEY_RECORDING_PRESET,
 253                                            &stream_type,
 254                                            sizeof(SLint32)),
 255       false);
 256
 257   // Realize the recorder object in synchronous mode.
 258   LOG_ON_FAILURE_AND_RETURN(
 259       recorder_object_->Realize(recorder_object_.Get(), SL_BOOLEAN_FALSE),
 260       false);
 261
 262   // Get an implicit recorder interface.
 263   LOG_ON_FAILURE_AND_RETURN(
 264       recorder_object_->GetInterface(
 265           recorder_object_.Get(), SL_IID_RECORD, &recorder_),
 266       false);
 267
 268   // Get the simple buffer queue interface.
 269   LOG_ON_FAILURE_AND_RETURN(
 270       recorder_object_->GetInterface(recorder_object_.Get(),
 271                                      SL_IID_ANDROIDSIMPLEBUFFERQUEUE,
 272                                      &simple_buffer_queue_),
 273       false);
 274
 275   // Register the input callback for the simple buffer queue.
 276   // This callback will be called when receiving new data from the device.
 277   LOG_ON_FAILURE_AND_RETURN(
 278       (*simple_buffer_queue_)->RegisterCallback(
 279           simple_buffer_queue_, SimpleBufferQueueCallback, this),
 280       false);
 281
 282   return true;
 283 }
 284
 285 void OpenSLESInputStream::SimpleBufferQueueCallback(
 286     SLAndroidSimpleBufferQueueItf buffer_queue,
 287     void* instance) {
 288   OpenSLESInputStream* stream =
 289       reinterpret_cast<OpenSLESInputStream*>(instance);
 290   stream->ReadBufferQueue();
 291 }
 292
 293 void OpenSLESInputStream::ReadBufferQueue() {
 294   base::AutoLock lock(lock_);
 295   if (!started_)
 296     return;
 297
 298   TRACE_EVENT0("audio", "OpenSLESOutputStream::ReadBufferQueue");
 299
 300   // Convert from interleaved format to deinterleaved audio bus format.
 301   audio_bus_->FromInterleaved(audio_data_[active_buffer_index_],
 302                               audio_bus_->frames(),
 303                               format_.bitsPerSample / 8);
 304
 305   // TODO(henrika): Investigate if it is possible to get an accurate
 306   // delay estimation.
 307   callback_->OnData(this, audio_bus_.get(), buffer_size_bytes_, 0.0);
 308
 309   // Done with this buffer. Send it to device for recording.
 310   SLresult err =
 311       (*simple_buffer_queue_)->Enqueue(simple_buffer_queue_,
 312                                        audio_data_[active_buffer_index_],
 313                                        buffer_size_bytes_);
 314   if (SL_RESULT_SUCCESS != err)
 315     HandleError(err);
 316
 317   active_buffer_index_ = (active_buffer_index_ + 1) % kMaxNumOfBuffersInQueue;
 318 }
 319
 320 void OpenSLESInputStream::SetupAudioBuffer() {
 321   DCHECK(thread_checker_.CalledOnValidThread());
 322   DCHECK(!audio_data_[0]);
 323   for (int i = 0; i < kMaxNumOfBuffersInQueue; ++i) {
 324     audio_data_[i] = new uint8[buffer_size_bytes_];
 325   }
 326 }
 327
 328 void OpenSLESInputStream::ReleaseAudioBuffer() {
 329   DCHECK(thread_checker_.CalledOnValidThread());
 330   if (audio_data_[0]) {
 331     for (int i = 0; i < kMaxNumOfBuffersInQueue; ++i) {
 332       delete[] audio_data_[i];
 333       audio_data_[i] = NULL;
 334     }
 335   }
 336 }
 337
 338 void OpenSLESInputStream::HandleError(SLresult error) {
 339   DLOG(ERROR) << "OpenSLES Input error " << error;
 340   if (callback_)
 341     callback_->OnError(this);
 342 }
 343
 344 }  // namespace media