/*

 * This file is part of mpv.

 *

 * 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.

 *

 * 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

 * GNU Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with mpv.  If not, see <http://www.gnu.org/licenses/>.

 */

#include <assert.h>

#include <float.h>

#include <math.h>

#include <stdarg.h>

#include <stdbool.h>

#include <string.h>

#include <libavutil/common.h>

#include <libavutil/lfg.h>

#include "video.h"

#include "misc/bstr.h"

#include "options/m_config.h"

#include "options/path.h"

#include "options/options.h"

#include "utils.h"

#include "hwdec.h"

#include "osd.h"

#include "ra.h"

#include "stream/stream.h"

#include "video_shaders.h"

#include "user_shaders.h"

#include "error_diffusion.h"

#include "video/out/filter_kernels.h"

#include "video/out/aspect.h"

#include "video/out/dither.h"

#include "video/out/vo.h"

// must be sorted, and terminated with 0

int filter_sizes[] =

    {2, 4, 6, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60, 64, 0};

int tscale_sizes[] = {2, 4, 6, 8, 0};

struct vertex_pt {

    float x, y;

};

struct texplane {

    struct ra_tex *tex;

    int w, h;

    bool flipped;

};

struct video_image {

    struct texplane planes[4];

    struct mp_image *mpi;       // original input image

    uint64_t id;                // unique ID identifying mpi contents

    bool hwdec_mapped;

};

enum plane_type {

    PLANE_NONE = 0,

    PLANE_RGB,

    PLANE_LUMA,

    PLANE_CHROMA,

    PLANE_ALPHA,

    PLANE_XYZ,

};

static const char *plane_names[] = {

    [PLANE_NONE] = "unknown",

    [PLANE_RGB] = "rgb",

    [PLANE_LUMA] = "luma",

    [PLANE_CHROMA] = "chroma",

    [PLANE_ALPHA] = "alpha",

    [PLANE_XYZ] = "xyz",

};

// A self-contained description of a source image which can be bound to a

// texture unit and sampled from. Contains metadata about how it's to be used

struct image {

    enum plane_type type; // must be set to something non-zero

    int components; // number of relevant coordinates

    float multiplier; // multiplier to be used when sampling

    struct ra_tex *tex;

    int w, h; // logical size (after transformation)

    struct gl_transform transform; // rendering transformation

    int padding; // number of leading padding components (e.g. 2 = rg is padding)

};

// A named image, for user scripting purposes

struct saved_img {

    const char *name;

    struct image img;

};

// A texture hook. This is some operation that transforms a named texture as

// soon as it's generated

struct tex_hook {

    const char *save_tex;

    const char *hook_tex[SHADER_MAX_HOOKS];

    const char *bind_tex[SHADER_MAX_BINDS];

    int components; // how many components are relevant (0 = same as input)

    bool align_offset; // whether to align hooked tex with reference.

    void *priv; // this gets talloc_freed when the tex_hook is removed

    void (*hook)(struct gl_video *p, struct image img, // generates GLSL

                 struct gl_transform *trans, void *priv);

    bool (*cond)(struct gl_video *p, struct image img, void *priv);

};

struct surface {

    struct ra_tex *tex;

    uint64_t id;

    double pts;

};

#define SURFACES_MAX 10

struct cached_file {

    char *path;

    struct bstr body;

};

struct pass_info {

    struct bstr desc;

    struct mp_pass_perf perf;

};

struct dr_buffer {

    struct ra_buf *buf;

    // The mpi reference will keep the data from being recycled (or from other

    // references gaining write access) while the GPU is accessing the buffer.

    struct mp_image *mpi;

};

struct gl_video {

    struct ra *ra;

    struct mpv_global *global;

    struct mp_log *log;

    struct gl_video_opts opts;

    struct m_config_cache *opts_cache;

    struct gl_lcms *cms;

    int fb_depth;               // actual bits available in GL main framebuffer

    struct m_color clear_color;

    bool force_clear_color;

    struct gl_shader_cache *sc;

    struct osd_state *osd_state;

    struct mpgl_osd *osd;

    double osd_pts;

    struct ra_tex *lut_3d_texture;

    bool use_lut_3d;

    int lut_3d_size[3];

    struct ra_tex *dither_texture;

    struct mp_image_params real_image_params;   // configured format

    struct mp_image_params image_params;        // texture format (mind hwdec case)

    struct mp_image_params target_params;       // target format

    struct ra_imgfmt_desc ra_format;            // texture format

    int plane_count;

    bool is_gray;

    bool has_alpha;

    char color_swizzle[5];

    bool use_integer_conversion;

    struct video_image image;

    struct dr_buffer *dr_buffers;

    int num_dr_buffers;

    bool using_dr_path;

    bool dumb_mode;

    bool forced_dumb_mode;

    // Cached vertex array, to avoid re-allocation per frame. For simplicity,

    // our vertex format is simply a list of `vertex_pt`s, since this greatly

    // simplifies offset calculation at the cost of (unneeded) flexibility.

    struct vertex_pt *tmp_vertex;

    struct ra_renderpass_input *vao;

