vo_opengl: further GL API use separation

Move multiple GL-specific things from the renderer to other places like
vo_opengl.c, vo_opengl_cb.c, and ra_gl.c.

The vp_w/vp_h parameters to gl_video_resize() make no sense anymore, and
are implicitly part of struct fbodst.

Checking the main framebuffer depth is moved to vo_opengl.c. For
vo_opengl_cb.c it always assumes 8. The API user now has to override
this manually. The previous heuristic didn't make much sense anyway.

The only remaining dependency on GL is the hwdec stuff, which is harder
to change.

1 files changed, 36 insertions, 87 deletions

diff --git a/video/out/opengl/video.c b/video/out/opengl/video.c
index 57c1c5b18f..408013fe22 100644
--- a/video/out/opengl/video.c
+++ b/video/out/opengl/video.c
@@ -176,7 +176,6 @@ struct dr_buffer {
 };
 
 struct gl_video {
-    GL *gl;
     struct ra *ra;
 
     struct mpv_global *global;
@@ -184,7 +183,6 @@ struct gl_video {
     struct gl_video_opts opts;
     struct m_config_cache *opts_cache;
     struct gl_lcms *cms;
-    bool gl_debug;
 
     int fb_depth;               // actual bits available in GL main framebuffer
 
@@ -252,7 +250,6 @@ struct gl_video {
     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
-    int vp_w, vp_h;
 
     // temporary during rendering
     struct img_tex pass_tex[TEXUNIT_VIDEO_NUM];
@@ -459,17 +456,8 @@ static struct bstr load_cached_file(struct gl_video *p, const char *path)
 
 static void debug_check_gl(struct gl_video *p, const char *msg)
 {
-    if (p->gl_debug)
-        gl_check_error(p->gl, p->log, msg);
-}
-
-void gl_video_set_debug(struct gl_video *p, bool enable)
-{
-    GL *gl = p->gl;
-
-    p->gl_debug = enable;
-    if (p->gl->debug_context)
-        gl_set_debug_logger(gl, enable ? p->log : NULL);
+    if (p->ra->fns->debug_marker)
+        p->ra->fns->debug_marker(p->ra, msg);
 }
 
 static void gl_video_reset_surfaces(struct gl_video *p)
@@ -1094,8 +1082,8 @@ static void pass_prepare_src_tex(struct gl_video *p)
         gl_sc_uniform_vec2(sc, texture_size, f);
         gl_sc_uniform_mat2(sc, texture_rot, true, (float *)s->transform.m);
         gl_sc_uniform_vec2(sc, texture_off, (float *)s->transform.t);
-        gl_sc_uniform_vec2(sc, pixel_size, (GLfloat[]){1.0f / f[0],
-                                                       1.0f / f[1]});
+        gl_sc_uniform_vec2(sc, pixel_size, (float[]){1.0f / f[0],
+                                                     1.0f / f[1]});
     }
 }
 
@@ -1137,7 +1125,7 @@ static void dispatch_compute(struct gl_video *p, int w, int h,
         // We need to rescale the coordinates to the true texture size
         char tex_scale[32];
         snprintf(tex_scale, sizeof(tex_scale), "tex_scale%d", n);
-        gl_sc_uniform_vec2(p->sc, tex_scale, (GLfloat[2]){
+        gl_sc_uniform_vec2(p->sc, tex_scale, (float[2]){
                 (float)s->w / s->tex->params.w,
                 (float)s->h / s->tex->params.h,
         });
@@ -1514,18 +1502,18 @@ static void load_shader(struct gl_video *p, struct bstr body)
     gl_sc_uniform_f(p->sc, "random", (double)av_lfg_get(&p->lfg) / UINT32_MAX);
     gl_sc_uniform_i(p->sc, "frame", p->frames_uploaded);
     gl_sc_uniform_vec2(p->sc, "input_size",
-                       (GLfloat[]){(p->src_rect.x1 - p->src_rect.x0) *
-                                   p->texture_offset.m[0][0],
-                                   (p->src_rect.y1 - p->src_rect.y0) *
-                                   p->texture_offset.m[1][1]});
+                       (float[]){(p->src_rect.x1 - p->src_rect.x0) *
+                                  p->texture_offset.m[0][0],
+                                  (p->src_rect.y1 - p->src_rect.y0) *
+                                  p->texture_offset.m[1][1]});
     gl_sc_uniform_vec2(p->sc, "target_size",
-                       (GLfloat[]){p->dst_rect.x1 - p->dst_rect.x0,
-                                   p->dst_rect.y1 - p->dst_rect.y0});
+                       (float[]){p->dst_rect.x1 - p->dst_rect.x0,
+                                 p->dst_rect.y1 - p->dst_rect.y0});
     gl_sc_uniform_vec2(p->sc, "tex_offset",
-                       (GLfloat[]){p->src_rect.x0 * p->texture_offset.m[0][0] +
-                                   p->texture_offset.t[0],
-                                   p->src_rect.y0 * p->texture_offset.m[1][1] +
-                                   p->texture_offset.t[1]});
+                       (float[]){p->src_rect.x0 * p->texture_offset.m[0][0] +
+                                 p->texture_offset.t[0],
+                                 p->src_rect.y0 * p->texture_offset.m[1][1] +
+                                 p->texture_offset.t[1]});
 }
 
 // Semantic equality
