Moves ownership of OpenSL engine object to Android audio manager

webrtc/modules/audio_device/android/opensles_player.cc

 /*
  *  Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/modules/audio_device/android/opensles_player.h"
 
 #include <android/log.h>
 
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/format_macros.h"
 #include "webrtc/base/timeutils.h"
+#include "webrtc/modules/audio_device/android/audio_common.h"
 #include "webrtc/modules/audio_device/android/audio_manager.h"
 #include "webrtc/modules/audio_device/fine_audio_buffer.h"
 
 #define TAG "OpenSLESPlayer"
 #define ALOGV(...) __android_log_print(ANDROID_LOG_VERBOSE, TAG, __VA_ARGS__)
 #define ALOGD(...) __android_log_print(ANDROID_LOG_DEBUG, TAG, __VA_ARGS__)
 #define ALOGE(...) __android_log_print(ANDROID_LOG_ERROR, TAG, __VA_ARGS__)
 #define ALOGW(...) __android_log_print(ANDROID_LOG_WARN, TAG, __VA_ARGS__)
 #define ALOGI(...) __android_log_print(ANDROID_LOG_INFO, TAG, __VA_ARGS__)
 
-#define RETURN_ON_ERROR(op, ...)        \
-  do {                                  \
-    SLresult err = (op);                \
-    if (err != SL_RESULT_SUCCESS) {     \
-      ALOGE("%s failed: %d", #op, err); \
-      return __VA_ARGS__;               \
-    }                                   \
+#define RETURN_ON_ERROR(op, ...)                          \
+  do {                                                    \
+    SLresult err = (op);                                  \
+    if (err != SL_RESULT_SUCCESS) {                       \
+      ALOGE("%s failed: %s", #op, GetSLErrorString(err)); \
+      return __VA_ARGS__;                                 \
+    }                                                     \
   } while (0)
 
 namespace webrtc {
 
 OpenSLESPlayer::OpenSLESPlayer(AudioManager* audio_manager)
-    : audio_parameters_(audio_manager->GetPlayoutAudioParameters()),
-      audio_device_buffer_(NULL),
+    : audio_manager_(audio_manager),
+      audio_parameters_(audio_manager->GetPlayoutAudioParameters()),
+      audio_device_buffer_(nullptr),
       initialized_(false),
       playing_(false),
       bytes_per_buffer_(0),
       buffer_index_(0),
       engine_(nullptr),
       player_(nullptr),
       simple_buffer_queue_(nullptr),
       volume_(nullptr),
       last_play_time_(0) {
   ALOGD("ctor%s", GetThreadInfo().c_str());
   // Use native audio output parameters provided by the audio manager and
   // define the PCM format structure.
   pcm_format_ = CreatePCMConfiguration(audio_parameters_.channels(),
                                        audio_parameters_.sample_rate(),
                                        audio_parameters_.bits_per_sample());
   // Detach from this thread since we want to use the checker to verify calls
   // from the internal  audio thread.
   thread_checker_opensles_.DetachFromThread();
 }
 
 OpenSLESPlayer::~OpenSLESPlayer() {
   ALOGD("dtor%s", GetThreadInfo().c_str());
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   Terminate();
   DestroyAudioPlayer();
   DestroyMix();
-  DestroyEngine();
-  RTC_DCHECK(!engine_object_.Get());
+  engine_ = nullptr;
   RTC_DCHECK(!engine_);
   RTC_DCHECK(!output_mix_.Get());
   RTC_DCHECK(!player_);
   RTC_DCHECK(!simple_buffer_queue_);
   RTC_DCHECK(!volume_);
 }
 
 int OpenSLESPlayer::Init() {
   ALOGD("Init%s", GetThreadInfo().c_str());
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   return 0;
 }
 
 int OpenSLESPlayer::Terminate() {
   ALOGD("Terminate%s", GetThreadInfo().c_str());
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   StopPlayout();
   return 0;
 }
 
 int OpenSLESPlayer::InitPlayout() {
   ALOGD("InitPlayout%s", GetThreadInfo().c_str());
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   RTC_DCHECK(!initialized_);
   RTC_DCHECK(!playing_);
-  CreateEngine();
+  ObtainEngineInterface();
   CreateMix();
   initialized_ = true;
   buffer_index_ = 0;
   last_play_time_ = rtc::Time();
   return 0;
 }
 
 int OpenSLESPlayer::StartPlayout() {
   ALOGD("StartPlayout%s", GetThreadInfo().c_str());
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 149 matching lines @@
   // Each buffer must be of this size to avoid unnecessary memcpy while caching
   // data between successive callbacks.
   const size_t required_buffer_size =
       fine_buffer_->RequiredPlayoutBufferSizeBytes();
   ALOGD("required buffer size: %" PRIuS, required_buffer_size);
   for (int i = 0; i < kNumOfOpenSLESBuffers; ++i) {
     audio_buffers_[i].reset(new SLint8[required_buffer_size]);
   }
 }
 
-bool OpenSLESPlayer::CreateEngine() {
-  ALOGD("CreateEngine");
+bool OpenSLESPlayer::ObtainEngineInterface() {
+  ALOGD("ObtainEngineInterface");
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  if (engine_object_.Get())
-    return true;
   RTC_DCHECK(!engine_);
-  const SLEngineOption option[] = {
-    {SL_ENGINEOPTION_THREADSAFE, static_cast<SLuint32>(SL_BOOLEAN_TRUE)}};
+  // Get access to (or create if not already existing) the global OpenSL Engine
+  // object.
+  SLObjectItf engine_object = audio_manager_->GetOpenSLEngine();
+  if (engine_object == nullptr) {
+    ALOGE("Failed to access the global OpenSL engine");
+    return false;
+  }
+  // Get the SL Engine Interface which is implicit.
   RETURN_ON_ERROR(
-      slCreateEngine(engine_object_.Receive(), 1, option, 0, NULL, NULL),
+      (*engine_object)->GetInterface(engine_object, SL_IID_ENGINE, &engine_),
       false);
-  RETURN_ON_ERROR(
-      engine_object_->Realize(engine_object_.Get(), SL_BOOLEAN_FALSE), false);
-  RETURN_ON_ERROR(engine_object_->GetInterface(engine_object_.Get(),
-                                               SL_IID_ENGINE, &engine_),
-                  false);
   return true;
 }
 
-void OpenSLESPlayer::DestroyEngine() {
-  ALOGD("DestroyEngine");
-  RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  if (!engine_object_.Get())
-    return;
-  engine_ = nullptr;
-  engine_object_.Reset();
-}
-
 bool OpenSLESPlayer::CreateMix() {
   ALOGD("CreateMix");
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   RTC_DCHECK(engine_);
   if (output_mix_.Get())
     return true;
 
   // Create the ouput mix on the engine object. No interfaces will be used.
   RETURN_ON_ERROR((*engine_)->CreateOutputMix(engine_, output_mix_.Receive(), 0,
-                                              NULL, NULL),
+                                              nullptr, nullptr),
                   false);
   RETURN_ON_ERROR(output_mix_->Realize(output_mix_.Get(), SL_BOOLEAN_FALSE),
                   false);
   return true;
 }
 
 void OpenSLESPlayer::DestroyMix() {
   ALOGD("DestroyMix");
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (!output_mix_.Get())
     return;
   output_mix_.Reset();
 }
 
 bool OpenSLESPlayer::CreateAudioPlayer() {
   ALOGD("CreateAudioPlayer");
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  RTC_DCHECK(engine_object_.Get());
   RTC_DCHECK(output_mix_.Get());
   if (player_object_.Get())
     return true;
   RTC_DCHECK(!player_);
   RTC_DCHECK(!simple_buffer_queue_);
   RTC_DCHECK(!volume_);
 
   // source: Android Simple Buffer Queue Data Locator is source.
   SLDataLocator_AndroidSimpleBufferQueue simple_buffer_queue = {
       SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE,
       static_cast<SLuint32>(kNumOfOpenSLESBuffers)};
   SLDataSource audio_source = {&simple_buffer_queue, &pcm_format_};
 
   // sink: OutputMix-based data is sink.
   SLDataLocator_OutputMix locator_output_mix = {SL_DATALOCATOR_OUTPUTMIX,
                                                 output_mix_.Get()};
-  SLDataSink audio_sink = {&locator_output_mix, NULL};
+  SLDataSink audio_sink = {&locator_output_mix, nullptr};
 
   // Define interfaces that we indend to use and realize.
   const SLInterfaceID interface_ids[] = {
       SL_IID_ANDROIDCONFIGURATION, SL_IID_BUFFERQUEUE, SL_IID_VOLUME};
   const SLboolean interface_required[] = {
       SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE};
 
   // Create the audio player on the engine interface.
   RETURN_ON_ERROR(
       (*engine_)->CreateAudioPlayer(
@@ skipping 109 matching lines @@
   RTC_DCHECK(player_);
   SLuint32 state;
   SLresult err = (*player_)->GetPlayState(player_, &state);
   if (SL_RESULT_SUCCESS != err) {
     ALOGE("GetPlayState failed: %d", err);
   }
   return state;
 }
 
 }  // namespace webrtc