    int vao_len;

    const struct ra_format *fbo_format;

    struct ra_tex *merge_tex[4];

    struct ra_tex *scale_tex[4];

    struct ra_tex *integer_tex[4];

    struct ra_tex *chroma_tex[4];

    struct ra_tex *indirect_tex;

    struct ra_tex *blend_subs_tex;

    struct ra_tex *error_diffusion_tex[2];

    struct ra_tex *screen_tex;

    struct ra_tex *output_tex;

    struct ra_tex **hook_textures;

    int num_hook_textures;

    int idx_hook_textures;

    struct ra_buf *hdr_peak_ssbo;

    struct surface surfaces[SURFACES_MAX];

    // user pass descriptions and textures

    struct tex_hook *tex_hooks;

    int num_tex_hooks;

    struct gl_user_shader_tex *user_textures;

    int num_user_textures;

    int surface_idx;

    int surface_now;

    int frames_drawn;

    bool is_interpolated;

    bool output_tex_valid;

    // state for configured scalers

    struct scaler scaler[SCALER_COUNT];

    struct mp_csp_equalizer_state *video_eq;

    struct mp_rect src_rect;    // displayed part of the source video

    struct mp_rect dst_rect;    // video rectangle on output window

    struct mp_osd_res osd_rect; // OSD size/margins

    // temporary during rendering

    struct compute_info pass_compute; // compute shader metadata for this pass

    struct image *pass_imgs;          // bound images for this pass

    int num_pass_imgs;

    struct saved_img *saved_imgs;     // saved (named) images for this frame

    int num_saved_imgs;

    // effective current texture metadata - this will essentially affect the

    // next render pass target, as well as implicitly tracking what needs to

    // be done with the image

    int texture_w, texture_h;

    struct gl_transform texture_offset; // texture transform without rotation

    int components;

    bool use_linear;

    float user_gamma;

    // pass info / metrics

    struct pass_info pass_fresh[VO_PASS_PERF_MAX];

    struct pass_info pass_redraw[VO_PASS_PERF_MAX];

    struct pass_info *pass;

    int pass_idx;

    struct timer_pool *upload_timer;

    struct timer_pool *blit_timer;

    struct timer_pool *osd_timer;

    int frames_uploaded;

    int frames_rendered;

    AVLFG lfg;

    // Cached because computing it can take relatively long

    int last_dither_matrix_size;

    float *last_dither_matrix;

    struct cached_file *files;

    int num_files;

    struct ra_hwdec_ctx hwdec_ctx;

    struct ra_hwdec_mapper *hwdec_mapper;

    struct ra_hwdec *hwdec_overlay;

    bool hwdec_active;

    bool dsi_warned;

    bool broken_frame; // temporary error state

    bool colorspace_override_warned;

    bool correct_downscaling_warned;

};

#define FIXED_SCALE_KERNELS \

    {"bilinear",             SCALER_BILINEAR}, \

    {"bicubic_fast",         SCALER_BICUBIC_FAST}, \

    {"oversample",           SCALER_OVERSAMPLE}, \

#define NON_POLAR_FILTER_KERNELS \

    {"spline16",      SCALER_SPLINE16}, \

    {"spline36",      SCALER_SPLINE36}, \

    {"spline64",      SCALER_SPLINE64}, \

    {"sinc",          SCALER_SINC}, \

    {"lanczos",       SCALER_LANCZOS}, \

    {"ginseng",       SCALER_GINSENG}, \

    {"bicubic",       SCALER_BICUBIC}, \

    {"hermite",       SCALER_HERMITE}, \

    {"catmull_rom",   SCALER_CATMULL_ROM}, \

    {"mitchell",      SCALER_MITCHELL}, \

    {"robidoux",      SCALER_ROBIDOUX}, \

    {"robidouxsharp", SCALER_ROBIDOUXSHARP}, \

    {"box",           SCALER_BOX}, \

    {"nearest",       SCALER_NEAREST}, \

    {"triangle",      SCALER_TRIANGLE}, \

    {"gaussian",      SCALER_GAUSSIAN}, \

#define POLAR_FILTER_KERNELS \

    {"jinc",                 SCALER_JINC}, \

    {"ewa_lanczos",          SCALER_EWA_LANCZOS}, \

    {"ewa_hanning",          SCALER_EWA_HANNING}, \

    {"ewa_ginseng",          SCALER_EWA_GINSENG}, \

    {"ewa_lanczossharp",     SCALER_EWA_LANCZOSSHARP}, \

    {"ewa_lanczos4sharpest", SCALER_EWA_LANCZOS4SHARPEST}, \

    {"ewa_lanczossoft",      SCALER_EWA_LANCZOSSOFT}, \

    {"haasnsoft",            SCALER_HAASNSOFT}, \

    {"ewa_robidoux",         SCALER_EWA_ROBIDOUX}, \

    {"ewa_robidouxsharp",    SCALER_EWA_ROBIDOUXSHARP}, \

