diff options
Diffstat (limited to 'video/out/aspect.c')
| -rw-r--r-- | video/out/aspect.c | 216 |
1 files changed, 216 insertions, 0 deletions
diff --git a/video/out/aspect.c b/video/out/aspect.c new file mode 100644 index 0000000..6e1cd63 --- /dev/null +++ b/video/out/aspect.c @@ -0,0 +1,216 @@ +/* + * 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/>. + */ + +/* Stuff for correct aspect scaling. */ +#include "aspect.h" +#include "math.h" +#include "vo.h" +#include "common/msg.h" +#include "options/options.h" +#include "video/mp_image.h" + +#include "vo.h" +#include "sub/osd.h" + +static void aspect_calc_panscan(struct mp_vo_opts *opts, + int w, int h, int d_w, int d_h, int unscaled, + int window_w, int window_h, double monitor_par, + int *out_w, int *out_h) +{ + int fwidth = window_w; + int fheight = (float)window_w / d_w * d_h / monitor_par; + if (fheight > window_h || fheight < h) { + int tmpw = (float)window_h / d_h * d_w * monitor_par; + if (tmpw <= window_w) { + fheight = window_h; + fwidth = tmpw; + } + } + + int vo_panscan_area = window_h - fheight; + double f_w = fwidth / (double)MPMAX(fheight, 1); + double f_h = 1; + if (vo_panscan_area == 0) { + vo_panscan_area = window_w - fwidth; + f_w = 1; + f_h = fheight / (double)MPMAX(fwidth, 1); + } + + if (unscaled) { + vo_panscan_area = 0; + if (unscaled != 2 || (d_w <= window_w && d_h <= window_h)) { + fwidth = d_w * monitor_par; + fheight = d_h; + } + } + + *out_w = fwidth + vo_panscan_area * opts->panscan * f_w; + *out_h = fheight + vo_panscan_area * opts->panscan * f_h; +} + +// Clamp [start, end) to range [0, size) with various fallbacks. +static void clamp_size(int size, int *start, int *end) +{ + *start = MPMAX(0, *start); + *end = MPMIN(size, *end); + if (*start >= *end) { + *start = 0; + *end = 1; + } +} + +static void src_dst_split_scaling(int src_size, int dst_size, + int scaled_src_size, + float zoom, float align, float pan, float scale, + int *src_start, int *src_end, + int *dst_start, int *dst_end, + int *osd_margin_a, int *osd_margin_b) +{ + scaled_src_size *= powf(2, zoom) * scale; + scaled_src_size = MPMAX(scaled_src_size, 1); + align = (align + 1) / 2; + + *dst_start = (dst_size - scaled_src_size) * align + pan * scaled_src_size; + *dst_end = *dst_start + scaled_src_size; + + // Distance of screen frame to video + *osd_margin_a = *dst_start; + *osd_margin_b = dst_size - *dst_end; + + // Clip to screen + int s_src = *src_end - *src_start; + int s_dst = *dst_end - *dst_start; + if (*dst_start < 0) { + int border = -(*dst_start) * s_src / s_dst; + *src_start += border; + *dst_start = 0; + } + if (*dst_end > dst_size) { + int border = (*dst_end - dst_size) * s_src / s_dst; + *src_end -= border; + *dst_end = dst_size; + } + + // For sanity: avoid bothering VOs with corner cases + clamp_size(src_size, src_start, src_end); + clamp_size(dst_size, dst_start, dst_end); +} + +static void calc_margin(float opts[2], int out[2], int size) +{ + out[0] = MPCLAMP((int)(opts[0] * size), 0, size); + out[1] = MPCLAMP((int)(opts[1] * size), 0, size); + + if (out[0] + out[1] >= size) { + // This case is not really supported. Show an error by 1 pixel. + out[0] = 0; + out[1] = MPMAX(0, size - 1); + } +} + +void mp_get_src_dst_rects(struct mp_log *log, struct mp_vo_opts *opts, + int vo_caps, struct mp_image_params *video, + int window_w, int window_h, double monitor_par, + struct mp_rect *out_src, + struct mp_rect *out_dst, + struct mp_osd_res *out_osd) +{ + int src_w = video->w; + int src_h = video->h; + int src_dw, src_dh; + + mp_image_params_get_dsize(video, &src_dw, &src_dh); + window_w = MPMAX(1, window_w); + window_h = MPMAX(1, window_h); + + int margin_x[2] = {0}; + int margin_y[2] = {0}; + if (opts->keepaspect) { + calc_margin(opts->margin_x, margin_x, window_w); + calc_margin(opts->margin_y, margin_y, window_h); + } + + int vid_window_w = window_w - margin_x[0] - margin_x[1]; + int vid_window_h = window_h - margin_y[0] - margin_y[1]; + + struct mp_rect dst = {0, 0, window_w, window_h}; + struct mp_rect src = {0, 0, src_w, src_h}; + if (mp_image_crop_valid(video)) + src = video->crop; + + if (vo_caps & VO_CAP_ROTATE90) { + if (video->rotate % 180 == 90) { + MPSWAP(int, src_w, src_h); + MPSWAP(int, src_dw, src_dh); + } + mp_rect_rotate(&src, src_w, src_h, video->rotate); + } + + struct mp_osd_res osd = { + .w = window_w, + .h = window_h, + .display_par = monitor_par, + }; + + if (opts->keepaspect) { + int scaled_width, scaled_height; + aspect_calc_panscan(opts, src_w, src_h, src_dw, src_dh, opts->unscaled, + vid_window_w, vid_window_h, monitor_par, + &scaled_width, &scaled_height); + src_dst_split_scaling(src_w, vid_window_w, scaled_width, + opts->zoom, opts->align_x, opts->pan_x, opts->scale_x, + &src.x0, &src.x1, &dst.x0, &dst.x1, + &osd.ml, &osd.mr); + src_dst_split_scaling(src_h, vid_window_h, scaled_height, + opts->zoom, opts->align_y, opts->pan_y, opts->scale_y, + &src.y0, &src.y1, &dst.y0, &dst.y1, + &osd.mt, &osd.mb); + } + + dst.x0 += margin_x[0]; + dst.y0 += margin_y[0]; + dst.x1 += margin_x[0]; + dst.y1 += margin_y[0]; + + // OSD really uses the full window, but was computed on the margin-cut + // video sub-window. Correct it to the full window. + osd.ml += margin_x[0]; + osd.mr += margin_x[1]; + osd.mt += margin_y[0]; + osd.mb += margin_y[1]; + + *out_src = src; + *out_dst = dst; + *out_osd = osd; + + int sw = src.x1 - src.x0, sh = src.y1 - src.y0; + int dw = dst.x1 - dst.x0, dh = dst.y1 - dst.y0; + + mp_verbose(log, "Window size: %dx%d (Borders: l=%d t=%d r=%d b=%d)\n", + window_w, window_h, + margin_x[0], margin_y[0], margin_x[1], margin_y[1]); + mp_verbose(log, "Video source: %dx%d (%d:%d)\n", + video->w, video->h, video->p_w, video->p_h); + mp_verbose(log, "Video display: (%d, %d) %dx%d -> (%d, %d) %dx%d\n", + src.x0, src.y0, sw, sh, dst.x0, dst.y0, dw, dh); + mp_verbose(log, "Video scale: %f/%f\n", + (double)dw / sw, (double)dh / sh); + mp_verbose(log, "OSD borders: l=%d t=%d r=%d b=%d\n", + osd.ml, osd.mt, osd.mr, osd.mb); + mp_verbose(log, "Video borders: l=%d t=%d r=%d b=%d\n", + dst.x0, dst.y0, window_w - dst.x1, window_h - dst.y1); +} |