import { getDefaultSmallFont } from "../../graphics/ui-fonts"; import { GrayImage } from "../../graphics/image"; import { truncateText, wrapText } from "../../graphics/textwrap"; import { PHOTO_GAMMA } from "../../native/image-files"; import { probeVideo, VideoPlayer, type VideoInfo, type VideoPlaybackState } from "../../native/video-player"; import { ConfigSettingBoolean, ConfigSettingEnum } from "../../ui/dashboard-settings"; import { type InputEvent } from "../../ui/gestures"; import { type Layer, type LayerContext } from "../../ui/layers"; import { drawRightValueMenuItem, drawToggleMenuItem } from "../../ui/menu"; import { Menu, type MenuDrawArgs } from "../../ui/menu-core"; import { LIST_ROW_TEXT_INSET, lineStep, listRowHeight } from "../../ui/metrics"; import { createInProcessWindow, YieldAtRootLayer, type InProcessAppOptions, type InProcessWindow, } from "../../ui/shell/in-process-window"; import { appViewportSize } from "../../ui/shell/geometry"; import { formatMediaTime, VIDEO_SIZES, videoHeightMode, videoRect, videoSizeLabel, type Rect, type VideoSize, } from "./video-layout"; export const videoSizeSetting = new ConfigSettingEnum({ id: "video-size", label: "Size", storageKey: "video.size", defaultValue: "large", values: VIDEO_SIZES, formatValue: videoSizeLabel, }); export const videoAudioSetting = new ConfigSettingBoolean({ id: "video-audio", label: "Audio", storageKey: "video.audio", defaultValue: true, description: "Play the video's sound on the phone's current audio output.", }); export const videoMonochromeSetting = new ConfigSettingBoolean({ id: "video-monochrome", label: "Monochrome", storageKey: "video.monochrome", defaultValue: false, description: "Show only black and white: far less to send per frame, so a higher frame rate.", }); /** How far one ring scroll seeks. */ const SEEK_STEP_MS = 10_000; const MARGIN_X = 18; const TITLE_Y = 10; const PANEL_WIDTH = 340; /** * One opened video: its probe result, the native player, and the window * glue. The window's base layer is the settings panel; playing pushes the * playback layer, and backing out of it (or the video ending) returns to the * panel with the position kept for Resume. */ class VideoSession { readonly probe: VideoInfo | { error: string }; private player: VideoPlayer | null = null; private window: InProcessWindow | null = null; private playback: VideoPlaybackLayer | null = null; /** Where Resume starts; 0 = from the beginning. */ resumeMs = 0; /** The last playback error, shown on the panel until the next Play. */ error: string | null = null; constructor( readonly path: string, readonly title: string, readonly surfaceId: string, ) { this.probe = probeVideo(path); } get info(): VideoInfo | null { return "error" in this.probe ? null : this.probe; } attach(window: InProcessWindow): void { this.window = window; } isPlaying(): boolean { return this.player?.isPlaying() ?? false; } positionMs(): number { return this.player?.positionMs() ?? this.resumeMs; } /** Current rect for a size choice, in the viewport of the band that size plays in. */ rectFor(size: VideoSize, viewport: { width: number; height: number }): Rect { const info = this.info; return videoRect(size, info ? { width: info.width, height: info.height } : viewport, viewport); } play(ctx: LayerContext, fromStart: boolean): void { const window = this.window; const info = this.info; if (!window || !info) return; this.error = null; const size = videoSizeSetting.get(); window.setHeightMode(videoHeightMode(size)); const viewport = ctx.stack.getBaseSize(); const rect = this.rectFor(size, viewport); const player = this.ensurePlayer(); this.playback = new VideoPlaybackLayer(this, rect, viewport); ctx.stack.push(this.playback); player.start({ path: this.path, surfaceId: this.surfaceId, rect, monochrome: videoMonochromeSetting.get(), gamma: PHOTO_GAMMA, audio: info.hasAudio && videoAudioSetting.get(), startMs: fromStart ? 0 : this.resumeMs, }); } togglePause(): void { const player = this.player; if (!player) return; if (player.isPlaying()) player.pause(); else player.resume(); } seekBy(deltaMs: number): void { const player = this.player; if (!player) return; const duration = this.info?.durationMs ?? 0; const target = Math.max(0, player.positionMs() + deltaMs); player.seekTo(duration > 0 ? Math.min(target, duration) : target); } /** The window went to the background or the screen went off: stop, keep the place. */ pauseForHost(): void { if (!this.player?.isPlaying()) return; this.player.pause(); // Paint the paused overlay now, so the retained surface shows it on return. this.window?.requestRender(); } /** Leave the playback layer for the panel, remembering where to resume. */ returnToPanel(resumeMs: number): void { const player = this.player; if (player) { player.pause(); player.stop(); } this.resumeMs = resumeMs; const window = this.window; const playback = this.playback; this.playback = null; if (window && playback) window.stack.popThrough(playback); window?.setHeightMode("min"); window?.requestRender(); } lastFrame(rect: Rect): GrayImage | null { return this.player?.lastFrame(rect.width, rect.height) ?? null; } release(): void { this.player?.release(); this.player = null; } private ensurePlayer(): VideoPlayer { if (!this.player) { this.player = new VideoPlayer({ onState: (state, positionMs) => this.onPlayerState(state, positionMs), onError: (message) => { this.error = message; this.returnToPanel(this.positionMs()); }, }); } return this.player; } private onPlayerState(state: VideoPlaybackState, _positionMs: number): void { if (state === "ended") { this.returnToPanel(0); return; } // A paused seek decoded its new frame: repaint it under the overlay. if (state === "paused") this.window?.requestRender(); } } type PanelRow = { kind: "size" } | { kind: "audio" } | { kind: "monochrome" } | { kind: "play"; fromStart: boolean }; /** * The pre-play settings panel (the window's root): picture size, audio and * monochrome, all remembered for the next video, then Play (or Resume plus * Play from start once a position is kept). */ class VideoSettingsLayer implements Layer { private readonly menu = new Menu({ wrap: false, rowGap: 1, highlight: { radius: 6 }, getHeight: () => listRowHeight(getDefaultSmallFont()), draw: (args) => this.drawRow(args), }); constructor(private readonly session: VideoSession) {} private rows(): PanelRow[] { if (!this.session.info) return []; const rows: PanelRow[] = [{ kind: "size" }, { kind: "audio" }, { kind: "monochrome" }]; rows.push({ kind: "play", fromStart: false }); if (this.session.resumeMs > 0) rows.push({ kind: "play", fromStart: true }); return rows; } paint(ctx: LayerContext): GrayImage { const font = getDefaultSmallFont(); const { width, height } = ctx.stack.getBaseSize(); const image = new GrayImage(width, height, 0); image.drawText(font, MARGIN_X, TITLE_Y, truncateText(font, this.session.title, width - 2 * MARGIN_X), 220); const step = lineStep(font); let y = TITLE_Y + step; const info = this.session.info; const errors: string[] = []; if (!info) errors.push(`Can't play this video: ${(this.session.probe as { error: string }).error}`); if (this.session.error) errors.push(`Playback stopped: ${this.session.error}`); if (info) { const facts = [`${info.width}x${info.height}`, formatMediaTime(info.durationMs), info.hasAudio ? "sound" : "no sound"]; image.drawText(font, MARGIN_X, y, facts.join(" ยท "), 130); y += step; } for (const error of errors) { for (const line of wrapText(font, error, width - 2 * MARGIN_X, { breakLongWords: true }).slice(0, 3)) { image.drawText(font, MARGIN_X, y, line, 200); y += step; } } y += 6; const rows = this.rows(); const selected = this.menu.selectedItem; const index = selected ? rows.findIndex((row) => sameRow(row, selected)) : -1; // Land on Resume/Play by default: the settings usually stay as they were. const playIndex = rows.findIndex((row) => row.kind === "play"); this.menu.setItems(rows, index >= 0 ? index : playIndex >= 0 ? playIndex : undefined); const panelWidth = Math.min(PANEL_WIDTH, width - 2 * (MARGIN_X - 6)); this.menu.paint(image, { x: MARGIN_X - 6, y, width: panelWidth, height: Math.max(0, height - y - 4) }, ctx.stack.isFocused()); return image; } async handleInput(event: InputEvent, ctx: LayerContext): Promise { switch (event.type) { case "scroll-up": case "scroll-down": await this.menu.handleInput(event); return; case "click": { const row = this.menu.selectedItem; if (row) this.activate(row, ctx); return; } default: return; } } private activate(row: PanelRow, ctx: LayerContext): void { switch (row.kind) { case "size": videoSizeSetting.set(videoSizeSetting.next()); return; case "audio": if (this.session.info?.hasAudio) videoAudioSetting.toggle(); return; case "monochrome": videoMonochromeSetting.toggle(); return; case "play": this.session.play(ctx, row.fromStart); return; } } private drawRow({ image, item, x, y, width, selected }: MenuDrawArgs): void { const font = getDefaultSmallFont(); const textX = x + 10; const textWidth = width - 20; switch (item.kind) { case "size": { const size = videoSizeSetting.get(); // The picture size this choice gets in its own band (full screen plays in the tall window). const rect = this.session.rectFor(size, appViewportSize(videoHeightMode(size))); drawRightValueMenuItem(image, font, textX, y, textWidth, "Size", `${videoSizeLabel(size)} ${rect.width}x${rect.height}`); return; } case "audio": { const hasAudio = this.session.info?.hasAudio ?? false; drawToggleMenuItem(image, font, textX, y, textWidth, hasAudio ? "Audio" : "Audio (none in file)", hasAudio && videoAudioSetting.get(), selected); return; } case "monochrome": drawToggleMenuItem(image, font, textX, y, textWidth, "Monochrome", videoMonochromeSetting.get(), selected); return; case "play": { const resumeMs = this.session.resumeMs; const label = item.fromStart ? "Play from start" : resumeMs > 0 ? `Resume from ${formatMediaTime(resumeMs)}` : "Play"; image.drawText(font, textX, y + LIST_ROW_TEXT_INSET, label, selected ? 255 : 200); return; } } } } function sameRow(a: PanelRow, b: PanelRow): boolean { return a.kind === b.kind && (a.kind !== "play" || b.kind !== "play" || a.fromStart === b.fromStart); } /** * The playing video. The native player draws frames into the video rect on * its own; this layer paints only when the window renders (input, pause, * focus): black around the latest frame, plus a status box while paused. * Click pauses/resumes, scroll seeks 10s, double-click returns to the panel. */ class VideoPlaybackLayer implements Layer { private leaving = false; constructor( private readonly session: VideoSession, private readonly rect: Rect, /** The viewport the rect was laid out in. */ private readonly viewport: { width: number; height: number }, ) {} paint(ctx: LayerContext): GrayImage { const { width, height } = ctx.stack.getBaseSize(); if ((width !== this.viewport.width || height !== this.viewport.height) && !this.leaving) { // The window was relaid out (display mode change) and the native player's rect no // longer fits the surface: back out to the panel, which lays out afresh on Play. this.leaving = true; setTimeout(() => this.session.returnToPanel(this.session.positionMs()), 0); } const image = new GrayImage(width, height, 0); const frame = this.session.lastFrame(this.rect); if (frame) image.bitBlt(frame, this.rect.x, this.rect.y); if (!this.session.isPlaying()) this.drawPausedBox(image, frame === null); return image; } async handleInput(event: InputEvent): Promise { switch (event.type) { case "click": this.session.togglePause(); return; case "scroll-up": this.session.seekBy(-SEEK_STEP_MS); return; case "scroll-down": this.session.seekBy(SEEK_STEP_MS); return; case "double-click": this.session.returnToPanel(this.session.positionMs()); return; default: return; } } /** * "Paused 1:23 / 3:52" over a progress bar, below the picture when there is * room (small sizes), else over its bottom edge. */ private drawPausedBox(image: GrayImage, loading: boolean): void { const font = getDefaultSmallFont(); const duration = this.session.info?.durationMs ?? 0; const position = this.session.positionMs(); const text = loading ? "Loading..." : `Paused ${formatMediaTime(position)} / ${formatMediaTime(duration)}`; const boxWidth = Math.min(image.width - 8, font.measureText(text) + 24); const boxHeight = font.lineHeight + 14; const rect = this.rect; const x = Math.round(rect.x + (rect.width - boxWidth) / 2); const below = rect.y + rect.height + 4; const y = below + boxHeight <= image.height ? below : Math.max(0, rect.y + rect.height - boxHeight - 6); image.fillRoundedRect(x, y, boxWidth, boxHeight, 1, 6); image.drawRoundedRect(x, y, boxWidth, boxHeight, 72, 6); image.drawText(font, x + 12, y + 5, text, 220); if (!loading && duration > 0) { const barWidth = boxWidth - 24; image.fillRect(x + 12, y + boxHeight - 5, barWidth, 2, 40); image.fillRect(x + 12, y + boxHeight - 5, Math.round((barWidth * Math.min(position, duration)) / duration), 2, 200); } } } /** A video file's player as its own window, opened from the Files app. */ export function createVideoPlayerWindow( windowId: string, title: string, path: string, options: InProcessAppOptions, ): InProcessWindow { const session = new VideoSession(path, title, `window:${windowId}`); const window = createInProcessWindow({ appId: "files", windowId, title, iconLetter: "V", icon: "film", closeable: true, actions: options.actions, baseLayer: new YieldAtRootLayer(new VideoSettingsLayer(session)), // A playing video is the thing being watched: no idle screen-off. keepsScreenOn: () => session.isPlaying(), onForegroundChanged: (foreground) => { if (!foreground) session.pauseForHost(); }, setScreenOn: (on) => { if (!on) session.pauseForHost(); }, submitFrame: options.submitFrame, setSurfaceVisible: options.setSurfaceVisible, removeSurface: options.removeSurface, reconfigureSurface: options.reconfigureSurface, onClosed: () => { session.release(); options.onClosed(); }, }); session.attach(window); return window; }