#define FILTER_WINDOWS \

    {"bartlett", WINDOW_BARTLETT}, \

    {"cosine",   WINDOW_COSINE}, \

    {"hanning",  WINDOW_HANNING}, \

    {"tukey",    WINDOW_TUKEY}, \

    {"hamming",  WINDOW_HAMMING}, \

    {"quadric",  WINDOW_QUADRIC}, \

    {"welch",    WINDOW_WELCH}, \

    {"kaiser",   WINDOW_KAISER}, \

    {"blackman", WINDOW_BLACKMAN}, \

    {"sphinx",   WINDOW_SPHINX}, \

static const struct m_opt_choice_alternatives scale_filters[] = {

    FIXED_SCALE_KERNELS

    NON_POLAR_FILTER_KERNELS

    POLAR_FILTER_KERNELS

    FILTER_WINDOWS

    {0},

};

static const struct m_opt_choice_alternatives cdscale_filters[] = {

    {"", SCALER_INHERIT},

    FIXED_SCALE_KERNELS

    NON_POLAR_FILTER_KERNELS

    POLAR_FILTER_KERNELS

    FILTER_WINDOWS

    {0},

};

static const struct m_opt_choice_alternatives tscale_filters[] = {

    {"oversample", SCALER_OVERSAMPLE},

    {"linear",     SCALER_LINEAR},

    NON_POLAR_FILTER_KERNELS

    FILTER_WINDOWS

    {"jinc",       WINDOW_JINC},

    {0},

};

static const struct m_opt_choice_alternatives filter_windows[] = {

    {"",     WINDOW_PREFERRED},

    FILTER_WINDOWS

    {"jinc", WINDOW_JINC},

    {0},

};

static const struct gl_video_opts gl_video_opts_def = {

    .dither_algo = DITHER_FRUIT,

    .dither_size = 6,

    .temporal_dither_period = 1,

    .error_diffusion = "sierra-lite",

    .fbo_format = "auto",

    .sigmoid_center = 0.75,

    .sigmoid_slope = 6.5,

    .scaler = {

        [SCALER_SCALE] =  {

            {SCALER_LANCZOS, .params = {NAN, NAN}, .functions = scale_filters},

            {WINDOW_PREFERRED, .params = {NAN, NAN}, .functions = filter_windows},

        },

        [SCALER_DSCALE] = {

            {SCALER_HERMITE, .params = {NAN, NAN}, .functions = cdscale_filters},

            {WINDOW_PREFERRED, .params = {NAN, NAN}, .functions = filter_windows},

        },

        [SCALER_CSCALE] = {

            {SCALER_INHERIT, .params = {NAN, NAN}, .functions = cdscale_filters},

            {WINDOW_PREFERRED, .params = {NAN, NAN}, .functions = filter_windows},

        },

        [SCALER_TSCALE] = {

            {SCALER_OVERSAMPLE, .params = {NAN, NAN}, .functions = tscale_filters},

            {WINDOW_PREFERRED, .params = {NAN, NAN}, .functions = filter_windows},

        },

    },

    .scaler_resizes_only = true,

    .correct_downscaling = true,

    .linear_downscaling = true,

    .sigmoid_upscaling = true,

    .interpolation_threshold = 0.01,

    .background = BACKGROUND_TILES,

    .background_color = {0, 0, 0, 255},

    .background_tile_color = {{237, 237, 237, 255},

                              {222, 222, 222, 255}},

    .background_tile_size = 16,

    .gamma = 1.0f,

    .tone_map = {

        .curve = TONE_MAPPING_AUTO,

        .curve_param = NAN,

        .max_boost = 1.0,

        .decay_rate = 20.0,

        .scene_threshold_low = 1.0,

        .scene_threshold_high = 3.0,

        .contrast_smoothness = 3.5,

    },

    .early_flush = -1,

    .shader_cache = true,

    .hwdec_interop = "auto",

    .treat_srgb_as_power22 = 1|2|4, // auto

};

static OPT_STRING_VALIDATE_FUNC(validate_error_diffusion_opt);

#define OPT_BASE_STRUCT struct gl_video_opts

// Use for options which use NAN for defaults.

#define OPT_FLOATDEF(field) \

    OPT_FLOAT(field), \

    .flags = M_OPT_DEFAULT_NAN

#define SCALER_OPTS(n, i) \

    {n"-param1", OPT_FLOATDEF(scaler[i].kernel.params[0])},                \

    {n"-param2", OPT_FLOATDEF(scaler[i].kernel.params[1])},                \

    {n"-blur",   OPT_FLOAT(scaler[i].kernel.blur)},                        \

    {n"-taper",  OPT_FLOAT(scaler[i].kernel.taper), M_RANGE(0.0, 1.0)},    \

    {n"-wparam", OPT_FLOATDEF(scaler[i].window.params[0])},                \

    {n"-wtaper", OPT_FLOAT(scaler[i].window.taper), M_RANGE(0.0, 1.0)},    \

    {n"-clamp",  OPT_FLOAT(scaler[i].clamp), M_RANGE(0.0, 1.0)},           \

    {n"-radius", OPT_FLOAT(scaler[i].radius), M_RANGE(0.5, 16.0)},         \

    {n"-antiring", OPT_FLOAT(scaler[i].antiring), M_RANGE(0.0, 1.0)},      \

    {n"-window", OPT_CHOICE_C(scaler[i].window.function, filter_windows)}

