Files

149 lines
4.7 KiB
TypeScript

/**
* Bridge to the Android FaceclawVideoPlayer: decodes a video file and
* streams its frames, scaled to gray, straight into a rect of a window's
* compositor surface, with the audio on the phone's default media route.
* Android only; on iOS probeVideo reports an error and nothing plays.
*/
import { Utils } from "@nativescript/core";
import { GrayImage } from "../graphics/image";
declare const com: any;
declare const java: any;
declare const global: any;
/** Containers MediaExtractor opens (AVI is not one of them). */
const PLAYABLE_VIDEO = /\.(mp4|m4v|mkv|webm|3gp|mov)$/i;
export function isPlayableVideoFile(name: string): boolean {
return PLAYABLE_VIDEO.test(name);
}
export type VideoInfo = {
/** Display size, rotation already applied. */
width: number;
height: number;
durationMs: number;
hasAudio: boolean;
};
/** Read a video's size, duration and tracks; an error string when it can't be played. */
export function probeVideo(path: string): VideoInfo | { error: string } {
if (!global.isAndroid) return { error: "Video playback is not supported on this phone" };
try {
const raw = JSON.parse(String(com.faceclaw.app.FaceclawVideoPlayer.probe(path)));
if (raw.error) return { error: String(raw.error) };
return {
width: Number(raw.width) || 0,
height: Number(raw.height) || 0,
durationMs: Number(raw.durationMs) || 0,
hasAudio: Boolean(raw.hasAudio),
};
} catch (error) {
return { error: String(error) };
}
}
export type VideoPlaybackState = "playing" | "paused" | "ended";
export type VideoPlayerCallbacks = {
/** State change, or a paused seek that landed on a new frame (state "paused"). */
onState: (state: VideoPlaybackState, positionMs: number) => void;
onError: (message: string) => void;
};
export type VideoStartOptions = {
path: string;
surfaceId: string;
/** The video's rect in surface coordinates. */
rect: { x: number; y: number; width: number; height: number };
monochrome: boolean;
/** Tone curve for gray output (ignored for monochrome); see PHOTO_GAMMA. */
gamma: number;
audio: boolean;
startMs: number;
};
/** One player; frames go to whatever surface the latest start() named. Main thread only. */
export class VideoPlayer {
private readonly player: any;
// The Java listener proxy must stay referenced or it gets GC'd.
private readonly listenerProxy: any;
// Reused direct buffer (and its JS view) for copyLastFrame; see java-direct-buffer.ts
// for why frames cross as a Java-allocated buffer.
private frameBuffer: any = null;
private frameView: Uint8Array | null = null;
constructor(callbacks: VideoPlayerCallbacks) {
this.player = new com.faceclaw.app.FaceclawVideoPlayer(Utils.android.getApplicationContext());
this.listenerProxy = new com.faceclaw.app.FaceclawVideoPlayer.Listener({
onStateChanged: (state: string, positionMs: number) => {
callbacks.onState(String(state) as VideoPlaybackState, Number(positionMs));
},
onError: (message: string) => callbacks.onError(String(message ?? "Playback failed")),
});
this.player.setListener(this.listenerProxy);
}
start(options: VideoStartOptions): void {
const { rect } = options;
this.player.start(
options.path,
options.surfaceId,
Math.round(rect.x),
Math.round(rect.y),
Math.round(rect.width),
Math.round(rect.height),
options.monochrome,
options.gamma,
options.audio,
Math.max(0, Math.round(options.startMs)),
);
}
/** Once this returns, no more frames reach the surface until resume(). */
pause(): void {
this.player.pause();
}
resume(): void {
this.player.resume();
}
seekTo(positionMs: number): void {
this.player.seekTo(Math.max(0, Math.round(positionMs)));
}
positionMs(): number {
return Number(this.player.getPositionMs());
}
isPlaying(): boolean {
return Boolean(this.player.isPlaying());
}
/** The latest decoded frame at the given size, or null before one exists. */
lastFrame(width: number, height: number): GrayImage | null {
const bytes = width * height;
if (bytes <= 0) return null;
if (!this.frameView || this.frameView.length !== bytes) {
this.frameBuffer = java.nio.ByteBuffer.allocateDirect(bytes);
this.frameView = new Uint8Array((ArrayBuffer as any).from(this.frameBuffer));
}
if (!this.player.copyLastFrame(this.frameBuffer)) return null;
const image = new GrayImage(width, height, 0);
image.pixels.set(this.frameView);
return image;
}
/** End playback and free the decoder and audio (the last frame stays readable). */
stop(): void {
this.player.stop();
}
release(): void {
this.player.release();
this.frameBuffer = null;
this.frameView = null;
}
}