Adds support for OpenSL ES based audio capture on Android

webrtc/modules/audio_device/android/opensles_player.h

 /*
  *  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.
  */
 
 #ifndef WEBRTC_MODULES_AUDIO_DEVICE_ANDROID_OPENSLES_PLAYER_H_
 #define WEBRTC_MODULES_AUDIO_DEVICE_ANDROID_OPENSLES_PLAYER_H_
 
-#include <memory>
-
 #include <SLES/OpenSLES.h>
 #include <SLES/OpenSLES_Android.h>
 #include <SLES/OpenSLES_AndroidConfiguration.h>
 
 #include "webrtc/base/thread_checker.h"
 #include "webrtc/modules/audio_device/android/audio_common.h"
 #include "webrtc/modules/audio_device/android/audio_manager.h"
 #include "webrtc/modules/audio_device/android/opensles_common.h"
 #include "webrtc/modules/audio_device/include/audio_device_defines.h"
 #include "webrtc/modules/audio_device/audio_device_generic.h"
@@ skipping 16 matching lines @@
 // to be able to call StartPlayout() again. This is inline with how the Java-
 // based implementation works.
 //
 // OpenSL ES is a native C API which have no Dalvik-related overhead such as
 // garbage collection pauses and it supports reduced audio output latency.
 // If the device doesn't claim this feature but supports API level 9 (Android
 // platform version 2.3) or later, then we can still use the OpenSL ES APIs but
 // the output latency may be higher.
 class OpenSLESPlayer {
  public:
-  // The lower output latency path is used only if the application requests a
-  // buffer count of 2 or more, and a buffer size and sample rate that are
-  // compatible with the device's native output configuration provided via the
-  // audio manager at construction.
-  static const int kNumOfOpenSLESBuffers = 4;
+  // Beginning with API level 17 (Android 4.2), a buffer count of 2 or more is
+  // required for lower latency. Beginning with API level 18 (Android 4.3), a
+  // buffer count of 1 is sufficient for lower latency. In addition, the buffer
+  // size and sample rate must be compatible with the device's native output
+  // configuration provided via the audio manager at construction.
+  // TODO(henrika): perhaps set this value dynamically based on OS version.
+  static const int kNumOfOpenSLESBuffers = 2;
 
   explicit OpenSLESPlayer(AudioManager* audio_manager);
   ~OpenSLESPlayer();
 
   int Init();
   int Terminate();
 
   int InitPlayout();
   bool PlayoutIsInitialized() const { return initialized_; }
 
@@ skipping 14 matching lines @@
   // They are both called from an internal "OpenSL ES thread" which is not
   // attached to the Dalvik VM.
   static void SimpleBufferQueueCallback(SLAndroidSimpleBufferQueueItf caller,
                                         void* context);
   void FillBufferQueue();
   // Reads audio data in PCM format using the AudioDeviceBuffer.
   // Can be called both on the main thread (during Start()) and from the
   // internal audio thread while output streaming is active.
   void EnqueuePlayoutData();
 
-  // Configures the SL_DATAFORMAT_PCM structure.
-  SLDataFormat_PCM CreatePCMConfiguration(size_t channels,
-                                          int sample_rate,
-                                          size_t bits_per_sample);
-
   // Allocate memory for audio buffers which will be used to render audio
   // via the SLAndroidSimpleBufferQueueItf interface.
   void AllocateDataBuffers();
 
   // Obtaines the SL Engine Interface from the existing global Engine object.
   // The interface exposes creation methods of all the OpenSL ES object types.
   // This method defines the |engine_| member variable.
   bool ObtainEngineInterface();
 
   // Creates/destroys the output mix object.
@@ skipping 31 matching lines @@
   AudioDeviceBuffer* audio_device_buffer_;
 
   bool initialized_;
   bool playing_;
 
   // PCM-type format definition.
   // TODO(henrika): add support for SLAndroidDataFormat_PCM_EX (android-21) if
   // 32-bit float representation is needed.
   SLDataFormat_PCM pcm_format_;
 
-  // Number of bytes per audio buffer in each |audio_buffers_[i]|.
-  // Typical sizes are 480 or 512 bytes corresponding to native output buffer
-  // sizes of 240 or 256 audio frames respectively.
-  size_t bytes_per_buffer_;
-
   // Queue of audio buffers to be used by the player object for rendering
   // audio. They will be used in a Round-robin way and the size of each buffer
   // is given by FineAudioBuffer::RequiredBufferSizeBytes().
   std::unique_ptr<SLint8[]> audio_buffers_[kNumOfOpenSLESBuffers];
 
   // FineAudioBuffer takes an AudioDeviceBuffer which delivers audio data
   // in chunks of 10ms. It then allows for this data to be pulled in
   // a finer or coarser granularity. I.e. interacting with this class instead
   // of directly with the AudioDeviceBuffer one can ask for any number of
   // audio data samples.
-  // Example: native buffer size is 240 audio frames at 48kHz sample rate.
-  // WebRTC will provide 480 audio frames per 10ms but OpenSL ES asks for 240
-  // in each callback (one every 5ms). This class can then ask for 240 and the
-  // FineAudioBuffer will ask WebRTC for new data only every second callback
-  // and also cach non-utilized audio.
-  std::unique_ptr<FineAudioBuffer> fine_buffer_;
+  // Example: native buffer size can be 192 audio frames at 48kHz sample rate.
+  // WebRTC will provide 480 audio frames per 10ms but OpenSL ES asks for 192
+  // in each callback (one every 4th ms). This class can then ask for 192 and
+  // the FineAudioBuffer will ask WebRTC for new data approximately only every
+  // second callback and also cache non-utilized audio.
+  std::unique_ptr<FineAudioBuffer> fine_audio_buffer_;
 
   // Keeps track of active audio buffer 'n' in the audio_buffers_[n] queue.
   // Example (kNumOfOpenSLESBuffers = 2): counts 0, 1, 0, 1, ...
   int buffer_index_;
 
   // This interface exposes creation methods for all the OpenSL ES object types.
   // It is the OpenSL ES API entry point.
   SLEngineItf engine_;
 
   // Output mix object to be used by the player object.
@@ skipping 16 matching lines @@
   // properties. This interface is supported on the Audio Player object.
   SLVolumeItf volume_;
 
   // Last time the OpenSL ES layer asked for audio data to play out.
   uint32_t last_play_time_;
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_AUDIO_DEVICE_ANDROID_OPENSLES_PLAYER_H_