Files
FireworksApp/frontend/src/scripts/browser-submission-processor.js
T

140 lines
6.4 KiB
JavaScript

const PREFIX = "[BoomCast][BrowserBeta]";
export function readBrowserProcessingConfig() {
const element = document.querySelector("#boomcast-browser-config");
if (!element) return { browserProcessingBeta: false };
try { return JSON.parse(element.textContent); }
catch (error) {
console.error(`${PREFIX} Configuration unavailable:`, error);
return { browserProcessingBeta: false };
}
}
export class BrowserSubmissionProcessor {
constructor(config = readBrowserProcessingConfig(), extractVideo = null, dependencies = {}) {
this.config = config;
this.extractVideo = extractVideo;
this.dependencies = dependencies;
this.userEnabled = false;
this.activeController = null;
}
isAvailable() { return this.config.browserProcessingBeta === true; }
isEnabled() { return this.isAvailable() && this.userEnabled; }
setEnabled(enabled) {
if (!enabled) this.cancel();
this.userEnabled = this.isAvailable() && enabled === true;
console.log(`${PREFIX} ${this.userEnabled ? "Browser processing enabled by user." : "Browser processing disabled by user; using existing server flow."}`);
}
cancel() {
this.activeController?.abort();
this.activeController = null;
}
async process(file, { signal, onState } = {}) {
this.cancel();
const controller = new AbortController();
this.activeController = controller;
const abort = () => controller.abort();
signal?.addEventListener("abort", abort, { once: true });
if (signal?.aborted) controller.abort();
try {
return await this.prepare(file, { signal: controller.signal, onState });
} finally {
signal?.removeEventListener("abort", abort);
if (this.activeController === controller) this.activeController = null;
}
}
canProcess(file) {
return this.isEnabled() && Boolean(file) && (BrowserSubmissionProcessor.isAudio(file) || BrowserSubmissionProcessor.isVideo(file));
}
static isAudio(file) {
return Boolean(file) && (file.type.startsWith("audio/") || (!file.type && /\.(aac|aif|aiff|flac|m4a|mp3|ogg|opus|wav|weba)$/i.test(file.name || "")));
}
static isVideo(file) {
return Boolean(file) && (file.type.startsWith("video/") || (!file.type && /\.(mp4|mov|m4v|webm|mkv|avi)$/i.test(file.name || "")));
}
async prepare(file, { signal, onState = () => {} } = {}) {
if (!this.canProcess(file)) return { file, metadata: null, gate: "unavailable" };
console.log(`${PREFIX} Initialising beta submission pipeline.`);
console.log(`${PREFIX} File selected:`, { type: file?.type || "", size: file?.size || 0 });
const video = BrowserSubmissionProcessor.isVideo(file);
const controller = new AbortController();
const abort = () => controller.abort();
signal?.addEventListener("abort", abort, { once: true });
const timeout = setTimeout(() => controller.abort(), 5000);
let policy;
try {
const response = await fetch(this.config.policyUrl, {
cache: "no-store", credentials: "same-origin", signal: controller.signal,
});
if (!response.ok) throw new Error(`Policy HTTP ${response.status}`);
policy = await response.json();
if (!policy.browser_processing_beta_enabled || policy.version !== this.config.policyVersion) {
console.log(`${PREFIX} Browser beta disabled or policy changed; using legacy submission flow.`);
return { file, metadata: null, gate: "unavailable" };
}
} catch (error) {
if (signal?.aborted) throw error;
console.error(`${PREFIX} Policy unavailable:`, error);
if (video) throw error;
return { file, metadata: null, gate: "unavailable" };
} finally {
clearTimeout(timeout);
signal?.removeEventListener("abort", abort);
}
if (signal?.aborted) throw new DOMException("Cancelled", "AbortError");
let preparedFile = file;
if (video) {
const extract = this.extractVideo || (await import("./ffmpeg-video-extractor.js")).extractVideoAudio;
preparedFile = await extract(file, { signal, onState });
}
const metadata = {
browser_processing_used: video,
browser_processing_version: policy.version,
browser_gate_result: "unavailable",
browser_override: false,
};
try {
onState("checking");
const prepareAudio = this.dependencies.prepareAudio || (await import("./audio-preprocessor.js")).AudioPreprocessor.prepare;
let waveform = await prepareAudio(preparedFile, { signal });
if (signal?.aborted) throw new DOMException("Cancelled", "AbortError");
try {
const classify = this.dependencies.classify || (await import("./browser-yamnet-classifier.js")).BrowserYamnetClassifier.classify;
const predictions = await classify(waveform, {
modelUrl: policy.model_url, classMapUrl: policy.class_map_url, signal,
});
if (signal?.aborted) throw new DOMException("Cancelled", "AbortError");
const evaluate = this.dependencies.evaluate || (await import("./browser-submission-gate.js")).BrowserSubmissionGate.evaluate;
const decision = evaluate(predictions, policy);
metadata.browser_processing_used = true;
metadata.browser_gate_result = decision.result;
metadata.browser_speech_detected = decision.speechDetected;
return { file: preparedFile, metadata, gate: decision.result, predictions: predictions.slice(0, 5) };
} finally {
waveform = null;
console.log("[BoomCast][Cleanup] Releasing waveform buffers.");
}
} catch (error) {
if (signal?.aborted) throw error;
console.error("[BoomCast][YAMNet] Local classification unavailable:", error);
console.log("[BoomCast][Gate] Falling back to server classification.");
metadata.browser_gate_result = "unavailable";
return { file: preparedFile, metadata, gate: "unavailable" };
}
}
cleanup() {
this.cancel();
console.log("[BoomCast][Cleanup] Browser beta resources released.");
}
}