const struct m_sub_options gl_video_conf = {

    .opts = (const m_option_t[]) {

        {"gpu-dumb-mode", OPT_CHOICE(dumb_mode,

            {"auto", 0}, {"yes", 1}, {"no", -1})},

        {"gamma-factor", OPT_FLOAT(gamma), M_RANGE(0.1, 2.0)},

        {"gamma-auto", OPT_BOOL(gamma_auto),

            .deprecation_message = "replacement: gamma-auto.lua"},

        {"target-prim", OPT_CHOICE_C(target_prim, pl_csp_prim_names)},

        {"target-trc", OPT_CHOICE_C(target_trc, pl_csp_trc_names)},

        {"target-peak", OPT_CHOICE(target_peak, {"auto", 0}),

            M_RANGE(10, 10000)},

        {"hdr-reference-white", OPT_CHOICE(hdr_reference_white, {"auto", 0}),

            M_RANGE(10, 10000)},

        {"sdr-adjust-gamma", OPT_CHOICE(sdr_adjust_gamma,

            {"auto", 0}, {"yes", 1}, {"no", -1})},

        {"treat-srgb-as-power22", OPT_CHOICE(treat_srgb_as_power22,

            {"no", 0}, {"input", 1}, {"output", 2}, {"both", 1|2}, {"auto", 1|2|4})},

        {"target-contrast", OPT_CHOICE(target_contrast, {"auto", 0}, {"inf", -1}),

            M_RANGE(10, 10 / PL_COLOR_HDR_BLACK)},

        {"target-gamut", OPT_CHOICE_C(target_gamut, pl_csp_prim_names)},

        {"tone-mapping", OPT_CHOICE(tone_map.curve,

            {"auto",     TONE_MAPPING_AUTO},

            {"clip",     TONE_MAPPING_CLIP},

            {"mobius",   TONE_MAPPING_MOBIUS},

            {"reinhard", TONE_MAPPING_REINHARD},

            {"hable",    TONE_MAPPING_HABLE},

            {"gamma",    TONE_MAPPING_GAMMA},

            {"linear",   TONE_MAPPING_LINEAR},

            {"spline",   TONE_MAPPING_SPLINE},

            {"bt.2390",  TONE_MAPPING_BT_2390},

            {"bt.2446a", TONE_MAPPING_BT_2446A},

            {"st2094-40", TONE_MAPPING_ST2094_40},

            {"st2094-10", TONE_MAPPING_ST2094_10})},

        {"tone-mapping-param", OPT_FLOATDEF(tone_map.curve_param)},

        {"inverse-tone-mapping", OPT_BOOL(tone_map.inverse)},

        {"tone-mapping-max-boost", OPT_FLOAT(tone_map.max_boost),

            M_RANGE(1.0, 10.0)},

        {"tone-mapping-visualize", OPT_BOOL(tone_map.visualize)},

        {"gamut-mapping-mode", OPT_CHOICE(tone_map.gamut_mode,

            {"auto",        GAMUT_AUTO},

            {"clip",        GAMUT_CLIP},

            {"perceptual",  GAMUT_PERCEPTUAL},

            {"relative",    GAMUT_RELATIVE},

            {"saturation",  GAMUT_SATURATION},

            {"absolute",    GAMUT_ABSOLUTE},

            {"desaturate",  GAMUT_DESATURATE},

            {"darken",      GAMUT_DARKEN},

            {"warn",        GAMUT_WARN},

            {"linear",      GAMUT_LINEAR})},

        {"hdr-compute-peak", OPT_CHOICE(tone_map.compute_peak,

            {"auto", 0},

            {"yes", 1},

            {"no", -1})},

        {"hdr-peak-percentile", OPT_FLOAT(tone_map.peak_percentile),

            M_RANGE(0.0, 100.0)},

        {"hdr-peak-decay-rate", OPT_FLOAT(tone_map.decay_rate),

            M_RANGE(0.0, 1000.0)},

        {"hdr-scene-threshold-low", OPT_FLOAT(tone_map.scene_threshold_low),

            M_RANGE(0, 20.0)},

        {"hdr-scene-threshold-high", OPT_FLOAT(tone_map.scene_threshold_high),

            M_RANGE(0, 20.0)},

        {"hdr-contrast-recovery", OPT_FLOAT(tone_map.contrast_recovery),

            M_RANGE(0, 2.0)},

        {"hdr-contrast-smoothness", OPT_FLOAT(tone_map.contrast_smoothness),

            M_RANGE(1.0, 100.0)},

        {"opengl-pbo", OPT_BOOL(pbo)},

        {"scale", OPT_CHOICE_C(scaler[SCALER_SCALE].kernel.function, scale_filters)},

        SCALER_OPTS("scale",  SCALER_SCALE),

        {"dscale", OPT_CHOICE_C(scaler[SCALER_DSCALE].kernel.function, cdscale_filters)},

        SCALER_OPTS("dscale", SCALER_DSCALE),

        {"cscale", OPT_CHOICE_C(scaler[SCALER_CSCALE].kernel.function, cdscale_filters)},

        SCALER_OPTS("cscale", SCALER_CSCALE),

        {"tscale", OPT_CHOICE_C(scaler[SCALER_TSCALE].kernel.function, tscale_filters)},

        SCALER_OPTS("tscale", SCALER_TSCALE),

        {"scaler-resizes-only", OPT_BOOL(scaler_resizes_only)},

        {"correct-downscaling", OPT_BOOL(correct_downscaling)},

        {"linear-downscaling", OPT_BOOL(linear_downscaling)},

        {"linear-upscaling", OPT_BOOL(linear_upscaling)},

        {"sigmoid-upscaling", OPT_BOOL(sigmoid_upscaling)},

        {"sigmoid-center", OPT_FLOAT(sigmoid_center), M_RANGE(0.0, 1.0)},

        {"sigmoid-slope", OPT_FLOAT(sigmoid_slope), M_RANGE(1.0, 20.0)},

        {"fbo-format", OPT_STRING(fbo_format)},

        {"dither-depth", OPT_CHOICE(dither_depth, {"no", -1}, {"auto", 0}),

            M_RANGE(-1, 16)},

        {"dither", OPT_CHOICE(dither_algo,

            {"fruit", DITHER_FRUIT},

            {"ordered", DITHER_ORDERED},

            {"error-diffusion", DITHER_ERROR_DIFFUSION},

            {"no", DITHER_NONE})},

        {"dither-size-fruit", OPT_INT(dither_size), M_RANGE(2, 8)},

        {"temporal-dither", OPT_BOOL(temporal_dither)},

        {"temporal-dither-period", OPT_INT(temporal_dither_period),

            M_RANGE(1, 128)},

        {"error-diffusion",

            OPT_STRING_VALIDATE(error_diffusion, validate_error_diffusion_opt)},

        {"background", OPT_CHOICE(background,

            {"none", BACKGROUND_NONE},

            {"color", BACKGROUND_COLOR},

            {"tiles", BACKGROUND_TILES})},

        {"opengl-rectangle-textures", OPT_BOOL(use_rectangle)},

        {"background-color", OPT_COLOR(background_color)},

        {"background-tile-color-0", OPT_COLOR(background_tile_color[0])},

        {"background-tile-color-1", OPT_COLOR(background_tile_color[1])},

        {"background-tile-size", OPT_INT(background_tile_size), M_RANGE(1, 4096)},

        {"interpolation", OPT_BOOL(interpolation)},

        {"interpolation-threshold", OPT_FLOAT(interpolation_threshold)},

        {"blend-subtitles", OPT_CHOICE(blend_subs,

            {"no", BLEND_SUBS_NO},

            {"yes", BLEND_SUBS_YES},

            {"video", BLEND_SUBS_VIDEO})},

        {"glsl-shaders", OPT_PATHLIST(user_shaders), .flags = M_OPT_FILE},

        {"glsl-shader", OPT_CLI_ALIAS("glsl-shaders-append")},

        {"glsl-shader-opts", OPT_KEYVALUELIST(user_shader_opts)},

        {"deband", OPT_BOOL(deband)},

        {"deband", OPT_SUBSTRUCT(deband_opts, deband_conf)},

        {"sharpen", OPT_FLOAT(unsharp)},

        {"gpu-tex-pad-x", OPT_INT(tex_pad_x), M_RANGE(0, 4096)},

        {"gpu-tex-pad-y", OPT_INT(tex_pad_y), M_RANGE(0, 4096)},

        {"", OPT_SUBSTRUCT(icc_opts, mp_icc_conf)},

        {"gpu-shader-cache", OPT_BOOL(shader_cache)},

        {"gpu-shader-cache-dir", OPT_STRING(shader_cache_dir), .flags = M_OPT_FILE},

        {"gpu-hwdec-interop",

            OPT_STRING_VALIDATE(hwdec_interop, ra_hwdec_validate_opt)},

        {"gamut-warning", OPT_REMOVED("Replaced by --gamut-mapping-mode=warn")},

        {"gamut-clipping", OPT_REMOVED("Replaced by --gamut-mapping-mode=desaturate")},

        {"tone-mapping-desaturate", OPT_REMOVED("Replaced by --tone-mapping-mode")},

        {"tone-mapping-desaturate-exponent", OPT_REMOVED("Replaced by --tone-mapping-mode")},

        {0}

    },

    .size = sizeof(struct gl_video_opts),

    .defaults = &gl_video_opts_def,

    .change_flags = UPDATE_VIDEO,

};

