summaryrefslogtreecommitdiffstats
path: root/video
diff options
context:
space:
mode:
authorwm4 <wm4@nowhere>2019-10-20 01:54:45 +0200
committerwm4 <wm4@nowhere>2019-10-20 02:17:31 +0200
commit07aa29ed8e11797310bbc8d569cc58e29bb794e3 (patch)
tree12f04a4c2f70fdc40bf8cf7060635bccfff06935 /video
parentfd539a542f04e88a8c5b245cc3c3b80b03c2a4b7 (diff)
downloadmpv-07aa29ed8e11797310bbc8d569cc58e29bb794e3.tar.bz2
mpv-07aa29ed8e11797310bbc8d569cc58e29bb794e3.tar.xz
video: add zimg wrapper
This provides a very similar API to sws_utils.h, which can be used to convert and scale from one mp_image to another. This commit adds only the code, but does not use it anywhere. The code is quite preliminary and barely tested. It supports only a few pixel formats, and will return failure for many others. (Unlike libswscale, which tries to support anything that FFmpeg knows.) zimg itself accepts only planar formats. Supporting other formats requires manual packing/unpacking. (Compared to libswscale, the zimg API is generally lower level, but allows for more flexibility.) Only BGR0 output was actually tested. It appears to work.
Diffstat (limited to 'video')
-rw-r--r--video/zimg.c608
-rw-r--r--video/zimg.h63
2 files changed, 671 insertions, 0 deletions
diff --git a/video/zimg.c b/video/zimg.c
new file mode 100644
index 0000000000..ef9738d660
--- /dev/null
+++ b/video/zimg.c
@@ -0,0 +1,608 @@
+/*
+ * 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 <libavutil/common.h>
+
+#include "common/common.h"
+#include "common/msg.h"
+#include "csputils.h"
+#include "options/m_config.h"
+#include "options/m_option.h"
+#include "video/img_format.h"
+#include "zimg.h"
+
+static_assert(MP_IMAGE_BYTE_ALIGN >= ZIMG_ALIGN, "");
+
+struct zimg_opts {
+ int scaler;
+ int fast;
+};
+
+#define OPT_BASE_STRUCT struct zimg_opts
+const struct m_sub_options zimg_conf = {
+ .opts = (struct m_option[]) {
+ OPT_CHOICE("scaler", scaler, 0,
+ ({"point", ZIMG_RESIZE_POINT},
+ {"bilinear", ZIMG_RESIZE_BILINEAR},
+ {"bicubic", ZIMG_RESIZE_BICUBIC},
+ {"spline16", ZIMG_RESIZE_SPLINE16},
+ {"lanczos", ZIMG_RESIZE_LANCZOS})),
+ OPT_FLAG("fast", fast, 0),
+ {0}
+ },
+ .size = sizeof(struct zimg_opts),
+ .defaults = &(const struct zimg_opts){
+ .scaler = ZIMG_RESIZE_BILINEAR,
+ .fast = 1,
+ },
+};
+
+struct mp_zimg_repack {
+ bool pack; // if false, this is for unpacking
+ struct mp_image_params fmt; // original mp format (possibly packed format)
+ int zimgfmt; // zimg equivalent unpacked format
+ int zplanes; // number of planes (zimgfmt)
+ unsigned zmask; // zimg_image_buffer.mask
+ int z_planes[4]; // z_planes[zimg_index] = mp_index
+
+ // If set, the pack/unpack callback to pass to zimg.
+ // Called with user==mp_zimg_repack.
+ zimg_filter_graph_callback repack;
+
+ // For packed_repack.
+ int components[4]; // p2[n] = mp_image.planes[components[n]]
+ // pack: p1 is dst, p2 is src
+ // unpack: p1 is src, p2 is dst
+ void (*packed_repack_scanline)(void *p1, void *p2[], int x0, int x1);
+
+ // Temporary memory for slice-wise repacking. This may be set even if repack
+ // is not set (then it may be used to avoid alignment issues). This has
+ // about one slice worth of data.
+ struct mp_image *tmp;
+
+ // Temporary, per-call source/target frame. (Regrettably a mutable field,
+ // but it's not the only one, and makes the callbacks much less of a mess
+ // by avoiding another "closure" indirection.)
+ // To be used by the repack callback.
+ struct mp_image *mpi;
+};
+
+void mp_zimg_set_from_cmdline(struct mp_zimg_context *ctx, struct mpv_global *g)
+{
+ struct zimg_opts *opts = mp_get_config_group(NULL, g, &zimg_conf);
+
+ ctx->scaler = opts->scaler;
+ ctx->fast = opts->fast;
+
+ talloc_free(opts);
+}
+
+static zimg_chroma_location_e mp_to_z_chroma(enum mp_chroma_location cl)
+{
+ switch (cl) {
+ case MP_CHROMA_LEFT: return ZIMG_CHROMA_LEFT;
+ case MP_CHROMA_CENTER: return ZIMG_CHROMA_CENTER;
+ default: return ZIMG_CHROMA_LEFT;
+ }
+}
+
+static zimg_matrix_coefficients_e mp_to_z_matrix(enum mp_csp csp)
+{
+ switch (csp) {
+ case MP_CSP_BT_601: return ZIMG_MATRIX_BT470_BG;
+ case MP_CSP_BT_709: return ZIMG_MATRIX_BT709;
+ case MP_CSP_SMPTE_240M: return ZIMG_MATRIX_ST240_M;
+ case MP_CSP_BT_2020_NC: return ZIMG_MATRIX_BT2020_NCL;
+ case MP_CSP_BT_2020_C: return ZIMG_MATRIX_BT2020_CL;
+ case MP_CSP_RGB: return ZIMG_MATRIX_RGB;
+ case MP_CSP_YCGCO: return ZIMG_MATRIX_YCGCO;
+ case MP_CSP_XYZ: // ?
+ default: return ZIMG_MATRIX_BT709;
+ }
+}
+
+static zimg_transfer_characteristics_e mp_to_z_trc(enum mp_csp_trc trc)
+{
+ switch (trc) {
+ case MP_CSP_TRC_BT_1886: return ZIMG_TRANSFER_BT709;
+ case MP_CSP_TRC_SRGB: return ZIMG_TRANSFER_IEC_61966_2_1;
+ case MP_CSP_TRC_LINEAR: return ZIMG_TRANSFER_LINEAR;
+ case MP_CSP_TRC_GAMMA22: return ZIMG_TRANSFER_BT470_M;
+ case MP_CSP_TRC_GAMMA28: return ZIMG_TRANSFER_BT470_BG;
+ case MP_CSP_TRC_PQ: return ZIMG_TRANSFER_ST2084;
+ case MP_CSP_TRC_HLG: return ZIMG_TRANSFER_ARIB_B67;
+ case MP_CSP_TRC_GAMMA18: // ?
+ case MP_CSP_TRC_GAMMA20:
+ case MP_CSP_TRC_GAMMA24:
+ case MP_CSP_TRC_GAMMA26:
+ case MP_CSP_TRC_PRO_PHOTO:
+ case MP_CSP_TRC_V_LOG:
+ case MP_CSP_TRC_S_LOG1:
+ case MP_CSP_TRC_S_LOG2: // ?
+ default: return ZIMG_TRANSFER_BT709;
+ }
+}
+
+static zimg_color_primaries_e mp_to_z_prim(enum mp_csp_prim prim)
+{
+ switch (prim) {
+ case MP_CSP_PRIM_BT_601_525:return ZIMG_PRIMARIES_ST170_M;
+ case MP_CSP_PRIM_BT_601_625:return ZIMG_PRIMARIES_BT470_BG;
+ case MP_CSP_PRIM_BT_709: return ZIMG_PRIMARIES_BT709;
+ case MP_CSP_PRIM_BT_2020: return ZIMG_PRIMARIES_BT2020;
+ case MP_CSP_PRIM_BT_470M: return ZIMG_PRIMARIES_BT470_M;
+ case MP_CSP_PRIM_APPLE: // ?
+ case MP_CSP_PRIM_ADOBE:
+ case MP_CSP_PRIM_PRO_PHOTO:
+ case MP_CSP_PRIM_CIE_1931:
+ case MP_CSP_PRIM_DCI_P3:
+ case MP_CSP_PRIM_DISPLAY_P3:
+ case MP_CSP_PRIM_V_GAMUT:
+ case MP_CSP_PRIM_S_GAMUT: // ?
+ default: return ZIMG_PRIMARIES_BT709;
+ }
+}
+
+static void destroy_zimg(struct mp_zimg_context *ctx)
+{
+ free(ctx->zimg_tmp);
+ ctx->zimg_tmp = NULL;
+ zimg_filter_graph_free(ctx->zimg_graph);
+ ctx->zimg_graph = NULL;
+ TA_FREEP(&ctx->zimg_src);
+ TA_FREEP(&ctx->zimg_dst);
+}
+
+static void free_mp_zimg(void *p)
+{
+ struct mp_zimg_context *ctx = p;
+
+ destroy_zimg(ctx);
+}
+
+struct mp_zimg_context *mp_zimg_alloc(void)
+{
+ struct mp_zimg_context *ctx = talloc_ptrtype(NULL, ctx);
+ *ctx = (struct mp_zimg_context) {
+ .log = mp_null_log,
+ .scaler = ZIMG_RESIZE_BILINEAR,
+ .scaler_params = {NAN, NAN},
+ .scaler_chroma = ZIMG_RESIZE_BILINEAR,
+ .scaler_chroma_params = {NAN, NAN},
+ .dither = ZIMG_DITHER_NONE,
+ .fast = true,
+ };
+ talloc_set_destructor(ctx, free_mp_zimg);
+ return ctx;
+}
+
+static void copy_rect(struct mp_image *dst, unsigned dst_mask,
+ struct mp_image *src, unsigned src_mask,
+ unsigned i, unsigned x0, unsigned x1)
+{
+ for (int p = 0; p < dst->fmt.num_planes; p++) {
+ int bpp = dst->fmt.bytes[p];
+ int xs = dst->fmt.xs[p];
+ int ys = dst->fmt.ys[p];
+ // Number of lines on this plane.
+ int h = (1 << dst->fmt.chroma_ys) - (1 << ys) + 1;
+
+ for (int y = i; y < i + h; y++) {
+ void *psrc = src->planes[p] +
+ src->stride[p] * (ptrdiff_t)((y >> ys) & src_mask) +
+ bpp * (x0 >> xs);
+ void *pdst = dst->planes[p] +
+ dst->stride[p] * (ptrdiff_t)((y >> ys) & dst_mask) +
+ bpp * (x0 >> xs);
+ memcpy(pdst, psrc, ((x1 - x0) >> xs) * bpp);
+ }
+ }
+}
+
+static int align_pack(void *user, unsigned i, unsigned x0, unsigned x1)
+{
+ struct mp_zimg_repack *r = user;
+
+ copy_rect(r->mpi, ZIMG_BUFFER_MAX, r->tmp, r->zmask, i, x0, x1);
+
+ return 0;
+}
+
+static int align_unpack(void *user, unsigned i, unsigned x0, unsigned x1)
+{
+ struct mp_zimg_repack *r = user;
+
+ copy_rect(r->tmp, r->zmask, r->mpi, ZIMG_BUFFER_MAX, i, x0, x1);
+
+ return 0;
+}
+
+// 3 8 bit color components sourced from 3 planes, plus 8 MSB padding bits.
+static void cccx8_pack(void *dst, void *src[], int x0, int x1)
+{
+ for (int x = x0; x < x1; x++) {
+ ((uint32_t *)dst)[x] =
+ ((uint8_t *)src[0])[x] |
+ ((uint32_t)((uint8_t *)src[1])[x] << 8) |
+ ((uint32_t)((uint8_t *)src[2])[x] << 16);
+ }
+}
+
+// 3 8 bit color components sourced from 3 planes, plus 8 LSB padding bits.
+static void xccc8_pack(void *dst, void *src[], int x0, int x1)
+{
+ for (int x = x0; x < x1; x++) {
+ ((uint32_t *)dst)[x] =
+ ((uint32_t)((uint8_t *)src[0])[x] << 8) |
+ ((uint32_t)((uint8_t *)src[1])[x] << 16) |
+ ((uint32_t)((uint8_t *)src[2])[x] << 24);
+ }
+}
+
+static int packed_repack(void *user, unsigned i, unsigned x0, unsigned x1)
+{
+ struct mp_zimg_repack *r = user;
+
+ uint32_t *p1 =
+ (void *)(r->mpi->planes[0] + r->mpi->stride[0] * (ptrdiff_t)i);
+
+ void *p2[3];
+ for (int p = 0; p < 3; p++) {
+ int s = r->components[p];
+ p2[p] = r->tmp->planes[s] + r->tmp->stride[s] * (ptrdiff_t)(i & r->zmask);
+ }
+
+ r->packed_repack_scanline(p1, p2, x0, x1);
+
+ return 0;
+}
+
+static void wrap_buffer(struct mp_zimg_repack *r,
+ zimg_image_buffer *buf,
+ zimg_filter_graph_callback *cb,
+ struct mp_image *mpi)
+{
+ *buf = (zimg_image_buffer){ZIMG_API_VERSION};
+ *cb = r->repack;
+
+ struct mp_image *wrap_mpi = r->tmp;
+
+ if (!*cb) {
+ bool aligned = true;
+ for (int n = 0; n < r->zplanes; n++) {
+ if (((uintptr_t)mpi->planes[n] % ZIMG_ALIGN) ||
+ (mpi->stride[n] % ZIMG_ALIGN))
+ aligned = false;
+ }
+ if (aligned) {
+ wrap_mpi = mpi;
+ } else {
+ *cb = r->pack ? align_pack : align_unpack;
+ }
+ }
+
+ for (int n = 0; n < r->zplanes; n++) {
+ int mplane = r->z_planes[n];
+ buf->plane[n].data = wrap_mpi->planes[mplane];
+ buf->plane[n].stride = wrap_mpi->stride[mplane];
+ buf->plane[n].mask = wrap_mpi == mpi ? ZIMG_BUFFER_MAX : r->zmask;
+ }
+
+ r->mpi = mpi;
+}
+
+// Tries to set a packer/unpacker for component-wise byte aligned RGB formats.
+static void setup_regular_rgb_packer(struct mp_zimg_repack *r)
+{
+ struct mp_regular_imgfmt desc;
+ if (!mp_get_regular_imgfmt(&desc, r->zimgfmt))
+ return;
+
+ if (desc.num_planes != 1 || desc.planes[0].num_components < 2)
+ return;
+ struct mp_regular_imgfmt_plane *p = &desc.planes[0];
+
+ for (int n = 0; n < p->num_components; n++) {
+ if (p->components[n] >= 4) // no alpha
+ return;
+ }
+
+ // Find a compatible planar format (typically AV_PIX_FMT_GBRP).
+ int depth = desc.component_size * 8 + MPMIN(0, desc.component_pad);
+ int planar_fmt = mp_imgfmt_find(0, 0, 3, depth, MP_IMGFLAG_RGB_P);
+ if (!planar_fmt)
+ return;
+
+ // Component ID to plane, implied by MP_IMGFLAG_RGB_P.
+ static int gbrp[4] = {0, 2, 0, 1};
+
+ if (desc.component_size == 1 && p->num_components == 4) {
+ if (!r->pack) // no unpacker yet
+ return;
+ if (p->components[0] && p->components[3]) // padding must be in MSB or LSB
+ return;
+ // The following assumes little endian (because the repack backends use
+ // word access, while the metadata here uses byte access).
+ int first = p->components[0] ? 0 : 1;
+ r->repack = packed_repack;
+ r->packed_repack_scanline = p->components[0] ? cccx8_pack : xccc8_pack;
+ r->zimgfmt = planar_fmt;
+ for (int n = 0; n < 3; n++)
+ r->components[n] = gbrp[p->components[first + n]];
+ return;
+ }
+}
+
+// (ctx can be NULL for the sake of probing.)
+static bool setup_format(zimg_image_format *zfmt, struct mp_zimg_repack *r,
+ struct mp_zimg_context *ctx)
+{
+ zimg_image_format_default(zfmt, ZIMG_API_VERSION);
+
+ struct mp_image_params fmt = r->fmt;
+ mp_image_params_guess_csp(&fmt);
+
+ r->zimgfmt = fmt.imgfmt;
+
+ setup_regular_rgb_packer(r);
+
+ struct mp_regular_imgfmt desc;
+ if (!mp_get_regular_imgfmt(&desc, r->zimgfmt))
+ return false;
+ enum mp_csp csp = mp_imgfmt_get_forced_csp(r->zimgfmt);
+
+ // no alpha plane, no odd chroma subsampling
+ if (desc.num_planes > 3 || !MP_IS_POWER_OF_2(desc.chroma_w) ||
+ !MP_IS_POWER_OF_2(desc.chroma_h))
+ return false;
+
+ // Accept only true planar formats.
+ for (int n = 0; n < desc.num_planes; n++) {
+ if (desc.planes[n].num_components != 1)
+ return false;
+ int c = desc.planes[n].components[0];
+ if (c < 1 || c > 3)
+ return false;
+ // Unfortunately, ffmpeg prefers GBR order for planar RGB, while zimg
+ // is sane. This makes it necessary to determine and fix the order.
+ r->z_planes[c - 1] = n;
+ }
+
+ r->zplanes = desc.num_planes;
+
+ zfmt->width = fmt.w;
+ zfmt->height = fmt.h;
+
+ zfmt->subsample_w = av_log2(desc.chroma_w);
+ zfmt->subsample_h = av_log2(desc.chroma_h);
+
+ zfmt->color_family = ZIMG_COLOR_YUV;
+ if (desc.num_planes == 1) {
+ zfmt->color_family = ZIMG_COLOR_GREY;
+ } else if (csp == MP_CSP_RGB) {
+ zfmt->color_family = ZIMG_COLOR_RGB;
+ }
+
+ if (desc.component_type == MP_COMPONENT_TYPE_UINT &&
+ desc.component_size == 1)
+ {
+ zfmt->pixel_type = ZIMG_PIXEL_BYTE;
+ } else if (desc.component_type == MP_COMPONENT_TYPE_UINT &&
+ desc.component_size == 2)
+ {
+ zfmt->pixel_type = ZIMG_PIXEL_WORD;
+ } else if (desc.component_type == MP_COMPONENT_TYPE_FLOAT &&
+ desc.component_size == 2)
+ {
+ zfmt->pixel_type = ZIMG_PIXEL_HALF;
+ } else if (desc.component_type == MP_COMPONENT_TYPE_FLOAT &&
+ desc.component_size == 4)
+ {
+ zfmt->pixel_type = ZIMG_PIXEL_FLOAT;
+ } else {
+ return false;
+ }
+
+ // (Formats like P010 are basically reported as P016.)
+ zfmt->depth = desc.component_size * 8 + MPMIN(0, desc.component_pad);
+
+ zfmt->pixel_range = fmt.color.levels == MP_CSP_LEVELS_PC ?
+ ZIMG_RANGE_FULL : ZIMG_RANGE_LIMITED;
+
+ zfmt->matrix_coefficients = mp_to_z_matrix(fmt.color.space);
+ zfmt->transfer_characteristics = mp_to_z_trc(fmt.color.gamma);
+ zfmt->color_primaries = mp_to_z_prim(fmt.color.primaries);
+ zfmt->chroma_location = mp_to_z_chroma(fmt.chroma_location);
+
+ if (ctx && ctx->fast) {
+ // mpv's default for RGB output slows down zimg significantly.
+ if (zfmt->transfer_characteristics == ZIMG_TRANSFER_IEC_61966_2_1 &&
+ zfmt->color_family == ZIMG_COLOR_RGB)
+ zfmt->transfer_characteristics = ZIMG_TRANSFER_BT709;
+ }
+
+ return true;
+}
+
+static bool allocate_buffer(struct mp_zimg_context *ctx,
+ struct mp_zimg_repack *r)
+{
+ unsigned lines = 0;
+ int err;
+ if (r->pack) {
+ err = zimg_filter_graph_get_output_buffering(ctx->zimg_graph, &lines);
+ } else {
+ err = zimg_filter_graph_get_input_buffering(ctx->zimg_graph, &lines);
+ }
+
+ if (err)
+ return false;
+
+ r->zmask = zimg_select_buffer_mask(lines);
+
+ // Either ZIMG_BUFFER_MAX, or a power-of-2 slice buffer.
+ assert(r->zmask == ZIMG_BUFFER_MAX || MP_IS_POWER_OF_2(r->zmask + 1));
+
+ int h = r->zmask == ZIMG_BUFFER_MAX ? r->fmt.h : r->zmask + 1;
+ if (h >= r->fmt.h) {
+ h = r->fmt.h;
+ r->zmask = ZIMG_BUFFER_MAX;
+ }
+
+ r->tmp = mp_image_alloc(r->zimgfmt, r->fmt.w, h);
+ talloc_steal(r, r->tmp);
+
+ return !!r->tmp;
+}
+
+bool mp_zimg_config(struct mp_zimg_context *ctx)
+{
+ destroy_zimg(ctx);
+
+ ctx->zimg_src = talloc_zero(NULL, struct mp_zimg_repack);
+ ctx->zimg_src->pack = false;
+ ctx->zimg_src->fmt = ctx->src;
+
+ ctx->zimg_dst = talloc_zero(NULL, struct mp_zimg_repack);
+ ctx->zimg_dst->pack = true;
+ ctx->zimg_dst->fmt = ctx->dst;
+
+ zimg_image_format src_fmt, dst_fmt;
+
+ if (!setup_format(&src_fmt, ctx->zimg_src, ctx) ||
+ !setup_format(&dst_fmt, ctx->zimg_dst, ctx))
+ goto fail;
+
+ zimg_graph_builder_params params;
+ zimg_graph_builder_params_default(&params, ZIMG_API_VERSION);
+
+ params.resample_filter = ctx->scaler;
+ params.filter_param_a = ctx->scaler_params[0];
+ params.filter_param_b = ctx->scaler_params[1];
+
+ params.resample_filter_uv = ctx->scaler_chroma;
+ params.filter_param_a_uv = ctx->scaler_chroma_params[0];
+ params.filter_param_b_uv = ctx->scaler_chroma_params[1];
+
+ params.dither_type = ctx->dither;
+
+ params.cpu_type = ZIMG_CPU_AUTO_64B;
+
+ if (ctx->fast)
+ params.allow_approximate_gamma = 1;
+
+ if (ctx->src.color.sig_peak > 0)
+ params.nominal_peak_luminance = ctx->src.color.sig_peak;
+
+ ctx->zimg_graph = zimg_filter_graph_build(&src_fmt, &dst_fmt, &params);
+ if (!ctx->zimg_graph) {
+ char err[128] = {0};
+ zimg_get_last_error(err, sizeof(err) - 1);
+ MP_ERR(ctx, "zimg_filter_graph_build: %s \n", err);
+ goto fail;
+ }
+
+ size_t tmp_size;
+ if (!zimg_filter_graph_get_tmp_size(ctx->zimg_graph, &tmp_size)) {
+ tmp_size = MP_ALIGN_UP(tmp_size, ZIMG_ALIGN);
+ ctx->zimg_tmp = aligned_alloc(ZIMG_ALIGN, tmp_size);
+ }
+
+ if (!ctx->zimg_tmp)
+ goto fail;
+
+ if (!allocate_buffer(ctx, ctx->zimg_src) ||
+ !allocate_buffer(ctx, ctx->zimg_dst))
+ goto fail;
+
+ return true;
+
+fail:
+ destroy_zimg(ctx);
+ return false;
+}
+
+bool mp_zimg_config_image_params(struct mp_zimg_context *ctx)
+{
+ if (ctx->zimg_src && mp_image_params_equal(&ctx->src, &ctx->zimg_src->fmt) &&
+ ctx->zimg_dst && mp_image_params_equal(&ctx->dst, &ctx->zimg_dst->fmt) &&
+ ctx->zimg_graph)
+ return true;
+ return mp_zimg_config(ctx);
+}
+
+bool mp_zimg_convert(struct mp_zimg_context *ctx, struct mp_image *dst,
+ struct mp_image *src)
+{
+ ctx->src = src->params;
+ ctx->dst = dst->params;
+
+ if (!mp_zimg_config_image_params(ctx)) {
+ MP_ERR(ctx, "zimg initialization failed.\n");
+ return false;
+ }
+
+ assert(ctx->zimg_graph);
+
+ zimg_image_buffer zsrc, zdst;
+ zimg_filter_graph_callback cbsrc, cbdst;
+
+ wrap_buffer(ctx->zimg_src, &zsrc, &cbsrc, src);
+ wrap_buffer(ctx->zimg_dst, &zdst, &cbdst, dst);
+
+ // An annoyance.
+ zimg_image_buffer_const zsrc_c = {ZIMG_API_VERSION};
+ for (int n = 0; n < 3; n++) {
+ zsrc_c.plane[n].data = zsrc.plane[n].data;
+ zsrc_c.plane[n].stride = zsrc.plane[n].stride;
+ zsrc_c.plane[n].mask = zsrc.plane[n].mask;
+ }
+
+ // (The API promises to succeed if no user callbacks fail, so no need
+ // to check the return value.)
+ zimg_filter_graph_process(ctx->zimg_graph, &zsrc_c, &zdst,
+ ctx->zimg_tmp,
+ cbsrc, ctx->zimg_src,
+ cbdst, ctx->zimg_dst);
+
+ ctx->zimg_src->mpi = NULL;
+ ctx->zimg_dst->mpi = NULL;
+
+ return true;
+}
+
+static bool supports_format(int imgfmt, bool out)
+{
+ struct mp_zimg_repack t = {
+ .pack = out,
+ .fmt = {
+ .imgfmt = imgfmt,
+ },
+ };
+ zimg_image_format fmt;
+ return setup_format(&fmt, &t, NULL);
+}
+
+bool mp_zimg_supports_in_format(int imgfmt)
+{
+ return supports_format(imgfmt, false);
+}
+
+bool mp_zimg_supports_out_format(int imgfmt)
+{
+ return supports_format(imgfmt, true);
+}
diff --git a/video/zimg.h b/video/zimg.h
new file mode 100644
index 0000000000..0d9c139f9a
--- /dev/null
+++ b/video/zimg.h
@@ -0,0 +1,63 @@
+#pragma once
+
+#include <stdbool.h>
+
+#include <zimg.h>
+
+#include "mp_image.h"
+
+#define ZIMG_ALIGN 64
+
+struct mpv_global;
+
+bool mp_zimg_supports_in_format(int imgfmt);
+bool mp_zimg_supports_out_format(int imgfmt);
+
+struct mp_zimg_context {
+ // Can be set for verbose error printing.
+ struct mp_log *log;
+
+ // User configuration. Note: changing these requires calling mp_zimg_config()
+ // to update the filter graph. The first mp_zimg_convert() call (or if the
+ // image format changes) will do this automatically.
+ zimg_resample_filter_e scaler;
+ double scaler_params[2];
+ zimg_resample_filter_e scaler_chroma;
+ double scaler_chroma_params[2];
+ zimg_dither_type_e dither;
+ bool fast; // reduce quality for better performance
+
+ // Input/output parameters. Note: if these mismatch with the
+ // mp_zimg_convert() parameters, mp_zimg_config() will be called
+ // automatically.
+ struct mp_image_params src, dst;
+
+ // Cached zimg state (if any). Private, do not touch.
+ zimg_filter_graph *zimg_graph;
+ void *zimg_tmp;
+ struct mp_zimg_repack *zimg_src;
+ struct mp_zimg_repack *zimg_dst;
+};
+
+// Allocate a zimg context. Always succeeds. Returns a talloc pointer (use
+// talloc_free() to release it).
+struct mp_zimg_context *mp_zimg_alloc(void);
+
+// Try to build the conversion chain using the parameters currently set in ctx.
+// If this succeeds, mp_zimg_convert() will always succeed (probably), as long
+// as the input has the same parameters.
+// Returns false on error.
+bool mp_zimg_config(struct mp_zimg_context *ctx);
+
+// Similar to mp_zimg_config(), but assume none of the user parameters changed,
+// except possibly .src and .dst. This essentially checks whether src/dst
+// changed, and if so, calls mp_zimg_config().
+bool mp_zimg_config_image_params(struct mp_zimg_context *ctx);
+
+// Convert/scale src to dst. On failure, the data in dst is not touched.
+bool mp_zimg_convert(struct mp_zimg_context *ctx, struct mp_image *dst,
+ struct mp_image *src);
+
+// Set the global zimg command line parameters on this context. Use this if you
+// want the user to be able to change the scaler etc.
+void mp_zimg_set_from_cmdline(struct mp_zimg_context *ctx, struct mpv_global *g);