mirror of
https://github.com/MrLowPr/overdrive.git
synced 2026-10-17 17:01:14 +02:00
664 lines
28 KiB
C++
664 lines
28 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 "gl_video.hpp"
|
|
|
|
#ifdef __APPLE__
|
|
#include <OpenGL/gl3.h>
|
|
#elif defined(PROSPERO)
|
|
#include <GL/glcorearb.h>
|
|
#else
|
|
#define GL_GLEXT_PROTOTYPES
|
|
#include <SDL2/SDL_opengl.h>
|
|
#endif
|
|
|
|
#include <algorithm>
|
|
#include <chrono>
|
|
#include <cmath>
|
|
#include <cstdio>
|
|
#include <string>
|
|
|
|
namespace {
|
|
const char* vertex_source = R"(#version 410 core
|
|
uniform vec4 dst; // framebuffer pixels: x0 y0 x1 y1
|
|
uniform vec4 src; // the part of the picture drawn, 0..1: x0 y0 x1 y1; beyond it, `contain`'s black bars
|
|
uniform vec2 size; // the framebuffer
|
|
out vec2 at;
|
|
void main() {
|
|
vec2 corner = vec2(float(gl_VertexID & 1), float(gl_VertexID >> 1));
|
|
vec2 p = mix(dst.xy, dst.zw, corner);
|
|
gl_Position = vec4(p.x / size.x * 2.0 - 1.0, 1.0 - p.y / size.y * 2.0, 0.0, 1.0);
|
|
at = mix(src.xy, src.zw, corner);
|
|
}
|
|
)";
|
|
|
|
// YUV to display RGB, shared by both programs. `yuv` holds normalized samples.
|
|
const char* color_source = R"(
|
|
uniform mat3 matrix; // Y'CbCr (range-expanded) to R'G'B'
|
|
uniform vec3 offset; // subtracted first: black level and chroma zero
|
|
uniform vec3 gain; // range expansion per component
|
|
uniform int transfer; // 0 SDR, 1 PQ, 2 HLG
|
|
uniform float alpha;
|
|
out vec4 color;
|
|
|
|
vec3 pq_to_nits(vec3 e) {
|
|
const float m1 = 0.1593017578125, m2 = 78.84375, c1 = 0.8359375, c2 = 18.8515625, c3 = 18.6875;
|
|
vec3 p = pow(clamp(e, 0.0, 1.0), vec3(1.0 / m2));
|
|
return pow(max(p - c1, 0.0) / (c2 - c3 * p), vec3(1.0 / m1)) * 10000.0;
|
|
}
|
|
vec3 hlg_to_nits(vec3 e) {
|
|
const float a = 0.17883277, b = 0.28466892, c = 0.55991073;
|
|
vec3 lo = e * e / 3.0, hi = (exp((e - c) / a) + b) / 12.0;
|
|
vec3 scene = mix(lo, hi, step(0.5, e));
|
|
float luma = dot(scene, vec3(0.2627, 0.6780, 0.0593));
|
|
return scene * pow(max(luma, 1e-6), 0.2) * 1000.0; // the BT.2100 OOTF for a 1000-nit display
|
|
}
|
|
// HDR to SDR: BT.2020 to BT.709 primaries, reference white (203 nits) to 1, a soft shoulder above 0.75
|
|
// on the brightest channel so hues hold, then the display's 2.4 gamma.
|
|
vec3 tone_map(vec3 nits) {
|
|
const mat3 to709 = mat3(1.6605, -0.1246, -0.0182, -0.5876, 1.1329, -0.1006, -0.0728, -0.0083, 1.1187);
|
|
vec3 rgb = max(to709 * (nits / 203.0), 0.0);
|
|
float peak = max(max(rgb.r, rgb.g), rgb.b);
|
|
const float knee = 0.75;
|
|
if (peak > knee) rgb *= (knee + (1.0 - knee) * tanh((peak - knee) / (1.0 - knee))) / peak;
|
|
return pow(rgb, vec3(1.0 / 2.4));
|
|
}
|
|
// From non-linear R'G'B' in the video's transfer.
|
|
void finish_rgb(vec3 rgb) {
|
|
if (transfer == 1) rgb = tone_map(pq_to_nits(rgb));
|
|
else if (transfer == 2) rgb = tone_map(hlg_to_nits(rgb));
|
|
color = vec4(clamp(rgb, 0.0, 1.0), 1.0) * alpha;
|
|
}
|
|
void finish(vec3 yuv) { finish_rgb(matrix * ((yuv - offset) * gain)); }
|
|
// Paints a letterbox bar: true where `at` lies outside the picture.
|
|
bool bar(vec2 at) {
|
|
if (all(greaterThanEqual(at, vec2(0.0))) && all(lessThanEqual(at, vec2(1.0)))) return false;
|
|
color = vec4(0.0, 0.0, 0.0, alpha);
|
|
return true;
|
|
}
|
|
)";
|
|
|
|
const char* texture_fragment = R"(#version 410 core
|
|
in vec2 at;
|
|
uniform sampler2D plane0, plane1, plane2;
|
|
uniform int interleaved;
|
|
uniform float scale; // 10-bit samples low in 16-bit words: 65535 / 1023
|
|
)";
|
|
const char* texture_main = R"(
|
|
void main() {
|
|
if (bar(at)) return;
|
|
float y = texture(plane0, at).r;
|
|
vec2 c = interleaved == 1 ? texture(plane1, at).rg : vec2(texture(plane1, at).r, texture(plane2, at).r);
|
|
finish(vec3(y, c) * scale);
|
|
}
|
|
)";
|
|
|
|
// The PS5 path: the frame's planes, as uploaded, in one buffer the shader reads samples from.
|
|
[[maybe_unused]] const char* storage_planes = R"(
|
|
layout(std430, binding = 0) readonly buffer Planes { uint words[]; };
|
|
uniform int wide; // 16-bit samples
|
|
uniform ivec3 offsets; // byte offset of each plane
|
|
uniform ivec3 pitches; // bytes per row
|
|
uniform ivec2 luma; // plane sizes in samples
|
|
uniform ivec2 chroma;
|
|
uniform int interleaved;
|
|
uniform float scale;
|
|
float sample_at(int at) {
|
|
uint word = words[at >> 2];
|
|
if (wide == 1) return float((word >> uint((at & 2) * 8)) & 0xFFFFu) / 65535.0;
|
|
return float((word >> uint((at & 3) * 8)) & 0xFFu) / 255.0;
|
|
}
|
|
// Bilinear between sample centres with clamped edges, as GL_LINEAR. `step` is bytes per sample pair
|
|
// position: 1 or 2 for a plane of its own, 2 or 4 for interleaved chroma, whose second component
|
|
// sits `second` bytes on.
|
|
float bilinear(int base, int pitch, ivec2 size, int step, int second, vec2 pos) {
|
|
vec2 p = pos * vec2(size) - 0.5, f = floor(p), t = p - f;
|
|
ivec2 a = clamp(ivec2(f), ivec2(0), size - 1), b = clamp(ivec2(f) + 1, ivec2(0), size - 1);
|
|
float s00 = sample_at(base + a.y * pitch + a.x * step + second), s10 = sample_at(base + a.y * pitch + b.x * step + second);
|
|
float s01 = sample_at(base + b.y * pitch + a.x * step + second), s11 = sample_at(base + b.y * pitch + b.x * step + second);
|
|
return mix(mix(s00, s10, t.x), mix(s01, s11, t.x), t.y);
|
|
}
|
|
vec2 chroma_at(vec2 at) {
|
|
int bytes = wide + 1;
|
|
if (interleaved == 1)
|
|
return vec2(bilinear(offsets.y, pitches.y, chroma, bytes * 2, 0, at), bilinear(offsets.y, pitches.y, chroma, bytes * 2, bytes, at));
|
|
return vec2(bilinear(offsets.y, pitches.y, chroma, bytes, 0, at), bilinear(offsets.z, pitches.z, chroma, bytes, 0, at));
|
|
}
|
|
)";
|
|
[[maybe_unused]] const char* storage_main = R"(
|
|
in vec2 at;
|
|
uniform int upscaled; // 1: the luma from `upscaled_plane`; 2: the picture from it, as R'G'B'
|
|
uniform sampler2D upscaled_plane;
|
|
void main() {
|
|
if (bar(at)) return;
|
|
if (upscaled == 2) {
|
|
finish_rgb(texture(upscaled_plane, at).rgb);
|
|
return;
|
|
}
|
|
vec3 yuv = vec3(upscaled == 1 ? 0.0 : bilinear(offsets.x, pitches.x, luma, wide + 1, 0, at), chroma_at(at)) * scale;
|
|
if (upscaled == 1) yuv.x = texture(upscaled_plane, at).r;
|
|
finish(yuv);
|
|
}
|
|
)";
|
|
// An upscaler's input out of the buffer, one invocation per luma sample: the luma, scaled as the
|
|
// picture shader scales it (mpv's LUMA), or with RGB defined the picture as R'G'B' (mpv's MAIN).
|
|
[[maybe_unused]] const char* extract_main = R"(
|
|
layout(local_size_x = 16, local_size_y = 16) in;
|
|
#ifdef RGB
|
|
layout(rgba16f, binding = 0) writeonly uniform image2D plane_out;
|
|
#else
|
|
layout(r16f, binding = 0) writeonly uniform image2D plane_out;
|
|
#endif
|
|
uniform mat3 matrix;
|
|
uniform vec3 offset, gain;
|
|
void main() {
|
|
ivec2 p = ivec2(gl_GlobalInvocationID.xy);
|
|
if (p.x >= luma.x || p.y >= luma.y) return;
|
|
float y = sample_at(offsets.x + p.y * pitches.x + p.x * (wide + 1)) * scale;
|
|
#ifdef RGB
|
|
vec3 yuv = vec3(y, chroma_at((vec2(p) + 0.5) / vec2(luma)) * scale);
|
|
imageStore(plane_out, p, vec4(matrix * ((yuv - offset) * gain), 1.0));
|
|
#else
|
|
imageStore(plane_out, p, vec4(y));
|
|
#endif
|
|
}
|
|
)";
|
|
|
|
GLuint compile(GLenum type, const std::string& source) {
|
|
GLuint shader = glCreateShader(type);
|
|
const char* text = source.c_str();
|
|
glShaderSource(shader, 1, &text, nullptr);
|
|
glCompileShader(shader);
|
|
GLint ok = 0;
|
|
glGetShaderiv(shader, GL_COMPILE_STATUS, &ok);
|
|
if (!ok) {
|
|
char log[2048] = {};
|
|
glGetShaderInfoLog(shader, sizeof log, nullptr, log);
|
|
std::fprintf(stderr, "Video shader compilation failed: %s\n", log);
|
|
glDeleteShader(shader);
|
|
return 0;
|
|
}
|
|
return shader;
|
|
}
|
|
|
|
GLuint program(const std::string& fragment_source) {
|
|
GLuint vertex = compile(GL_VERTEX_SHADER, vertex_source), fragment = compile(GL_FRAGMENT_SHADER, fragment_source);
|
|
GLuint linked = 0;
|
|
if (vertex && fragment) {
|
|
linked = glCreateProgram();
|
|
glAttachShader(linked, vertex);
|
|
glAttachShader(linked, fragment);
|
|
glLinkProgram(linked);
|
|
GLint ok = 0;
|
|
glGetProgramiv(linked, GL_LINK_STATUS, &ok);
|
|
if (!ok) {
|
|
char log[2048] = {};
|
|
glGetProgramInfoLog(linked, sizeof log, nullptr, log);
|
|
std::fprintf(stderr, "Video shader link failed: %s\n", log);
|
|
glDeleteProgram(linked);
|
|
linked = 0;
|
|
}
|
|
}
|
|
if (vertex) glDeleteShader(vertex);
|
|
if (fragment) glDeleteShader(fragment);
|
|
return linked;
|
|
}
|
|
|
|
using video::interleaved;
|
|
bool wide(video::Format format) { return video::deep(format); }
|
|
|
|
std::uint32_t micros_since(std::chrono::steady_clock::time_point start) {
|
|
return static_cast<std::uint32_t>(
|
|
std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - start).count());
|
|
}
|
|
|
|
// Kr and Kb of each matrix (BT.601, BT.709, BT.2020).
|
|
void set_color(GLuint program, const video::Frame& frame, float alpha) {
|
|
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;
|
|
// Column-major: R' = Y + 2(1-Kr) Cr; B' = Y + 2(1-Kb) Cb; G' from the luma equation.
|
|
const float matrix[9] = {1, 1, 1,
|
|
0, -2 * (1 - b) * b / g, 2 * (1 - b),
|
|
2 * (1 - r), -2 * (1 - r) * r / g, 0};
|
|
glUniformMatrix3fv(glGetUniformLocation(program, "matrix"), 1, GL_FALSE, matrix);
|
|
if (frame.full_range) {
|
|
glUniform3f(glGetUniformLocation(program, "offset"), 0, 0.5f, 0.5f);
|
|
glUniform3f(glGetUniformLocation(program, "gain"), 1, 1, 1);
|
|
} else {
|
|
glUniform3f(glGetUniformLocation(program, "offset"), 16 / 255.0f, 128 / 255.0f, 128 / 255.0f);
|
|
glUniform3f(glGetUniformLocation(program, "gain"), 255 / 219.0f, 255 / 224.0f, 255 / 224.0f);
|
|
}
|
|
glUniform1i(glGetUniformLocation(program, "transfer"), static_cast<int>(frame.transfer));
|
|
glUniform1f(glGetUniformLocation(program, "alpha"), alpha);
|
|
glUniform1i(glGetUniformLocation(program, "interleaved"), interleaved(frame.format) ? 1 : 0);
|
|
glUniform1f(glGetUniformLocation(program, "scale"), video::sample_scale(frame.format));
|
|
}
|
|
#ifdef GL_COMPUTE_SHADER
|
|
GLuint compute_program(const std::string& source) {
|
|
GLuint shader = compile(GL_COMPUTE_SHADER, source), linked = 0;
|
|
if (!shader) return 0;
|
|
linked = glCreateProgram();
|
|
glAttachShader(linked, shader);
|
|
glLinkProgram(linked);
|
|
glDeleteShader(shader);
|
|
GLint ok = 0;
|
|
glGetProgramiv(linked, GL_LINK_STATUS, &ok);
|
|
if (!ok) {
|
|
glDeleteProgram(linked);
|
|
return 0;
|
|
}
|
|
return linked;
|
|
}
|
|
#endif
|
|
|
|
// The planes' layout in the buffer, for a program that includes storage_planes.
|
|
[[maybe_unused]] void set_planes(GLuint program, const video::Frame& frame, const int offsets[3], const int pitches[3]) {
|
|
glUniform3i(glGetUniformLocation(program, "offsets"), offsets[0], offsets[1], offsets[2]);
|
|
glUniform3i(glGetUniformLocation(program, "pitches"), pitches[0], pitches[1], pitches[2]);
|
|
glUniform2i(glGetUniformLocation(program, "luma"), frame.width, frame.height);
|
|
glUniform2i(glGetUniformLocation(program, "chroma"), (frame.width + 1) / 2, (frame.height + 1) / 2);
|
|
glUniform1i(glGetUniformLocation(program, "wide"), wide(frame.format) ? 1 : 0);
|
|
}
|
|
} // namespace
|
|
|
|
bool GlVideo::init(bool storage_allowed) {
|
|
release();
|
|
texture_program_ = program(std::string(texture_fragment) + color_source + texture_main);
|
|
#ifdef GL_SHADER_STORAGE_BUFFER
|
|
GLint major = 0, minor = 0;
|
|
glGetIntegerv(GL_MAJOR_VERSION, &major);
|
|
glGetIntegerv(GL_MINOR_VERSION, &minor);
|
|
if (storage_allowed && (major > 4 || (major == 4 && minor >= 3)))
|
|
storage_program_ = program(std::string("#version 430 core\n") + storage_planes + color_source + storage_main);
|
|
#else
|
|
(void)storage_allowed;
|
|
#endif
|
|
mode_ = storage_program_ ? Upload::storage : Upload::textures;
|
|
upscalers_.resize(std::size_t(upscalers::count()));
|
|
upscaler_tried_.assign(std::size_t(upscalers::count()), false);
|
|
glGenVertexArrays(1, &vao_);
|
|
while (glGetError() != GL_NO_ERROR) {}
|
|
return texture_program_ || storage_program_;
|
|
}
|
|
|
|
void GlVideo::release() {
|
|
for (Entry& entry : entries_) free_entry(entry);
|
|
entries_.clear();
|
|
for (unsigned int* program : {&texture_program_, &storage_program_, &extract_luma_, &extract_rgb_}) {
|
|
if (*program) glDeleteProgram(*program);
|
|
*program = 0;
|
|
}
|
|
if (vao_) glDeleteVertexArrays(1, &vao_);
|
|
vao_ = 0;
|
|
for (GlUpscale& upscaler : upscalers_) upscaler.release();
|
|
upscaler_tried_.assign(upscaler_tried_.size(), false);
|
|
}
|
|
|
|
void GlVideo::free_entry(Entry& entry) {
|
|
for (unsigned int& texture : entry.textures)
|
|
if (texture) glDeleteTextures(1, &texture);
|
|
for (Planes& planes : entry.planes)
|
|
if (planes.buffer) glDeleteBuffers(1, &planes.buffer);
|
|
for (const Source* source : {&entry.source, &entry.compare_source})
|
|
if (source->texture) glDeleteTextures(1, &source->texture);
|
|
entry = {};
|
|
}
|
|
|
|
GlVideo::Entry& GlVideo::entry(std::uint64_t id) {
|
|
for (Entry& entry : entries_)
|
|
if (entry.id == id) return entry;
|
|
entries_.push_back({});
|
|
entries_.back().id = id;
|
|
return entries_.back();
|
|
}
|
|
|
|
void GlVideo::upload_textures(Entry& entry, const video::Frame& frame) {
|
|
const bool deep = wide(frame.format), pairs = interleaved(frame.format);
|
|
const int cw = (frame.width + 1) / 2, ch = (frame.height + 1) / 2;
|
|
const int planes = pairs ? 2 : 3;
|
|
Planes& described = entry.planes[0];
|
|
if (described.format != frame.format || described.width != frame.width || described.height != frame.height ||
|
|
!entry.textures[0]) {
|
|
for (unsigned int& texture : entry.textures)
|
|
if (texture) glDeleteTextures(1, &texture);
|
|
glGenTextures(planes, entry.textures);
|
|
for (int i = 0; i < planes; ++i) {
|
|
glBindTexture(GL_TEXTURE_2D, entry.textures[i]);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
|
const bool two = pairs && i == 1;
|
|
const GLenum internal = deep ? (two ? GL_RG16 : GL_R16) : (two ? GL_RG8 : GL_R8);
|
|
glTexImage2D(GL_TEXTURE_2D, 0, internal, i ? cw : frame.width, i ? ch : frame.height, 0, two ? GL_RG : GL_RED,
|
|
deep ? GL_UNSIGNED_SHORT : GL_UNSIGNED_BYTE, nullptr);
|
|
}
|
|
described.format = frame.format;
|
|
described.width = frame.width;
|
|
described.height = frame.height;
|
|
}
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
for (int i = 0; i < planes; ++i) {
|
|
const bool two = pairs && i == 1;
|
|
const int element = (deep ? 2 : 1) * (two ? 2 : 1);
|
|
glBindTexture(GL_TEXTURE_2D, entry.textures[i]);
|
|
glPixelStorei(GL_UNPACK_ROW_LENGTH, frame.pitch[i] / element);
|
|
const int w = i ? cw : frame.width, h = i ? ch : frame.height;
|
|
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, w, h, two ? GL_RG : GL_RED, deep ? GL_UNSIGNED_SHORT : GL_UNSIGNED_BYTE,
|
|
frame.planes[i]);
|
|
upload_bytes_ += static_cast<std::uint64_t>(frame.pitch[i]) * h;
|
|
}
|
|
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
|
|
described.valid = true;
|
|
described.sequence = frame.sequence;
|
|
}
|
|
|
|
void GlVideo::upload_storage(Planes& planes, const video::Frame& frame) {
|
|
#ifdef GL_SHADER_STORAGE_BUFFER
|
|
const auto start = std::chrono::steady_clock::now();
|
|
const int ch = (frame.height + 1) / 2;
|
|
const int count = interleaved(frame.format) ? 2 : 3;
|
|
std::size_t total = 0;
|
|
for (int i = 0; i < count; ++i) {
|
|
planes.offsets[i] = static_cast<int>(total);
|
|
planes.pitches[i] = frame.pitch[i];
|
|
total += (static_cast<std::size_t>(frame.pitch[i]) * (i ? ch : frame.height) + 3) & ~std::size_t(3);
|
|
}
|
|
if (!planes.buffer) glGenBuffers(1, &planes.buffer);
|
|
glBindBuffer(GL_SHADER_STORAGE_BUFFER, planes.buffer);
|
|
// A new store each frame: the GPU may still read the previous one.
|
|
glBufferData(GL_SHADER_STORAGE_BUFFER, static_cast<GLsizeiptr>(total), nullptr, GL_STREAM_DRAW);
|
|
for (int i = 0; i < count; ++i)
|
|
glBufferSubData(GL_SHADER_STORAGE_BUFFER, planes.offsets[i],
|
|
static_cast<GLsizeiptr>(frame.pitch[i]) * (i ? ch : frame.height), frame.planes[i]);
|
|
glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
|
|
planes.valid = true;
|
|
planes.sequence = frame.sequence;
|
|
planes.format = frame.format;
|
|
planes.width = frame.width;
|
|
planes.height = frame.height;
|
|
planes.model = planes.tried = upscalers::kNone;
|
|
upload_bytes_ += total;
|
|
upload_us_ += micros_since(start);
|
|
#else
|
|
(void)planes;
|
|
(void)frame;
|
|
#endif
|
|
}
|
|
|
|
// The model's upscaler, compiled on first use; null where it cannot run.
|
|
GlUpscale* GlVideo::upscaler(int model) {
|
|
#ifdef GL_COMPUTE_SHADER
|
|
if (model < 0 || model >= upscalers::count() || mode_ != Upload::storage) return nullptr;
|
|
GlUpscale& upscaler = upscalers_[std::size_t(model)];
|
|
if (!upscaler_tried_[std::size_t(model)]) {
|
|
upscaler_tried_[std::size_t(model)] = true;
|
|
const auto start = std::chrono::steady_clock::now();
|
|
const std::string extract = std::string("#version 430 core\n") + storage_planes + extract_main;
|
|
if (!extract_luma_) extract_luma_ = compute_program(extract);
|
|
if (!extract_rgb_) extract_rgb_ = compute_program(std::string("#version 430 core\n#define RGB\n") + storage_planes + extract_main);
|
|
const bool ready = extract_luma_ && extract_rgb_ && upscaler.init(model);
|
|
std::fprintf(stderr, "Video upscale %s %s (%.1f ms to compile)\n", upscalers::name(model),
|
|
ready ? "ready" : "unavailable", micros_since(start) / 1000.0);
|
|
}
|
|
return upscaler.ready() && extract_luma_ && extract_rgb_ ? &upscaler : nullptr;
|
|
#else
|
|
(void)model;
|
|
return nullptr;
|
|
#endif
|
|
}
|
|
|
|
// The picture in `planes` (uploaded from a frame described by `frame`) into `source` as an upscaler reads it.
|
|
void GlVideo::extract(Source& source, const Planes& planes, const video::Frame& frame, bool rgb) {
|
|
#ifdef GL_COMPUTE_SHADER
|
|
if (!source.texture || source.w != planes.width || source.h != planes.height || source.rgb != rgb) {
|
|
if (source.texture) glDeleteTextures(1, &source.texture);
|
|
glGenTextures(1, &source.texture);
|
|
glBindTexture(GL_TEXTURE_2D, source.texture);
|
|
glTexStorage2D(GL_TEXTURE_2D, 1, rgb ? GL_RGBA16F : GL_R16F, planes.width, planes.height);
|
|
// Anime4K reads its source bilinearly at the output's size.
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
source.w = planes.width;
|
|
source.h = planes.height;
|
|
source.rgb = rgb;
|
|
}
|
|
const GLuint program = rgb ? extract_rgb_ : extract_luma_;
|
|
glUseProgram(program);
|
|
set_planes(program, frame, planes.offsets, planes.pitches);
|
|
set_color(program, frame, 1);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, planes.buffer);
|
|
glBindImageTexture(0, source.texture, 0, GL_FALSE, 0, GL_WRITE_ONLY, rgb ? GL_RGBA16F : GL_R16F);
|
|
glDispatchCompute(GLuint((planes.width + 15) / 16), GLuint((planes.height + 15) / 16), 1);
|
|
glMemoryBarrier(GL_TEXTURE_FETCH_BARRIER_BIT | GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
|
|
glBindImageTexture(0, 0, 0, GL_FALSE, 0, GL_WRITE_ONLY, rgb ? GL_RGBA16F : GL_R16F);
|
|
#else
|
|
(void)source;
|
|
(void)planes;
|
|
(void)frame;
|
|
(void)rgb;
|
|
#endif
|
|
}
|
|
|
|
// Turns the picture waiting in planes[1 - shown] into the upscaler's input and starts its run, a share
|
|
// of it now. False when it cannot run.
|
|
bool GlVideo::start_upscale(Entry& entry, GlUpscale& upscaler, int model, const video::Frame& frame) {
|
|
#ifdef GL_COMPUTE_SHADER
|
|
const int back = 1 - entry.shown;
|
|
const Planes& planes = entry.planes[back];
|
|
extract(entry.source, planes, frame, upscaler.reads_rgb());
|
|
entry.planes[back].tried = model;
|
|
if (!upscaler.start(entry.source.texture, planes.width, planes.height, back)) return false;
|
|
entry.job_model = model;
|
|
// Half now, half at the next display frame: a 24 or 30 fps picture is due every two or three.
|
|
if (upscaler.step(0.5f)) finish_upscale(entry, upscaler);
|
|
return true;
|
|
#else
|
|
(void)entry;
|
|
(void)upscaler;
|
|
(void)model;
|
|
(void)frame;
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
// The run is done: its picture is the one shown from now on.
|
|
void GlVideo::finish_upscale(Entry& entry, GlUpscale& upscaler) {
|
|
entry.shown = 1 - entry.shown;
|
|
entry.planes[entry.shown].model = entry.job_model;
|
|
entry.planes[entry.shown].generation = upscaler.generation();
|
|
entry.job_model = upscalers::kNone;
|
|
}
|
|
|
|
void GlVideo::draw(std::uint64_t id, const video::Frame& frame, Fit fit, const Target& target, int x, int y, int w,
|
|
int h, int fb_w, int fb_h, int upscale, const Compare& compare) {
|
|
if (!frame.planes[0] || frame.width <= 0 || frame.height <= 0) return;
|
|
Entry& e = entry(id);
|
|
e.drawn = true;
|
|
// The picture's shape, fitted into the element's box. `contain` still draws the whole box, its bars
|
|
// black, so nothing under the element shows through them.
|
|
const float bw = float(target.x1 - target.x0), bh = float(target.y1 - target.y0);
|
|
if (bw <= 0 || bh <= 0) return;
|
|
const float picture = frame.width * frame.aspect / frame.height, box = bw / bh;
|
|
float dx0 = target.x0, dy0 = target.y0, dx1 = target.x1, dy1 = target.y1;
|
|
float sx0 = 0, sy0 = 0, sx1 = 1, sy1 = 1;
|
|
if (fit == Fit::contain) {
|
|
if (picture > box) {
|
|
const float part = picture / box;
|
|
sy0 = 0.5f - part / 2;
|
|
sy1 = 0.5f + part / 2;
|
|
} else {
|
|
const float part = box / picture;
|
|
sx0 = 0.5f - part / 2;
|
|
sx1 = 0.5f + part / 2;
|
|
}
|
|
} else if (fit == Fit::cover) {
|
|
if (picture > box) {
|
|
const float part = box / picture;
|
|
sx0 = (1 - part) / 2;
|
|
sx1 = sx0 + part;
|
|
} else {
|
|
const float part = picture / box;
|
|
sy0 = (1 - part) / 2;
|
|
sy1 = sy0 + part;
|
|
}
|
|
}
|
|
|
|
// The picture's size on screen, in window pixels, against the model's condition for a doubler.
|
|
const float shown_w = (dx1 - dx0) / (sx1 - sx0) * w / fb_w, shown_h = (dy1 - dy0) / (sy1 - sy0) * h / fb_h;
|
|
GlUpscale* upscaling = upscaler(upscale);
|
|
if (upscaling && !(shown_w > frame.width * upscaling->threshold() && shown_h > frame.height * upscaling->threshold()))
|
|
upscaling = nullptr;
|
|
if (mode_ == Upload::textures) {
|
|
if (!e.planes[0].valid || e.planes[0].sequence != frame.sequence) {
|
|
const auto start = std::chrono::steady_clock::now();
|
|
upload_textures(e, frame);
|
|
upload_us_ += micros_since(start);
|
|
}
|
|
} else if (!upscaling) {
|
|
e.job_model = upscalers::kNone;
|
|
Planes& shown = e.planes[e.shown];
|
|
if (!shown.valid || shown.sequence != frame.sequence) upload_storage(shown, frame);
|
|
} else {
|
|
if (e.job_model != upscalers::kNone && e.job_model != upscale) e.job_model = upscalers::kNone;
|
|
if (e.job_model != upscalers::kNone && upscaling->step(1.0f)) finish_upscale(e, *upscaling);
|
|
const Planes &shown = e.planes[e.shown], &back = e.planes[1 - e.shown];
|
|
const bool waiting = e.job_model != upscalers::kNone && back.sequence == frame.sequence;
|
|
// A paused picture never changes: a model picked over it runs on it once, as a new picture would.
|
|
const bool current = shown.valid && shown.sequence == frame.sequence && shown.tried == upscale;
|
|
if (!waiting && !current) {
|
|
// A picture due every display frame leaves no time to split a run: finish the last one now.
|
|
if (e.job_model != upscalers::kNone) {
|
|
upscaling->step(1.0f);
|
|
finish_upscale(e, *upscaling);
|
|
}
|
|
upload_storage(e.planes[1 - e.shown], frame);
|
|
if (!start_upscale(e, *upscaling, upscale, frame)) e.shown = 1 - e.shown; // plain, at once
|
|
}
|
|
}
|
|
|
|
const Planes& planes = e.planes[mode_ == Upload::textures ? 0 : e.shown];
|
|
if (!planes.valid) return;
|
|
unsigned int upscaled = 0;
|
|
if (upscaling && planes.model == upscale) upscaled = upscaling->result(e.shown, planes.generation);
|
|
video::Frame described = frame;
|
|
described.format = planes.format;
|
|
described.width = planes.width;
|
|
described.height = planes.height;
|
|
|
|
// The other side of a comparison: the picture shown, through the compare model, once per picture.
|
|
GlUpscale* comparing = nullptr;
|
|
unsigned int compared = 0;
|
|
if (compare.on && mode_ == Upload::storage) {
|
|
comparing = upscaler(compare.model);
|
|
if (comparing && !(shown_w > planes.width * comparing->threshold() && shown_h > planes.height * comparing->threshold()))
|
|
comparing = nullptr;
|
|
if (comparing == upscaling) {
|
|
compared = upscaled;
|
|
} else if (comparing) {
|
|
if (e.compare_model != compare.model || e.compare_sequence != planes.sequence ||
|
|
e.compare_generation != comparing->generation()) {
|
|
extract(e.compare_source, planes, described, comparing->reads_rgb());
|
|
if (comparing->start(e.compare_source.texture, planes.width, planes.height, 0)) comparing->step(1.0f);
|
|
e.compare_model = compare.model;
|
|
e.compare_sequence = planes.sequence;
|
|
e.compare_generation = comparing->generation();
|
|
}
|
|
compared = comparing->result(0, e.compare_generation);
|
|
}
|
|
}
|
|
|
|
const GLuint used = mode_ == Upload::storage ? storage_program_ : texture_program_;
|
|
glUseProgram(used);
|
|
glBindVertexArray(vao_);
|
|
glUniform4f(glGetUniformLocation(used, "dst"), dx0, dy0, dx1, dy1);
|
|
glUniform4f(glGetUniformLocation(used, "src"), sx0, sy0, sx1, sy1);
|
|
glUniform2f(glGetUniformLocation(used, "size"), float(fb_w), float(fb_h));
|
|
set_color(used, frame, target.alpha);
|
|
if (mode_ == Upload::storage) {
|
|
#ifdef GL_SHADER_STORAGE_BUFFER
|
|
set_planes(used, described, planes.offsets, planes.pitches);
|
|
glUniform1i(glGetUniformLocation(used, "interleaved"), interleaved(planes.format) ? 1 : 0);
|
|
glUniform1f(glGetUniformLocation(used, "scale"), video::sample_scale(planes.format));
|
|
glUniform1i(glGetUniformLocation(used, "upscaled_plane"), 0);
|
|
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, planes.buffer);
|
|
#endif
|
|
} else {
|
|
const int count = interleaved(frame.format) ? 2 : 3;
|
|
for (int i = 0; i < count; ++i) {
|
|
glActiveTexture(GL_TEXTURE0 + i);
|
|
glBindTexture(GL_TEXTURE_2D, e.textures[i]);
|
|
}
|
|
glUniform1i(glGetUniformLocation(used, "plane0"), 0);
|
|
glUniform1i(glGetUniformLocation(used, "plane1"), 1);
|
|
glUniform1i(glGetUniformLocation(used, "plane2"), 2);
|
|
}
|
|
// GL counts scissor rows from the bottom of the window.
|
|
const float sx = float(w) / fb_w, sy = float(h) / fb_h;
|
|
const int cx0 = x + int(target.clip_x0 * sx + 0.5f), cx1 = x + int(target.clip_x1 * sx + 0.5f);
|
|
const int cy0 = y + h - int(target.clip_y1 * sy + 0.5f), cy1 = y + h - int(target.clip_y0 * sy + 0.5f);
|
|
glEnable(GL_SCISSOR_TEST);
|
|
// The picture between window columns x0 and x1, from `result` of `by` (0: as it comes).
|
|
const auto paint = [&](unsigned int result, const GlUpscale* by, int x0, int x1) {
|
|
if (x1 <= x0) return;
|
|
if (mode_ == Upload::storage) {
|
|
glUniform1i(glGetUniformLocation(used, "upscaled"), !result ? 0 : by->reads_rgb() ? 2 : 1);
|
|
glActiveTexture(GL_TEXTURE0);
|
|
glBindTexture(GL_TEXTURE_2D, result);
|
|
}
|
|
glScissor(x0, cy0, x1 - x0, std::max(cy1 - cy0, 0));
|
|
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
|
|
};
|
|
if (!compare.on) {
|
|
paint(upscaled, upscaling, cx0, cx1);
|
|
} else {
|
|
const float split = dx0 + (compare.split - sx0) / (sx1 - sx0) * (dx1 - dx0);
|
|
const int at = std::clamp(x + int(split * sx + 0.5f), cx0, cx1);
|
|
paint(upscaled, upscaling, cx0, at);
|
|
paint(compared, comparing, at, cx1);
|
|
}
|
|
if (mode_ == Upload::storage) glBindTexture(GL_TEXTURE_2D, 0);
|
|
if (mode_ == Upload::textures) {
|
|
for (int i = 2; i >= 0; --i) {
|
|
glActiveTexture(GL_TEXTURE0 + i);
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
std::string GlVideo::take_upscale_log() {
|
|
std::string out;
|
|
for (int model = 0; model < int(upscalers_.size()); ++model) {
|
|
const GlUpscale::Stats stats = upscalers_[std::size_t(model)].take_stats();
|
|
if (!stats.runs && !stats.steps) continue;
|
|
char line[160];
|
|
std::snprintf(line, sizeof line, "%s%s: %u frames, gpu %.2f ms per frame, %.2f ms longest step (%u steps timed)",
|
|
out.empty() ? "" : "\n", upscalers::name(model), stats.runs,
|
|
stats.runs ? stats.gpu_ns / 1e6 / stats.runs : 0.0, stats.max_step_ns / 1e6, stats.steps);
|
|
out += line;
|
|
}
|
|
return out;
|
|
}
|
|
|
|
void GlVideo::dump_upscale_at(const std::string& prefix, std::uint64_t run) {
|
|
for (int model = 0; model < int(upscalers_.size()); ++model)
|
|
upscalers_[std::size_t(model)].dump_at(prefix + "-" + upscalers::name(model), run);
|
|
}
|
|
|
|
void GlVideo::end_present() {
|
|
std::erase_if(entries_, [&](Entry& entry) {
|
|
if (entry.drawn) {
|
|
entry.drawn = false;
|
|
return false;
|
|
}
|
|
free_entry(entry);
|
|
return true;
|
|
});
|
|
}
|
|
|