static void uninit_rendering(struct gl_video *p);

static void uninit_scaler(struct gl_video *p, struct scaler *scaler);

static void check_gl_features(struct gl_video *p);

static bool pass_upload_image(struct gl_video *p, struct mp_image *mpi, uint64_t id);

static void reinit_from_options(struct gl_video *p);

static void get_scale_factors(struct gl_video *p, bool transpose_rot, double xy[2]);

static void gl_video_setup_hooks(struct gl_video *p);

static void gl_video_update_options(struct gl_video *p);

#define GLSL(x) gl_sc_add(p->sc, #x "\n");

#define GLSLF(...) gl_sc_addf(p->sc, __VA_ARGS__)

#define GLSLHF(...) gl_sc_haddf(p->sc, __VA_ARGS__)

#define PRELUDE(...) gl_sc_paddf(p->sc, __VA_ARGS__)

static struct bstr load_cached_file(struct gl_video *p, const char *path)

{

    if (!path || !path[0])

        return (struct bstr){0};

    for (int n = 0; n < p->num_files; n++) {

        if (strcmp(p->files[n].path, path) == 0)

            return p->files[n].body;

    }

    // not found -> load it

    char *fname = mp_get_user_path(NULL, p->global, path);

    struct bstr s = stream_read_file(fname, p, p->global, 1000000000); // 1GB

