RepoMirrors
/
mpv
mirror of https://github.com/mpv-player/mpv
1
0
Fork 0
Code Issues Releases Wiki Activity

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.
This commit is contained in:
wm4 2014-05-06 20:22:32 +02:00
parent 587f42b56c
commit feb1f8f18f
5 changed files with 173 additions and 85 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
old-makefile
View File

@ -299,6 +299,7 @@ SOURCES = audio/audio.c \
video/out/vo.c \
video/out/vo_null.c \
video/out/vo_image.c \
video/out/win_state.c \
osdep/$(GETCH) \
osdep/$(TIMER) \
$(SOURCES-yes)

103
video/out/vo.c
View File

@ -36,6 +36,7 @@
#include "bstr/bstr.h"
#include "vo.h"
#include "aspect.h"
#include "win_state.h"
#include "input/input.h"
#include "options/m_config.h"
#include "common/msg.h"
@ -234,78 +235,6 @@ void vo_destroy(struct vo *vo)
talloc_free(vo);
}
static void calc_monitor_aspect(struct mp_vo_opts *opts, int scr_w, int scr_h,
float *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;
}
}
// Set window size (vo->dwidth/dheight) and position (vo->dx/dy) according to
// the video display size d_w/d_h.
// NOTE: currently, all GUI 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 config() with no size change,
// multi-monitor stuff, and possibly more.
static void determine_window_geometry(struct vo *vo, int d_w, int d_h)
{
struct mp_vo_opts *opts = vo->opts;
int scr_w = opts->screenwidth;
int scr_h = opts->screenheight;
MP_DBG(vo, "screen size: %dx%d\n", scr_w, scr_h);
calc_monitor_aspect(opts, scr_w, scr_h, &vo->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);
vo->dx = (int)(opts->screenwidth - d_w) / 2;
vo->dy = (int)(opts->screenheight - d_h) / 2;
m_geometry_apply(&vo->dx, &vo->dy, &d_w, &d_h, scr_w, scr_h,
&opts->geometry);
vo->dx += vo->xinerama_x;
vo->dy += vo->xinerama_y;
vo->dwidth = d_w;
vo->dheight = d_h;
}
static void check_vo_caps(struct vo *vo)
{
int rot = vo->params->rotate;
@ -320,23 +249,27 @@ static void check_vo_caps(struct vo *vo)
int vo_reconfig(struct vo *vo, struct mp_image_params *params, int flags)
{
int d_width = params->d_w;
int d_height = params->d_h;
if (vo_control(vo, VOCTRL_UPDATE_SCREENINFO, NULL) == VO_TRUE) {
int w = params->d_w, h = params->d_h;
if ((vo->driver->caps & VO_CAP_ROTATE90) && params->rotate % 180 == 90)
MPSWAP(int, w, h);
determine_window_geometry(vo, w, h);
d_width = vo->dwidth;
d_height = vo->dheight;
}
vo->dwidth = d_width;
vo->dheight = d_height;
vo->dwidth = params->d_w;
vo->dheight = params->d_h;
talloc_free(vo->params);
vo->params = talloc_memdup(vo, params, sizeof(*params));
// Emulate the old way of calculating the window geometry settings.
if (vo_control(vo, VOCTRL_UPDATE_SCREENINFO, NULL) == VO_TRUE) {
struct mp_rect rc = {
vo->xinerama_x,
vo->xinerama_y,
vo->xinerama_x + vo->opts->screenwidth,
vo->xinerama_y + vo->opts->screenheight,
};
struct vo_win_geometry geo;
vo_calc_window_geometry(vo, &rc, &geo);
vo_apply_window_geometry(vo, &geo);
vo->dx = geo.win.x0;
vo->dy = geo.win.y0;
}
int ret = vo->driver->reconfig(vo, vo->params, flags);
vo->config_ok = ret >= 0;
if (vo->config_ok) {

123
video/out/win_state.c Normal file
View File

@ -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;
}

30
video/out/win_state.h Normal file
View File

@ -0,0 +1,30 @@
#ifndef MP_WIN_STATE_H_
#define MP_WIN_STATE_H_
#include "common/common.h"
struct vo;
enum {
// By user settings, the window manager's chosen window position should
// be overridden.
VO_WIN_FORCE_POS = (1 << 0),
};
struct vo_win_geometry {
// Bitfield of VO_WIN_* flags
int flags;
// Position & size of the window. In xinerama coordinates, i.e. they're
// relative to the virtual desktop encompassing all screens, not the
// current screen.
struct mp_rect win;
// Aspect ratio of the current monitor.
// (calculated from screen size and options.)
double monitor_par;
};
void vo_calc_window_geometry(struct vo *vo, const struct mp_rect *screen,
struct vo_win_geometry *out_geo);
void vo_apply_window_geometry(struct vo *vo, const struct vo_win_geometry *geo);
#endif

1
wscript_build.py
View File

@ -360,6 +360,7 @@ def build(ctx):
( "video/out/vo_xv.c", "xv" ),
( "video/out/w32_common.c", "gdi" ),
( "video/out/wayland_common.c", "wayland" ),
( "video/out/win_state.c"),
( "video/out/x11_common.c", "x11" ),
## osdep