mirror of
https://git.undefined-dev.fr/Blendman974/faceclaw.git
synced 2026-11-19 21:03:09 +00:00
149 lines
4.7 KiB
TypeScript
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;
|
|
}
|
|
}
|