From bce31914d76b65d8f2148f7e391e40877b617b37 Mon Sep 17 00:00:00 2001
From: xiaomings <xiaomings@google.com>
Date: Thu, 20 Apr 2023 12:47:01 -0700
Subject: [PATCH] [media] Support configurable audio write ahead

Enables the web app to configure the audio write ahead duration through
an extension, and enables the extension for linux-x64x11.

Se the original PR https://github.com/youtube/cobalt/pull/121 for
details.

b/267678497
b/267678497
---
 .../src/components/player.ts                  |  55 +++++--
 .../src/components/source_buffer_info.ts      |   7 +-
 .../src/components/video_info.ts              |   6 +-
 cobalt/dom/html_media_element.cc              |  33 +++++
 cobalt/dom/html_media_element.h               |   8 ++
 cobalt/dom/html_media_element.idl             |   6 +
 cobalt/dom/source_buffer.cc                   |  11 ++
 cobalt/dom/source_buffer.h                    |   3 +
 cobalt/dom/source_buffer.idl                  |   6 +
 cobalt/extension/audio_write_ahead.h          |  83 +++++++++++
 cobalt/media/base/pipeline.h                  |   4 +
 cobalt/media/base/sbplayer_bridge.cc          |  30 ++++
 cobalt/media/base/sbplayer_bridge.h           |   2 +
 cobalt/media/base/sbplayer_interface.cc       |  32 +++++
 cobalt/media/base/sbplayer_interface.h        |  19 +++
 cobalt/media/base/sbplayer_pipeline.cc        | 136 +++++++++++++++---
 cobalt/media/media_module.cc                  |  23 ++-
 cobalt/media/media_module.h                   |   7 +
 cobalt/media/player/web_media_player.h        |   3 +
 cobalt/media/player/web_media_player_impl.cc  |   7 +
 cobalt/media/player/web_media_player_impl.h   |   5 +
 starboard/common/media.cc                     |  49 +++++++
 starboard/common/media.h                      |   4 +
 starboard/linux/shared/BUILD.gn               |   3 +
 .../linux/shared/system_get_extensions.cc     |   6 +
 .../media_set_audio_write_duration_test.cc    |  13 ++
 .../audio_write_ahead/audio_write_ahead.cc    |  45 ++++++
 .../audio_write_ahead/audio_write_ahead.gni   |  22 +++
 .../audio_write_ahead/audio_write_ahead.h     |  28 ++++
 ...ite_ahead_media_get_audio_configuration.cc |  46 ++++++
 ...rite_ahead_media_get_audio_configuration.h |  32 +++++
 ...te_ahead_player_get_audio_configuration.cc |  61 ++++++++
 ...ite_ahead_player_get_audio_configuration.h |  35 +++++
 .../filter/testing/audio_decoder_test.cc      |  25 +++-
 .../chromium/media/filters/chunk_demuxer.cc   |  35 +++++
 .../chromium/media/filters/chunk_demuxer.h    |  11 ++
 36 files changed, 864 insertions(+), 37 deletions(-)
 create mode 100644 cobalt/extension/audio_write_ahead.h
 create mode 100644 starboard/shared/audio_write_ahead/audio_write_ahead.cc
 create mode 100644 starboard/shared/audio_write_ahead/audio_write_ahead.gni
 create mode 100644 starboard/shared/audio_write_ahead/audio_write_ahead.h
 create mode 100644 starboard/shared/audio_write_ahead/audio_write_ahead_media_get_audio_configuration.cc
 create mode 100644 starboard/shared/audio_write_ahead/audio_write_ahead_media_get_audio_configuration.h
 create mode 100644 starboard/shared/audio_write_ahead/audio_write_ahead_player_get_audio_configuration.cc
 create mode 100644 starboard/shared/audio_write_ahead/audio_write_ahead_player_get_audio_configuration.h

