1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
/*
* 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 "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 = 1.0 / (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_up, bool allow_down)
{
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_up && *w <= n_w && *h <= n_h)
return;
if (!allow_down && *w >= n_w && *h >= n_h)
return;
// If aspect mismatches, always make the window smaller than the fit box
// (Or larger, if allow_down==false.)
double asp = (double)*w / *h;
double n_asp = (double)n_w / n_h;
if ((n_asp <= asp) == allow_down) {
*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.
// screen: position of the screen on virtual desktop on which the window
// should be placed
// dpi_scale: the DPI multiplier to get from virtual to real coordinates
// (>1 for "hidpi")
// 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_geometry2(struct vo *vo, const struct mp_rect *screen,
double dpi_scale, 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_gpu creates a hidden window
// in order to create a rendering context.
struct mp_image_params params = { .w = 320, .h = 200 };
if (vo->params)
params = *vo->params;
if (!opts->hidpi_window_scale)
dpi_scale = 1;
int d_w, d_h;
mp_image_params_get_dsize(¶ms, &d_w, &d_h);
if ((vo->driver->caps & VO_CAP_ROTATE90) && params.rotate % 180 == 90)
MPSWAP(int, d_w, d_h);
d_w = MPCLAMP(d_w * opts->window_scale * dpi_scale, 1, 16000);
d_h = MPCLAMP(d_h * opts->window_scale * dpi_scale, 1, 16000);
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, true);
apply_autofit(&d_w, &d_h, scr_w, scr_h, &opts->autofit_smaller, true, false);
apply_autofit(&d_w, &d_h, scr_w, scr_h, &opts->autofit_larger, false, true);
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;
}
void vo_calc_window_geometry(struct vo *vo, const struct mp_rect *screen,
struct vo_win_geometry *out_geo)
{
vo_calc_window_geometry2(vo, screen, 1.0, out_geo);
}
// 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;
}
|
