Enable high latency audio on Android N+ for basic playback.

media/audio/android/opensles_output.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/audio/android/opensles_output.h"
 
+#include "base/android/build_info.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "media/audio/android/audio_manager_android.h"
 #include "media/base/audio_timestamp_helper.h"
 
 #define LOG_ON_FAILURE_AND_RETURN(op, ...)      \
   do {                                          \
     SLresult err = (op);                        \
     if (err != SL_RESULT_SUCCESS) {             \
       DLOG(ERROR) << #op << " failed: " << err; \
       return __VA_ARGS__;                       \
     }                                           \
   } while (0)
 
+#if !defined(SL_ANDROID_KEY_PERFORMANCE_MODE)
+/** Audio Performance mode key */
+#define SL_ANDROID_KEY_PERFORMANCE_MODE \
+  ((const SLchar*)"androidPerformanceMode")
+
+/** Audio performance values */
+/*      No specific performance requirement. Allows HW and SW pre/post
+ * processing. */
+#define SL_ANDROID_PERFORMANCE_NONE ((SLuint32)0x00000000)
+/*      Priority given to latency. No HW or software pre/post processing.
+ *      This is the default if no performance mode is specified. */
+#define SL_ANDROID_PERFORMANCE_LATENCY ((SLuint32)0x00000001)
+/*      Priority given to latency while still allowing HW pre and post
+ * processing. */
+#define SL_ANDROID_PERFORMANCE_LATENCY_EFFECTS ((SLuint32)0x00000002)
+/*      Priority given to power saving if latency is not a concern.
+ *      Allows HW and SW pre/post processing. */
+#define SL_ANDROID_PERFORMANCE_POWER_SAVING ((SLuint32)0x00000003)
+#endif
+
 namespace media {
 
 OpenSLESOutputStream::OpenSLESOutputStream(AudioManagerAndroid* manager,
                                            const AudioParameters& params,
                                            SLint32 stream_type)
     : audio_manager_(manager),
       stream_type_(stream_type),
       callback_(NULL),
       player_(NULL),
       simple_buffer_queue_(NULL),
       audio_data_(),
       active_buffer_index_(0),
       bytes_per_frame_(params.GetBytesPerFrame()),
       buffer_size_bytes_(params.GetBytesPerBuffer()),
       started_(false),
       muted_(false),
       volume_(1.0),
       samples_per_second_(params.sample_rate()),
+      use_high_latency_(params.latency_tag() == AudioLatency::LATENCY_PLAYBACK),
       delay_calculator_(samples_per_second_) {
   DVLOG(2) << "OpenSLESOutputStream::OpenSLESOutputStream("
            << "stream_type=" << stream_type << ")";
   format_.formatType = SL_DATAFORMAT_PCM;
   format_.numChannels = static_cast<SLuint32>(params.channels());
   // Despite the name, this field is actually the sampling rate in millihertz :|
   format_.samplesPerSec = static_cast<SLuint32>(samples_per_second_ * 1000);
   format_.bitsPerSample = params.bits_per_sample();
   format_.containerSize = params.bits_per_sample();
   format_.endianness = SL_BYTEORDER_LITTLEENDIAN;
   format_.channelMask = ChannelCountToSLESChannelMask(params.channels());
   audio_bus_ = AudioBus::Create(params);
+
+  if (use_high_latency_) {
+    LOG(ERROR) << "Enabling high latency audio with buffer size: "
+               << params.frames_per_buffer();
+  }
 }
 
 OpenSLESOutputStream::~OpenSLESOutputStream() {
   DVLOG(2) << "OpenSLESOutputStream::~OpenSLESOutputStream()";
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!engine_object_.Get());
   DCHECK(!player_object_.Get());
   DCHECK(!output_mixer_.Get());
   DCHECK(!player_);
   DCHECK(!simple_buffer_queue_);
@@ skipping 202 matching lines @@
 
   // Create AudioPlayer and specify SL_IID_ANDROIDCONFIGURATION.
   SLAndroidConfigurationItf player_config;
   LOG_ON_FAILURE_AND_RETURN(
       player_object_->GetInterface(
           player_object_.Get(), SL_IID_ANDROIDCONFIGURATION, &player_config),
       false);
 
   // Set configuration using the stream type provided at construction.
   LOG_ON_FAILURE_AND_RETURN(
-      (*player_config)->SetConfiguration(player_config,
-                                         SL_ANDROID_KEY_STREAM_TYPE,
-                                         &stream_type_,
-                                         sizeof(SLint32)),
+      (*player_config)
+          ->SetConfiguration(player_config, SL_ANDROID_KEY_STREAM_TYPE,
+                             &stream_type_, sizeof(SLint32)),
       false);
 
+  // Set configuration using the stream type provided at construction.
+  if (use_high_latency_ && base::android::BuildInfo::GetInstance()->sdk_int() >=
+                               base::android::SDK_VERSION_NOUGAT) {
+    SLuint32 perf_mode = SL_ANDROID_PERFORMANCE_POWER_SAVING;
+    LOG_ON_FAILURE_AND_RETURN(
+        (*player_config)
+            ->SetConfiguration(player_config, SL_ANDROID_KEY_PERFORMANCE_MODE,
+                               &perf_mode, sizeof(SLuint32)),
+        false);
+  }
+
   // Realize the player object in synchronous mode.
   LOG_ON_FAILURE_AND_RETURN(
       player_object_->Realize(player_object_.Get(), SL_BOOLEAN_FALSE), false);
 
   // Get an implicit player interface.
   LOG_ON_FAILURE_AND_RETURN(
       player_object_->GetInterface(player_object_.Get(), SL_IID_PLAY, &player_),
       false);
 
   // Get the simple buffer queue interface.
@@ skipping 117 matching lines @@
   }
 }
 
 void OpenSLESOutputStream::HandleError(SLresult error) {
   DLOG(ERROR) << "OpenSLES Output error " << error;
   if (callback_)
     callback_->OnError(this);
 }
 
 }  // namespace media