    talloc_free(fname);

    if (s.len) {

        struct cached_file new = {

            .path = talloc_strdup(p, path),

            .body = s,

        };

        MP_TARRAY_APPEND(p, p->files, p->num_files, new);

        return new.body;

    }

    return (struct bstr){0};

}

static void debug_check_gl(struct gl_video *p, const char *msg)

{

    if (p->ra->fns->debug_marker)

        p->ra->fns->debug_marker(p->ra, msg);

}

static void gl_video_reset_surfaces(struct gl_video *p)

{

    for (int i = 0; i < SURFACES_MAX; i++) {

        p->surfaces[i].id = 0;

        p->surfaces[i].pts = MP_NOPTS_VALUE;

    }

    p->surface_idx = 0;

    p->surface_now = 0;

    p->frames_drawn = 0;

    p->output_tex_valid = false;

}

static void gl_video_reset_hooks(struct gl_video *p)

{

    for (int i = 0; i < p->num_tex_hooks; i++)

        talloc_free(p->tex_hooks[i].priv);

    for (int i = 0; i < p->num_user_textures; i++)

        ra_tex_free(p->ra, &p->user_textures[i].tex);

    p->num_tex_hooks = 0;

    p->num_user_textures = 0;

}

static inline int surface_wrap(int id)

{

    id = id % SURFACES_MAX;

    return id < 0 ? id + SURFACES_MAX : id;

}

static void reinit_osd(struct gl_video *p)

{

    mpgl_osd_destroy(p->osd);

    p->osd = NULL;

    if (p->osd_state)

        p->osd = mpgl_osd_init(p->ra, p->log, p->osd_state);

}

static void uninit_rendering(struct gl_video *p)

{

    for (int n = 0; n < SCALER_COUNT; n++)

        uninit_scaler(p, &p->scaler[n]);

    ra_tex_free(p->ra, &p->dither_texture);

    for (int n = 0; n < 4; n++) {

        ra_tex_free(p->ra, &p->merge_tex[n]);

        ra_tex_free(p->ra, &p->scale_tex[n]);

        ra_tex_free(p->ra, &p->integer_tex[n]);

        ra_tex_free(p->ra, &p->chroma_tex[n]);

    }

    ra_tex_free(p->ra, &p->indirect_tex);

    ra_tex_free(p->ra, &p->blend_subs_tex);

    ra_tex_free(p->ra, &p->screen_tex);

    ra_tex_free(p->ra, &p->output_tex);

    for (int n = 0; n < 2; n++)

        ra_tex_free(p->ra, &p->error_diffusion_tex[n]);

    for (int n = 0; n < SURFACES_MAX; n++)

        ra_tex_free(p->ra, &p->surfaces[n].tex);

    for (int n = 0; n < p->num_hook_textures; n++)

        ra_tex_free(p->ra, &p->hook_textures[n]);

    gl_video_reset_surfaces(p);

    gl_video_reset_hooks(p);

    gl_sc_reset_error(p->sc);

}

bool gl_video_gamma_auto_enabled(struct gl_video *p)

{

    return p->opts.gamma_auto;

}

// Warning: profile.start must point to a ta allocation, and the function

//          takes over ownership.

void gl_video_set_icc_profile(struct gl_video *p, bstr icc_data)

{

    if (gl_lcms_set_memory_profile(p->cms, icc_data))

        reinit_from_options(p);

}

bool gl_video_icc_auto_enabled(struct gl_video *p)

{

    return p->opts.icc_opts ? p->opts.icc_opts->profile_auto : false;

}

static bool gl_video_get_lut3d(struct gl_video *p, enum pl_color_primaries prim,

                               enum pl_color_transfer trc)

{

    if (!p->use_lut_3d)

        return false;

    struct AVBufferRef *icc = NULL;

    if (p->image.mpi)

        icc = p->image.mpi->icc_profile;

    if (p->lut_3d_texture && !gl_lcms_has_changed(p->cms, prim, trc, icc))

        return true;

    // GLES3 doesn't provide filtered 16 bit integer textures

    // GLES2 doesn't even provide 3D textures

