android: Enable AudioTrack playback params in tunnel mode (youtube#9168)

This commit enables dynamic playback rate control for audio tracks
on Android when operating in tunnel mode. It integrates the Android
AudioTrack.setPlaybackParams() API to delegate playback speed
adjustments to the platform.

Previously, only playback rates of 0.0 (pause) and 1.0 (normal) were
directly supported by the audio sink. Other rates were handled by
software time stretching or explicitly not implemented at the
platform level. By utilizing setPlaybackParams() for tunnel mode
audio, Cobalt can leverage hardware acceleration or platform-optimized
handling for variable speed playback, potentially improving
performance and reducing CPU overhead. The change also ensures the
audio buffer size is sufficiently increased to accommodate faster
playback speeds.

Bug: 311422213

Author: jasonzhangxx

cobalt/android/apk/app/src/main/java/dev/cobalt/media/AudioTrackBridge.java

@@ -20,6 +20,7 @@
 import android.media.AudioFormat;
 import android.media.AudioManager;
 import android.media.AudioTrack;
+import android.media.PlaybackParams;
 import android.os.Build;
 import androidx.annotation.GuardedBy;
 import androidx.annotation.RequiresApi;
@@ -227,11 +228,34 @@ public void release() {
     mAvSyncPacketBytesRemaining = 0;
   }
 
+
+  @CalledByNative
+  public boolean setPlaybackRate(float playbackRate) {
+    if (mAudioTrack == null) {
+      Log.e(TAG, "Unable to setPlaybackRate with NULL audio track.");
+      return false;
+    }
+    if (!mTunnelModeEnabled) {
+      Log.i(TAG, "Skip SetPlaybackRate for non tunnel mode tracks.");
+      return true;
+    }
+
+    try {
+      PlaybackParams params = mAudioTrack.getPlaybackParams();
+      params.setSpeed(playbackRate);
+      mAudioTrack.setPlaybackParams(params);
+    } catch (IllegalArgumentException | IllegalStateException e) {
+      Log.e(TAG, String.format("Unable to setPlaybackRate, error: %s", e.toString()));
+      return false;
+    }
+    return true;
+  }
+
   @CalledByNative
   public int setVolume(float gain) {
     if (mAudioTrack == null) {
       Log.e(TAG, "Unable to setVolume with NULL audio track.");
-      return 0;
+      return AudioTrack.ERROR_INVALID_OPERATION;
     }
     return mAudioTrack.setVolume(gain);
   }

starboard/android/shared/audio_track_audio_sink_type.cc

@@ -188,13 +188,19 @@ AudioTrackAudioSink::~AudioTrackAudioSink() {
 
 void AudioTrackAudioSink::SetPlaybackRate(double playback_rate) {
   SB_DCHECK_GE(playback_rate, 0.0);
-  if (playback_rate != 0.0 && playback_rate != 1.0) {
-    SB_NOTIMPLEMENTED() << "TODO: Only playback rates of 0.0 and 1.0 are "
-                           "currently supported.";
-    playback_rate = (playback_rate > 0.0) ? 1.0 : 0.0;
+  SB_DLOG(INFO) << "Set playback rate to " << playback_rate;
+
+  {
+    std::lock_guard lock(mutex_);
+    playback_rate_ = playback_rate;
+  }
+
+  // AudioTrack doesn't support playback speed of 0.
+  if (playback_rate > 0.0) {
+    // AudioTrackBridge.setPlaybackRate() currently is only enabled for tunnel
+    // mode. It will be no-op for non tunnel player.
+    bridge_.SetPlaybackRate(playback_rate);
   }
-  std::lock_guard lock(mutex_);
-  playback_rate_ = playback_rate;
 }
 
 // TODO: Break down the function into manageable pieces.
@@ -439,6 +445,21 @@ int AudioTrackAudioSinkType::GetMinBufferSizeInFrames(
     int sampling_frequency_hz) {
   SB_CHECK(audio_track_audio_sink_type_);
   JNIEnv* env = AttachCurrentThread();
+
+  const bool force_tunnel_mode =
+      features::FeatureList::IsEnabled(features::kForceTunnelMode);
+  if (force_tunnel_mode) {
+    // AudioTrack.setPlaybackParams() needs extra buffer to support playback
+    // speed greater than 1.0x.
+    const double kMaxPlaybackSpeed = 2.0;
+    return std::max<int>(
+        AudioOutputManager::GetInstance()->GetMinBufferSizeInFrames(
+            env, sample_type, channels, sampling_frequency_hz),
+        audio_track_audio_sink_type_->GetMinBufferSizeInFramesInternal(
+            channels, sample_type, sampling_frequency_hz) *
+            kMaxPlaybackSpeed);
+  }
+
   return std::max(
       AudioOutputManager::GetInstance()->GetMinBufferSizeInFrames(
           env, sample_type, channels, sampling_frequency_hz),

starboard/android/shared/audio_track_bridge.cc

@@ -19,6 +19,7 @@
 #include "starboard/android/shared/audio_output_manager.h"
 #include "starboard/android/shared/media_common.h"
 #include "starboard/audio_sink.h"
+#include "starboard/common/check_op.h"
 #include "starboard/common/log.h"
 #include "starboard/shared/starboard/media/media_util.h"
 
@@ -241,6 +242,21 @@ int AudioTrackBridge::WriteSample(const uint8_t* samples,
   return bytes_written;
 }
 
+void AudioTrackBridge::SetPlaybackRate(
+    double playback_rate,
+    JNIEnv* env /*= AttachCurrentThread()*/) {
+  SB_DCHECK(env);
+  SB_DCHECK(is_valid());
+  // AudioTrack doesn't support playback speed of 0.
+  SB_DCHECK_GT(playback_rate, 0.0);
+
+  jboolean status = Java_AudioTrackBridge_setPlaybackRate(
+      env, j_audio_track_bridge_, static_cast<float>(playback_rate));
+  if (!status) {
+    SB_LOG(ERROR) << "Failed to set playback rate to " << playback_rate;
+  }
+}
+
 void AudioTrackBridge::SetVolume(double volume,
                                  JNIEnv* env /*= AttachCurrentThread()*/) {
   SB_DCHECK(env);

starboard/android/shared/audio_track_bridge.h

@@ -71,6 +71,8 @@ class AudioTrackBridge {
                   int64_t sync_time,
                   JNIEnv* env = base::android::AttachCurrentThread());
 
+  void SetPlaybackRate(double playback_rate,
+                       JNIEnv* env = base::android::AttachCurrentThread());
   void SetVolume(double volume,
                  JNIEnv* env = base::android::AttachCurrentThread());
 

starboard/android/shared/player_components_factory.cc

@@ -94,6 +94,10 @@ class AudioRendererSinkAndroid : public AudioRendererSinkImpl {
     return tunnel_mode_audio_session_id_ != -1;
   }
 
+  bool AllowDirectPlaybackRateSetting() const override {
+    return tunnel_mode_audio_session_id_ != -1;
+  }
+
  private:
   bool IsAudioSampleTypeSupported(
       SbMediaAudioSampleType audio_sample_type) const override {

starboard/shared/starboard/player/filter/audio_renderer_internal_pcm.cc

@@ -214,10 +214,13 @@ void AudioRendererPcm::SetPlaybackRate(double playback_rate) {
 
   playback_rate_ = playback_rate;
 
-  audio_renderer_sink_->SetPlaybackRate(playback_rate_ > 0.0 ? 1.0 : 0.0);
+  double adjusted_playback_rate = playback_rate_ > 0.0 ? 1.0 : 0.0;
+  if (audio_renderer_sink_->AllowDirectPlaybackRateSetting()) {
+    adjusted_playback_rate = playback_rate_;
+  }
+
+  audio_renderer_sink_->SetPlaybackRate(adjusted_playback_rate);
   if (audio_renderer_sink_->HasStarted()) {
-    // TODO: Remove SetPlaybackRate() support from audio sink as it only need to
-    // support play/pause.
     if (playback_rate_ > 0.0) {
       if (process_audio_data_job_token_.is_valid()) {
         RemoveJobByToken(process_audio_data_job_token_);
@@ -334,14 +337,12 @@ int64_t AudioRendererPcm::GetCurrentMediaTime(bool* is_playing,
     frames_played =
         audio_frame_tracker_.GetFutureFramesPlayedAdjustedToPlaybackRate(
             elapsed_frames, playback_rate);
-#if BUILDFLAG(IS_ANDROID)
     if (audio_renderer_sink_->AllowOverflowAudioSamples()) {
       // A simple workaround to handle silence frames for tunnel mode player.
       // |playback_rate| is ignored as tunnel mode doesn't support
       // vsp.
       frames_played += audio_frame_tracker_.GetOverflowedFrames();
     }
-#endif  // BUILDFLAG(IS_ANDROID)
     media_time =
         seeking_to_time_ + frames_played * 1'000'000LL / samples_per_second;
     if (media_time < last_media_time_) {
@@ -490,15 +491,13 @@ void AudioRendererPcm::UpdateVariablesOnSinkThread_Locked(
       frames_consumed_set_at_ = system_time_on_consume_frames;
     }
 
-#if BUILDFLAG(IS_ANDROID)
     if (audio_renderer_sink_->AllowOverflowAudioSamples()) {
       auto silence_frames_consumed =
           frames_consumed_on_sink_thread_ - non_silence_frames_consumed;
       frames_consumed_by_sink_since_last_get_current_time_ +=
           silence_frames_consumed;
       frames_consumed_set_at_ = system_time_on_consume_frames;
     }
-#endif  // BUILDFLAG(IS_ANDROID)
 
     consume_frames_called_ = true;
     frames_consumed_on_sink_thread_ = 0;
@@ -723,16 +722,22 @@ bool AudioRendererPcm::AppendAudioToFrameBuffer(bool* is_frame_buffer_full) {
 
   int offset_to_append = total_frames_sent_to_sink_ % max_cached_frames_;
 
+  double adjusted_playback_rate = playback_rate_;
+  if (audio_renderer_sink_->AllowDirectPlaybackRateSetting()) {
+    adjusted_playback_rate = 1.0;
+  }
+
   scoped_refptr<DecodedAudio> decoded_audio = time_stretcher_.Read(
-      max_cached_frames_ - frames_in_buffer, playback_rate_);
+      max_cached_frames_ - frames_in_buffer, adjusted_playback_rate);
   SB_DCHECK(decoded_audio);
 
   {
     std::lock_guard lock(mutex_);
     if (decoded_audio->frames() == 0 && eos_state_ == kEOSDecoded) {
       eos_state_ = kEOSSentToSink;
     }
-    audio_frame_tracker_.AddFrames(decoded_audio->frames(), playback_rate_);
+    audio_frame_tracker_.AddFrames(decoded_audio->frames(),
+                                   adjusted_playback_rate);
   }
 
   // |time_stretcher_| only support kSbMediaAudioSampleTypeFloat32 and

starboard/shared/starboard/player/filter/audio_renderer_sink.h

@@ -68,6 +68,7 @@ class AudioRendererSink {
   virtual void SetPlaybackRate(double playback_rate) = 0;
 
   virtual bool AllowOverflowAudioSamples() const { return false; }
+  virtual bool AllowDirectPlaybackRateSetting() const { return false; }
 };
 
 }  // namespace starboard