Package-level declarations

One immutable hardware image and its explicit ImageReader lease.

Turns direct MediaCodec output into immutable RGBA hardware Bitmap frames for a GPU client.

Android's monotonic clock, on the exact time base AudioTimestamp.nanoTime reports: System.nanoTime(), which is CLOCK_MONOTONIC.

The Android output half: AndroidMonotonicClock paired with AudioTrackSinkFactory, and null for video.

Draws frames into a Surface the caller owns.

What an AppKitWindow hosts for the picture.

Draws frames into an AppKitWindow.

A window to draw video into.

Who owns the process-wide iOS audio-session category and activation policy.

The one clock the engine and the audio device share on Apple platforms.

Apple output: CoreAudio, on CoreAudio's own clock.

The Android audio output: one AudioTrack in MODE_STREAM behind the engine's pull contract.

Creates AudioTrackSinks for the engine. One sink per playback session.

Draws frames onto an AWT canvas, on a thread of its own.

Fills a packed integer raster with one frame's pixels, one ARGB value per pixel, no row padding.

Audio output through CoreAudio, owned in C.

Creates CoreAudioSink instances.

The desktop JVM audio output: one javax.sound.sampled.SourceDataLine behind the engine's pull contract.

Creates DesktopAudioSinks for the engine. One sink per playback session.

The desktop JVM monotonic clock: System.nanoTime(), the base every deadline DesktopAudioSink publishes is computed on.

The desktop JVM output half: DesktopMonotonicClock paired with DesktopAudioSinkFactory, and null for video. One object lights up macOS, Linux and Windows, because javax.sound.sampled and java.awt are in the JDK on all three.

Renders one picture offscreen through Metal and reads the RGBA bytes back (the hardware path on Apple). This is what replaces the CPU colour conversion for a consumer that needs BYTES rather than a layer, KiteVideo above all: the YUV-to-RGB arithmetic runs in the fragment shader, a VideoToolbox frame is wrapped with no copy at all, and the CPU pays exactly one readback memcpy, which is the no-CPU-RGBA law with the one copy its Android sibling also pays.

How a Metal renderer reads a frame's pixels. The output module never depends on the FFmpeg backend, so a consumer that owns both sides supplies this resolver, exactly the way the CG renderers take their convert lambda. The two shapes are the two truths a frame can have: a CVPixelBuffer straight from VideoToolbox (zero copies), or software planes read out of the decoder's buffers (one memcpy per plane, no colour conversion on the CPU, which is law 2 of YUV until the GPU).

The GPU renderer: one Metal core for macOS and iOS, drawing into a caller-owned CAMetalLayer.

Presents frames into an AVSampleBufferDisplayLayer, on iOS and on macOS.

Converts software frames away from the caller and presents the newest finished image in its layer.

Draws frames onto an HTML canvas.

Builds WebCanvasVideoRenderers for one canvas. See WebCanvasVideoRenderer for keepDisplayAwake.

Keeps a page's screen awake while it shows a playing picture (#238), through the W3C Screen Wake Lock API. A browser keeps the screen on by itself only for a playing video element, and the player draws onto a canvas, so without this the display dims and locks in the middle of a film.

Fills a JS byte array with one frame's RGBA, tightly packed, no row padding.

performance.now(), which is the page's monotonic clock.

The web output side: a clock and a sink, and no renderer.

The page's half of the sound of a player that runs in a Web Worker (#100): the AudioContext and the AudioWorklet, which only a page may own, and the port a worker writes the sound to.

The output backend of a player that runs in a Web Worker (#100): the worker's clock, and a sink that writes to the page's worklet through port, the WebWorkletAudio.workerPort the page transferred. sampleRate, channels and outputLatencySeconds are the page's figures.