[media] Add BUFFER_FLAG_DECODE_ONLY experiment

This PR adds the experiment of using the MediaCodec flag
BUFFER_FLAG_DECODE_ONLY (introduced in Android 34) for resource
improvement during playback. This experiment is currently hard-coded to
be false, but when the Starboard-Feature Extension is added, a follow up
PR will be submitted to make this a proper feature experiment.

To get this experiment to work, we now make MediaCodecBridge keep track
of seekToTime in playbacks with a Seek() function.

Bug: 423927047

Author: johnedocampo

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

@@ -68,6 +68,8 @@ class MediaCodecBridge {
   private boolean mFlushed;
   private long mLastPresentationTimeUs;
   private double mPlaybackRate = 1.0;
+  private long mSeekToTime = 0;
+  private boolean mBufferFlagDecodeOnlyExperiment = false;
   private int mFps = 30;
   private final boolean mIsTunnelingPlayback;
 
@@ -397,6 +399,12 @@ public static boolean isFrameRenderedCallbackEnabled() {
     return Build.VERSION.SDK_INT >= 34;
   }
 
+  private boolean isDecodeOnly(long presentationTimeUs) {
+    // Starting with Android 14, we can use BUFFER_FLAG_DECODE_ONLY to explicitly skip video frames
+    // before the seek time so that they won't be rendered.
+    return Build.VERSION.SDK_INT >= 34 && (mBufferFlagDecodeOnlyExperiment) && (presentationTimeUs < mSeekToTime);
+  }
+
   @CalledByNative
   public static void createVideoMediaCodecBridge(
       long nativeMediaCodecBridge,
@@ -652,6 +660,11 @@ private void setPlaybackRate(double playbackRate) {
     }
   }
 
+  @CalledByNative
+  private void seek(long seekToTime) {
+    mSeekToTime = seekToTime;
+  }
+
   private void updateOperatingRate() {
     // We needn't set operation rate if playback rate is 0 or less.
     if (Double.compare(mPlaybackRate, 0.0) <= 0) {
@@ -739,6 +752,9 @@ private int queueInputBuffer(
       int index, int offset, int size, long presentationTimeUs, int flags) {
     resetLastPresentationTimeIfNeeded(presentationTimeUs);
     try {
+      if (isDecodeOnly(presentationTimeUs)) {
+        flags |= MediaCodec.BUFFER_FLAG_DECODE_ONLY;
+      }
       mMediaCodec.get().queueInputBuffer(index, offset, size, presentationTimeUs, flags);
     } catch (Exception e) {
       Log.e(TAG, "Failed to queue input buffer", e);
@@ -773,6 +789,10 @@ private int queueSecureInputBuffer(
         return MediaCodecStatus.ERROR;
       }
 
+      int flags = 0;
+      if (isDecodeOnly(presentationTimeUs)) {
+        flags |= MediaCodec.BUFFER_FLAG_DECODE_ONLY;
+      }
       mMediaCodec.get().queueSecureInputBuffer(index, offset, cryptoInfo, presentationTimeUs, 0);
     } catch (MediaCodec.CryptoException e) {
       int errorCode = e.getErrorCode();

starboard/android/shared/media_codec_bridge.cc

@@ -388,6 +388,11 @@ void MediaCodecBridge::SetPlaybackRate(double playback_rate) {
                                         playback_rate);
 }
 
+void MediaCodecBridge::Seek(int64_t seek_to_time) {
+  JNIEnv* env = AttachCurrentThread();
+  return Java_MediaCodecBridge_seek(env, j_media_codec_bridge_, seek_to_time);
+}
+
 bool MediaCodecBridge::Restart() {
   JNIEnv* env = AttachCurrentThread();
   return Java_MediaCodecBridge_restart(env, j_media_codec_bridge_) == JNI_TRUE;

starboard/android/shared/media_codec_bridge.h

@@ -203,6 +203,7 @@ class MediaCodecBridge {
   void ReleaseOutputBufferAtTimestamp(jint index, jlong render_timestamp_ns);
 
   void SetPlaybackRate(double playback_rate);
+  void Seek(int64_t seek_to_time);
   bool Restart();
   jint Flush();
   void Stop();

starboard/android/shared/media_decoder.cc

@@ -231,6 +231,15 @@ void MediaDecoder::SetPlaybackRate(double playback_rate) {
   media_codec_bridge_->SetPlaybackRate(playback_rate);
 }
 
+void MediaDecoder::Seek(int64_t seek_to_time) {
+  SB_DCHECK(media_type_ == kSbMediaTypeVideo);
+  SB_DCHECK(media_codec_bridge_);
+  if (!media_codec_bridge_) {
+    return;
+  }
+  media_codec_bridge_->Seek(seek_to_time);
+}
+
 // static
 void* MediaDecoder::DecoderThreadEntryPoint(void* context) {
   SB_DCHECK(context);

starboard/android/shared/media_decoder.h

@@ -109,6 +109,8 @@ class MediaDecoder final
 
   void SetPlaybackRate(double playback_rate);
 
+  void Seek(int64_t seek_to_time);
+
   size_t GetNumberOfPendingInputs() const {
     return number_of_pending_inputs_.load();
   }

starboard/android/shared/video_decoder.cc

@@ -758,6 +758,7 @@ bool VideoDecoder::InitializeCodec(const VideoStreamInfo& video_stream_info,
           std::bind(&VideoDecoder::ReportError, this, _1, _2));
     }
     media_decoder_->SetPlaybackRate(playback_rate_);
+    media_decoder_->Seek(0);
 
     if (video_stream_info.codec == kSbMediaVideoCodecAv1) {
       SB_DCHECK(!pending_input_buffers_.empty());
@@ -1267,6 +1268,16 @@ void VideoDecoder::ReportError(SbPlayerError error,
   error_cb_(kSbPlayerErrorDecode, error_message);
 }
 
+void VideoDecoder::Seek(int64_t seek_to_time) {
+  seek_to_time_ = seek_to_time;
+  if (video_frame_tracker_) {
+    video_frame_tracker_->Seek(seek_to_time_);
+  }
+  if (media_decoder_) {
+    return media_decoder_->Seek(seek_to_time_);
+  }
+}
+
 }  // namespace starboard::android::shared
 
 extern "C" SB_EXPORT_PLATFORM void

starboard/android/shared/video_decoder.h

@@ -98,6 +98,8 @@ class VideoDecoder
   void UpdateDecodeTargetSizeAndContentRegion_Locked();
   void SetPlaybackRate(double playback_rate);
 
+  void Seek(int64_t seek_to_time);
+
   void OnNewTextureAvailable();
 
   bool is_decoder_created() const { return media_decoder_ != NULL; }
@@ -209,6 +211,7 @@ class VideoDecoder
   bool end_of_stream_written_ = false;
   volatile int64_t first_buffer_timestamp_;  // microseconds
   std::atomic_bool has_new_texture_available_{false};
+  int64_t seek_to_time_ = 0;
 
   // Use |owns_video_surface_| only on decoder thread, to avoid unnecessary
   // invocation of ReleaseVideoSurface(), though ReleaseVideoSurface() would

starboard/android/shared/video_render_algorithm.cc

@@ -118,8 +118,8 @@ void VideoRenderAlgorithm::Render(
 }
 
 void VideoRenderAlgorithm::Seek(int64_t seek_to_time) {
-  if (frame_tracker_) {
-    frame_tracker_->Seek(seek_to_time);
+  if (video_decoder_) {
+    video_decoder_->Seek(seek_to_time);
   }
 }