@@ -1688,8 +1676,6 @@ static void pass_sample_separated(struct gl_video *p, struct img_tex src,
 static void pass_dispatch_sample_polar(struct gl_video *p, struct scaler *scaler,
                                        struct img_tex tex, int w, int h)
 {
-    GL *gl = p->gl;
-
     uint64_t reqs = RA_CAP_COMPUTE | RA_CAP_NESTED_ARRAY;
     if ((p->ra->caps & reqs) != reqs)
         goto fallback;
@@ -1713,8 +1699,8 @@ static void pass_dispatch_sample_polar(struct gl_video *p, struct scaler *scaler
     int iw = (int)ceil(bw / ratiox) + padding + 1,
         ih = (int)ceil(bh / ratioy) + padding + 1;
 
-    int shmem_req = iw * ih * tex.components * sizeof(GLfloat);
-    if (shmem_req > gl->max_shmem)
+    int shmem_req = iw * ih * tex.components * sizeof(float);
+    if (shmem_req > p->ra->max_shmem)
         goto fallback;
 
     pass_is_compute(p, bw, bh);
@@ -2499,10 +2485,15 @@ static void pass_colormanage(struct gl_video *p, struct mp_colorspace src, bool
     }
 }
 
+void gl_video_set_fb_depth(struct gl_video *p, int fb_depth)
+{
+    p->fb_depth = fb_depth;
+}
+
 static void pass_dither(struct gl_video *p)
 {
     // Assume 8 bits per component if unknown.
-    int dst_depth = p->fb_depth;
+    int dst_depth = p->fb_depth > 0 ? p->fb_depth : 8;
     if (p->opts.dither_depth > 0)
         dst_depth = p->opts.dither_depth;
 
@@ -3001,40 +2992,16 @@ static void gl_video_interpolate_frame(struct gl_video *p, struct vo_frame *t,
     p->frames_drawn += 1;
 }
 
-// (fbo==0 makes BindFramebuffer select the screen backbuffer)
-void gl_video_render_frame(struct gl_video *p, struct vo_frame *frame, int fbo)
+void gl_video_render_frame(struct gl_video *p, struct vo_frame *frame,
+                           struct fbodst target)
 {
-    GL *gl = p->gl;
-
-    if (fbo && !(gl->mpgl_caps & MPGL_CAP_FB)) {
-        MP_FATAL(p, "Rendering to FBO requested, but no FBO extension found!\n");
-        return;
-    }
-
-    if (p->fb_depth == 0) {
-        debug_check_gl(p, "before retrieving framebuffer depth");
-        p->fb_depth = gl_get_fb_depth(gl, fbo);
-        debug_check_gl(p, "retrieving framebuffer depth");
-        if (p->fb_depth > 0) {
-            MP_VERBOSE(p, "Reported display depth: %d\n", p->fb_depth);
-        } else {
-            p->fb_depth = 8;
-        }
-    }
-
-    struct fbodst target = {
-        .tex = ra_create_wrapped_fb(p->ra, fbo, p->vp_w, abs(p->vp_h)),
-        .flip = p->vp_h < 0,
-    };
-    struct mp_rect target_rc = {0, 0, p->vp_w, abs(p->vp_h)};
+    struct mp_rect target_rc = {0, 0, target.tex->params.w, target.tex->params.h};
 
     p->broken_frame = false;
 
     bool has_frame = !!frame->current;
 
-    if (!has_frame || p->dst_rect.x0 > 0 || p->dst_rect.y0 > 0 ||
-        p->dst_rect.x1 < p->vp_w || p->dst_rect.y1 < abs(p->vp_h))
-    {
+    if (!has_frame || !mp_rect_equals(&p->dst_rect, &target_rc)) {
         struct m_color c = p->opts.background;
         float color[4] = {c.r / 255.0, c.g / 255.0, c.b / 255.0, c.a / 255.0};
         p->ra->fns->clear(p->ra, target.tex, color, &target_rc);
@@ -3140,32 +3107,27 @@ done:
         p->ra->fns->clear(p->ra, target.tex, color, &target_rc);
     }
 
-    ra_tex_free(p->ra, &target.tex);
-
     // The playloop calls this last before waiting some time until it decides
     // to call flip_page(). Tell OpenGL to start execution of the GPU commands
     // while we sleep (this happens asynchronously).
     if ((p->opts.early_flush == -1 && !frame->display_synced) ||
         p->opts.early_flush == 1)
     {
-        gl->Flush();
+        if (p->ra->fns->flush)
+            p->ra->fns->flush(p->ra);
     }
 
     p->frames_rendered++;
     pass_report_performance(p);
 }
 
-// vp_w/vp_h is the implicit size of the target framebuffer.
-// vp_h can be negative to flip the screen.
-void gl_video_resize(struct gl_video *p, int vp_w, int vp_h,
+void gl_video_resize(struct gl_video *p,
                      struct mp_rect *src, struct mp_rect *dst,
                      struct mp_osd_res *osd)
 {
     p->src_rect = *src;
     p->dst_rect = *dst;
     p->osd_rect = *osd;
-    p->vp_w = vp_w;
-    p->vp_h = vp_h;
 
     gl_video_reset_surfaces(p);
 
@@ -3173,7 +3135,7 @@ void gl_video_resize(struct gl_video *p, int vp_w, int vp_h,
         mpgl_osd_resize(p->osd, p->osd_rect, p->image_params.stereo_out);
 
     if (p->hwdec && p->hwdec->driver->overlay_adjust)
-        p->hwdec->driver->overlay_adjust(p->hwdec, vp_w, abs(vp_h), src, dst);
+        p->hwdec->driver->overlay_adjust(p->hwdec, src, dst);
 }
 
 static void frame_perf_data(struct pass_info pass[], struct mp_frame_perf *out)
@@ -3375,10 +3337,10 @@ static bool check_dumb_mode(struct gl_video *p)
 static void check_gl_features(struct gl_video *p)
 {
     struct ra *ra = p->ra;
-    GL *gl = p->gl;
     bool have_float_tex = !!ra_find_float16_format(ra, 1);
     bool have_mglsl = ra->glsl_version >= 130; // modern GLSL
-    bool have_texrg = gl->mpgl_caps & MPGL_CAP_TEX_RG;
+    const struct ra_format *rg_tex = ra_find_unorm_format(p->ra, 1, 2);
+    bool have_texrg = rg_tex && !rg_tex->luminance_alpha;
     bool have_compute = ra->caps & RA_CAP_COMPUTE;
     bool have_ssbo = ra->caps & RA_CAP_BUF_RW;
 
@@ -3512,8 +3474,6 @@ void gl_video_uninit(struct gl_video *p)
     if (!p)
         return;
 
-    GL *gl = p->gl;
-
     uninit_video(p);
 
     gl_sc_destroy(p->sc);
@@ -3532,8 +3492,6 @@ void gl_video_uninit(struct gl_video *p)
 
     mpgl_osd_destroy(p->osd);
 
-    gl_set_debug_logger(gl, NULL);
-
     // Forcibly destroy possibly remaining image references. This should also
     // cause gl_video_dr_free_buffer() to be called for the remaining buffers.
     gc_pending_dr_fences(p, true);
@@ -3541,8 +3499,7 @@ void gl_video_uninit(struct gl_video *p)
     // Should all have been unreffed already.
     assert(!p->num_dr_buffers);
 
-    p->ra->fns->destroy(p->ra);
-    talloc_free(p->ra);
+    ra_free(&p->ra);
     talloc_free(p);
 }
 
@@ -3603,18 +3560,11 @@ void gl_video_set_osd_source(struct gl_video *p, struct osd_state *osd)
     reinit_osd(p);
 }
 
-struct gl_video *gl_video_init(GL *gl, struct mp_log *log, struct mpv_global *g)
+struct gl_video *gl_video_init(struct ra *ra, struct mp_log *log,
+                               struct mpv_global *g)
 {
-    struct ra *ra = talloc_zero(NULL, struct ra);
-    ra->log = log;
-    if (ra_init_gl(ra, gl) < 0) {
-        talloc_free(ra);
-        return NULL;
-    }
-
     struct gl_video *p = talloc_ptrtype(NULL, p);
     *p = (struct gl_video) {
-        .gl = gl,
         .ra = ra,
         .global = g,
         .log = log,
@@ -3628,7 +3578,6 @@ struct gl_video *gl_video_init(GL *gl, struct mp_log *log, struct mpv_global *g)
     p->opts = *opts;
     for (int n = 0; n < SCALER_COUNT; n++)
         p->scaler[n] = (struct scaler){.index = n};
-    gl_video_set_debug(p, true);
     init_gl(p);
     reinit_from_options(p);
     return p;