    const struct ra_format *fmt = ra_find_unorm_format(p->ra, 2, 4);

    if (!fmt || !(p->ra->caps & RA_CAP_TEX_3D)) {

        p->use_lut_3d = false;

        MP_WARN(p, "Disabling color management (no RGBA16 3D textures).\n");

        return false;

    }

    struct lut3d *lut3d = NULL;

    if (!fmt || !gl_lcms_get_lut3d(p->cms, &lut3d, prim, trc, icc) || !lut3d) {

        p->use_lut_3d = false;

        return false;

    }

    ra_tex_free(p->ra, &p->lut_3d_texture);

    struct ra_tex_params params = {

        .dimensions = 3,

        .w = lut3d->size[0],

        .h = lut3d->size[1],

        .d = lut3d->size[2],

        .format = fmt,

        .render_src = true,

        .src_linear = true,

        .initial_data = lut3d->data,

    };

    p->lut_3d_texture = ra_tex_create(p->ra, &params);

    debug_check_gl(p, "after 3d lut creation");

    for (int i = 0; i < 3; i++)

        p->lut_3d_size[i] = lut3d->size[i];

    talloc_free(lut3d);

    if (!p->lut_3d_texture) {

        p->use_lut_3d = false;

        return false;

    }

    return true;

}

// Fill an image struct from a ra_tex + some metadata

static struct image image_wrap(struct ra_tex *tex, enum plane_type type,

                               int components)

{

    mp_assert(type != PLANE_NONE);

    return (struct image){

        .type = type,

        .tex = tex,

        .multiplier = 1.0,

        .w = tex ? tex->params.w : 1,

        .h = tex ? tex->params.h : 1,

        .transform = identity_trans,

        .components = components,

    };

}

// Bind an image to a free texture unit and return its ID.

static int pass_bind(struct gl_video *p, struct image img)

{

    int idx = p->num_pass_imgs;

    MP_TARRAY_APPEND(p, p->pass_imgs, p->num_pass_imgs, img);

    return idx;

}

// Rotation by 90° and flipping.

// w/h is used for recentering.

static void get_transform(float w, float h, int rotate, bool flip,

                          struct gl_transform *out_tr)

{

    int a = rotate % 90 ? 0 : (rotate / 90) % 4;

    int sin90[4] = {0, 1, 0, -1}; // just to avoid rounding issues etc.

    int cos90[4] = {1, 0, -1, 0};

    struct gl_transform tr = {{{ cos90[a], sin90[a]},

                               {-sin90[a], cos90[a]}}};

    // basically, recenter to keep the whole image in view

    float b[2] = {1, 1};

    gl_transform_vec(tr, &b[0], &b[1]);

    tr.t[0] += b[0] < 0 ? w : 0;

    tr.t[1] += b[1] < 0 ? h : 0;

    if (flip) {

        struct gl_transform fliptr = {{{1, 0}, {0, -1}}, {0, h}};

        gl_transform_trans(fliptr, &tr);

    }

    *out_tr = tr;

}

// Return the chroma plane upscaled to luma size, but with additional padding

// for image sizes not aligned to subsampling.

static int chroma_upsize(int size, int pixel)

{

    return (size + pixel - 1) / pixel * pixel;

}

// If a and b are on the same plane, return what plane type should be used.

// If a or b are none, the other type always wins.

// Usually: LUMA/RGB/XYZ > CHROMA > ALPHA

static enum plane_type merge_plane_types(enum plane_type a, enum plane_type b)

{

    if (a == PLANE_NONE)

        return b;

    if (b == PLANE_LUMA || b == PLANE_RGB || b == PLANE_XYZ)

        return b;

    if (b != PLANE_NONE && a == PLANE_ALPHA)

        return b;

    return a;

}

// Places a video_image's image textures + associated metadata into img[]. The

// number of textures is equal to p->plane_count. Any necessary plane offsets

// are stored in off. (e.g. chroma position)

static void pass_get_images(struct gl_video *p, struct video_image *vimg,

                            struct image img[4], struct gl_transform off[4])

{

    mp_assert(vimg->mpi);

    int w = p->image_params.w;

    int h = p->image_params.h;

    // Determine the chroma offset

    float ls_w = 1.0 / p->ra_format.chroma_w;

    float ls_h = 1.0 / p->ra_format.chroma_h;

    struct gl_transform chroma = {{{ls_w, 0.0}, {0.0, ls_h}}};

    if (p->image_params.chroma_location != PL_CHROMA_CENTER) {

        float cx, cy;

        pl_chroma_location_offset(p->image_params.chroma_location, &cx, &cy);

        // By default texture coordinates are such that chroma is centered with

        // any chroma subsampling. If a specific direction is given, make it

        // so that the luma and chroma sample line up exactly.

        // For 4:4:4, setting chroma location should have no effect at all.

        // luma sample size (in chroma coord. space)

        chroma.t[0] = ls_w < 1 ? ls_w * -cx : 0;

        chroma.t[1] = ls_h < 1 ? ls_h * -cy : 0;

    }

