2015-09-05 12:03:00 +00:00
|
|
|
/*
|
|
|
|
* This file is part of mpv.
|
|
|
|
*
|
2016-01-19 17:36:34 +00:00
|
|
|
* mpv is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
2015-09-05 12:03:00 +00:00
|
|
|
*
|
|
|
|
* mpv is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
2016-01-19 17:36:34 +00:00
|
|
|
* GNU Lesser General Public License for more details.
|
2015-09-05 12:03:00 +00:00
|
|
|
*
|
2016-01-19 17:36:34 +00:00
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
|
|
* License along with mpv. If not, see <http://www.gnu.org/licenses/>.
|
2015-09-05 12:03:00 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <math.h>
|
|
|
|
|
|
|
|
#include "video_shaders.h"
|
|
|
|
#include "video.h"
|
|
|
|
|
|
|
|
#define GLSL(x) gl_sc_add(sc, #x "\n");
|
|
|
|
#define GLSLF(...) gl_sc_addf(sc, __VA_ARGS__)
|
2015-09-05 15:39:27 +00:00
|
|
|
#define GLSLH(x) gl_sc_hadd(sc, #x "\n");
|
|
|
|
#define GLSLHF(...) gl_sc_haddf(sc, __VA_ARGS__)
|
2015-09-05 12:03:00 +00:00
|
|
|
|
2015-12-05 18:54:25 +00:00
|
|
|
// Set up shared/commonly used variables and macros
|
2015-09-05 12:03:00 +00:00
|
|
|
void sampler_prelude(struct gl_shader_cache *sc, int tex_num)
|
|
|
|
{
|
2015-09-05 15:39:27 +00:00
|
|
|
GLSLF("#undef tex\n");
|
2015-09-05 12:03:00 +00:00
|
|
|
GLSLF("#define tex texture%d\n", tex_num);
|
|
|
|
GLSLF("vec2 pos = texcoord%d;\n", tex_num);
|
|
|
|
GLSLF("vec2 size = texture_size%d;\n", tex_num);
|
2016-02-25 20:27:55 +00:00
|
|
|
GLSLF("vec2 pt = pixel_size%d;\n", tex_num);
|
2015-09-05 12:03:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void pass_sample_separated_get_weights(struct gl_shader_cache *sc,
|
|
|
|
struct scaler *scaler)
|
|
|
|
{
|
|
|
|
gl_sc_uniform_sampler(sc, "lut", scaler->gl_target,
|
|
|
|
TEXUNIT_SCALERS + scaler->index);
|
2015-12-05 18:54:25 +00:00
|
|
|
// Define a new variable to cache the corrected fcoord.
|
|
|
|
GLSLF("float fcoord_lut = LUT_POS(fcoord, %d.0);\n", scaler->lut_size);
|
2015-09-05 12:03:00 +00:00
|
|
|
|
|
|
|
int N = scaler->kernel->size;
|
|
|
|
if (N == 2) {
|
2016-05-14 10:02:02 +00:00
|
|
|
GLSL(vec2 c1 = texture(lut, vec2(0.5, fcoord_lut)).rg;)
|
2015-09-05 12:03:00 +00:00
|
|
|
GLSL(float weights[2] = float[](c1.r, c1.g);)
|
|
|
|
} else if (N == 6) {
|
2015-12-05 18:54:25 +00:00
|
|
|
GLSL(vec4 c1 = texture(lut, vec2(0.25, fcoord_lut));)
|
|
|
|
GLSL(vec4 c2 = texture(lut, vec2(0.75, fcoord_lut));)
|
2015-09-05 12:03:00 +00:00
|
|
|
GLSL(float weights[6] = float[](c1.r, c1.g, c1.b, c2.r, c2.g, c2.b);)
|
|
|
|
} else {
|
|
|
|
GLSLF("float weights[%d];\n", N);
|
|
|
|
for (int n = 0; n < N / 4; n++) {
|
2015-12-05 18:54:25 +00:00
|
|
|
GLSLF("c = texture(lut, vec2(1.0 / %d.0 + %d.0 / %d.0, fcoord_lut));\n",
|
2015-09-05 12:03:00 +00:00
|
|
|
N / 2, n, N / 4);
|
|
|
|
GLSLF("weights[%d] = c.r;\n", n * 4 + 0);
|
|
|
|
GLSLF("weights[%d] = c.g;\n", n * 4 + 1);
|
|
|
|
GLSLF("weights[%d] = c.b;\n", n * 4 + 2);
|
|
|
|
GLSLF("weights[%d] = c.a;\n", n * 4 + 3);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Handle a single pass (either vertical or horizontal). The direction is given
|
|
|
|
// by the vector (d_x, d_y). If the vector is 0, then planar interpolation is
|
|
|
|
// used instead (samples from texture0 through textureN)
|
|
|
|
void pass_sample_separated_gen(struct gl_shader_cache *sc, struct scaler *scaler,
|
|
|
|
int d_x, int d_y)
|
|
|
|
{
|
|
|
|
int N = scaler->kernel->size;
|
|
|
|
bool use_ar = scaler->conf.antiring > 0;
|
|
|
|
bool planar = d_x == 0 && d_y == 0;
|
2016-02-23 15:18:17 +00:00
|
|
|
GLSL(color = vec4(0.0);)
|
2015-09-05 12:03:00 +00:00
|
|
|
GLSLF("{\n");
|
|
|
|
if (!planar) {
|
2015-11-19 20:19:04 +00:00
|
|
|
GLSLF("vec2 dir = vec2(%d.0, %d.0);\n", d_x, d_y);
|
2015-09-05 12:03:00 +00:00
|
|
|
GLSL(pt *= dir;)
|
|
|
|
GLSL(float fcoord = dot(fract(pos * size - vec2(0.5)), dir);)
|
2015-11-19 20:19:04 +00:00
|
|
|
GLSLF("vec2 base = pos - fcoord * pt - pt * vec2(%d.0);\n", N / 2 - 1);
|
2015-09-05 12:03:00 +00:00
|
|
|
}
|
|
|
|
GLSL(vec4 c;)
|
|
|
|
if (use_ar) {
|
|
|
|
GLSL(vec4 hi = vec4(0.0);)
|
|
|
|
GLSL(vec4 lo = vec4(1.0);)
|
|
|
|
}
|
|
|
|
pass_sample_separated_get_weights(sc, scaler);
|
|
|
|
GLSLF("// scaler samples\n");
|
|
|
|
for (int n = 0; n < N; n++) {
|
|
|
|
if (planar) {
|
|
|
|
GLSLF("c = texture(texture%d, texcoord%d);\n", n, n);
|
|
|
|
} else {
|
2015-11-19 20:19:04 +00:00
|
|
|
GLSLF("c = texture(tex, base + pt * vec2(%d.0));\n", n);
|
2015-09-05 12:03:00 +00:00
|
|
|
}
|
|
|
|
GLSLF("color += vec4(weights[%d]) * c;\n", n);
|
|
|
|
if (use_ar && (n == N/2-1 || n == N/2)) {
|
|
|
|
GLSL(lo = min(lo, c);)
|
|
|
|
GLSL(hi = max(hi, c);)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (use_ar)
|
|
|
|
GLSLF("color = mix(color, clamp(color, lo, hi), %f);\n",
|
|
|
|
scaler->conf.antiring);
|
|
|
|
GLSLF("}\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
void pass_sample_polar(struct gl_shader_cache *sc, struct scaler *scaler)
|
|
|
|
{
|
|
|
|
double radius = scaler->kernel->f.radius;
|
|
|
|
int bound = (int)ceil(radius);
|
|
|
|
bool use_ar = scaler->conf.antiring > 0;
|
2016-02-23 15:18:17 +00:00
|
|
|
GLSL(color = vec4(0.0);)
|
2015-09-05 12:03:00 +00:00
|
|
|
GLSLF("{\n");
|
|
|
|
GLSL(vec2 fcoord = fract(pos * size - vec2(0.5));)
|
|
|
|
GLSL(vec2 base = pos - fcoord * pt;)
|
|
|
|
GLSL(vec4 c;)
|
|
|
|
GLSLF("float w, d, wsum = 0.0;\n");
|
|
|
|
if (use_ar) {
|
|
|
|
GLSL(vec4 lo = vec4(1.0);)
|
|
|
|
GLSL(vec4 hi = vec4(0.0);)
|
|
|
|
}
|
|
|
|
gl_sc_uniform_sampler(sc, "lut", scaler->gl_target,
|
|
|
|
TEXUNIT_SCALERS + scaler->index);
|
|
|
|
GLSLF("// scaler samples\n");
|
|
|
|
for (int y = 1-bound; y <= bound; y++) {
|
|
|
|
for (int x = 1-bound; x <= bound; x++) {
|
|
|
|
// Since we can't know the subpixel position in advance, assume a
|
|
|
|
// worst case scenario
|
|
|
|
int yy = y > 0 ? y-1 : y;
|
|
|
|
int xx = x > 0 ? x-1 : x;
|
|
|
|
double dmax = sqrt(xx*xx + yy*yy);
|
|
|
|
// Skip samples definitely outside the radius
|
|
|
|
if (dmax >= radius)
|
|
|
|
continue;
|
2015-11-19 20:19:04 +00:00
|
|
|
GLSLF("d = length(vec2(%d.0, %d.0) - fcoord)/%f;\n", x, y, radius);
|
2015-09-05 12:03:00 +00:00
|
|
|
// Check for samples that might be skippable
|
2015-12-05 16:37:22 +00:00
|
|
|
if (dmax >= radius - M_SQRT2)
|
2015-09-05 12:03:00 +00:00
|
|
|
GLSLF("if (d < 1.0) {\n");
|
2015-11-19 20:20:40 +00:00
|
|
|
if (scaler->gl_target == GL_TEXTURE_1D) {
|
2015-12-05 18:54:25 +00:00
|
|
|
GLSLF("w = texture1D(lut, LUT_POS(d, %d.0)).r;\n",
|
|
|
|
scaler->lut_size);
|
2015-11-19 20:20:40 +00:00
|
|
|
} else {
|
2015-12-05 18:54:25 +00:00
|
|
|
GLSLF("w = texture(lut, vec2(0.5, LUT_POS(d, %d.0))).r;\n",
|
|
|
|
scaler->lut_size);
|
2015-11-19 20:20:40 +00:00
|
|
|
}
|
2015-09-05 12:03:00 +00:00
|
|
|
GLSL(wsum += w;)
|
2015-11-19 20:19:04 +00:00
|
|
|
GLSLF("c = texture(tex, base + pt * vec2(%d.0, %d.0));\n", x, y);
|
2015-09-05 12:03:00 +00:00
|
|
|
GLSL(color += vec4(w) * c;)
|
|
|
|
if (use_ar && x >= 0 && y >= 0 && x <= 1 && y <= 1) {
|
|
|
|
GLSL(lo = min(lo, c);)
|
|
|
|
GLSL(hi = max(hi, c);)
|
|
|
|
}
|
2015-12-05 16:37:22 +00:00
|
|
|
if (dmax >= radius - M_SQRT2)
|
2015-09-05 12:03:00 +00:00
|
|
|
GLSLF("}\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
GLSL(color = color / vec4(wsum);)
|
|
|
|
if (use_ar)
|
|
|
|
GLSLF("color = mix(color, clamp(color, lo, hi), %f);\n",
|
|
|
|
scaler->conf.antiring);
|
|
|
|
GLSLF("}\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
static void bicubic_calcweights(struct gl_shader_cache *sc, const char *t, const char *s)
|
|
|
|
{
|
|
|
|
// Explanation of how bicubic scaling with only 4 texel fetches is done:
|
|
|
|
// http://www.mate.tue.nl/mate/pdfs/10318.pdf
|
|
|
|
// 'Efficient GPU-Based Texture Interpolation using Uniform B-Splines'
|
|
|
|
// Explanation why this algorithm normally always blurs, even with unit
|
|
|
|
// scaling:
|
|
|
|
// http://bigwww.epfl.ch/preprints/ruijters1001p.pdf
|
|
|
|
// 'GPU Prefilter for Accurate Cubic B-spline Interpolation'
|
|
|
|
GLSLF("vec4 %s = vec4(-0.5, 0.1666, 0.3333, -0.3333) * %s"
|
|
|
|
" + vec4(1, 0, -0.5, 0.5);\n", t, s);
|
|
|
|
GLSLF("%s = %s * %s + vec4(0, 0, -0.5, 0.5);\n", t, t, s);
|
|
|
|
GLSLF("%s = %s * %s + vec4(-0.6666, 0, 0.8333, 0.1666);\n", t, t, s);
|
|
|
|
GLSLF("%s.xy *= vec2(1, 1) / vec2(%s.z, %s.w);\n", t, t, t);
|
2016-05-16 10:10:47 +00:00
|
|
|
GLSLF("%s.xy += vec2(1.0 + %s, 1.0 - %s);\n", t, s, s);
|
2015-09-05 12:03:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void pass_sample_bicubic_fast(struct gl_shader_cache *sc)
|
|
|
|
{
|
|
|
|
GLSLF("{\n");
|
|
|
|
GLSL(vec2 fcoord = fract(pos * size + vec2(0.5, 0.5));)
|
|
|
|
bicubic_calcweights(sc, "parmx", "fcoord.x");
|
|
|
|
bicubic_calcweights(sc, "parmy", "fcoord.y");
|
|
|
|
GLSL(vec4 cdelta;)
|
2016-05-14 10:02:02 +00:00
|
|
|
GLSL(cdelta.xz = parmx.rg * vec2(-pt.x, pt.x);)
|
|
|
|
GLSL(cdelta.yw = parmy.rg * vec2(-pt.y, pt.y);)
|
2015-09-05 12:03:00 +00:00
|
|
|
// first y-interpolation
|
|
|
|
GLSL(vec4 ar = texture(tex, pos + cdelta.xy);)
|
|
|
|
GLSL(vec4 ag = texture(tex, pos + cdelta.xw);)
|
|
|
|
GLSL(vec4 ab = mix(ag, ar, parmy.b);)
|
|
|
|
// second y-interpolation
|
|
|
|
GLSL(vec4 br = texture(tex, pos + cdelta.zy);)
|
|
|
|
GLSL(vec4 bg = texture(tex, pos + cdelta.zw);)
|
|
|
|
GLSL(vec4 aa = mix(bg, br, parmy.b);)
|
|
|
|
// x-interpolation
|
|
|
|
GLSL(color = mix(aa, ab, parmx.b);)
|
|
|
|
GLSLF("}\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
void pass_sample_oversample(struct gl_shader_cache *sc, struct scaler *scaler,
|
|
|
|
int w, int h)
|
|
|
|
{
|
|
|
|
GLSLF("{\n");
|
|
|
|
GLSL(vec2 pos = pos + vec2(0.5) * pt;) // round to nearest
|
|
|
|
GLSL(vec2 fcoord = fract(pos * size - vec2(0.5));)
|
|
|
|
// Determine the mixing coefficient vector
|
|
|
|
gl_sc_uniform_vec2(sc, "output_size", (float[2]){w, h});
|
2016-04-12 13:55:48 +00:00
|
|
|
GLSL(vec2 coeff = fcoord * output_size/size;)
|
2015-09-05 12:03:00 +00:00
|
|
|
float threshold = scaler->conf.kernel.params[0];
|
2016-04-12 13:55:48 +00:00
|
|
|
threshold = isnan(threshold) ? 0.0 : threshold;
|
|
|
|
GLSLF("coeff = (coeff - %f) / %f;\n", threshold, 1.0 - 2 * threshold);
|
|
|
|
GLSL(coeff = clamp(coeff, 0.0, 1.0);)
|
2015-09-05 12:03:00 +00:00
|
|
|
// Compute the right blend of colors
|
2016-04-12 13:55:48 +00:00
|
|
|
GLSL(color = texture(tex, pos + pt * (coeff - fcoord));)
|
2015-09-05 12:03:00 +00:00
|
|
|
GLSLF("}\n");
|
|
|
|
}
|
|
|
|
|
vo_opengl: implement HDR (SMPTE ST2084)
Currently, this relies on the user manually entering their display
brightness (since we have no way to detect this at runtime or from ICC
metadata). The default value of 250 was picked by looking at ~10 reviews
on tftcentral.co.uk and realizing they all come with around 250 cd/m^2
out of the box. (In addition, ITU-R Rec. BT.2022 supports this)
Since there is no metadata in FFmpeg to indicate usage of this TRC, the
only way to actually play HDR content currently is to set
``--vf=format=gamma=st2084``. (It could be guessed based on SEI, but
this is not implemented yet)
Incidentally, since SEI is ignored, it's currently assumed that all
content is scaled to 10,000 cd/m^2 (and hard-clipped where out of
range). I don't see this assumption changing much, though.
As an unfortunate consequence of the fact that we don't know the display
brightness, mixed with the fact that LittleCMS' parametric tone curves
are not flexible enough to support PQ, we have to build the 3DLUT
against gamma 2.2 if it's used. This might be a good thing, though,
consdering the PQ source space is probably not fantastic for
interpolation either way.
Partially addresses #2572.
2016-05-15 18:16:12 +00:00
|
|
|
// Common constants for SMPTE ST.2084 (HDR)
|
|
|
|
static const float HDR_M1 = 2610./4096 * 1./4,
|
|
|
|
HDR_M2 = 2523./4096 * 128,
|
|
|
|
HDR_C1 = 3424./4096,
|
|
|
|
HDR_C2 = 2413./4096 * 32,
|
|
|
|
HDR_C3 = 2392./4096 * 32;
|
|
|
|
|
2015-09-05 12:03:00 +00:00
|
|
|
// Linearize (expand), given a TRC as input
|
|
|
|
void pass_linearize(struct gl_shader_cache *sc, enum mp_csp_trc trc)
|
|
|
|
{
|
|
|
|
if (trc == MP_CSP_TRC_LINEAR)
|
|
|
|
return;
|
|
|
|
|
|
|
|
GLSL(color.rgb = clamp(color.rgb, 0.0, 1.0);)
|
|
|
|
switch (trc) {
|
2015-09-30 21:05:42 +00:00
|
|
|
case MP_CSP_TRC_SRGB:
|
|
|
|
GLSL(color.rgb = mix(color.rgb / vec3(12.92),
|
|
|
|
pow((color.rgb + vec3(0.055))/vec3(1.055), vec3(2.4)),
|
|
|
|
lessThan(vec3(0.04045), color.rgb));)
|
|
|
|
break;
|
|
|
|
case MP_CSP_TRC_BT_1886:
|
2016-02-13 14:33:00 +00:00
|
|
|
// We don't have an actual black point, so we assume a perfect display
|
|
|
|
GLSL(color.rgb = pow(color.rgb, vec3(2.4));)
|
2015-09-30 21:05:42 +00:00
|
|
|
break;
|
|
|
|
case MP_CSP_TRC_GAMMA18:
|
|
|
|
GLSL(color.rgb = pow(color.rgb, vec3(1.8));)
|
|
|
|
break;
|
|
|
|
case MP_CSP_TRC_GAMMA22:
|
|
|
|
GLSL(color.rgb = pow(color.rgb, vec3(2.2));)
|
|
|
|
break;
|
|
|
|
case MP_CSP_TRC_GAMMA28:
|
|
|
|
GLSL(color.rgb = pow(color.rgb, vec3(2.8));)
|
|
|
|
break;
|
|
|
|
case MP_CSP_TRC_PRO_PHOTO:
|
|
|
|
GLSL(color.rgb = mix(color.rgb / vec3(16.0),
|
|
|
|
pow(color.rgb, vec3(1.8)),
|
|
|
|
lessThan(vec3(0.03125), color.rgb));)
|
|
|
|
break;
|
vo_opengl: implement HDR (SMPTE ST2084)
Currently, this relies on the user manually entering their display
brightness (since we have no way to detect this at runtime or from ICC
metadata). The default value of 250 was picked by looking at ~10 reviews
on tftcentral.co.uk and realizing they all come with around 250 cd/m^2
out of the box. (In addition, ITU-R Rec. BT.2022 supports this)
Since there is no metadata in FFmpeg to indicate usage of this TRC, the
only way to actually play HDR content currently is to set
``--vf=format=gamma=st2084``. (It could be guessed based on SEI, but
this is not implemented yet)
Incidentally, since SEI is ignored, it's currently assumed that all
content is scaled to 10,000 cd/m^2 (and hard-clipped where out of
range). I don't see this assumption changing much, though.
As an unfortunate consequence of the fact that we don't know the display
brightness, mixed with the fact that LittleCMS' parametric tone curves
are not flexible enough to support PQ, we have to build the 3DLUT
against gamma 2.2 if it's used. This might be a good thing, though,
consdering the PQ source space is probably not fantastic for
interpolation either way.
Partially addresses #2572.
2016-05-15 18:16:12 +00:00
|
|
|
case MP_CSP_TRC_SMPTE_ST2084:
|
|
|
|
GLSLF("color.rgb = pow(color.rgb, vec3(1.0/%f));\n", HDR_M2);
|
|
|
|
GLSLF("color.rgb = max(color.rgb - vec3(%f), vec3(0.0)) \n"
|
|
|
|
" / (vec3(%f) - vec3(%f) * color.rgb);\n",
|
|
|
|
HDR_C1, HDR_C2, HDR_C3);
|
|
|
|
GLSLF("color.rgb = pow(color.rgb, vec3(1.0/%f));\n", HDR_M1);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
abort();
|
2015-09-05 12:03:00 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Delinearize (compress), given a TRC as output
|
|
|
|
void pass_delinearize(struct gl_shader_cache *sc, enum mp_csp_trc trc)
|
|
|
|
{
|
|
|
|
if (trc == MP_CSP_TRC_LINEAR)
|
|
|
|
return;
|
|
|
|
|
|
|
|
GLSL(color.rgb = clamp(color.rgb, 0.0, 1.0);)
|
|
|
|
switch (trc) {
|
2015-09-30 21:05:42 +00:00
|
|
|
case MP_CSP_TRC_SRGB:
|
|
|
|
GLSL(color.rgb = mix(color.rgb * vec3(12.92),
|
|
|
|
vec3(1.055) * pow(color.rgb, vec3(1.0/2.4))
|
|
|
|
- vec3(0.055),
|
|
|
|
lessThanEqual(vec3(0.0031308), color.rgb));)
|
|
|
|
break;
|
|
|
|
case MP_CSP_TRC_BT_1886:
|
2016-02-13 14:33:00 +00:00
|
|
|
GLSL(color.rgb = pow(color.rgb, vec3(1.0/2.4));)
|
2015-09-30 21:05:42 +00:00
|
|
|
break;
|
|
|
|
case MP_CSP_TRC_GAMMA18:
|
|
|
|
GLSL(color.rgb = pow(color.rgb, vec3(1.0/1.8));)
|
|
|
|
break;
|
|
|
|
case MP_CSP_TRC_GAMMA22:
|
|
|
|
GLSL(color.rgb = pow(color.rgb, vec3(1.0/2.2));)
|
|
|
|
break;
|
|
|
|
case MP_CSP_TRC_GAMMA28:
|
|
|
|
GLSL(color.rgb = pow(color.rgb, vec3(1.0/2.8));)
|
|
|
|
break;
|
|
|
|
case MP_CSP_TRC_PRO_PHOTO:
|
|
|
|
GLSL(color.rgb = mix(color.rgb * vec3(16.0),
|
|
|
|
pow(color.rgb, vec3(1.0/1.8)),
|
|
|
|
lessThanEqual(vec3(0.001953), color.rgb));)
|
|
|
|
break;
|
vo_opengl: implement HDR (SMPTE ST2084)
Currently, this relies on the user manually entering their display
brightness (since we have no way to detect this at runtime or from ICC
metadata). The default value of 250 was picked by looking at ~10 reviews
on tftcentral.co.uk and realizing they all come with around 250 cd/m^2
out of the box. (In addition, ITU-R Rec. BT.2022 supports this)
Since there is no metadata in FFmpeg to indicate usage of this TRC, the
only way to actually play HDR content currently is to set
``--vf=format=gamma=st2084``. (It could be guessed based on SEI, but
this is not implemented yet)
Incidentally, since SEI is ignored, it's currently assumed that all
content is scaled to 10,000 cd/m^2 (and hard-clipped where out of
range). I don't see this assumption changing much, though.
As an unfortunate consequence of the fact that we don't know the display
brightness, mixed with the fact that LittleCMS' parametric tone curves
are not flexible enough to support PQ, we have to build the 3DLUT
against gamma 2.2 if it's used. This might be a good thing, though,
consdering the PQ source space is probably not fantastic for
interpolation either way.
Partially addresses #2572.
2016-05-15 18:16:12 +00:00
|
|
|
case MP_CSP_TRC_SMPTE_ST2084:
|
|
|
|
GLSLF("color.rgb = pow(color.rgb, vec3(%f));\n", HDR_M1);
|
|
|
|
GLSLF("color.rgb = (vec3(%f) + vec3(%f) * color.rgb) \n"
|
|
|
|
" / (vec3(1.0) + vec3(%f) * color.rgb);\n",
|
|
|
|
HDR_C1, HDR_C2, HDR_C3);
|
|
|
|
GLSLF("color.rgb = pow(color.rgb, vec3(%f));\n", HDR_M2);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
abort();
|
2015-09-05 12:03:00 +00:00
|
|
|
}
|
|
|
|
}
|
2015-09-05 15:39:27 +00:00
|
|
|
|
2016-05-16 00:44:30 +00:00
|
|
|
// Tone map from one brightness to another
|
|
|
|
void pass_tone_map(struct gl_shader_cache *sc, float peak_src, float peak_dst,
|
|
|
|
enum tone_mapping algo, float param)
|
|
|
|
{
|
|
|
|
// First we renormalize to the output range
|
|
|
|
float scale = peak_src / peak_dst;
|
|
|
|
GLSLF("color.rgb *= vec3(%f);\n", scale);
|
|
|
|
|
|
|
|
// Then we use some algorithm to map back to [0,1]
|
|
|
|
switch (algo) {
|
|
|
|
case TONE_MAPPING_CLIP:
|
|
|
|
GLSL(color.rgb = clamp(color.rgb, 0.0, 1.0);)
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TONE_MAPPING_SIMPLE: {
|
|
|
|
float contrast = isnan(param) ? 0.5 : param,
|
|
|
|
offset = (1.0 - contrast) / contrast;
|
|
|
|
GLSLF("color.rgb = color.rgb / (color.rgb + vec3(%f));\n", offset);
|
|
|
|
GLSLF("color.rgb *= vec3(%f);\n", (scale + offset) / scale);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case TONE_MAPPING_GAMMA: {
|
|
|
|
float gamma = isnan(param) ? 1.8 : param;
|
|
|
|
GLSLF("color.rgb = pow(color.rgb / vec3(%f), vec3(%f));\n",
|
|
|
|
scale, 1.0/gamma);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case TONE_MAPPING_LINEAR: {
|
|
|
|
float coeff = isnan(param) ? 1.0 : param;
|
|
|
|
GLSLF("color.rgb = vec3(%f) * color.rgb;\n", coeff / scale);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-09-05 15:39:27 +00:00
|
|
|
// Wide usage friendly PRNG, shamelessly stolen from a GLSL tricks forum post.
|
|
|
|
// Obtain random numbers by calling rand(h), followed by h = permute(h) to
|
2016-05-14 05:05:04 +00:00
|
|
|
// update the state. Assumes the texture was hooked.
|
2015-09-05 15:39:27 +00:00
|
|
|
static void prng_init(struct gl_shader_cache *sc, AVLFG *lfg)
|
|
|
|
{
|
|
|
|
GLSLH(float mod289(float x) { return x - floor(x / 289.0) * 289.0; })
|
|
|
|
GLSLH(float permute(float x) { return mod289((34.0*x + 1.0) * x); })
|
|
|
|
GLSLH(float rand(float x) { return fract(x / 41.0); })
|
|
|
|
|
|
|
|
// Initialize the PRNG by hashing the position + a random uniform
|
2016-05-14 05:05:04 +00:00
|
|
|
GLSL(vec3 _m = vec3(HOOKED_pos, random) + vec3(1.0);)
|
2015-09-05 15:39:27 +00:00
|
|
|
GLSL(float h = permute(permute(permute(_m.x)+_m.y)+_m.z);)
|
|
|
|
gl_sc_uniform_f(sc, "random", (double)av_lfg_get(lfg) / UINT32_MAX);
|
|
|
|
}
|
|
|
|
|
2015-09-23 20:21:59 +00:00
|
|
|
struct deband_opts {
|
|
|
|
int enabled;
|
|
|
|
int iterations;
|
|
|
|
float threshold;
|
|
|
|
float range;
|
|
|
|
float grain;
|
|
|
|
};
|
|
|
|
|
2015-09-05 15:39:27 +00:00
|
|
|
const struct deband_opts deband_opts_def = {
|
2015-10-21 09:09:01 +00:00
|
|
|
.iterations = 1,
|
2015-09-05 15:39:27 +00:00
|
|
|
.threshold = 64.0,
|
2015-10-21 09:09:01 +00:00
|
|
|
.range = 16.0,
|
2015-09-05 15:39:27 +00:00
|
|
|
.grain = 48.0,
|
|
|
|
};
|
|
|
|
|
|
|
|
#define OPT_BASE_STRUCT struct deband_opts
|
|
|
|
const struct m_sub_options deband_conf = {
|
|
|
|
.opts = (const m_option_t[]) {
|
|
|
|
OPT_INTRANGE("iterations", iterations, 0, 1, 16),
|
|
|
|
OPT_FLOATRANGE("threshold", threshold, 0, 0.0, 4096.0),
|
|
|
|
OPT_FLOATRANGE("range", range, 0, 1.0, 64.0),
|
|
|
|
OPT_FLOATRANGE("grain", grain, 0, 0.0, 4096.0),
|
|
|
|
{0}
|
|
|
|
},
|
|
|
|
.size = sizeof(struct deband_opts),
|
|
|
|
.defaults = &deband_opts_def,
|
|
|
|
};
|
|
|
|
|
2016-05-14 05:05:04 +00:00
|
|
|
// Stochastically sample a debanded result from a hooked texture.
|
2015-09-05 15:39:27 +00:00
|
|
|
void pass_sample_deband(struct gl_shader_cache *sc, struct deband_opts *opts,
|
2016-05-14 05:05:04 +00:00
|
|
|
AVLFG *lfg)
|
2015-09-05 15:39:27 +00:00
|
|
|
{
|
2016-05-14 05:05:04 +00:00
|
|
|
// Initialize the PRNG
|
2016-02-23 15:18:17 +00:00
|
|
|
GLSLF("{\n");
|
2015-09-05 15:39:27 +00:00
|
|
|
prng_init(sc, lfg);
|
|
|
|
|
|
|
|
// Helper: Compute a stochastic approximation of the avg color around a
|
|
|
|
// pixel
|
2016-05-14 05:05:04 +00:00
|
|
|
GLSLHF("vec4 average(float range, inout float h) {\n");
|
2015-09-05 15:39:27 +00:00
|
|
|
// Compute a random rangle and distance
|
|
|
|
GLSLH(float dist = rand(h) * range; h = permute(h);)
|
|
|
|
GLSLH(float dir = rand(h) * 6.2831853; h = permute(h);)
|
2016-05-14 05:05:04 +00:00
|
|
|
GLSLH(vec2 o = dist * vec2(cos(dir), sin(dir));)
|
2015-09-05 15:39:27 +00:00
|
|
|
|
|
|
|
// Sample at quarter-turn intervals around the source pixel
|
|
|
|
GLSLH(vec4 ref[4];)
|
2016-05-14 05:05:04 +00:00
|
|
|
GLSLH(ref[0] = HOOKED_texOff(vec2( o.x, o.y));)
|
|
|
|
GLSLH(ref[1] = HOOKED_texOff(vec2(-o.y, o.x));)
|
|
|
|
GLSLH(ref[2] = HOOKED_texOff(vec2(-o.x, -o.y));)
|
|
|
|
GLSLH(ref[3] = HOOKED_texOff(vec2( o.y, -o.x));)
|
2015-09-05 15:39:27 +00:00
|
|
|
|
|
|
|
// Return the (normalized) average
|
2016-05-14 05:05:04 +00:00
|
|
|
GLSLH(return (ref[0] + ref[1] + ref[2] + ref[3])/4.0;)
|
|
|
|
GLSLHF("}\n");
|
2015-09-05 15:39:27 +00:00
|
|
|
|
|
|
|
// Sample the source pixel
|
2016-05-14 05:05:04 +00:00
|
|
|
GLSL(color = HOOKED_tex(HOOKED_pos);)
|
2015-09-05 15:39:27 +00:00
|
|
|
GLSLF("vec4 avg, diff;\n");
|
|
|
|
for (int i = 1; i <= opts->iterations; i++) {
|
|
|
|
// Sample the average pixel and use it instead of the original if
|
|
|
|
// the difference is below the given threshold
|
2016-05-14 05:05:04 +00:00
|
|
|
GLSLF("avg = average(%f, h);\n", i * opts->range);
|
2015-09-05 15:39:27 +00:00
|
|
|
GLSL(diff = abs(color - avg);)
|
|
|
|
GLSLF("color = mix(avg, color, greaterThan(diff, vec4(%f)));\n",
|
|
|
|
opts->threshold / (i * 16384.0));
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add some random noise to smooth out residual differences
|
|
|
|
GLSL(vec3 noise;)
|
|
|
|
GLSL(noise.x = rand(h); h = permute(h);)
|
|
|
|
GLSL(noise.y = rand(h); h = permute(h);)
|
|
|
|
GLSL(noise.z = rand(h); h = permute(h);)
|
|
|
|
GLSLF("color.xyz += %f * (noise - vec3(0.5));\n", opts->grain/8192.0);
|
2016-02-23 15:18:17 +00:00
|
|
|
GLSLF("}\n");
|
2015-09-05 15:39:27 +00:00
|
|
|
}
|
2015-09-23 20:43:27 +00:00
|
|
|
|
2016-05-14 05:05:04 +00:00
|
|
|
// Assumes the texture was hooked
|
2016-04-19 18:45:40 +00:00
|
|
|
void pass_sample_unsharp(struct gl_shader_cache *sc, float param) {
|
2015-09-23 20:43:27 +00:00
|
|
|
GLSLF("// unsharp\n");
|
|
|
|
GLSLF("{\n");
|
2016-05-14 05:05:04 +00:00
|
|
|
GLSL(float st1 = 1.2;)
|
|
|
|
GLSL(vec4 p = HOOKED_tex(HOOKED_pos);)
|
|
|
|
GLSL(vec4 sum1 = HOOKED_texOff(st1 * vec2(+1, +1))
|
|
|
|
+ HOOKED_texOff(st1 * vec2(+1, -1))
|
|
|
|
+ HOOKED_texOff(st1 * vec2(-1, +1))
|
|
|
|
+ HOOKED_texOff(st1 * vec2(-1, -1));)
|
|
|
|
GLSL(float st2 = 1.5;)
|
|
|
|
GLSL(vec4 sum2 = HOOKED_texOff(st2 * vec2(+1, 0))
|
|
|
|
+ HOOKED_texOff(st2 * vec2( 0, +1))
|
|
|
|
+ HOOKED_texOff(st2 * vec2(-1, 0))
|
|
|
|
+ HOOKED_texOff(st2 * vec2( 0, -1));)
|
2015-09-23 20:43:27 +00:00
|
|
|
GLSL(vec4 t = p * 0.859375 + sum2 * -0.1171875 + sum1 * -0.09765625;)
|
|
|
|
GLSLF("color = p + t * %f;\n", param);
|
|
|
|
GLSLF("}\n");
|
|
|
|
}
|