dymokomi/luce-browser-engine
Source of release 0.6.0
0.6.0 / src / web / external / lib_media / playback_manager.lucb
#==============================================================================================
#
# playback_manager - LibMedia's PlaybackManager, a seam without demuxers
#
# DESCRIPTION:
# LibMedia plays media through FFmpeg and its own Matroska reader (Containers/,
# FFmpeg/, the data providers and sinks, the audio output). None of it is ported yet
# (phase 4), so this port keeps LibMedia as a seam, like a Ladybird built without
# demuxers: PlaybackManager::create_demuxer_for_stream answers a NotImplemented
# DecoderError for every stream. Everything else here is
# Libraries/LibMedia/PlaybackManager.h and .cpp as they run when that happens:
#
# - add_media_source reports the error through on_unsupported_format_error on the
# event loop (handle_media_init_error), so HTMLMediaElement takes the "media data
# ... in an unsupported format" steps: it cancels the fetch and goes back to its
# resource selection, which tries the next <source> and ends in the dedicated media
# source failure steps (error event, poster shown, the load event no longer delayed);
# - the manager stays in the Starting state (StartingStateHandler over
# ResumingStateHandler): play and pause only flip its playing flag, its state is
# Starting and no data is available;
# - its time comes from a GenericTimeProvider and is clamped to the duration (zero);
# - it has no tracks, so buffered_time_ranges is empty and nothing has a sink.
#
# The thread pool is not used: the demuxer's verdict is known at once, and the report
# is deferred to the event loop as handle_media_init_error defers it. What only a demuxer
# makes reachable (track data, Playing/Paused/Seeking states, sinks) traps.
#
# The manager is an OwnPtr in HTMLMediaElement; its destructor revokes the weak link
# (media_playback_manager_destruct), which the element calls where the C++ OwnPtr
# destroys it.
#
# Copyright (c) 2022-2026, Gregory Bertilson <gregory@ladybird.org>
# Copyright (c) 2026 the luce-browser authors.
# SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================
# mark: GenericTimeProvider =====================================================================
## Ported from Libraries/LibMedia/Providers/GenericTimeProvider.cpp:15 Media::GenericTimeProvider::current_time.
func media_generic_time_provider_current_time(this: const MediaGenericTimeProvider*) -> ak.Duration:
var time = this.m_media_time
if let resumed = this.m_monotonic_time_on_resume:
let now = ak.monotonic_time_now()
_ = ak.duration_add_assign(&time, ak.monotonic_time_sub_monotonic_time(&now, resumed))
return time
# mark: Creation and destruction ================================================================
## Ported from Libraries/LibMedia/PlaybackManager.cpp:146 Media::PlaybackManager::create, with the
## constructor (PlaybackManager.cpp:154).
pub func media_playback_manager_create() -> MediaPlaybackManager*:
let link = new MediaWeakPlaybackManagerLink(m_manager = none) else trap("out of memory")
let time_provider = new MediaGenericTimeProvider(m_monotonic_time_on_resume = none, m_media_time = ak.duration_zero()) else trap("out of memory")
let playback_manager = new MediaPlaybackManager(m_handler = none, m_weak_link = link, m_time_provider = time_provider, m_preferred_video_track = none,
m_preferred_audio_track = none, m_duration = ak.duration_zero()) else trap("out of memory")
link.m_manager = playback_manager
playback_manager.m_handler = new MediaStartingStateHandler(m_manager = playback_manager) else trap("out of memory")
# m_handler->on_enter(): ResumingStateHandler's does nothing.
return playback_manager
## Ported from Libraries/LibMedia/PlaybackManager.cpp:160 Media::PlaybackManager::~PlaybackManager:
## the OwnPtr's destructor (see the header).
pub func media_playback_manager_destruct(this: MediaPlaybackManager*):
this.m_weak_link.m_manager = none
## Ported from Libraries/LibMedia/PlaybackManager.h:56 Media::PlaybackManager::set_audio_output_disabled.
pub func media_playback_manager_set_audio_output_disabled(this: MediaPlaybackManager*, disabled: bool):
this.m_audio_output_disabled = disabled
# mark: Media sources ===========================================================================
## Ported from Libraries/LibMedia/PlaybackManager.cpp:25 Media::PlaybackManager::create_demuxer_for_stream:
## the seam (see the header). Ladybird asks its Matroska reader, then FFmpeg.
func media_playback_manager_create_demuxer_for_stream(stream: MediaIncrementallyPopulatedStream*) -> MediaDecoderError:
_ = stream
return media_decoder_error_with_description(MediaDecoderErrorCategory.not_implemented, "No demuxer for this media: LibMedia's demuxers are not ported")
## The captures of handle_media_init_error's deferred invocation: `[self = move(self), error = move(error)]`.
struct MediaPlaybackManagerInitError:
var link: MediaWeakPlaybackManagerLink*
var error_: MediaDecoderError
static func invoke(context: void*?):
let captures = (MediaPlaybackManagerInitError*)(context else trap("media init error: no captures"))
let self_ = captures.link.m_manager else return
if ak.function1_is_set(&self_.on_unsupported_format_error):
ak.function1_call(&self_.on_unsupported_format_error, captures.error_)
## Ported from Libraries/LibMedia/PlaybackManager.cpp:165 Media::handle_media_init_error (static).
func media_playback_manager_handle_media_init_error(link: MediaWeakPlaybackManagerLink*, error_: MediaDecoderError):
let captures = new MediaPlaybackManagerInitError(link = link, error_ = error_) else trap("out of memory")
core_deferred_invoke(ak.Function0[unit](call = MediaPlaybackManagerInitError.invoke, context = captures))
## Ported from Libraries/LibMedia/PlaybackManager.cpp:178 Media::PlaybackManager::add_media_source (a stream).
pub func media_playback_manager_add_media_source(this: MediaPlaybackManager*, stream: MediaIncrementallyPopulatedStream*):
# Threading::ThreadPool::the().submit([...] { auto demuxer_or_error = create_demuxer_for_stream(stream); ... }),
# run here: the seam's demuxer always fails, so prepare_playback_from_demuxer is never reached.
let error_ = media_playback_manager_create_demuxer_for_stream(stream)
media_playback_manager_handle_media_init_error(this.m_weak_link, error_)
# mark: Tracks ==================================================================================
## Ported from Libraries/LibMedia/PlaybackManager.h:62 Media::PlaybackManager::video_tracks.
pub func media_playback_manager_video_tracks(this: MediaPlaybackManager*) -> ak.Vector[MediaTrack]:
return this.m_video_tracks
## Ported from Libraries/LibMedia/PlaybackManager.h:63 Media::PlaybackManager::audio_tracks.
pub func media_playback_manager_audio_tracks(this: MediaPlaybackManager*) -> ak.Vector[MediaTrack]:
return this.m_audio_tracks
## Ported from Libraries/LibMedia/PlaybackManager.h:64 Media::PlaybackManager::preferred_video_track.
pub func media_playback_manager_preferred_video_track(this: MediaPlaybackManager*) -> MediaTrack?:
return this.m_preferred_video_track
## Ported from Libraries/LibMedia/PlaybackManager.h:65 Media::PlaybackManager::preferred_audio_track.
pub func media_playback_manager_preferred_audio_track(this: MediaPlaybackManager*) -> MediaTrack?:
return this.m_preferred_audio_track
## Ported from Libraries/LibMedia/PlaybackManager.cpp:318 Media::PlaybackManager::get_or_create_the_displaying_video_sink_for_track:
## get_video_data_for_track finds no data for any track here (VERIFY_NOT_REACHED, as in C++).
pub func media_playback_manager_get_or_create_the_displaying_video_sink_for_track(this: MediaPlaybackManager*, track: MediaTrack) -> MediaDisplayingVideoSink*:
trap("VERIFY_NOT_REACHED: PlaybackManager::get_video_data_for_track (no demuxer, no track data)")
## Ported from Libraries/LibMedia/PlaybackManager.cpp:335 Media::PlaybackManager::remove_the_displaying_video_sink_for_track.
pub func media_playback_manager_remove_the_displaying_video_sink_for_track(this: MediaPlaybackManager*, track: MediaTrack):
trap("VERIFY_NOT_REACHED: PlaybackManager::get_video_data_for_track (no demuxer, no track data)")
## Ported from Libraries/LibMedia/PlaybackManager.cpp:345 Media::PlaybackManager::enable_an_audio_track.
pub func media_playback_manager_enable_an_audio_track(this: MediaPlaybackManager*, track: MediaTrack):
trap("VERIFY_NOT_REACHED: PlaybackManager::get_audio_data_for_track (no demuxer, no track data)")
## Ported from Libraries/LibMedia/PlaybackManager.cpp:358 Media::PlaybackManager::disable_an_audio_track.
pub func media_playback_manager_disable_an_audio_track(this: MediaPlaybackManager*, track: MediaTrack):
trap("VERIFY_NOT_REACHED: PlaybackManager::get_audio_data_for_track (no demuxer, no track data)")
# mark: Playback ================================================================================
## The manager's state handler (always the Starting state here, see the header).
func media_playback_manager_handler(this: MediaPlaybackManager*) -> MediaStartingStateHandler*:
return this.m_handler else trap("PlaybackManager: no state handler")
## Ported from Libraries/LibMedia/PlaybackStates/ResumingStateHandler.cpp:15 Media::ResumingStateHandler::resume:
## replace_state_handler<PlayingStateHandler> or <PausedStateHandler>, which only a demuxer's tracks reach.
func media_starting_state_handler_resume(this: MediaStartingStateHandler*):
if this.m_playing:
trap("unported (P4): Media::PlayingStateHandler (media playback)")
trap("unported (P4): Media::PausedStateHandler (media playback)")
## Ported from Libraries/LibMedia/PlaybackManager.cpp:387 Media::PlaybackManager::start, with
## StartingStateHandler::start (StartingStateHandler.cpp:13).
pub func media_playback_manager_start(this: MediaPlaybackManager*):
let handler = media_playback_manager_handler(this)
handler.m_started = true
# if (manager().m_tracks_still_buffering.is_empty()) resume(); (no track ever buffers here)
media_starting_state_handler_resume(handler)
## Ported from Libraries/LibMedia/PlaybackManager.cpp:392 Media::PlaybackManager::play, with
## ResumingStateHandler::play.
pub func media_playback_manager_play(this: MediaPlaybackManager*):
media_playback_manager_handler(this).m_playing = true
## Ported from Libraries/LibMedia/PlaybackManager.cpp:397 Media::PlaybackManager::pause, with
## ResumingStateHandler::pause.
pub func media_playback_manager_pause(this: MediaPlaybackManager*):
media_playback_manager_handler(this).m_playing = false
## Ported from Libraries/LibMedia/PlaybackManager.cpp:402 Media::PlaybackManager::seek: the handler's
## seek (PlaybackStateHandler::seek) replaces it with a SeekingStateHandler, which drives the
## data providers.
pub func media_playback_manager_seek(this: MediaPlaybackManager*, timestamp: ak.Duration, seek_mode: MediaSeekMode):
trap("unported (P4): Media::SeekingStateHandler (media playback)")
## Ported from Libraries/LibMedia/PlaybackManager.cpp:408 Media::PlaybackManager::is_playing.
pub func media_playback_manager_is_playing(this: MediaPlaybackManager*) -> bool:
return media_playback_manager_handler(this).m_playing
## Ported from Libraries/LibMedia/PlaybackManager.cpp:413 Media::PlaybackManager::state
## (StartingStateHandler::state).
pub func media_playback_manager_state(this: MediaPlaybackManager*) -> MediaPlaybackState:
_ = media_playback_manager_handler(this)
return MediaPlaybackState.starting
## Ported from Libraries/LibMedia/PlaybackManager.cpp:418 Media::PlaybackManager::available_data
## (StartingStateHandler::available_data).
pub func media_playback_manager_available_data(this: MediaPlaybackManager*) -> MediaAvailableData:
_ = media_playback_manager_handler(this)
return MediaAvailableData.none_
## Ported from Libraries/LibMedia/PlaybackManager.cpp:423 Media::PlaybackManager::buffered_time_ranges:
## the intersection of the enabled tracks' buffered ranges; there are no tracks here.
pub func media_playback_manager_buffered_time_ranges(this: MediaPlaybackManager*) -> MediaTimeRanges:
_ = this
return MediaTimeRanges()
## Ported from Libraries/LibMedia/PlaybackManager.cpp:446 Media::PlaybackManager::set_volume: the audio
## sink's volume, when there is a sink (there is none without audio tracks).
pub func media_playback_manager_set_volume(this: MediaPlaybackManager*, volume: f64):
_ = this
_ = volume
## Ported from Libraries/LibMedia/PlaybackManager.h:58 Media::PlaybackManager::duration.
pub func media_playback_manager_duration(this: MediaPlaybackManager*) -> ak.Duration:
return this.m_duration
## Ported from Libraries/LibMedia/PlaybackManager.h:60 Media::PlaybackManager::current_time:
## `min(m_time_provider->current_time(), duration())`.
pub func media_playback_manager_current_time(this: MediaPlaybackManager*) -> ak.Duration:
let time = media_generic_time_provider_current_time(this.m_time_provider)
if ak.duration_cmp(&time, this.m_duration) < 0:
return time
return this.m_duration
# mark: Callbacks ===============================================================================
## `playback_manager->on_duration_change = ...` (Libraries/LibMedia/PlaybackManager.h).
pub func media_playback_manager_set_on_duration_change(this: MediaPlaybackManager*, callback: ak.Function1[ak.Duration, unit]):
this.on_duration_change = callback
## `playback_manager->on_track_added = ...` (Libraries/LibMedia/PlaybackManager.h).
pub func media_playback_manager_set_on_track_added(this: MediaPlaybackManager*, callback: ak.Function1[const MediaTrack*, unit]):
this.on_track_added = callback
## `playback_manager->on_metadata_parsed = ...` (Libraries/LibMedia/PlaybackManager.h).
pub func media_playback_manager_set_on_metadata_parsed(this: MediaPlaybackManager*, callback: ak.Function0[unit]):
this.on_metadata_parsed = callback
## `playback_manager->on_unsupported_format_error = ...` (Libraries/LibMedia/PlaybackManager.h).
pub func media_playback_manager_set_on_unsupported_format_error(this: MediaPlaybackManager*, callback: ak.Function1[MediaDecoderError, unit]):
this.on_unsupported_format_error = callback
## `playback_manager->on_error = ...` (Libraries/LibMedia/PlaybackManager.h).
pub func media_playback_manager_set_on_error(this: MediaPlaybackManager*, callback: ak.Function1[MediaDecoderError, unit]):
this.on_error = callback
## `playback_manager->on_playback_state_change = ...` (Libraries/LibMedia/PlaybackManager.h).
pub func media_playback_manager_set_on_playback_state_change(this: MediaPlaybackManager*, callback: ak.Function0[unit]):
this.on_playback_state_change = callback