    memset(img, 0, 4 * sizeof(img[0]));

    for (int n = 0; n < p->plane_count; n++) {

        struct texplane *t = &vimg->planes[n];

        enum plane_type type = PLANE_NONE;

        int padding = 0;

        for (int i = 0; i < 4; i++) {

            int c = p->ra_format.components[n][i];

            enum plane_type ctype;

            if (c == 0) {

                ctype = PLANE_NONE;

            } else if (c == 4) {

                ctype = PLANE_ALPHA;

            } else if (p->image_params.repr.sys == PL_COLOR_SYSTEM_RGB) {

                ctype = PLANE_RGB;

            } else if (p->image_params.repr.sys == PL_COLOR_SYSTEM_XYZ) {

                ctype = PLANE_XYZ;

            } else {

                ctype = c == 1 ? PLANE_LUMA : PLANE_CHROMA;

            }

            type = merge_plane_types(type, ctype);

            if (!c && padding == i)

                padding = i + 1;

        }

        int msb_valid_bits =

            p->ra_format.component_bits + MPMIN(p->ra_format.component_pad, 0);

        int csp = type == PLANE_ALPHA ? PL_COLOR_SYSTEM_RGB : p->image_params.repr.sys;

        float tex_mul =

            1.0 / mp_get_csp_mul(csp, msb_valid_bits, p->ra_format.component_bits);

        if (p->ra_format.component_type == RA_CTYPE_FLOAT)

            tex_mul = 1.0;

        img[n] = (struct image){

            .type = type,

            .tex = t->tex,

            .multiplier = tex_mul,

            .w = t->w,

            .h = t->h,

            .padding = padding,

        };

        for (int i = 0; i < 4; i++)

            img[n].components += !!p->ra_format.components[n][i];

        get_transform(t->w, t->h, p->image_params.rotate, t->flipped,

                      &img[n].transform);

        if (p->image_params.rotate % 180 == 90)

            MPSWAP(int, img[n].w, img[n].h);

        off[n] = identity_trans;

        if (type == PLANE_CHROMA) {

            struct gl_transform rot;

            // Reverse the rotation direction here because the different

            // coordinate system of chroma offset results in rotation

            // in the opposite direction.

            get_transform(0, 0, 360 - p->image_params.rotate, t->flipped, &rot);

            struct gl_transform tr = chroma;

            gl_transform_vec(rot, &tr.t[0], &tr.t[1]);

            float dx = (chroma_upsize(w, p->ra_format.chroma_w) - w) * ls_w;

            float dy = (chroma_upsize(h, p->ra_format.chroma_h) - h) * ls_h;

            // Adjust the chroma offset if the real chroma size is fractional

            // due image sizes not aligned to chroma subsampling.

            if (rot.m[0][0] < 0)

                tr.t[0] += dx;

            if (rot.m[1][0] < 0)

                tr.t[0] += dy;

            if (rot.m[0][1] < 0)

                tr.t[1] += dx;

            if (rot.m[1][1] < 0)

                tr.t[1] += dy;

            off[n] = tr;

        }

    }

}

// Return the index of the given component (assuming all non-padding components

// of all planes are concatenated into a linear list).

static int find_comp(struct ra_imgfmt_desc *desc, int component)

{

    int cur = 0;

    for (int n = 0; n < desc->num_planes; n++) {

        for (int i = 0; i < 4; i++) {

            if (desc->components[n][i]) {

                if (desc->components[n][i] == component)

                    return cur;

                cur++;

            }

        }

    }

    return -1;

}

static void init_video(struct gl_video *p)

{

    p->use_integer_conversion = false;

    struct ra_hwdec *hwdec = ra_hwdec_get(&p->hwdec_ctx, p->image_params.imgfmt);

    if (hwdec) {

        if (hwdec->driver->overlay_frame) {

            MP_WARN(p, "Using HW-overlay mode. No GL filtering is performed "

                       "on the video!\n");

            p->hwdec_overlay = hwdec;

        } else {

            p->hwdec_mapper = ra_hwdec_mapper_create(hwdec, &p->image_params);

            if (!p->hwdec_mapper)

                MP_ERR(p, "Initializing texture for hardware decoding failed.\n");

        }

        if (p->hwdec_mapper)

            p->image_params = p->hwdec_mapper->dst_params;

        const char **exts = hwdec->glsl_extensions;

        for (int n = 0; exts && exts[n]; n++)

            gl_sc_enable_extension(p->sc, (char *)exts[n]);

        p->hwdec_active = true;

    }

    p->ra_format = (struct ra_imgfmt_desc){0};

    ra_get_imgfmt_desc(p->ra, p->image_params.imgfmt, &p->ra_format);

    p->plane_count = p->ra_format.num_planes;

    p->has_alpha = false;

    p->is_gray = true;

    for (int n = 0; n < p->ra_format.num_planes; n++) {

        for (int i = 0; i < 4; i++) {

            if (p->ra_format.components[n][i]) {

                p->has_alpha |= p->ra_format.components[n][i] == 4;

                p->is_gray &= p->ra_format.components[n][i] == 1 ||