video/out: separate out code to compute window size

Currently, vo_reconfig() calculates the requested window size and sets
the vo->dwidth/dheight fields _if_ VOCTRL_UPDATE_SCREENINFO is
implemented by the VO or the windowing backend. The window size can be
different from the display size if e.g. the --geometry option is used.
It will also set the vo->dx/dy fields and read vo->xinerama_x/y.

It turned out that this is very backwards and actually requires the
windowing backends to workaround these things. There's also
MPOpts.screenwidth/screenheight, which used to map to actual options,
but is now used only to communicate the screen size to the vo.c code
calculating the window size and position.

Change this by making the window geometry calculations available as
separate functions. This commit doesn't change any VO code yet, and just
emulates the old way using the new functions. VO code will remove its
usage of VOCTRL_UPDATE_SCREENINFO and use the new functions directly.

1 files changed, 123 insertions, 0 deletions

diff --git a/video/out/win_state.c b/video/out/win_state.c
new file mode 100644
index 0000000000..7b9f0c7bcd
--- /dev/null
+++ b/video/out/win_state.c
@@ -0,0 +1,123 @@
+/*
+ * This file is part of mpv.
+ *
+ * mpv is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with mpv.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "win_state.h"
+#include "vo.h"
+
+#include "video/mp_image.h"
+
+static void calc_monitor_aspect(struct mp_vo_opts *opts, int scr_w, int scr_h,
+                                double *pixelaspect, int *w, int *h)
+{
+    *pixelaspect = 1.0 / opts->monitor_pixel_aspect;
+
+    if (scr_w > 0 && scr_h > 0 && opts->force_monitor_aspect)
+        *pixelaspect = opts->force_monitor_aspect * scr_h / scr_w;
+
+    if (*pixelaspect < 1) {
+        *h /= *pixelaspect;
+    } else {
+        *w *= *pixelaspect;
+    }
+}
+
+// Fit *w/*h into the size specified by geo.
+static void apply_autofit(int *w, int *h, int scr_w, int scr_h,
+                          struct m_geometry *geo, bool allow_upscale)
+{
+    if (!geo->wh_valid)
+        return;
+
+    int dummy;
+    int n_w = *w, n_h = *h;
+    m_geometry_apply(&dummy, &dummy, &n_w, &n_h, scr_w, scr_h, geo);
+
+    if (!allow_upscale && *w <= n_w && *h <= n_h)
+        return;
+
+    // If aspect mismatches, always make the window smaller than the fit box
+    double asp = (double)*w / *h;
+    double n_asp = (double)n_w / n_h;
+    if (n_asp <= asp) {
+        *w = n_w;
+        *h = n_w / asp;
+    } else {
+        *w = n_h * asp;
+        *h = n_h;
+    }
+}
+
+// Compute the "suggested" window size and position and return it in *out_geo.
+// screen is the bounding box of the current screen within the virtual desktop.
+// Does not change *vo.
+// Use vo_apply_window_geometry() to copy the result into the vo.
+// NOTE: currently, all windowing backends do their own handling of window
+//       geometry additional to this code. This is to deal with initial window
+//       placement, fullscreen handling, avoiding resize on reconfig() with no
+//       size change, multi-monitor stuff, and possibly more.
+void vo_calc_window_geometry(struct vo *vo, const struct mp_rect *screen,
+                             struct vo_win_geometry *out_geo)
+{
+    struct mp_vo_opts *opts = vo->opts;
+
+    *out_geo = (struct vo_win_geometry){0};
+
+    // The case of calling this function even though no video was configured
+    // yet (i.e. vo->params==NULL) happens when vo_opengl creates a hidden
+    // window in order to create an OpenGL context.
+    struct mp_image_params params = { .d_w = 320, .d_h = 200 };
+    if (vo->params)
+        params = *vo->params;
+
+    int d_w = params.d_w;
+    int d_h = params.d_h;
+    if ((vo->driver->caps & VO_CAP_ROTATE90) && params.rotate % 180 == 90)
+        MPSWAP(int, d_w, d_h);
+
+    int scr_w = screen->x1 - screen->x0;
+    int scr_h = screen->y1 - screen->y0;
+
+    MP_DBG(vo, "screen size: %dx%d\n", scr_w, scr_h);
+
+    calc_monitor_aspect(opts, scr_w, scr_h, &out_geo->monitor_par, &d_w, &d_h);
+
+    apply_autofit(&d_w, &d_h, scr_w, scr_h, &opts->autofit, true);
+    apply_autofit(&d_w, &d_h, scr_w, scr_h, &opts->autofit_larger, false);
+
+    out_geo->win.x0 = (int)(scr_w - d_w) / 2;
+    out_geo->win.y0 = (int)(scr_h - d_h) / 2;
+    m_geometry_apply(&out_geo->win.x0, &out_geo->win.y0, &d_w, &d_h,
+                     scr_w, scr_h, &opts->geometry);
+
+    out_geo->win.x0 += screen->x0;
+    out_geo->win.y0 += screen->y0;
+    out_geo->win.x1 = out_geo->win.x0 + d_w;
+    out_geo->win.y1 = out_geo->win.y0 + d_h;
+
+    if (opts->geometry.xy_valid || opts->force_window_position)
+        out_geo->flags |= VO_WIN_FORCE_POS;
+}
+
+// Copy the parameters in *geo to the vo fields.
+// (Doesn't do anything else - windowing backends should trigger VO_EVENT_RESIZE
+//  to ensure that the VO reinitializes rendering properly.)
+void vo_apply_window_geometry(struct vo *vo, const struct vo_win_geometry *geo)
+{
+    vo->dwidth = geo->win.x1 - geo->win.x0;
+    vo->dheight = geo->win.y1 - geo->win.y0;
+    vo->monitor_par = geo->monitor_par;
+}