diff --git a/cobalt/demos/content/media-element-demo/src/components/player.ts b/cobalt/demos/content/media-element-demo/src/components/player.ts
index 7bd9c1710583..60e3a5c2d7dd 100644
--- a/cobalt/demos/content/media-element-demo/src/components/player.ts
+++ b/cobalt/demos/content/media-element-demo/src/components/player.ts
@@ -25,6 +25,18 @@ export class Player extends Component<Props> {
   /** The <video> element. */
   private videoEl!: HTMLVideoElement;
 
+  /** The video SourceBuffer */
+  private videoSourceBuffer!: SourceBuffer;
+
+  /** The audio SourceBuffer */
+  private audioSourceBuffer!: SourceBuffer;
+
+  /** max(videoSourceBuffer.writeHead - videoEl.currentTime) */
+  private maxVideoWriteHeadDistance!: number;
+
+  /** max(audioSourceBuffer.writeHead - videoEl.currentTime) */
+  private maxAudioWriteHeadDistance!: number;
+
   /** The element displaying video download buffer info. */
   private videoDownloadBufferInfo!: Element;
 
@@ -53,6 +65,8 @@ export class Player extends Component<Props> {
     super(props);
     this.videos = convertToMediaArray(props.video);
     this.audios = convertToMediaArray(props.audio);
+    this.maxVideoWriteHeadDistance = 0;
+    this.maxAudioWriteHeadDistance = 0;
   }
 
   /** @override */
@@ -93,12 +107,37 @@ export class Player extends Component<Props> {
   }
 
   private renderVideoInfo() {
+    var h5vccAudioConnectors = '';
+    try {
+      h5vccAudioConnectors = this.videoEl.h5vccAudioConnectors;
+    } catch (error) {}
     renderComponent(
         VideoInfo, {
           duration: this.videoEl.duration,
           currentTime: this.videoEl.currentTime,
+          audioConnectors: h5vccAudioConnectors,
         },
         this.videoInfo);
+    if (this.videoSourceBuffer) {
+      this.maxVideoWriteHeadDistance =
+          Math.max(this.maxVideoWriteHeadDistance,
+                   this.videoSourceBuffer.writeHead - this.videoEl.currentTime);
+      renderComponent(
+        SourceBufferInfo,
+          {name: 'Video', sourceBuffer: this.videoSourceBuffer,
+           maxWriteHeadDistance: this.maxVideoWriteHeadDistance},
+         this.videoSourceBufferInfo);
+      }
+    if (this.audioSourceBuffer) {
+      this.maxAudioWriteHeadDistance =
+          Math.max(this.maxAudioWriteHeadDistance,
+                   this.audioSourceBuffer.writeHead - this.videoEl.currentTime);
+      renderComponent(
+        SourceBufferInfo,
+        {name: 'Audio', sourceBuffer: this.audioSourceBuffer,
+         maxWriteHeadDistance: this.maxAudioWriteHeadDistance},
+        this.audioSourceBufferInfo);
+    }
   }
 
   private async play() {
@@ -149,7 +188,7 @@ export class Player extends Component<Props> {
 
   /**
    * Plays all videos as adaptive videos.
-   * TODO: dynmaically calculate the source buffer MIME.
+   * TODO: dynamically calculate the source buffer MIME.
    */
   private playAdaptiveVideo() {
     const ms = new MediaSource();
@@ -158,12 +197,7 @@ export class Player extends Component<Props> {
       if (this.videos.length > 0) {
         const videoSourceBuffer =
             ms.addSourceBuffer('video/mp4; codecs="avc1.640028"');
-        videoSourceBuffer.addEventListener('updateend', () => {
-          renderComponent(
-              SourceBufferInfo,
-              {name: 'Video', sourceBuffer: videoSourceBuffer},
-              this.videoSourceBufferInfo);
-        });
+        this.videoSourceBuffer = videoSourceBuffer;
         const downloadBuffer = new DownloadBuffer(this.videos);
         downloadBuffer.register((reportMap) => {
           renderComponent(
@@ -176,12 +210,7 @@ export class Player extends Component<Props> {
       if (this.audios.length > 0) {
         const audioSourceBuffer =
             ms.addSourceBuffer('audio/mp4; codecs="mp4a.40.2"');
-        audioSourceBuffer.addEventListener('updateend', () => {
-          renderComponent(
-              SourceBufferInfo,
-              {name: 'Audio', sourceBuffer: audioSourceBuffer},
-              this.audioSourceBufferInfo);
-        });
+        this.audioSourceBuffer = audioSourceBuffer;
         const downloadBuffer = new DownloadBuffer(this.audios);
         downloadBuffer.register(
             (reportMap) => {renderComponent(
diff --git a/cobalt/demos/content/media-element-demo/src/components/source_buffer_info.ts b/cobalt/demos/content/media-element-demo/src/components/source_buffer_info.ts
index 92343f302a3f..6747f66e0f87 100644
--- a/cobalt/demos/content/media-element-demo/src/components/source_buffer_info.ts
+++ b/cobalt/demos/content/media-element-demo/src/components/source_buffer_info.ts
@@ -1,9 +1,12 @@
 interface Props {
   sourceBuffer: SourceBuffer;
   name: string;
+  maxWriteHeadDistance: number;
 }
 
 /** A component that displays the source buffer info. */
-export function SourceBufferInfo({sourceBuffer, name}: Props) {
-  return `<div>${name} buffered: ${sourceBuffer.buffered.end(0)} sec</div>`;
+export function SourceBufferInfo({sourceBuffer, name, maxWriteHeadDistance}: Props) {
+  return `<div>${name} buffered: ${sourceBuffer.buffered.end(0)} sec` +
+      `, writeHead: ${sourceBuffer.writeHead} sec` +
+      `, maxWriteHeadDistance: ${maxWriteHeadDistance} sec</div>`;
 }
diff --git a/cobalt/demos/content/media-element-demo/src/components/video_info.ts b/cobalt/demos/content/media-element-demo/src/components/video_info.ts
index 3f8306ffbcf6..68012c888a02 100644
--- a/cobalt/demos/content/media-element-demo/src/components/video_info.ts
+++ b/cobalt/demos/content/media-element-demo/src/components/video_info.ts
@@ -1,9 +1,13 @@
 interface Props {
   duration: number;
   currentTime: number;
+  audioConnectors: string;
 }
 
 /** A component that displays video info. */
-export function VideoInfo({duration, currentTime}: Props) {
+export function VideoInfo({duration, currentTime, audioConnectors}: Props) {
+  if (audioConnectors) {
+    return `<div>${currentTime} / ${duration} / audioConnectors: ${audioConnectors}</div>`;
+  }
   return `<div>${currentTime} / ${duration}</div>`;
 }
diff --git a/cobalt/dom/html_media_element.cc b/cobalt/dom/html_media_element.cc
index d516ac84d351..637ef8542603 100644
--- a/cobalt/dom/html_media_element.cc
+++ b/cobalt/dom/html_media_element.cc
@@ -19,6 +19,7 @@
 #include <limits>
 #include <memory>
 #include <utility>
+#include <vector>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ -26,6 +27,7 @@
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
+#include "base/strings/string_util.h"
 #include "base/trace_event/trace_event.h"
 #include "cobalt/base/instance_counter.h"
 #include "cobalt/base/tokens.h"
@@ -36,6 +38,7 @@
 #include "cobalt/dom/media_settings.h"
 #include "cobalt/dom/media_source.h"
 #include "cobalt/dom/media_source_ready_state.h"
+#include "cobalt/extension/audio_write_ahead.h"
 #include "cobalt/loader/fetcher_factory.h"
 #include "cobalt/media/url_fetcher_data_source.h"
 #include "cobalt/media/web_media_player_factory.h"
@@ -45,6 +48,7 @@
 #include "cobalt/web/dom_exception.h"
 #include "cobalt/web/event.h"
 #include "cobalt/web/web_settings.h"
+#include "starboard/system.h"
 
 #include "cobalt/dom/eme/media_encrypted_event.h"
 #include "cobalt/dom/eme/media_encrypted_event_init.h"
@@ -156,6 +160,17 @@ HTMLMediaElement::HTMLMediaElement(Document* document, base::Token tag_name)
       sent_end_event_(false),
       request_mode_(loader::kNoCORSMode) {
   TRACE_EVENT0("cobalt::dom", "HTMLMediaElement::HTMLMediaElement()");
+
+  const CobaltExtensionConfigurableAudioWriteAheadApi* extension_api =
+      static_cast<const CobaltExtensionConfigurableAudioWriteAheadApi*>(
+          SbSystemGetExtension(
+              kCobaltExtensionConfigurableAudioWriteAheadName));
+  if (extension_api) {
+    DCHECK_EQ(extension_api->name,
+              std::string(kCobaltExtensionConfigurableAudioWriteAheadName));
+    DCHECK_EQ(extension_api->version, 1u);
+    audio_write_ahead_extension_enabled_ = true;
+  }
   LOG(INFO) << "Create HTMLMediaElement with volume " << volume_
             << ", playback rate " << playback_rate_ << ".";
   ON_INSTANCE_CREATED(HTMLMediaElement);
@@ -641,6 +656,24 @@ void HTMLMediaElement::ScheduleEvent(const scoped_refptr<web::Event>& event) {
   event_queue_.Enqueue(event);
 }
 
+std::string HTMLMediaElement::h5vcc_audio_connectors(
+    script::ExceptionState* exception_state) const {
+  if (audio_write_ahead_extension_enabled_) {
+    if (!player_) {
+      web::DOMException::Raise(web::DOMException::kInvalidStateErr,
+                               exception_state);
+      return std::string();
+    }
+
+    std::vector<std::string> configs = player_->GetAudioConnectors();
+    return base::JoinString(configs, ";");
+  }
+
+  web::DOMException::Raise(web::DOMException::kNotSupportedErr,
+                           exception_state);
+  return std::string();
+}
+
 void HTMLMediaElement::CreateMediaPlayer() {
   TRACE_EVENT0("cobalt::dom", "HTMLMediaElement::CreateMediaPlayer()");
   LOG(INFO) << "Create media player.";
diff --git a/cobalt/dom/html_media_element.h b/cobalt/dom/html_media_element.h
index 4276fd86a600..35cb2f62cd77 100644
--- a/cobalt/dom/html_media_element.h
+++ b/cobalt/dom/html_media_element.h
@@ -146,6 +146,12 @@ class HTMLMediaElement : public HTMLElement,
   // function won't modify the target of the |event| passed in.
   void ScheduleEvent(const scoped_refptr<web::Event>& event);
 
+  // Returns semicolon separated names of audio connectors, like
+  // "hdmi;bluetooth".
+  // TODO(b/267678497): The current interface is tentative, to be refined.
+  std::string h5vcc_audio_connectors(
+      script::ExceptionState* exception_state) const;
+
   // Set max video capabilities.
   void SetMaxVideoCapabilities(const std::string& max_video_capabilities,
                                script::ExceptionState* exception_state);
@@ -306,6 +312,8 @@ class HTMLMediaElement : public HTMLElement,
 
   loader::RequestMode request_mode_;
 
+  bool audio_write_ahead_extension_enabled_ = false;
+
   DISALLOW_COPY_AND_ASSIGN(HTMLMediaElement);
 };
 
diff --git a/cobalt/dom/html_media_element.idl b/cobalt/dom/html_media_element.idl
index 4a1a509cbff4..401060a6f7b7 100644
--- a/cobalt/dom/html_media_element.idl
+++ b/cobalt/dom/html_media_element.idl
@@ -61,4 +61,10 @@ interface HTMLMediaElement : HTMLElement {
   attribute boolean controls;
   [RaisesException] attribute double volume;
   attribute boolean muted;
+
+  // non standard, semicolon separated names of audio connectors, like
+  // "hdmi;bluetooth".  It raises `NotSupportedError` on apps doesn't support
+  // this feature, or `InvalidStateError` if there isn't an active playback.
+  // TODO(b/267678497): The current interface is tentative, to be refined.
+  [RaisesException] readonly attribute DOMString h5vccAudioConnectors;
 };
diff --git a/cobalt/dom/source_buffer.cc b/cobalt/dom/source_buffer.cc
index 267677b303de..039303fe8a96 100644
--- a/cobalt/dom/source_buffer.cc
+++ b/cobalt/dom/source_buffer.cc
@@ -453,6 +453,17 @@ void SourceBuffer::set_track_defaults(
   track_defaults_ = track_defaults;
 }
 
+double SourceBuffer::write_head(script::ExceptionState* exception_state) const {
+  if (media_source_ == NULL) {
+    web::DOMException::Raise(web::DOMException::kInvalidStateErr,
+                             exception_state);
+    return 0.0;
+  }
+
+  DCHECK(chunk_demuxer_);
+  return chunk_demuxer_->GetWriteHead(id_).InSecondsF();
+}
+
 void SourceBuffer::OnRemovedFromMediaSource() {
   if (media_source_ == NULL) {
     return;
diff --git a/cobalt/dom/source_buffer.h b/cobalt/dom/source_buffer.h
index c61117706d65..76d0aa7792df 100644
--- a/cobalt/dom/source_buffer.h
+++ b/cobalt/dom/source_buffer.h
@@ -134,6 +134,9 @@ class SourceBuffer : public web::EventTarget {
 
   // Custom, not in any spec.
   //
+  // Return the highest presentation timestamp written to SbPlayer.
+  double write_head(script::ExceptionState* exception_state) const;
+
   void OnRemovedFromMediaSource();
   double GetHighestPresentationTimestamp() const;
 
diff --git a/cobalt/dom/source_buffer.idl b/cobalt/dom/source_buffer.idl
index 1fd805351430..bb755e2a5364 100644
--- a/cobalt/dom/source_buffer.idl
+++ b/cobalt/dom/source_buffer.idl
@@ -38,4 +38,10 @@ interface SourceBuffer : EventTarget {
   // [RaisesException] void abort();
   [RaisesException] void remove(double start, unrestricted double end);
   [RaisesException] attribute TrackDefaultList trackDefaults;
+
+  // Non standard interface (b/267678497).
+  // Returns the highest presentation timestamp written to SbPlayer, raises
+  // `InvalidStateError` if the SourceBuffer object has been removed from the
+  // MediaSource object.
+  [RaisesException] readonly attribute double writeHead;
 };
diff --git a/cobalt/extension/audio_write_ahead.h b/cobalt/extension/audio_write_ahead.h
new file mode 100644
index 000000000000..1291b71c33ae
--- /dev/null
+++ b/cobalt/extension/audio_write_ahead.h
@@ -0,0 +1,83 @@
+// Copyright 2023 The Cobalt Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef COBALT_EXTENSION_AUDIO_WRITE_AHEAD_H_
+#define COBALT_EXTENSION_AUDIO_WRITE_AHEAD_H_
+
+#include "starboard/media.h"
+#include "starboard/player.h"
+#include "starboard/time.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define kCobaltExtensionConfigurableAudioWriteAheadName \
+  "dev.cobalt.extension.ConfigurableAudioWriteAhead"
+
+#define kCobaltExtensionPlayerWriteDurationLocal (kSbTimeSecond / 2)
+#define kCobaltExtensionPlayerWriteDurationRemote (kSbTimeSecond * 10)
+
+typedef enum CobaltExtensionMediaAudioConnector {
+  kCobaltExtensionMediaAudioConnectorUnknown,
+
+  kCobaltExtensionMediaAudioConnectorAnalog,
+  kCobaltExtensionMediaAudioConnectorBluetooth,
+  kCobaltExtensionMediaAudioConnectorBuiltIn,
+  kCobaltExtensionMediaAudioConnectorHdmi,
+  kCobaltExtensionMediaAudioConnectorRemoteWired,
+  kCobaltExtensionMediaAudioConnectorRemoteWireless,
+  kCobaltExtensionMediaAudioConnectorRemoteOther,
+  kCobaltExtensionMediaAudioConnectorSpdif,
+  kCobaltExtensionMediaAudioConnectorUsb,
+
+} CobaltExtensionMediaAudioConnector;
+
+typedef struct CobaltExtensionMediaAudioConfiguration {
+  CobaltExtensionMediaAudioConnector connector;
+
+  SbTime latency;
+
+  SbMediaAudioCodingType coding_type;
+
+  int number_of_channels;
+
+} CobaltExtensionMediaAudioConfiguration;
+
+typedef struct CobaltExtensionConfigurableAudioWriteAheadApi {
+  // Name should be the string
+  // |kCobaltExtensionConfigurableAudioWriteAheadName|. This helps to validate
+  // that the extension API is correct.
+  const char* name;
+
+  // This specifies the version of the API that is implemented.
+  uint32_t version;
+
+  // The fields below this point were added in version 1 or later.
+
+  bool (*MediaGetAudioConfiguration)(
+      int output_index,
+      CobaltExtensionMediaAudioConfiguration* out_configuration);
+
+  bool (*PlayerGetAudioConfiguration)(
+      SbPlayer player, int index,
+      CobaltExtensionMediaAudioConfiguration* out_audio_configuration);
+
+} CobaltExtensionConfigurableAudioWriteAheadApi;
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // COBALT_EXTENSION_AUDIO_WRITE_AHEAD_H_
diff --git a/cobalt/media/base/pipeline.h b/cobalt/media/base/pipeline.h
index ccb3a1bca89c..d2d82960b409 100644
--- a/cobalt/media/base/pipeline.h
+++ b/cobalt/media/base/pipeline.h
@@ -98,6 +98,7 @@ class MEDIA_EXPORT Pipeline : public base::RefCountedThreadSafe<Pipeline> {
       const GetDecodeTargetGraphicsContextProviderFunc&
           get_decode_target_graphics_context_provider_func,
       bool allow_resume_after_suspend, bool allow_batched_sample_write,
+      SbTime audio_write_duration_local, SbTime audio_write_duration_remote,
       MediaLog* media_log, DecodeTargetProvider* decode_target_provider);
 
   virtual ~Pipeline() {}
@@ -217,6 +218,9 @@ class MEDIA_EXPORT Pipeline : public base::RefCountedThreadSafe<Pipeline> {
   // be 0.
   virtual void GetNaturalVideoSize(gfx::Size* out_size) const = 0;
 
+  // Gets the names of audio connectors used by the audio output.
+  virtual std::vector<std::string> GetAudioConnectors() const = 0;
+
   // Return true if loading progress has been made since the last time this
   // method was called.
   virtual bool DidLoadingProgress() const = 0;
diff --git a/cobalt/media/base/sbplayer_bridge.cc b/cobalt/media/base/sbplayer_bridge.cc
index 10674e3b9908..7d45642613fe 100644
--- a/cobalt/media/base/sbplayer_bridge.cc
+++ b/cobalt/media/base/sbplayer_bridge.cc
@@ -370,6 +370,36 @@ void SbPlayerBridge::GetInfo(uint32* video_frames_decoded,
   GetInfo_Locked(video_frames_decoded, video_frames_dropped, media_time);
 }
 
+std::vector<CobaltExtensionMediaAudioConfiguration>
+SbPlayerBridge::GetAudioConfigurations() {
+  DCHECK(sbplayer_interface_->IsAudioWriteAheadExtensionEnabled());
+  base::AutoLock auto_lock(lock_);
+
+  if (!SbPlayerIsValid(player_)) {
+    return std::vector<CobaltExtensionMediaAudioConfiguration>();
+  }
+
+  std::vector<CobaltExtensionMediaAudioConfiguration> configurations;
+
+  // Set a limit to avoid infinite loop.
+  constexpr int kMaxAudioConfigurations = 32;
+
+  for (int i = 0; i < kMaxAudioConfigurations; ++i) {
+    CobaltExtensionMediaAudioConfiguration configuration;
+    if (!sbplayer_interface_->GetAudioConfiguration(player_, i,
+                                                    &configuration)) {
+      break;
+    }
+
+    configurations.push_back(configuration);
+  }
+
+  LOG_IF(WARNING, configurations.empty())
+      << "Failed to find any audio configurations.";
+
+  return configurations;
+}
+
 #if SB_HAS(PLAYER_WITH_URL)
 void SbPlayerBridge::GetUrlPlayerBufferedTimeRanges(
     base::TimeDelta* buffer_start_time, base::TimeDelta* buffer_length_time) {
diff --git a/cobalt/media/base/sbplayer_bridge.h b/cobalt/media/base/sbplayer_bridge.h
index efb6ea8e803e..80f1215c988e 100644
--- a/cobalt/media/base/sbplayer_bridge.h
+++ b/cobalt/media/base/sbplayer_bridge.h
@@ -24,6 +24,7 @@
 #include "base/message_loop/message_loop.h"
 #include "base/synchronization/lock.h"
 #include "base/time/time.h"
+#include "cobalt/extension/audio_write_ahead.h"
 #include "cobalt/media/base/cval_stats.h"
 #include "cobalt/media/base/decode_target_provider.h"
 #include "cobalt/media/base/decoder_buffer_cache.h"
@@ -115,6 +116,7 @@ class SbPlayerBridge {
   void SetPlaybackRate(double playback_rate);
   void GetInfo(uint32* video_frames_decoded, uint32* video_frames_dropped,
                base::TimeDelta* media_time);
+  std::vector<CobaltExtensionMediaAudioConfiguration> GetAudioConfigurations();
 
 #if SB_HAS(PLAYER_WITH_URL)
   void GetUrlPlayerBufferedTimeRanges(base::TimeDelta* buffer_start_time,
diff --git a/cobalt/media/base/sbplayer_interface.cc b/cobalt/media/base/sbplayer_interface.cc
index 7c44daee6e0c..968d526f3e29 100644
--- a/cobalt/media/base/sbplayer_interface.cc
+++ b/cobalt/media/base/sbplayer_interface.cc
@@ -14,9 +14,29 @@
 
 #include "cobalt/media/base/sbplayer_interface.h"
 
+#include <string>
+
 namespace cobalt {
 namespace media {
 
+DefaultSbPlayerInterface::DefaultSbPlayerInterface() {
+  const CobaltExtensionConfigurableAudioWriteAheadApi* extension_api =
+      static_cast<const CobaltExtensionConfigurableAudioWriteAheadApi*>(
+          SbSystemGetExtension(
+              kCobaltExtensionConfigurableAudioWriteAheadName));
+  if (!extension_api) {
+    return;
+  }
+
+  DCHECK_EQ(extension_api->name,
+            std::string(kCobaltExtensionConfigurableAudioWriteAheadName));
+  DCHECK_EQ(extension_api->version, 1u);
+  DCHECK_NE(extension_api->PlayerGetAudioConfiguration, nullptr);
+
+  audio_write_duration_player_get_audio_configuration_ =
+      extension_api->PlayerGetAudioConfiguration;
+}
+
 SbPlayer DefaultSbPlayerInterface::Create(
     SbWindow window, const SbPlayerCreationParam* creation_param,
     SbPlayerDeallocateSampleFunc sample_deallocate_func,
@@ -109,5 +129,17 @@ void DefaultSbPlayerInterface::GetUrlPlayerExtraInfo(
 }
 #endif  // SB_HAS(PLAYER_WITH_URL)
 
+bool DefaultSbPlayerInterface::IsAudioWriteAheadExtensionEnabled() const {
+  return audio_write_duration_player_get_audio_configuration_ != nullptr;
+}
+
+bool DefaultSbPlayerInterface::GetAudioConfiguration(
+    SbPlayer player, int index,
+    CobaltExtensionMediaAudioConfiguration* out_audio_configuration) {
+  DCHECK(IsAudioWriteAheadExtensionEnabled());
+  return audio_write_duration_player_get_audio_configuration_(
+      player, index, out_audio_configuration);
+}
+
 }  // namespace media
 }  // namespace cobalt
diff --git a/cobalt/media/base/sbplayer_interface.h b/cobalt/media/base/sbplayer_interface.h
index e79c1e65fc8b..751ff11cc18a 100644
--- a/cobalt/media/base/sbplayer_interface.h
+++ b/cobalt/media/base/sbplayer_interface.h
@@ -15,6 +15,7 @@
 #ifndef COBALT_MEDIA_BASE_SBPLAYER_INTERFACE_H_
 #define COBALT_MEDIA_BASE_SBPLAYER_INTERFACE_H_
 
+#include "cobalt/extension/audio_write_ahead.h"
 #include "cobalt/media/base/cval_stats.h"
 #include "starboard/player.h"
 
@@ -68,6 +69,11 @@ class SbPlayerInterface {
       SbPlayer player, SbUrlPlayerExtraInfo* out_url_player_info) = 0;
 #endif  // SB_HAS(PLAYER_WITH_URL)
 
+  virtual bool IsAudioWriteAheadExtensionEnabled() const = 0;
+  virtual bool GetAudioConfiguration(
+      SbPlayer player, int index,
+      CobaltExtensionMediaAudioConfiguration* out_audio_configuration) = 0;
+
   // disabled by default, but can be enabled via h5vcc setting.
   void EnableCValStats(bool should_enable) {
     cval_stats_.Enable(should_enable);
@@ -77,6 +83,8 @@ class SbPlayerInterface {
 
 class DefaultSbPlayerInterface final : public SbPlayerInterface {
  public:
+  DefaultSbPlayerInterface();
+
   SbPlayer Create(
       SbWindow window, const SbPlayerCreationParam* creation_param,
       SbPlayerDeallocateSampleFunc sample_deallocate_func,
@@ -113,6 +121,17 @@ class DefaultSbPlayerInterface final : public SbPlayerInterface {
   void GetUrlPlayerExtraInfo(
       SbPlayer player, SbUrlPlayerExtraInfo* out_url_player_info) override;
 #endif  // SB_HAS(PLAYER_WITH_URL)
+
+  bool IsAudioWriteAheadExtensionEnabled() const override;
+  bool GetAudioConfiguration(
+      SbPlayer player, int index,
+      CobaltExtensionMediaAudioConfiguration* out_audio_configuration) override;
+
+ private:
+  bool (*audio_write_duration_player_get_audio_configuration_)(
+      SbPlayer player, int index,
+      CobaltExtensionMediaAudioConfiguration* out_audio_configuration) =
+      nullptr;
 };
 
 
diff --git a/cobalt/media/base/sbplayer_pipeline.cc b/cobalt/media/base/sbplayer_pipeline.cc
index 958a34031896..016734fc8666 100644
--- a/cobalt/media/base/sbplayer_pipeline.cc
+++ b/cobalt/media/base/sbplayer_pipeline.cc
@@ -30,12 +30,14 @@
 #include "base/trace_event/trace_event.h"
 #include "cobalt/base/c_val.h"
 #include "cobalt/base/startup_timer.h"
+#include "cobalt/extension/audio_write_ahead.h"
 #include "cobalt/math/size.h"
 #include "cobalt/media/base/media_export.h"
 #include "cobalt/media/base/pipeline.h"
 #include "cobalt/media/base/playback_statistics.h"
 #include "cobalt/media/base/sbplayer_bridge.h"
 #include "cobalt/media/base/sbplayer_set_bounds_helper.h"
+#include "starboard/common/media.h"
 #include "starboard/common/string.h"
 #include "starboard/configuration_constants.h"
 #include "starboard/time.h"
@@ -66,6 +68,7 @@ using ::media::DemuxerStream;
 using ::media::PipelineStatistics;
 using ::media::PipelineStatusCallback;
 using ::media::VideoDecoderConfig;
+using ::starboard::GetCobaltExtensionMediaAudioConnectorName;
 
 static const int kRetryDelayAtSuspendInMilliseconds = 100;
 
@@ -90,6 +93,35 @@ struct StartTaskParameters {
 #endif  // SB_HAS(PLAYER_WITH_URL)
 };
 
+bool HasRemoteAudioOutputs(
+    const std::vector<CobaltExtensionMediaAudioConfiguration>& configurations) {
+  for (auto&& configuration : configurations) {
+    const auto connector = configuration.connector;
+    switch (connector) {
+      case kCobaltExtensionMediaAudioConnectorUnknown:
+      case kCobaltExtensionMediaAudioConnectorAnalog:
+      case kCobaltExtensionMediaAudioConnectorBuiltIn:
+      case kCobaltExtensionMediaAudioConnectorHdmi:
+      case kCobaltExtensionMediaAudioConnectorSpdif:
+      case kCobaltExtensionMediaAudioConnectorUsb:
+        LOG(INFO) << "Encountered local audio connector: "
+                  << GetCobaltExtensionMediaAudioConnectorName(connector);
+        break;
+      case kCobaltExtensionMediaAudioConnectorBluetooth:
+      case kCobaltExtensionMediaAudioConnectorRemoteWired:
+      case kCobaltExtensionMediaAudioConnectorRemoteWireless:
+      case kCobaltExtensionMediaAudioConnectorRemoteOther:
+        LOG(INFO) << "Encountered remote audio connector: "
+                  << GetCobaltExtensionMediaAudioConnectorName(connector);
+        return true;
+    }
+  }
+
+  LOG(INFO) << "No remote audio outputs found.";
+
+  return false;
+}
+
 // SbPlayerPipeline is a PipelineBase implementation that uses the SbPlayer
 // interface internally.
 class MEDIA_EXPORT SbPlayerPipeline : public Pipeline,
@@ -103,6 +135,7 @@ class MEDIA_EXPORT SbPlayerPipeline : public Pipeline,
       const GetDecodeTargetGraphicsContextProviderFunc&
           get_decode_target_graphics_context_provider_func,
       bool allow_resume_after_suspend, bool allow_batched_sample_write,
+      SbTime audio_write_duration_local, SbTime audio_write_duration_remote,
       MediaLog* media_log, DecodeTargetProvider* decode_target_provider);
   ~SbPlayerPipeline() override;
 
@@ -148,6 +181,7 @@ class MEDIA_EXPORT SbPlayerPipeline : public Pipeline,
   TimeDelta GetMediaStartDate() const override;
 #endif  // SB_HAS(PLAYER_WITH_URL)
   void GetNaturalVideoSize(gfx::Size* out_size) const override;
+  std::vector<std::string> GetAudioConnectors() const override;
 
   bool DidLoadingProgress() const override;
   PipelineStatistics GetStatistics() const override;
@@ -322,19 +356,29 @@ class MEDIA_EXPORT SbPlayerPipeline : public Pipeline,
 
   DecodeTargetProvider* decode_target_provider_;
 
+  // The following two variables are used only when the Configurable Audio Write
+  // Ahead extension is enabled.
+  const SbTime audio_write_duration_local_;
+  const SbTime audio_write_duration_remote_;
+
+  // When the Configurable Audio Write Ahead extension is enabled,
+  // the two variables below should always contain the same value.
+  //
   // Read audio from the stream if |timestamp_of_last_written_audio_| is less
-  // than |seek_time_| + |kAudioPrerollLimit|, this effectively allows 10
-  // seconds of audio to be written to the SbPlayer after playback startup or
-  // seek.
-  static const SbTime kAudioPrerollLimit = 10 * kSbTimeSecond;
-  // Don't read audio from the stream more than |kAudioLimit| ahead of the
-  // current media time during playing.
-  static const SbTime kAudioLimit = kSbTimeSecond;
+  // than |seek_time_| + |audio_write_duration_for_preroll_|, this effectively
+  // allows 10 seconds of audio to be written to the SbPlayer after playback
+  // startup or seek.
+  SbTime audio_write_duration_;
+  // Don't read audio from the stream more than |audio_write_duration_| ahead of
+  // the current media time during playing.
+  SbTime audio_write_duration_for_preroll_;
+
   // Only call GetMediaTime() from OnNeedData if it has been
   // |kMediaTimeCheckInterval| since the last call to GetMediaTime().
   static const SbTime kMediaTimeCheckInterval = 0.1 * kSbTimeSecond;
   // Timestamp for the last written audio.
   SbTime timestamp_of_last_written_audio_ = 0;
+
   // Last media time reported by GetMediaTime().
   base::CVal<SbTime> last_media_time_;
   // Time when we last checked the media time.
@@ -357,6 +401,7 @@ SbPlayerPipeline::SbPlayerPipeline(
     const GetDecodeTargetGraphicsContextProviderFunc&
         get_decode_target_graphics_context_provider_func,
     bool allow_resume_after_suspend, bool allow_batched_sample_write,
+    SbTime audio_write_duration_local, SbTime audio_write_duration_remote,
     MediaLog* media_log, DecodeTargetProvider* decode_target_provider)
     : pipeline_identifier_(
           base::StringPrintf("%X", g_pipeline_identifier_counter++)),
@@ -398,6 +443,8 @@ SbPlayerPipeline::SbPlayerPipeline(
                     kSbPlayerStateInitialized,
                     "The underlying SbPlayer state of the media pipeline."),
       decode_target_provider_(decode_target_provider),
+      audio_write_duration_local_(audio_write_duration_local),
+      audio_write_duration_remote_(audio_write_duration_remote),
       last_media_time_(base::StringPrintf("Media.Pipeline.%s.LastMediaTime",
                                           pipeline_identifier_.c_str()),
                        0, "Last media time reported by the underlying player."),
@@ -406,7 +453,15 @@ SbPlayerPipeline::SbPlayerPipeline(
                              pipeline_identifier_.c_str()),
           "", "The max video capabilities required for the media pipeline."),
       playback_statistics_(pipeline_identifier_) {
-  SbMediaSetAudioWriteDuration(kAudioLimit);
+  DCHECK(sbplayer_interface_);
+  if (!sbplayer_interface_->IsAudioWriteAheadExtensionEnabled()) {
+    audio_write_duration_ = kSbTimeSecond;
+    audio_write_duration_for_preroll_ = 10 * kSbTimeSecond;
+    SbMediaSetAudioWriteDuration(audio_write_duration_);
+    LOG(INFO) << "Setting audio write duration to " << audio_write_duration_
+              << ", the duration during preroll is "
+              << audio_write_duration_for_preroll_;
+  }
 }
 
 SbPlayerPipeline::~SbPlayerPipeline() { DCHECK(!player_bridge_); }
@@ -782,6 +837,27 @@ void SbPlayerPipeline::GetNaturalVideoSize(gfx::Size* out_size) const {
   *out_size = natural_size_;
 }
 
+std::vector<std::string> SbPlayerPipeline::GetAudioConnectors() const {
+  if (sbplayer_interface_->IsAudioWriteAheadExtensionEnabled()) {
+    base::AutoLock auto_lock(lock_);
+    if (!player_bridge_) {
+      return std::vector<std::string>();
+    }
+
+    std::vector<std::string> connectors;
+
+    auto configurations = player_bridge_->GetAudioConfigurations();
+    for (auto&& configuration : configurations) {
+      connectors.push_back(
+          GetCobaltExtensionMediaAudioConnectorName(configuration.connector));
+    }
+
+    return connectors;
+  }
+
+  return std::vector<std::string>();
+}
+
 bool SbPlayerPipeline::DidLoadingProgress() const {
   base::AutoLock auto_lock(lock_);
   bool ret = did_loading_progress_;
@@ -1037,6 +1113,18 @@ void SbPlayerPipeline::CreatePlayer(SbDrmSystem drm_system) {
         *decode_to_texture_output_mode_, decode_target_provider_,
         max_video_capabilities_, pipeline_identifier_));
     if (player_bridge_->IsValid()) {
+      if (sbplayer_interface_->IsAudioWriteAheadExtensionEnabled()) {
+        // TODO(b/267678497): When `player_bridge_->GetAudioConfigurations()`
+        // returns no audio configurations, update the write durations again
+        // before the SbPlayer reaches `kSbPlayerStatePresenting`.
+        audio_write_duration_for_preroll_ = audio_write_duration_ =
+            HasRemoteAudioOutputs(player_bridge_->GetAudioConfigurations())
+                ? audio_write_duration_remote_
+                : audio_write_duration_local_;
+        LOG(INFO) << "SbPlayerBridge created, with audio write duration at "
+                  << audio_write_duration_for_preroll_;
+      }
+
       SetPlaybackRateTask(playback_rate_);
       SetVolumeTask(volume_);
     } else {
@@ -1270,17 +1358,18 @@ void SbPlayerPipeline::OnNeedData(DemuxerStream::Type type,
       GetMediaTime();
     }
 
-    // Delay reading audio more than |kAudioLimit| ahead of playback after the
-    // player has received enough audio for preroll, taking into account that
-    // our estimate of playback time might be behind by
+    // Delay reading audio more than |audio_write_duration_| ahead of playback
+    // after the player has received enough audio for preroll, taking into
+    // account that our estimate of playback time might be behind by
     // |kMediaTimeCheckInterval|.
     if (timestamp_of_last_written_audio_ - seek_time_.ToSbTime() >
-        kAudioPrerollLimit) {
+        audio_write_duration_for_preroll_) {
       // The estimated time ahead of playback may be negative if no audio has
       // been written.
       SbTime time_ahead_of_playback =
           timestamp_of_last_written_audio_ - last_media_time_;
-      if (time_ahead_of_playback > (kAudioLimit + kMediaTimeCheckInterval)) {
+      if (time_ahead_of_playback >
+          (audio_write_duration_ + kMediaTimeCheckInterval)) {
         task_runner_->PostDelayedTask(
             FROM_HERE,
             base::Bind(&SbPlayerPipeline::DelayedNeedData, this, max_buffers),
@@ -1350,6 +1439,15 @@ void SbPlayerPipeline::OnPlayerStatus(SbPlayerState state) {
         playback_statistics_.OnPresenting(
             video_stream_->video_decoder_config());
       }
+      if (sbplayer_interface_->IsAudioWriteAheadExtensionEnabled()) {
+        audio_write_duration_for_preroll_ = audio_write_duration_ =
+            HasRemoteAudioOutputs(player_bridge_->GetAudioConfigurations())
+                ? audio_write_duration_remote_
+                : audio_write_duration_local_;
+        LOG(INFO)
+            << "SbPlayerBridge reaches kSbPlayerStatePresenting, with audio"
+            << " write duration at " << audio_write_duration_;
+      }
       break;
     }
     case kSbPlayerStateEndOfStream:
@@ -1606,12 +1704,14 @@ scoped_refptr<Pipeline> Pipeline::Create(
     const GetDecodeTargetGraphicsContextProviderFunc&
         get_decode_target_graphics_context_provider_func,
     bool allow_resume_after_suspend, bool allow_batched_sample_write,
+    SbTime audio_write_duration_local, SbTime audio_write_duration_remote,
     MediaLog* media_log, DecodeTargetProvider* decode_target_provider) {
-  return new SbPlayerPipeline(interface, window, task_runner,
-                              get_decode_target_graphics_context_provider_func,
-                              allow_resume_after_suspend,
-                              allow_batched_sample_write, media_log,
-                              decode_target_provider);
+  return new SbPlayerPipeline(
+      interface, window, task_runner,
+      get_decode_target_graphics_context_provider_func,
+      allow_resume_after_suspend, allow_batched_sample_write,
+      audio_write_duration_local, audio_write_duration_remote, media_log,
+      decode_target_provider);
 }
 
 }  // namespace media
diff --git a/cobalt/media/media_module.cc b/cobalt/media/media_module.cc
index 95965a5bb2b8..aedc5c6f55a7 100644
--- a/cobalt/media/media_module.cc
+++ b/cobalt/media/media_module.cc
@@ -194,6 +194,18 @@ bool MediaModule::SetConfiguration(const std::string& name, int32 value) {
     LOG(INFO) << (value ? "Enabling" : "Disabling")
               << " media metrics collection.";
     return true;
+  } else if (sbplayer_interface_->IsAudioWriteAheadExtensionEnabled()) {
+    if (name == "AudioWriteDurationLocal" && value > 0) {
+      audio_write_duration_local_ = value;
+      LOG(INFO) << "Set AudioWriteDurationLocal to "
+                << audio_write_duration_local_;
+      return true;
+    } else if (name == "AudioWriteDurationRemote" && value > 0) {
+      audio_write_duration_remote_ = value;
+      LOG(INFO) << "Set AudioWriteDurationRemote to "
+                << audio_write_duration_remote_;
+      return true;
+    }
   }
   return false;
 }
@@ -206,12 +218,21 @@ std::unique_ptr<WebMediaPlayer> MediaModule::CreateWebMediaPlayer(
     window = system_window_->GetSbWindow();
   }
 
+  SbTime audio_write_duration_local = -1;
+  SbTime audio_write_duration_remote = -1;
+
+  if (sbplayer_interface_->IsAudioWriteAheadExtensionEnabled()) {
+    audio_write_duration_local = audio_write_duration_local_;
+    audio_write_duration_remote = audio_write_duration_remote_;
+  }
+
   return std::unique_ptr<WebMediaPlayer>(new media::WebMediaPlayerImpl(
       sbplayer_interface_.get(), window,
       base::Bind(&MediaModule::GetSbDecodeTargetGraphicsContextProvider,
                  base::Unretained(this)),
       client, this, options_.allow_resume_after_suspend,
-      allow_batched_sample_write_, &media_log_));
+      allow_batched_sample_write_, audio_write_duration_local,
+      audio_write_duration_remote, &media_log_));
 }
 
 void MediaModule::Suspend() {
diff --git a/cobalt/media/media_module.h b/cobalt/media/media_module.h
index 6ca47b80714b..f4c25941ee30 100644
--- a/cobalt/media/media_module.h
+++ b/cobalt/media/media_module.h
@@ -24,6 +24,7 @@
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/optional.h"
+#include "cobalt/extension/audio_write_ahead.h"
 #include "cobalt/math/size.h"
 #include "cobalt/media/base/sbplayer_interface.h"
 #include "cobalt/media/can_play_type_handler.h"
@@ -123,6 +124,12 @@ class MediaModule : public WebMediaPlayerFactory,
 
   bool allow_batched_sample_write_ = false;
 
+  // The following two variables are used only when the Configurable Audio Write
+  // Ahead extension is enabled.
+  SbTime audio_write_duration_local_ = kCobaltExtensionPlayerWriteDurationLocal;
+  SbTime audio_write_duration_remote_ =
+      kCobaltExtensionPlayerWriteDurationRemote;
+
   DecoderBufferAllocator decoder_buffer_allocator_;
 };
 
diff --git a/cobalt/media/player/web_media_player.h b/cobalt/media/player/web_media_player.h
index 132247345bae..459ec6ed0b86 100644
--- a/cobalt/media/player/web_media_player.h
+++ b/cobalt/media/player/web_media_player.h
@@ -130,6 +130,9 @@ class WebMediaPlayer {
   virtual int GetNaturalWidth() const = 0;
   virtual int GetNaturalHeight() const = 0;
 
+  // Names of audio connectors used by the playback.
+  virtual std::vector<std::string> GetAudioConnectors() const = 0;
+
   // Getters of playback state.
   virtual bool IsPaused() const = 0;
   virtual bool IsSeeking() const = 0;
diff --git a/cobalt/media/player/web_media_player_impl.cc b/cobalt/media/player/web_media_player_impl.cc
index 8073366cb2ca..8f9ba9af87a7 100644
--- a/cobalt/media/player/web_media_player_impl.cc
+++ b/cobalt/media/player/web_media_player_impl.cc
@@ -118,6 +118,7 @@ WebMediaPlayerImpl::WebMediaPlayerImpl(
         get_decode_target_graphics_context_provider_func,
     WebMediaPlayerClient* client, WebMediaPlayerDelegate* delegate,
     bool allow_resume_after_suspend, bool allow_batched_sample_write,
+    SbTime audio_write_duration_local, SbTime audio_write_duration_remote,
     ::media::MediaLog* const media_log)
     : pipeline_thread_("media_pipeline"),
       network_state_(WebMediaPlayer::kNetworkStateEmpty),
@@ -146,6 +147,7 @@ WebMediaPlayerImpl::WebMediaPlayerImpl(
       Pipeline::Create(interface, window, pipeline_thread_.task_runner(),
                        get_decode_target_graphics_context_provider_func,
                        allow_resume_after_suspend_, allow_batched_sample_write_,
+                       audio_write_duration_local, audio_write_duration_remote,
                        media_log_, decode_target_provider_.get());
 
   // Also we want to be notified of |main_loop_| destruction.
@@ -428,6 +430,11 @@ int WebMediaPlayerImpl::GetNaturalHeight() const {
   return size.height();
 }
 
+std::vector<std::string> WebMediaPlayerImpl::GetAudioConnectors() const {
+  DCHECK_EQ(main_loop_, base::MessageLoop::current());
+  return pipeline_->GetAudioConnectors();
+}
+
 bool WebMediaPlayerImpl::IsPaused() const {
   DCHECK_EQ(main_loop_, base::MessageLoop::current());
 
diff --git a/cobalt/media/player/web_media_player_impl.h b/cobalt/media/player/web_media_player_impl.h
index b64f318dc39f..9139ce82e5f0 100644
--- a/cobalt/media/player/web_media_player_impl.h
+++ b/cobalt/media/player/web_media_player_impl.h
@@ -110,6 +110,8 @@ class WebMediaPlayerImpl : public WebMediaPlayer,
                      WebMediaPlayerDelegate* delegate,
                      bool allow_resume_after_suspend,
                      bool allow_batched_sample_write,
+                     SbTime audio_write_duration_local,
+                     SbTime audio_write_duration_remote,
                      ::media::MediaLog* const media_log);
   ~WebMediaPlayerImpl() override;
 
@@ -146,6 +148,9 @@ class WebMediaPlayerImpl : public WebMediaPlayer,
   int GetNaturalWidth() const override;
   int GetNaturalHeight() const override;
 
+  // Names of audio connectors used by the playback.
+  std::vector<std::string> GetAudioConnectors() const override;
+
   // Getters of playback state.
   bool IsPaused() const override;
   bool IsSeeking() const override;
diff --git a/starboard/common/media.cc b/starboard/common/media.cc
index eb74ac84b227..f9cdac043958 100644
--- a/starboard/common/media.cc
+++ b/starboard/common/media.cc
@@ -639,6 +639,55 @@ const char* GetMediaVideoCodecName(SbMediaVideoCodec codec) {
   return "invalid";
 }
 
+const char* GetMediaAudioConnectorName(SbMediaAudioConnector connector) {
+  switch (connector) {
+    case kSbMediaAudioConnectorNone:
+      return "none";
+    case kSbMediaAudioConnectorAnalog:
+      return "analog";
+    case kSbMediaAudioConnectorBluetooth:
+      return "bluetooth";
+    case kSbMediaAudioConnectorHdmi:
+      return "hdmi";
+    case kSbMediaAudioConnectorNetwork:
+      return "network";
+    case kSbMediaAudioConnectorSpdif:
+      return "spdif";
+    case kSbMediaAudioConnectorUsb:
+      return "usb";
+  }
+  SB_NOTREACHED();
+  return "invalid";
+}
+
+const char* GetCobaltExtensionMediaAudioConnectorName(
+    CobaltExtensionMediaAudioConnector connector) {
+  switch (connector) {
+    case kCobaltExtensionMediaAudioConnectorUnknown:
+      return "unknown";
+    case kCobaltExtensionMediaAudioConnectorAnalog:
+      return "analog";
+    case kCobaltExtensionMediaAudioConnectorBluetooth:
+      return "bluetooth";
+    case kCobaltExtensionMediaAudioConnectorBuiltIn:
+      return "builtin";
+    case kCobaltExtensionMediaAudioConnectorHdmi:
+      return "hdmi";
+    case kCobaltExtensionMediaAudioConnectorRemoteWired:
+      return "remote-wired";
+    case kCobaltExtensionMediaAudioConnectorRemoteWireless:
+      return "remote-wireless";
+    case kCobaltExtensionMediaAudioConnectorRemoteOther:
+      return "remote-other";
+    case kCobaltExtensionMediaAudioConnectorSpdif:
+      return "spdif";
+    case kCobaltExtensionMediaAudioConnectorUsb:
+      return "usb";
+  }
+  SB_NOTREACHED();
+  return "invalid";
+}
+
 const char* GetMediaPrimaryIdName(SbMediaPrimaryId primary_id) {
   switch (primary_id) {
     case kSbMediaPrimaryIdReserved0:
diff --git a/starboard/common/media.h b/starboard/common/media.h
index a51641e6b41e..401551d6da9f 100644
--- a/starboard/common/media.h
+++ b/starboard/common/media.h
@@ -17,12 +17,16 @@
 
 #include <ostream>
 
+#include "cobalt/extension/audio_write_ahead.h"
 #include "starboard/media.h"
 
 namespace starboard {
 
 const char* GetMediaAudioCodecName(SbMediaAudioCodec codec);
 const char* GetMediaVideoCodecName(SbMediaVideoCodec codec);
+const char* GetMediaAudioConnectorName(SbMediaAudioConnector connector);
+const char* GetCobaltExtensionMediaAudioConnectorName(
+    CobaltExtensionMediaAudioConnector connector);
 const char* GetMediaPrimaryIdName(SbMediaPrimaryId primary_id);
 const char* GetMediaTransferIdName(SbMediaTransferId transfer_id);
 const char* GetMediaMatrixIdName(SbMediaMatrixId matrix_id);
diff --git a/starboard/linux/shared/BUILD.gn b/starboard/linux/shared/BUILD.gn
index f0974046e90d..227f5741dadd 100644
--- a/starboard/linux/shared/BUILD.gn
+++ b/starboard/linux/shared/BUILD.gn
@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import("//starboard/shared/audio_write_ahead/audio_write_ahead.gni")
 import("//starboard/shared/starboard/media/media_tests.gni")
 import("//starboard/shared/starboard/player/buildfiles.gni")
 import("//starboard/shared/starboard/player/player_tests.gni")
@@ -397,6 +398,8 @@ static_library("starboard_platform_sources") {
 
   sources += common_player_sources
 
+  sources += audio_write_ahead_sources
+
   sources -= [ "//starboard/shared/starboard/player/player_set_bounds.cc" ]
 
   configs += [
diff --git a/starboard/linux/shared/system_get_extensions.cc b/starboard/linux/shared/system_get_extensions.cc
index fba44bd83382..5697e9fe449a 100644
--- a/starboard/linux/shared/system_get_extensions.cc
+++ b/starboard/linux/shared/system_get_extensions.cc
@@ -14,6 +14,7 @@
 
 #include "starboard/system.h"
 
+#include "cobalt/extension/audio_write_ahead.h"
 #include "cobalt/extension/configuration.h"
 #include "cobalt/extension/crash_handler.h"
 #include "cobalt/extension/demuxer.h"
@@ -22,6 +23,7 @@
 #include "cobalt/extension/platform_service.h"
 #include "starboard/common/string.h"
 #include "starboard/linux/shared/soft_mic_platform_service.h"
+#include "starboard/shared/audio_write_ahead/audio_write_ahead.h"
 #include "starboard/shared/ffmpeg/ffmpeg_demuxer.h"
 #include "starboard/shared/posix/free_space.h"
 #include "starboard/shared/posix/memory_mapped_file.h"
@@ -59,6 +61,10 @@ const void* SbSystemGetExtension(const char* name) {
   if (strcmp(name, kCobaltExtensionFreeSpaceName) == 0) {
     return starboard::shared::posix::GetFreeSpaceApi();
   }
+  if (strcmp(name, kCobaltExtensionConfigurableAudioWriteAheadName) == 0) {
+    return starboard::shared::audio_write_ahead::
+        GetConfigurableAudioWriteAheadApi();
+  }
   if (strcmp(name, kCobaltExtensionDemuxerApi) == 0) {
     auto command_line =
         starboard::shared::starboard::Application::Get()->GetCommandLine();
diff --git a/starboard/nplb/media_set_audio_write_duration_test.cc b/starboard/nplb/media_set_audio_write_duration_test.cc
index 84ff9b2df63d..326caa2a2e73 100644
--- a/starboard/nplb/media_set_audio_write_duration_test.cc
+++ b/starboard/nplb/media_set_audio_write_duration_test.cc
@@ -14,6 +14,7 @@
 
 #include "starboard/media.h"
 
+#include "cobalt/extension/audio_write_ahead.h"
 #include "starboard/common/optional.h"
 #include "starboard/common/spin_lock.h"
 #include "starboard/configuration_constants.h"
@@ -147,6 +148,18 @@ class SbMediaSetAudioWriteDurationTest
     int ticket;
   };
 
+  void SetUp() override {
+    const CobaltExtensionConfigurableAudioWriteAheadApi* extension_api =
+        static_cast<const CobaltExtensionConfigurableAudioWriteAheadApi*>(
+            SbSystemGetExtension(
+                kCobaltExtensionConfigurableAudioWriteAheadName));
+    if (!extension_api) {
+      return;
+    }
+    GTEST_SKIP() << "Skipping all tests as "
+                    "CobaltExtensionConfigurableAudioWriteAhead is enabled.";
+  }
+
   FakeGraphicsContextProvider fake_graphics_context_provider_;
   VideoDmpReader dmp_reader_;
   SbPlayerState player_state_ = kSbPlayerStateInitialized;
diff --git a/starboard/shared/audio_write_ahead/audio_write_ahead.cc b/starboard/shared/audio_write_ahead/audio_write_ahead.cc
new file mode 100644
index 000000000000..5316775329eb
--- /dev/null
+++ b/starboard/shared/audio_write_ahead/audio_write_ahead.cc
@@ -0,0 +1,45 @@
+// Copyright 2023 The Cobalt Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "starboard/shared/audio_write_ahead/audio_write_ahead.h"
+
+#include "cobalt/extension/audio_write_ahead.h"
+#include "starboard/common/log.h"
+#include "starboard/shared/audio_write_ahead/audio_write_ahead_media_get_audio_configuration.h"
+#include "starboard/shared/audio_write_ahead/audio_write_ahead_player_get_audio_configuration.h"
+
+namespace starboard {
+namespace shared {
+namespace audio_write_ahead {
+
+namespace {
+
+const CobaltExtensionConfigurableAudioWriteAheadApi
+    kConfigurableAudioWriteAheadApi = {
+        kCobaltExtensionConfigurableAudioWriteAheadName,
+        1,
+        &ConfigurableAudioWriteAheadMediaGetAudioConfiguration,
+        &ConfigurableAudioWriteAheadPlayerGetAudioConfiguration,
+};
+
+}  // namespace
+
+const void* GetConfigurableAudioWriteAheadApi() {
+  SB_LOG(INFO) << "Audio write ahead extension enabled.";
+  return &kConfigurableAudioWriteAheadApi;
+}
+
+}  // namespace audio_write_ahead
+}  // namespace shared
+}  // namespace starboard
diff --git a/starboard/shared/audio_write_ahead/audio_write_ahead.gni b/starboard/shared/audio_write_ahead/audio_write_ahead.gni
new file mode 100644
index 000000000000..2356b0b438b9
--- /dev/null
+++ b/starboard/shared/audio_write_ahead/audio_write_ahead.gni
@@ -0,0 +1,22 @@
+# Copyright 2023 The Cobalt Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+audio_write_ahead_sources = [
+  "//starboard/shared/audio_write_ahead/audio_write_ahead.cc",
+  "//starboard/shared/audio_write_ahead/audio_write_ahead.h",
+  "//starboard/shared/audio_write_ahead/audio_write_ahead_media_get_audio_configuration.cc",
+  "//starboard/shared/audio_write_ahead/audio_write_ahead_media_get_audio_configuration.h",
+  "//starboard/shared/audio_write_ahead/audio_write_ahead_player_get_audio_configuration.cc",
+  "//starboard/shared/audio_write_ahead/audio_write_ahead_player_get_audio_configuration.h",
+]
diff --git a/starboard/shared/audio_write_ahead/audio_write_ahead.h b/starboard/shared/audio_write_ahead/audio_write_ahead.h
new file mode 100644
index 000000000000..a9eccba8a57a
--- /dev/null
+++ b/starboard/shared/audio_write_ahead/audio_write_ahead.h
@@ -0,0 +1,28 @@
+// Copyright 2023 The Cobalt Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef STARBOARD_SHARED_AUDIO_WRITE_AHEAD_AUDIO_WRITE_AHEAD_H_
+#define STARBOARD_SHARED_AUDIO_WRITE_AHEAD_AUDIO_WRITE_AHEAD_H_
+
+namespace starboard {
+namespace shared {
+namespace audio_write_ahead {
+
+const void* GetConfigurableAudioWriteAheadApi();
+
+}  // namespace audio_write_ahead
+}  // namespace shared
+}  // namespace starboard
+
+#endif  // STARBOARD_SHARED_AUDIO_WRITE_AHEAD_AUDIO_WRITE_AHEAD_H_
diff --git a/starboard/shared/audio_write_ahead/audio_write_ahead_media_get_audio_configuration.cc b/starboard/shared/audio_write_ahead/audio_write_ahead_media_get_audio_configuration.cc
new file mode 100644
index 000000000000..af603401bff5
--- /dev/null
+++ b/starboard/shared/audio_write_ahead/audio_write_ahead_media_get_audio_configuration.cc
@@ -0,0 +1,46 @@
+// Copyright 2023 The Cobalt Authors.All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "starboard/shared/audio_write_ahead/audio_write_ahead_media_get_audio_configuration.h"
+
+#include "starboard/audio_sink.h"
+#include "starboard/common/log.h"
+#include "starboard/media.h"
+
+namespace starboard {
+namespace shared {
+namespace audio_write_ahead {
+
+bool ConfigurableAudioWriteAheadMediaGetAudioConfiguration(
+    int output_index,
+    CobaltExtensionMediaAudioConfiguration* out_configuration) {
+  SB_DCHECK(output_index >= 0);
+  SB_DCHECK(out_configuration);
+
+  if (output_index != 0) {
+    return false;
+  }
+
+  *out_configuration = {};
+
+  out_configuration->connector = kCobaltExtensionMediaAudioConnectorUnknown;
+  out_configuration->latency = 0;
+  out_configuration->coding_type = kSbMediaAudioCodingTypePcm;
+  out_configuration->number_of_channels = SbAudioSinkGetMaxChannels();
+  return true;
+}
+
+}  // namespace audio_write_ahead
+}  // namespace shared
+}  // namespace starboard
diff --git a/starboard/shared/audio_write_ahead/audio_write_ahead_media_get_audio_configuration.h b/starboard/shared/audio_write_ahead/audio_write_ahead_media_get_audio_configuration.h
new file mode 100644
index 000000000000..38770be46e94
--- /dev/null
+++ b/starboard/shared/audio_write_ahead/audio_write_ahead_media_get_audio_configuration.h
@@ -0,0 +1,32 @@
+// Copyright 2023 The Cobalt Authors.All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef STARBOARD_SHARED_AUDIO_WRITE_AHEAD_AUDIO_WRITE_AHEAD_MEDIA_GET_AUDIO_CONFIGURATION_H_
+#define STARBOARD_SHARED_AUDIO_WRITE_AHEAD_AUDIO_WRITE_AHEAD_MEDIA_GET_AUDIO_CONFIGURATION_H_
+
+#include "cobalt/extension/audio_write_ahead.h"
+
+namespace starboard {
+namespace shared {
+namespace audio_write_ahead {
+
+bool ConfigurableAudioWriteAheadMediaGetAudioConfiguration(
+    int output_index,
+    CobaltExtensionMediaAudioConfiguration* out_configuration);
+
+}  // namespace audio_write_ahead
+}  // namespace shared
+}  // namespace starboard
+
+#endif  // STARBOARD_SHARED_AUDIO_WRITE_AHEAD_AUDIO_WRITE_AHEAD_MEDIA_GET_AUDIO_CONFIGURATION_H_
diff --git a/starboard/shared/audio_write_ahead/audio_write_ahead_player_get_audio_configuration.cc b/starboard/shared/audio_write_ahead/audio_write_ahead_player_get_audio_configuration.cc
new file mode 100644
index 000000000000..2bfc79004c4b
--- /dev/null
+++ b/starboard/shared/audio_write_ahead/audio_write_ahead_player_get_audio_configuration.cc
@@ -0,0 +1,61 @@
+// Copyright 2023 The Cobalt Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "starboard/shared/audio_write_ahead/audio_write_ahead_player_get_audio_configuration.h"
+
+#include <string>
+
+#include "starboard/common/log.h"
+#include "starboard/system.h"
+
+namespace starboard {
+namespace shared {
+namespace audio_write_ahead {
+
+bool ConfigurableAudioWriteAheadPlayerGetAudioConfiguration(
+    SbPlayer player,
+    int index,
+    CobaltExtensionMediaAudioConfiguration* out_audio_configuration) {
+  SB_DCHECK(SbPlayerIsValid(player));
+  SB_DCHECK(index >= 0);
+  SB_DCHECK(out_audio_configuration);
+
+  if (index > 0) {
+    // We assume that |player| only uses the primary (index 0) audio output.
+    // For playbacks using more than one audio outputs, or using audio outputs
+    // other than the primary one, the platform should have its own
+    // `SbPlayerGetAudioConfiguration()` implementation.
+    return false;
+  }
+
+  const CobaltExtensionConfigurableAudioWriteAheadApi* audio_write_ahead_api =
+      static_cast<const CobaltExtensionConfigurableAudioWriteAheadApi*>(
+          SbSystemGetExtension(
+              kCobaltExtensionConfigurableAudioWriteAheadName));
+  if (!audio_write_ahead_api) {
+    return false;
+  }
+
+  SB_DCHECK(audio_write_ahead_api->name ==
+            std::string(kCobaltExtensionConfigurableAudioWriteAheadName));
+  SB_DCHECK(audio_write_ahead_api->version == 1u);
+  SB_DCHECK(audio_write_ahead_api->MediaGetAudioConfiguration);
+
+  return audio_write_ahead_api->MediaGetAudioConfiguration(
+      index, out_audio_configuration);
+}
+
+}  // namespace audio_write_ahead
+}  // namespace shared
+}  // namespace starboard
diff --git a/starboard/shared/audio_write_ahead/audio_write_ahead_player_get_audio_configuration.h b/starboard/shared/audio_write_ahead/audio_write_ahead_player_get_audio_configuration.h
new file mode 100644
index 000000000000..3df8038b761c
--- /dev/null
+++ b/starboard/shared/audio_write_ahead/audio_write_ahead_player_get_audio_configuration.h
@@ -0,0 +1,35 @@
+// Copyright 2023 The Cobalt Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef STARBOARD_SHARED_AUDIO_WRITE_AHEAD_AUDIO_WRITE_AHEAD_PLAYER_GET_AUDIO_CONFIGURATION_H_
+#define STARBOARD_SHARED_AUDIO_WRITE_AHEAD_AUDIO_WRITE_AHEAD_PLAYER_GET_AUDIO_CONFIGURATION_H_
+
+#include "cobalt/extension/audio_write_ahead.h"
+
+#include "starboard/player.h"
+
+namespace starboard {
+namespace shared {
+namespace audio_write_ahead {
+
+bool ConfigurableAudioWriteAheadPlayerGetAudioConfiguration(
+    SbPlayer player,
+    int index,
+    CobaltExtensionMediaAudioConfiguration* out_audio_configuration);
+
+}  // namespace audio_write_ahead
+}  // namespace shared
+}  // namespace starboard
+
+#endif  // STARBOARD_SHARED_AUDIO_WRITE_AHEAD_AUDIO_WRITE_AHEAD_PLAYER_GET_AUDIO_CONFIGURATION_H_
diff --git a/starboard/shared/starboard/player/filter/testing/audio_decoder_test.cc b/starboard/shared/starboard/player/filter/testing/audio_decoder_test.cc
index 2904b6a66824..45ca471acda1 100644
--- a/starboard/shared/starboard/player/filter/testing/audio_decoder_test.cc
+++ b/starboard/shared/starboard/player/filter/testing/audio_decoder_test.cc
@@ -22,6 +22,7 @@
 #include <utility>
 #include <vector>
 
+#include "cobalt/extension/audio_write_ahead.h"
 #include "starboard/common/condition_variable.h"
 #include "starboard/common/media.h"
 #include "starboard/common/mutex.h"
@@ -69,6 +70,18 @@ class AudioDecoderTest
     ASSERT_NE(dmp_reader_.audio_codec(), kSbMediaAudioCodecNone);
     ASSERT_GT(dmp_reader_.number_of_audio_buffers(), 0);
 
+    const CobaltExtensionConfigurableAudioWriteAheadApi* extension_api =
+        static_cast<const CobaltExtensionConfigurableAudioWriteAheadApi*>(
+            SbSystemGetExtension(
+                kCobaltExtensionConfigurableAudioWriteAheadName));
+
+    if (extension_api) {
+      SB_DCHECK(extension_api->name ==
+                std::string(kCobaltExtensionConfigurableAudioWriteAheadName));
+      SB_DCHECK(extension_api->version == 1u);
+      audio_write_ahead_extension_enabled_ = true;
+    }
+
     CreateComponents(dmp_reader_.audio_codec(), dmp_reader_.audio_sample_info(),
                      &audio_decoder_, &audio_renderer_sink_);
   }
@@ -379,6 +392,8 @@ class AudioDecoderTest
   int decoded_audio_samples_per_second_ = 0;
 
   bool first_output_received_ = false;
+
+  bool audio_write_ahead_extension_enabled_ = false;
 };
 
 std::string GetAudioDecoderTestConfigName(
@@ -590,7 +605,10 @@ TEST_P(AudioDecoderTest, MultipleInputs) {
 
 TEST_P(AudioDecoderTest, LimitedInput) {
   SbTime duration = kSbTimeSecond / 2;
-  SbMediaSetAudioWriteDuration(duration);
+
+  if (!audio_write_ahead_extension_enabled_) {
+    SbMediaSetAudioWriteDuration(duration);
+  }
 
   ASSERT_FALSE(last_decoded_audio_);
   int start_index = 0;
@@ -606,7 +624,10 @@ TEST_P(AudioDecoderTest, LimitedInput) {
 
 TEST_P(AudioDecoderTest, ContinuedLimitedInput) {
   SbTime duration = kSbTimeSecond / 2;
-  SbMediaSetAudioWriteDuration(duration);
+
+  if (!audio_write_ahead_extension_enabled_) {
+    SbMediaSetAudioWriteDuration(duration);
+  }
 
   SbTime start = SbTimeGetMonotonicNow();
   int start_index = 0;
diff --git a/third_party/chromium/media/filters/chunk_demuxer.cc b/third_party/chromium/media/filters/chunk_demuxer.cc
index 1d6e475e8da9..2b729a451ec3 100644
--- a/third_party/chromium/media/filters/chunk_demuxer.cc
+++ b/third_party/chromium/media/filters/chunk_demuxer.cc
@@ -180,6 +180,9 @@ void ChunkDemuxerStream::Seek(base::TimeDelta time) {
   DCHECK(state_ == UNINITIALIZED || state_ == RETURNING_ABORT_FOR_READS)
       << state_;
 
+#if defined(STARBOARD)
+  write_head_ = time;
+#endif // defined (STARBOARD)
   stream_->Seek(time);
 }
 
@@ -225,6 +228,15 @@ bool ChunkDemuxerStream::EvictCodedFrames(base::TimeDelta media_time,
   return stream_->GarbageCollectIfNeeded(media_time, newDataSize);
 }
 
+#if defined(STARBOARD)
+
+base::TimeDelta ChunkDemuxerStream::GetWriteHead() const {
+  base::AutoLock auto_lock(lock_);
+  return write_head_;
+}
+
+#endif  // defined(STARBOARD)
+
 void ChunkDemuxerStream::OnMemoryPressure(
     base::TimeDelta media_time,
     base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level,
@@ -473,6 +485,7 @@ void ChunkDemuxerStream::CompletePendingReadIfPossible_Locked() {
 
   DemuxerStream::Status status = DemuxerStream::kAborted;
   std::vector<scoped_refptr<DecoderBuffer>> buffers;
+  base::TimeDelta write_head = write_head_;
 
   if (pending_config_change_) {
     status = kConfigChanged;
@@ -491,6 +504,7 @@ void ChunkDemuxerStream::CompletePendingReadIfPossible_Locked() {
                  << buffer->timestamp().InSecondsF() << ", dur "
                  << buffer->duration().InSecondsF() << ", key "
                  << buffer->is_key_frame();
+        write_head = std::max(write_head, buffer->timestamp());
         buffers.push_back(std::move(buffer));
         status = DemuxerStream::kOk;
       } else if (stream_status == SourceBufferStreamStatus::kEndOfStream) {
@@ -529,6 +543,8 @@ void ChunkDemuxerStream::CompletePendingReadIfPossible_Locked() {
     return;
   }
 
+  DCHECK_LE(write_head_, write_head);
+  write_head_ = write_head;
   std::move(read_cb_).Run(status, buffers);
 }
 #else // defined(STARBOARD)
@@ -1077,6 +1093,25 @@ bool ChunkDemuxer::EvictCodedFrames(const std::string& id,
   return itr->second->EvictCodedFrames(currentMediaTime, newDataSize);
 }
 
+#if defined(STARBOARD)
+
+base::TimeDelta ChunkDemuxer::GetWriteHead(const std::string& id) const {
+  base::AutoLock auto_lock(lock_);
+  DCHECK(IsValidId(id));
+
+  auto iter = id_to_streams_map_.find(id);
+  if (iter == id_to_streams_map_.end() ||
+      iter->second.empty()) {
+    // Handled just in case.
+    SB_NOTREACHED();
+    return base::TimeDelta();
+  }
+
+  return iter->second[0]->GetWriteHead();
+}
+
+#endif  // defined(STARBOARD)
+
 bool ChunkDemuxer::AppendData(const std::string& id,
                               const uint8_t* data,
                               size_t length,
diff --git a/third_party/chromium/media/filters/chunk_demuxer.h b/third_party/chromium/media/filters/chunk_demuxer.h
index fd67e6f7b8dd..2e7129194e2e 100644
--- a/third_party/chromium/media/filters/chunk_demuxer.h
+++ b/third_party/chromium/media/filters/chunk_demuxer.h
@@ -79,6 +79,10 @@ class MEDIA_EXPORT ChunkDemuxerStream : public DemuxerStream {
   // https://w3c.github.io/media-source/#sourcebuffer-coded-frame-eviction
   bool EvictCodedFrames(base::TimeDelta media_time, size_t newDataSize);
 
+#if defined(STARBOARD)
+  base::TimeDelta GetWriteHead() const;
+#endif  // defined(STARBOARD)
+
   void OnMemoryPressure(
       base::TimeDelta media_time,
       base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level,
@@ -207,6 +211,9 @@ class MEDIA_EXPORT ChunkDemuxerStream : public DemuxerStream {
   State state_ GUARDED_BY(lock_);
   ReadCB read_cb_ GUARDED_BY(lock_);
   bool is_enabled_ GUARDED_BY(lock_);
+#if defined(STARBOARD)
+  base::TimeDelta write_head_ GUARDED_BY(lock_);
+#endif  // defined(STARBOARD)
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(ChunkDemuxerStream);
 };
@@ -383,6 +390,10 @@ class MEDIA_EXPORT ChunkDemuxer : public Demuxer {
                         base::TimeDelta currentMediaTime,
                         size_t newDataSize) WARN_UNUSED_RESULT;
 
+#if defined(STARBOARD)
+  base::TimeDelta GetWriteHead(const std::string& id) const;
+#endif  // defined(STARBOARD)
+
   void OnMemoryPressure(
       base::TimeDelta currentMediaTime,
       base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level,