mirror of
https://github.com/MrLowPr/overdrive.git
synced 2026-10-17 17:01:14 +02:00
548 lines
25 KiB
C++
548 lines
25 KiB
C++
// Copyright (C) 2026 half144 and PS5 React contributors
|
|
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
// Additional attribution term: see LICENSE-ATTRIBUTION.
|
|
#include "host_api.hpp"
|
|
#include "app_config.hpp"
|
|
#include "video_api.hpp"
|
|
|
|
#if PS5_REACT_VIDEO
|
|
#include "video_audio.hpp"
|
|
#include "video_player.hpp"
|
|
|
|
extern "C" {
|
|
#include "er_scene.h"
|
|
}
|
|
|
|
#include <algorithm>
|
|
#include <chrono>
|
|
#include <cmath>
|
|
#include <cstdio>
|
|
#include <cstring>
|
|
#include <memory>
|
|
#include <string>
|
|
#include <thread>
|
|
#include <vector>
|
|
|
|
namespace {
|
|
struct Entry {
|
|
std::uint32_t id = 0;
|
|
std::unique_ptr<video::Player> player;
|
|
std::string name; // the placeholder image the <Video> element draws, and the presenter replaces
|
|
GlVideo::Fit fit = GlVideo::Fit::contain;
|
|
int upscale = upscalers::kNone;
|
|
GlVideo::Compare compare;
|
|
bool audio = true;
|
|
};
|
|
|
|
// Oldest first: the newest player with audio owns the mixer's video slot.
|
|
std::vector<Entry> players;
|
|
std::uint32_t next_id = 1;
|
|
std::vector<std::string> unload_names;
|
|
std::vector<std::pair<std::shared_ptr<void>, std::int64_t>> kept_rings;
|
|
std::int64_t last_now_us = 0;
|
|
|
|
// Every placeholder is the same opaque black tile: an <Image layer> qualifies only with opaque pixels.
|
|
constexpr int kTile = 16;
|
|
std::uint32_t tile[kTile * kTile];
|
|
|
|
Entry* find(std::uint32_t id) {
|
|
for (Entry& entry : players)
|
|
if (entry.id == id) return &entry;
|
|
return nullptr;
|
|
}
|
|
|
|
void assign_audio() {
|
|
Entry* owner = nullptr;
|
|
for (Entry& entry : players)
|
|
if (entry.audio) owner = &entry;
|
|
for (Entry& entry : players) entry.player->set_audio_output(&entry == owner);
|
|
}
|
|
|
|
// Joining a player's threads can take a decode's length; it is done off the render thread.
|
|
void dispose(Entry& entry) {
|
|
for (auto& ring : entry.player->detach_audio()) kept_rings.emplace_back(std::move(ring), last_now_us + 300'000);
|
|
unload_names.push_back(entry.name);
|
|
std::thread([player = std::move(entry.player)]() mutable { player.reset(); }).detach();
|
|
}
|
|
|
|
bool get_bool(JSContext* ctx, JSValueConst object, const char* key, bool fallback) {
|
|
JSValue value = JS_GetPropertyStr(ctx, object, key);
|
|
const bool result = JS_IsUndefined(value) ? fallback : JS_ToBool(ctx, value) > 0;
|
|
JS_FreeValue(ctx, value);
|
|
return result;
|
|
}
|
|
|
|
double get_number(JSContext* ctx, JSValueConst object, const char* key, double fallback) {
|
|
JSValue value = JS_GetPropertyStr(ctx, object, key);
|
|
double result = fallback;
|
|
if (JS_IsNumber(value)) JS_ToFloat64(ctx, &result, value);
|
|
JS_FreeValue(ctx, value);
|
|
return std::isfinite(result) ? result : fallback;
|
|
}
|
|
|
|
// 'pcm', 'auto' or 'passthrough'; false for anything else.
|
|
bool audio_output_mode(JSContext* ctx, JSValueConst value, video::AudioOutput& mode) {
|
|
const char* name = JS_ToCString(ctx, value);
|
|
if (!name) return false;
|
|
const bool known = !std::strcmp(name, "pcm") || !std::strcmp(name, "auto") || !std::strcmp(name, "passthrough");
|
|
mode = !std::strcmp(name, "auto") ? video::AudioOutput::automatic
|
|
: !std::strcmp(name, "passthrough") ? video::AudioOutput::passthrough : video::AudioOutput::pcm;
|
|
JS_FreeCString(ctx, name);
|
|
return known;
|
|
}
|
|
|
|
Entry* entry_arg(JSContext* ctx, JSValueConst value, const char* call) {
|
|
std::uint32_t id = 0;
|
|
if (JS_ToUint32(ctx, &id, value)) return nullptr;
|
|
Entry* entry = find(id);
|
|
if (!entry) JS_ThrowRangeError(ctx, "%s: no open video %u", call, id);
|
|
return entry;
|
|
}
|
|
|
|
JSValue open(JSContext* ctx, JSValueConst, int argc, JSValueConst* argv) {
|
|
const char* url = argc ? JS_ToCString(ctx, argv[0]) : nullptr;
|
|
if (!url) return JS_ThrowTypeError(ctx, "video.open: expected a URL or path");
|
|
std::string source = url;
|
|
JS_FreeCString(ctx, url);
|
|
if (source.empty()) return JS_ThrowTypeError(ctx, "video.open: expected a URL or path");
|
|
if (!PS5_REACT_NETWORKING && source.find("://") != std::string::npos)
|
|
return JS_ThrowPlainError(ctx, "video.open %s: streaming needs \"networking\": true in app.json", source.c_str());
|
|
// App paths (/app0, /download0, ...) map to real paths as the filesystem does; URLs pass through.
|
|
if (source.find("://") == std::string::npos) {
|
|
char path[1024];
|
|
if (!host::resolve_path(source.c_str(), path, sizeof path))
|
|
return JS_ThrowPlainError(ctx, "video.open %s: not an app path or URL", source.c_str());
|
|
source = path;
|
|
}
|
|
video::Options options;
|
|
JSValueConst settings = argc > 1 ? argv[1] : JS_UNDEFINED;
|
|
if (JS_IsObject(settings)) {
|
|
options.paused = get_bool(ctx, settings, "paused", false);
|
|
options.muted = get_bool(ctx, settings, "muted", false);
|
|
options.loop = get_bool(ctx, settings, "loop", false);
|
|
options.audio = get_bool(ctx, settings, "audio", true);
|
|
options.volume = static_cast<float>(get_number(ctx, settings, "volume", 1));
|
|
options.start = get_number(ctx, settings, "start", 0);
|
|
JSValue output = JS_GetPropertyStr(ctx, settings, "audioOutput");
|
|
const bool known = JS_IsUndefined(output) || audio_output_mode(ctx, output, options.audio_output);
|
|
JS_FreeValue(ctx, output);
|
|
if (!known) return JS_ThrowRangeError(ctx, "video.open %s: audioOutput is 'pcm', 'auto' or 'passthrough'", source.c_str());
|
|
JSValue headers = JS_GetPropertyStr(ctx, settings, "headers");
|
|
if (JS_IsObject(headers)) {
|
|
JSPropertyEnum* names = nullptr;
|
|
std::uint32_t count = 0;
|
|
if (!JS_GetOwnPropertyNames(ctx, &names, &count, headers, JS_GPN_STRING_MASK | JS_GPN_ENUM_ONLY)) {
|
|
for (std::uint32_t i = 0; i < count; ++i) {
|
|
const char* name = JS_AtomToCString(ctx, names[i].atom);
|
|
JSValue value = JS_GetProperty(ctx, headers, names[i].atom);
|
|
const char* text = JS_ToCString(ctx, value);
|
|
if (name && text && !std::strpbrk(name, "\r\n:") && !std::strpbrk(text, "\r\n"))
|
|
options.headers.push_back(std::string(name) + ": " + text);
|
|
if (text) JS_FreeCString(ctx, text);
|
|
if (name) JS_FreeCString(ctx, name);
|
|
JS_FreeValue(ctx, value);
|
|
JS_FreeAtom(ctx, names[i].atom);
|
|
}
|
|
js_free(ctx, names);
|
|
}
|
|
}
|
|
JS_FreeValue(ctx, headers);
|
|
}
|
|
if (options.audio) video_audio::start();
|
|
Entry entry;
|
|
entry.id = next_id++;
|
|
entry.name = "video:" + std::to_string(entry.id);
|
|
entry.audio = options.audio;
|
|
if (!er_image_load_argb(entry.name.c_str(), tile, kTile, kTile, true))
|
|
return JS_ThrowPlainError(ctx, "video.open %s: the image registry is full", source.c_str());
|
|
// The newest player gets the audio; the one that had it goes quiet.
|
|
for (Entry& other : players)
|
|
if (options.audio) other.player->set_audio_output(false);
|
|
entry.player = std::make_unique<video::Player>(source, options);
|
|
players.push_back(std::move(entry));
|
|
JSValue out = JS_NewObject(ctx);
|
|
JS_SetPropertyStr(ctx, out, "id", JS_NewUint32(ctx, players.back().id));
|
|
JS_SetPropertyStr(ctx, out, "name", JS_NewString(ctx, players.back().name.c_str()));
|
|
return out;
|
|
}
|
|
|
|
JSValue close(JSContext* ctx, JSValueConst, int argc, JSValueConst* argv) {
|
|
std::uint32_t id = 0;
|
|
if (!argc || JS_ToUint32(ctx, &id, argv[0])) return JS_ThrowTypeError(ctx, "video.close: expected a video id");
|
|
for (auto it = players.begin(); it != players.end(); ++it) {
|
|
if (it->id != id) continue;
|
|
dispose(*it);
|
|
players.erase(it);
|
|
assign_audio();
|
|
break;
|
|
}
|
|
return JS_UNDEFINED;
|
|
}
|
|
|
|
JSValue set_paused(JSContext* ctx, JSValueConst, int argc, JSValueConst* argv) {
|
|
Entry* entry = argc >= 2 ? entry_arg(ctx, argv[0], "video.setPaused") : nullptr;
|
|
if (!entry) return argc >= 2 ? JS_EXCEPTION : JS_ThrowTypeError(ctx, "video.setPaused: expected id and paused");
|
|
entry->player->set_paused(JS_ToBool(ctx, argv[1]) > 0, last_now_us);
|
|
return JS_UNDEFINED;
|
|
}
|
|
|
|
JSValue seek(JSContext* ctx, JSValueConst, int argc, JSValueConst* argv) {
|
|
Entry* entry = argc >= 2 ? entry_arg(ctx, argv[0], "video.seek") : nullptr;
|
|
double seconds = 0;
|
|
if (!entry) return argc >= 2 ? JS_EXCEPTION : JS_ThrowTypeError(ctx, "video.seek: expected id and seconds");
|
|
if (JS_ToFloat64(ctx, &seconds, argv[1]) || !std::isfinite(seconds))
|
|
return JS_ThrowTypeError(ctx, "video.seek: seconds must be a number");
|
|
entry->player->seek(seconds);
|
|
return JS_UNDEFINED;
|
|
}
|
|
|
|
JSValue set_volume(JSContext* ctx, JSValueConst, int argc, JSValueConst* argv) {
|
|
Entry* entry = argc >= 2 ? entry_arg(ctx, argv[0], "video.setVolume") : nullptr;
|
|
double volume = 1;
|
|
if (!entry) return argc >= 2 ? JS_EXCEPTION : JS_ThrowTypeError(ctx, "video.setVolume: expected id and volume");
|
|
if (JS_ToFloat64(ctx, &volume, argv[1])) return JS_EXCEPTION;
|
|
entry->player->set_volume(static_cast<float>(volume));
|
|
return JS_UNDEFINED;
|
|
}
|
|
|
|
JSValue set_muted(JSContext* ctx, JSValueConst, int argc, JSValueConst* argv) {
|
|
Entry* entry = argc >= 2 ? entry_arg(ctx, argv[0], "video.setMuted") : nullptr;
|
|
if (!entry) return argc >= 2 ? JS_EXCEPTION : JS_ThrowTypeError(ctx, "video.setMuted: expected id and muted");
|
|
entry->player->set_muted(JS_ToBool(ctx, argv[1]) > 0);
|
|
return JS_UNDEFINED;
|
|
}
|
|
|
|
JSValue set_loop(JSContext* ctx, JSValueConst, int argc, JSValueConst* argv) {
|
|
Entry* entry = argc >= 2 ? entry_arg(ctx, argv[0], "video.setLoop") : nullptr;
|
|
if (!entry) return argc >= 2 ? JS_EXCEPTION : JS_ThrowTypeError(ctx, "video.setLoop: expected id and loop");
|
|
entry->player->set_loop(JS_ToBool(ctx, argv[1]) > 0);
|
|
return JS_UNDEFINED;
|
|
}
|
|
|
|
JSValue set_audio_delay(JSContext* ctx, JSValueConst, int argc, JSValueConst* argv) {
|
|
Entry* entry = argc >= 2 ? entry_arg(ctx, argv[0], "video.setAudioDelay") : nullptr;
|
|
double seconds = 0;
|
|
if (!entry) return argc >= 2 ? JS_EXCEPTION : JS_ThrowTypeError(ctx, "video.setAudioDelay: expected id and seconds");
|
|
if (JS_ToFloat64(ctx, &seconds, argv[1])) return JS_EXCEPTION;
|
|
entry->player->set_audio_delay(seconds);
|
|
return JS_UNDEFINED;
|
|
}
|
|
|
|
JSValue set_fit(JSContext* ctx, JSValueConst, int argc, JSValueConst* argv) {
|
|
Entry* entry = argc >= 2 ? entry_arg(ctx, argv[0], "video.setResizeMode") : nullptr;
|
|
std::int32_t fit = 0;
|
|
if (!entry) return argc >= 2 ? JS_EXCEPTION : JS_ThrowTypeError(ctx, "video.setResizeMode: expected id and mode");
|
|
if (JS_ToInt32(ctx, &fit, argv[1]) || fit < 0 || fit > 2)
|
|
return JS_ThrowRangeError(ctx, "video.setResizeMode: 0 contain, 1 cover or 2 stretch");
|
|
entry->fit = static_cast<GlVideo::Fit>(fit);
|
|
return JS_UNDEFINED;
|
|
}
|
|
|
|
JSValue set_upscale(JSContext* ctx, JSValueConst, int argc, JSValueConst* argv) {
|
|
Entry* entry = argc >= 2 ? entry_arg(ctx, argv[0], "video.setUpscale") : nullptr;
|
|
if (!entry) return argc >= 2 ? JS_EXCEPTION : JS_ThrowTypeError(ctx, "video.setUpscale: expected id and model");
|
|
const char* name = JS_ToCString(ctx, argv[1]);
|
|
if (!name) return JS_EXCEPTION;
|
|
const int model = *name ? upscalers::find(name) : upscalers::kNone;
|
|
const bool known = !*name || model != upscalers::kNone;
|
|
JS_FreeCString(ctx, name);
|
|
if (!known) return JS_ThrowRangeError(ctx, "video.setUpscale: '' for none, or %s", upscalers::names().c_str());
|
|
entry->upscale = model;
|
|
return JS_UNDEFINED;
|
|
}
|
|
|
|
// setCompare(id, model, split): right of `split` (0..1 across the picture) the picture goes through
|
|
// `model` ('' for none) instead; a null model ends the comparison.
|
|
JSValue set_compare(JSContext* ctx, JSValueConst, int argc, JSValueConst* argv) {
|
|
Entry* entry = argc >= 3 ? entry_arg(ctx, argv[0], "video.setCompare") : nullptr;
|
|
if (!entry) return argc >= 3 ? JS_EXCEPTION : JS_ThrowTypeError(ctx, "video.setCompare: expected id, model and split");
|
|
if (JS_IsNull(argv[1]) || JS_IsUndefined(argv[1])) {
|
|
entry->compare = {};
|
|
return JS_UNDEFINED;
|
|
}
|
|
double split = 0.5;
|
|
if (JS_ToFloat64(ctx, &split, argv[2])) return JS_EXCEPTION;
|
|
const char* name = JS_ToCString(ctx, argv[1]);
|
|
if (!name) return JS_EXCEPTION;
|
|
const int model = *name ? upscalers::find(name) : upscalers::kNone;
|
|
const bool known = !*name || model != upscalers::kNone;
|
|
JS_FreeCString(ctx, name);
|
|
if (!known) return JS_ThrowRangeError(ctx, "video.setCompare: null, '' for none, or %s", upscalers::names().c_str());
|
|
entry->compare = {true, model, float(std::clamp(split, 0.0, 1.0))};
|
|
return JS_UNDEFINED;
|
|
}
|
|
|
|
JSValue set_audio_output(JSContext* ctx, JSValueConst, int argc, JSValueConst* argv) {
|
|
Entry* entry = argc >= 2 ? entry_arg(ctx, argv[0], "video.setAudioOutput") : nullptr;
|
|
if (!entry) return argc >= 2 ? JS_EXCEPTION : JS_ThrowTypeError(ctx, "video.setAudioOutput: expected id and mode");
|
|
video::AudioOutput mode;
|
|
if (!audio_output_mode(ctx, argv[1], mode))
|
|
return JS_ThrowRangeError(ctx, "video.setAudioOutput: 'pcm', 'auto' or 'passthrough'");
|
|
entry->player->set_audio_mode(mode);
|
|
return JS_UNDEFINED;
|
|
}
|
|
|
|
JSValue select_subtitle(JSContext* ctx, JSValueConst, int argc, JSValueConst* argv) {
|
|
Entry* entry = argc >= 2 ? entry_arg(ctx, argv[0], "video.selectSubtitleTrack") : nullptr;
|
|
std::int32_t index = -1;
|
|
if (!entry) return argc >= 2 ? JS_EXCEPTION : JS_ThrowTypeError(ctx, "video.selectSubtitleTrack: expected id and track");
|
|
if (JS_ToInt32(ctx, &index, argv[1])) return JS_EXCEPTION;
|
|
entry->player->select_subtitle_track(index);
|
|
return JS_UNDEFINED;
|
|
}
|
|
|
|
JSValue add_subtitle(JSContext* ctx, JSValueConst, int argc, JSValueConst* argv) {
|
|
Entry* entry = argc >= 2 ? entry_arg(ctx, argv[0], "video.addSubtitle") : nullptr;
|
|
if (!entry) return argc >= 2 ? JS_EXCEPTION : JS_ThrowTypeError(ctx, "video.addSubtitle: expected id and URL");
|
|
const auto text = [&](int i) {
|
|
std::string out;
|
|
if (argc > i && JS_IsString(argv[i]))
|
|
if (const char* value = JS_ToCString(ctx, argv[i])) {
|
|
out = value;
|
|
JS_FreeCString(ctx, value);
|
|
}
|
|
return out;
|
|
};
|
|
std::string source = text(1);
|
|
if (source.empty()) return JS_ThrowTypeError(ctx, "video.addSubtitle: expected a URL or path");
|
|
if (source.find("://") == std::string::npos) {
|
|
char path[1024];
|
|
if (!host::resolve_path(source.c_str(), path, sizeof path))
|
|
return JS_ThrowPlainError(ctx, "video.addSubtitle %s: not an app path or URL", source.c_str());
|
|
source = path;
|
|
} else if (!PS5_REACT_NETWORKING) {
|
|
return JS_ThrowPlainError(ctx, "video.addSubtitle %s: streaming needs \"networking\": true in app.json", source.c_str());
|
|
}
|
|
return JS_NewInt32(ctx, entry->player->add_subtitle_file(source, text(2), text(3)));
|
|
}
|
|
|
|
JSValue select_audio(JSContext* ctx, JSValueConst, int argc, JSValueConst* argv) {
|
|
Entry* entry = argc >= 2 ? entry_arg(ctx, argv[0], "video.selectAudioTrack") : nullptr;
|
|
std::int32_t index = -1;
|
|
if (!entry) return argc >= 2 ? JS_EXCEPTION : JS_ThrowTypeError(ctx, "video.selectAudioTrack: expected id and track");
|
|
if (JS_ToInt32(ctx, &index, argv[1])) return JS_EXCEPTION;
|
|
entry->player->select_audio_track(index);
|
|
return JS_UNDEFINED;
|
|
}
|
|
|
|
const char* state_name(video::State state) {
|
|
switch (state) {
|
|
case video::State::loading: return "loading";
|
|
case video::State::ready: return "ready";
|
|
case video::State::buffering: return "buffering";
|
|
case video::State::ended: return "ended";
|
|
case video::State::failed: return "failed";
|
|
}
|
|
return "failed";
|
|
}
|
|
|
|
JSValue poll(JSContext* ctx, JSValueConst, int, JSValueConst*) {
|
|
JSValue out = JS_NewArray(ctx);
|
|
std::uint32_t index = 0;
|
|
for (const Entry& entry : players) {
|
|
const video::Status status = entry.player->status();
|
|
JSValue item = JS_NewObject(ctx);
|
|
JS_SetPropertyStr(ctx, item, "id", JS_NewUint32(ctx, entry.id));
|
|
JS_SetPropertyStr(ctx, item, "state", JS_NewString(ctx, state_name(status.state)));
|
|
JS_SetPropertyStr(ctx, item, "paused", JS_NewBool(ctx, status.paused));
|
|
JS_SetPropertyStr(ctx, item, "seeking", JS_NewBool(ctx, status.seeking));
|
|
JS_SetPropertyStr(ctx, item, "position", JS_NewFloat64(ctx, status.position));
|
|
JS_SetPropertyStr(ctx, item, "duration", JS_NewFloat64(ctx, status.duration));
|
|
JS_SetPropertyStr(ctx, item, "buffered", JS_NewFloat64(ctx, status.buffered));
|
|
JS_SetPropertyStr(ctx, item, "width", JS_NewInt32(ctx, status.width));
|
|
JS_SetPropertyStr(ctx, item, "height", JS_NewInt32(ctx, status.height));
|
|
JS_SetPropertyStr(ctx, item, "aspect", JS_NewFloat64(ctx, status.aspect));
|
|
JS_SetPropertyStr(ctx, item, "error", JS_NewString(ctx, status.error.c_str()));
|
|
JS_SetPropertyStr(ctx, item, "videoCodec", JS_NewString(ctx, status.video_codec.c_str()));
|
|
JS_SetPropertyStr(ctx, item, "audioCodec", JS_NewString(ctx, status.audio_codec.c_str()));
|
|
JS_SetPropertyStr(ctx, item, "decoder", JS_NewString(ctx, status.decoder.c_str()));
|
|
JS_SetPropertyStr(ctx, item, "audioTrack", JS_NewInt32(ctx, status.audio_track));
|
|
JS_SetPropertyStr(ctx, item, "shownFrames", JS_NewFloat64(ctx, static_cast<double>(status.shown_frames)));
|
|
JS_SetPropertyStr(ctx, item, "droppedFrames", JS_NewFloat64(ctx, static_cast<double>(status.dropped_frames)));
|
|
JS_SetPropertyStr(ctx, item, "lateMs", JS_NewFloat64(ctx, status.late_ms));
|
|
JS_SetPropertyStr(ctx, item, "audioClock", JS_NewBool(ctx, status.audio_clock));
|
|
JS_SetPropertyStr(ctx, item, "audioPassthrough", JS_NewBool(ctx, status.audio_passthrough));
|
|
JSValue tracks = JS_NewArray(ctx);
|
|
std::uint32_t at = 0;
|
|
for (const video::Track& track : status.audio_tracks) {
|
|
JSValue t = JS_NewObject(ctx);
|
|
JS_SetPropertyStr(ctx, t, "index", JS_NewInt32(ctx, track.index));
|
|
JS_SetPropertyStr(ctx, t, "language", JS_NewString(ctx, track.language.c_str()));
|
|
JS_SetPropertyStr(ctx, t, "title", JS_NewString(ctx, track.title.c_str()));
|
|
JS_SetPropertyStr(ctx, t, "codec", JS_NewString(ctx, track.codec.c_str()));
|
|
JS_SetPropertyStr(ctx, t, "channels", JS_NewInt32(ctx, track.channels));
|
|
JS_SetPropertyUint32(ctx, tracks, at++, t);
|
|
}
|
|
JS_SetPropertyStr(ctx, item, "audioTracks", tracks);
|
|
JSValue subtitles = JS_NewArray(ctx);
|
|
at = 0;
|
|
for (const video::Track& track : status.subtitle_tracks) {
|
|
JSValue t = JS_NewObject(ctx);
|
|
JS_SetPropertyStr(ctx, t, "index", JS_NewInt32(ctx, track.index));
|
|
JS_SetPropertyStr(ctx, t, "language", JS_NewString(ctx, track.language.c_str()));
|
|
JS_SetPropertyStr(ctx, t, "title", JS_NewString(ctx, track.title.c_str()));
|
|
JS_SetPropertyStr(ctx, t, "codec", JS_NewString(ctx, track.codec.c_str()));
|
|
JS_SetPropertyStr(ctx, t, "external", JS_NewBool(ctx, track.external));
|
|
JS_SetPropertyUint32(ctx, subtitles, at++, t);
|
|
}
|
|
JS_SetPropertyStr(ctx, item, "subtitleTracks", subtitles);
|
|
JS_SetPropertyStr(ctx, item, "subtitleTrack", JS_NewInt32(ctx, status.subtitle_track));
|
|
JS_SetPropertyStr(ctx, item, "subtitle", JS_NewString(ctx, status.subtitle.c_str()));
|
|
JS_SetPropertyUint32(ctx, out, index++, item);
|
|
}
|
|
return out;
|
|
}
|
|
} // namespace
|
|
|
|
namespace video_layers {
|
|
bool find(const char* image_name, Layer& layer) {
|
|
if (!image_name || std::strncmp(image_name, "video:", 6) != 0) return false;
|
|
for (const Entry& entry : players) {
|
|
if (entry.name != image_name) continue;
|
|
layer.id = entry.id;
|
|
layer.frame = entry.player->frame();
|
|
layer.fit = entry.fit;
|
|
layer.upscale = entry.upscale;
|
|
layer.compare = entry.compare;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
namespace {
|
|
float sample_at(const video::Frame& frame, int plane, int x, int y, int second) {
|
|
const bool wide = video::deep(frame.format);
|
|
const bool pairs = video::interleaved(frame.format) && plane == 1;
|
|
const int bytes = wide ? 2 : 1, step = bytes * (pairs ? 2 : 1);
|
|
const std::uint8_t* at = frame.planes[plane] + static_cast<std::size_t>(y) * frame.pitch[plane] + x * step + second * bytes;
|
|
if (!wide) return at[0] / 255.0f;
|
|
const float value = (at[0] | (at[1] << 8)) / 65535.0f;
|
|
return value * video::sample_scale(frame.format);
|
|
}
|
|
|
|
float pq_to_nits(float e) {
|
|
const float m1 = 0.1593017578125f, m2 = 78.84375f, c1 = 0.8359375f, c2 = 18.8515625f, c3 = 18.6875f;
|
|
const float p = std::pow(std::clamp(e, 0.0f, 1.0f), 1 / m2);
|
|
return std::pow(std::max(p - c1, 0.0f) / (c2 - c3 * p), 1 / m1) * 10000;
|
|
}
|
|
} // namespace
|
|
|
|
bool sample(const char* image_name, int dst_x, int dst_y, int dst_w, int dst_h, int x, int y, unsigned rgb[3]) {
|
|
Layer layer;
|
|
if (!find(image_name, layer)) return false;
|
|
rgb[0] = rgb[1] = rgb[2] = 0;
|
|
const video::Frame* frame = layer.frame;
|
|
if (!frame || dst_w <= 0 || dst_h <= 0) return true;
|
|
// The same fit as GlVideo::draw.
|
|
const float picture = frame->width * frame->aspect / frame->height, box = float(dst_w) / dst_h;
|
|
float u = (x + 0.5f - dst_x) / dst_w, v = (y + 0.5f - dst_y) / dst_h;
|
|
if (layer.fit == GlVideo::Fit::contain) {
|
|
if (picture > box) v = (v - 0.5f) * box / picture + 0.5f;
|
|
else u = (u - 0.5f) * picture / box + 0.5f;
|
|
if (u < 0 || u >= 1 || v < 0 || v >= 1) return true;
|
|
} else if (layer.fit == GlVideo::Fit::cover) {
|
|
if (picture > box) u = (u - 0.5f) * box / picture + 0.5f;
|
|
else v = (v - 0.5f) * picture / box + 0.5f;
|
|
}
|
|
const int px = std::clamp(int(u * frame->width), 0, frame->width - 1), py = std::clamp(int(v * frame->height), 0, frame->height - 1);
|
|
const bool pairs = video::interleaved(frame->format);
|
|
float yuv[3] = {sample_at(*frame, 0, px, py, 0), sample_at(*frame, 1, px / 2, py / 2, 0),
|
|
pairs ? sample_at(*frame, 1, px / 2, py / 2, 1) : sample_at(*frame, 2, px / 2, py / 2, 0)};
|
|
const float kr[] = {0.299f, 0.2126f, 0.2627f}, kb[] = {0.114f, 0.0722f, 0.0593f};
|
|
const int m = static_cast<int>(frame->matrix);
|
|
const float r = kr[m], b = kb[m], g = 1 - r - b;
|
|
float Y, cb, cr;
|
|
if (frame->full_range) { Y = yuv[0]; cb = yuv[1] - 0.5f; cr = yuv[2] - 0.5f; }
|
|
else { Y = (yuv[0] - 16 / 255.0f) * 255 / 219; cb = (yuv[1] - 128 / 255.0f) * 255 / 224; cr = (yuv[2] - 128 / 255.0f) * 255 / 224; }
|
|
float out[3] = {Y + 2 * (1 - r) * cr, Y - 2 * (1 - b) * b / g * cb - 2 * (1 - r) * r / g * cr, Y + 2 * (1 - b) * cb};
|
|
if (frame->transfer == video::Transfer::pq) {
|
|
// As the shader: nits, BT.2020 to BT.709, reference white to 1, the soft shoulder, gamma 2.4.
|
|
float n[3] = {pq_to_nits(out[0]) / 203, pq_to_nits(out[1]) / 203, pq_to_nits(out[2]) / 203};
|
|
float c[3] = {1.6605f * n[0] - 0.5876f * n[1] - 0.0728f * n[2], -0.1246f * n[0] + 1.1329f * n[1] - 0.0083f * n[2],
|
|
-0.0182f * n[0] - 0.1006f * n[1] + 1.1187f * n[2]};
|
|
const float peak = std::max({c[0], c[1], c[2], 0.0f}), knee = 0.75f;
|
|
const float scale = peak > knee ? (knee + (1 - knee) * std::tanh((peak - knee) / (1 - knee))) / peak : 1;
|
|
for (int i = 0; i < 3; ++i) out[i] = std::pow(std::max(c[i] * scale, 0.0f), 1 / 2.4f);
|
|
}
|
|
for (int i = 0; i < 3; ++i) rgb[2 - i] = static_cast<unsigned>(std::clamp(out[i], 0.0f, 1.0f) * 255 + 0.5f);
|
|
return true;
|
|
}
|
|
|
|
void update(std::int64_t now_us, std::int64_t frame_us) {
|
|
last_now_us = now_us;
|
|
// Closed during this frame's JavaScript, before the commit that removed their elements painted.
|
|
for (const std::string& name : unload_names) er_image_unload(name.c_str());
|
|
unload_names.clear();
|
|
std::erase_if(kept_rings, [&](const auto& kept) { return kept.second <= now_us; });
|
|
for (Entry& entry : players) entry.player->update(now_us, frame_us);
|
|
}
|
|
|
|
std::string summary() {
|
|
std::string out;
|
|
for (const Entry& entry : players) {
|
|
const video::Status s = entry.player->status();
|
|
char line[384];
|
|
std::snprintf(line, sizeof line, "%svideo %u %s %.1f/%.1fs buffered %.1fs %s %dx%d via %s shown=%llu dropped=%llu "
|
|
"late=%.1fms clock=%s%s queue=%d/%d starved=%d%s%s", out.empty() ? "" : "\n", entry.id, state_name(s.state), s.position,
|
|
s.duration, s.buffered, s.video_codec.c_str(), s.width, s.height, s.decoder.c_str(),
|
|
static_cast<unsigned long long>(s.shown_frames), static_cast<unsigned long long>(s.dropped_frames),
|
|
s.late_ms, s.audio_clock ? "audio" : "wall", s.audio_passthrough ? " passthrough" : "", s.queued_frames, s.queued_packets, s.starved_updates,
|
|
s.error.empty() ? "" : " error=", s.error.c_str());
|
|
out += line;
|
|
}
|
|
return out;
|
|
}
|
|
|
|
void stop() {
|
|
for (Entry& entry : players) {
|
|
for (auto& ring : entry.player->detach_audio()) kept_rings.emplace_back(std::move(ring), 0);
|
|
entry.player.reset();
|
|
}
|
|
players.clear();
|
|
// The mixer reads a ring swapped out for at most a grain or two.
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(30));
|
|
kept_rings.clear();
|
|
}
|
|
} // namespace video_layers
|
|
|
|
JSValue ps5_react_video_api(JSContext* ctx) {
|
|
JSValue out = JS_NewObject(ctx);
|
|
const struct { const char* name; JSCFunction* call; int length; } functions[] = {
|
|
{"open", open, 2}, {"close", close, 1}, {"setPaused", set_paused, 2}, {"seek", seek, 2},
|
|
{"setVolume", set_volume, 2}, {"setMuted", set_muted, 2}, {"setLoop", set_loop, 2},
|
|
{"setAudioDelay", set_audio_delay, 2}, {"setAudioOutput", set_audio_output, 2},
|
|
{"setResizeMode", set_fit, 2}, {"setUpscale", set_upscale, 2}, {"setCompare", set_compare, 3}, {"selectAudioTrack", select_audio, 2},
|
|
{"selectSubtitleTrack", select_subtitle, 2}, {"addSubtitle", add_subtitle, 4}, {"poll", poll, 0},
|
|
};
|
|
for (const auto& function : functions)
|
|
JS_SetPropertyStr(ctx, out, function.name, JS_NewCFunction(ctx, function.call, function.name, function.length));
|
|
return out;
|
|
}
|
|
|
|
#else
|
|
|
|
// Without "video" in app.json the app links no FFmpeg; <Video> reports how to turn it on.
|
|
namespace video_layers {
|
|
bool find(const char*, Layer&) { return false; }
|
|
bool sample(const char*, int, int, int, int, int, int, unsigned*) { return false; }
|
|
void update(std::int64_t, std::int64_t) {}
|
|
void stop() {}
|
|
std::string summary() { return {}; }
|
|
} // namespace video_layers
|
|
|
|
namespace {
|
|
JSValue disabled(JSContext* ctx, JSValueConst, int, JSValueConst*) {
|
|
return JS_ThrowPlainError(ctx, "video.open: set \"video\": true in app.json to play video");
|
|
}
|
|
JSValue none(JSContext* ctx, JSValueConst, int, JSValueConst*) { return JS_NewArray(ctx); }
|
|
} // namespace
|
|
|
|
JSValue ps5_react_video_api(JSContext* ctx) {
|
|
JSValue out = JS_NewObject(ctx);
|
|
JS_SetPropertyStr(ctx, out, "open", JS_NewCFunction(ctx, disabled, "open", 2));
|
|
JS_SetPropertyStr(ctx, out, "poll", JS_NewCFunction(ctx, none, "poll", 0));
|
|
return out;
|
|
}
|
|
|
|
#endif
|