Enable float audio output on L+ Android devices.

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_sample_types.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)
 
 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()),
+      have_float_output_(base::android::BuildInfo::GetInstance()->sdk_int() >=
+                         base::android::SDK_VERSION_LOLLIPOP),
+      bytes_per_frame_(have_float_output_ ? params.channels() * sizeof(float)
+                                          : params.GetBytesPerFrame()),
+      buffer_size_bytes_(have_float_output_
+                             ? bytes_per_frame_ * params.frames_per_buffer()
+                             : params.GetBytesPerBuffer()),
       delay_calculator_(samples_per_second_) {
   DVLOG(2) << "OpenSLESOutputStream::OpenSLESOutputStream("
            << "stream_type=" << stream_type << ")";
+
+  audio_bus_ = AudioBus::Create(params);
+
+  if (have_float_output_) {
+    float_format_.formatType = SL_ANDROID_DATAFORMAT_PCM_EX;
+    float_format_.numChannels = static_cast<SLuint32>(params.channels());
+    // Despite the name, this field is actually the sampling rate in millihertz.
+    float_format_.sampleRate =
+        static_cast<SLuint32>(samples_per_second_ * 1000);
+    float_format_.bitsPerSample = 32;
+    float_format_.containerSize = 32;
+    float_format_.endianness = SL_BYTEORDER_LITTLEENDIAN;
+    float_format_.channelMask =
+        ChannelCountToSLESChannelMask(params.channels());
+    float_format_.representation = SL_ANDROID_PCM_REPRESENTATION_FLOAT;
+    return;
+  }
+
   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);
 }
 
 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 171 matching lines @@
                             false);
 
   // Realizing the output mix object in synchronous mode.
   LOG_ON_FAILURE_AND_RETURN(
       output_mixer_->Realize(output_mixer_.Get(), SL_BOOLEAN_FALSE), false);
 
   // Audio source configuration.
   SLDataLocator_AndroidSimpleBufferQueue simple_buffer_queue = {
       SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE,
       static_cast<SLuint32>(kMaxNumOfBuffersInQueue)};
-  SLDataSource audio_source = {&simple_buffer_queue, &format_};
+  SLDataSource audio_source;
+  if (have_float_output_)
+    audio_source = {&simple_buffer_queue, &float_format_};
+  else
+    audio_source = {&simple_buffer_queue, &format_};
 
   // Audio sink configuration.
   SLDataLocator_OutputMix locator_output_mix = {SL_DATALOCATOR_OUTPUTMIX,
                                                 output_mixer_.Get()};
   SLDataSink audio_sink = {&locator_output_mix, NULL};
 
   // Create an audio player.
   const SLInterfaceID interface_id[] = {SL_IID_BUFFERQUEUE, SL_IID_VOLUME,
                                         SL_IID_ANDROIDCONFIGURATION};
   const SLboolean interface_required[] = {SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE,
@@ skipping 111 matching lines @@
       callback_->OnMoreData(delay, base::TimeTicks::Now(), 0, audio_bus_.get());
   if (frames_filled <= 0) {
     // Audio source is shutting down, or halted on error.
     return;
   }
 
   // Note: If the internal representation ever changes from 16-bit PCM to
   // raw float, the data must be clipped and sanitized since it may come
   // from an untrusted source such as NaCl.
   audio_bus_->Scale(muted_ ? 0.0f : volume_);
-  audio_bus_->ToInterleaved(frames_filled, format_.bitsPerSample / 8,
-                            audio_data_[active_buffer_index_]);
+  if (!have_float_output_) {
+    audio_bus_->ToInterleaved(frames_filled, format_.bitsPerSample / 8,
+                              audio_data_[active_buffer_index_]);
+  } else {
+    audio_bus_->ToInterleaved<Float32SampleTypeTraits>(
+        frames_filled,
+        reinterpret_cast<float*>(audio_data_[active_buffer_index_]));
+  }
 
   delay_calculator_.AddFrames(frames_filled);
   const int num_filled_bytes = frames_filled * bytes_per_frame_;
   DCHECK_LE(static_cast<size_t>(num_filled_bytes), buffer_size_bytes_);
 
   // Enqueue the buffer for playback.
   err = (*simple_buffer_queue_)
             ->Enqueue(simple_buffer_queue_, audio_data_[active_buffer_index_],
                       num_filled_bytes);
   if (SL_RESULT_SUCCESS != err)
     HandleError(err);
 
   active_buffer_index_ = (active_buffer_index_ + 1) % kMaxNumOfBuffersInQueue;
 }
 
 void OpenSLESOutputStream::SetupAudioBuffer() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!audio_data_[0]);
-  for (int i = 0; i < kMaxNumOfBuffersInQueue; ++i) {
+  for (int i = 0; i < kMaxNumOfBuffersInQueue; ++i)
     audio_data_[i] = new uint8_t[buffer_size_bytes_];
-  }
 }
 
 void OpenSLESOutputStream::ReleaseAudioBuffer() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (audio_data_[0]) {
     for (int i = 0; i < kMaxNumOfBuffersInQueue; ++i) {
       delete[] audio_data_[i];
       audio_data_[i] = NULL;
     }
   }
 }
 
 void OpenSLESOutputStream::HandleError(SLresult error) {
   DLOG(ERROR) << "OpenSLES Output error " << error;
   if (callback_)
     callback_->OnError(this);
 }
 
 }  // namespace media