Adding upstream version 0.37.0.upstream/0.37.0

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 757 insertions, 0 deletions

diff --git a/video/image_writer.c b/video/image_writer.c
new file mode 100644
index 0000000..288d809
--- /dev/null
+++ b/video/image_writer.c
@@ -0,0 +1,757 @@
+/*
+ * 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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <inttypes.h>
+
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
+#include <libavutil/mem.h>
+#include <libavutil/opt.h>
+#include <libavutil/pixdesc.h>
+
+#include "common/msg.h"
+#include "config.h"
+
+#if HAVE_JPEG
+#include <setjmp.h>
+#include <jpeglib.h>
+#endif
+
+#include "osdep/io.h"
+
+#include "common/av_common.h"
+#include "common/msg.h"
+#include "image_writer.h"
+#include "mpv_talloc.h"
+#include "video/fmt-conversion.h"
+#include "video/img_format.h"
+#include "video/mp_image.h"
+#include "video/sws_utils.h"
+
+#include "options/m_option.h"
+
+const struct image_writer_opts image_writer_opts_defaults = {
+    .format = AV_CODEC_ID_MJPEG,
+    .high_bit_depth = true,
+    .png_compression = 7,
+    .png_filter = 5,
+    .jpeg_quality = 90,
+    .jpeg_source_chroma = true,
+    .webp_quality = 75,
+    .webp_compression = 4,
+    .jxl_distance = 1.0,
+    .jxl_effort = 4,
+    .avif_encoder = "libaom-av1",
+    .avif_pixfmt = "yuv420p",
+    .avif_opts = (char*[]){
+        "usage",    "allintra",
+        "crf",      "32",
+        "cpu-used", "8",
+        "tune",     "ssim",
+        NULL
+    },
+    .tag_csp = true,
+};
+
+const struct m_opt_choice_alternatives mp_image_writer_formats[] = {
+    {"jpg",  AV_CODEC_ID_MJPEG},
+    {"jpeg", AV_CODEC_ID_MJPEG},
+    {"png",  AV_CODEC_ID_PNG},
+    {"webp", AV_CODEC_ID_WEBP},
+#if HAVE_JPEGXL
+    {"jxl",  AV_CODEC_ID_JPEGXL},
+#endif
+#if HAVE_AVIF_MUXER
+    {"avif",  AV_CODEC_ID_AV1},
+#endif
+    {0}
+};
+
+#define OPT_BASE_STRUCT struct image_writer_opts
+
+const struct m_option image_writer_opts[] = {
+    {"format", OPT_CHOICE_C(format, mp_image_writer_formats)},
+    {"jpeg-quality", OPT_INT(jpeg_quality), M_RANGE(0, 100)},
+    {"jpeg-source-chroma", OPT_BOOL(jpeg_source_chroma)},
+    {"png-compression", OPT_INT(png_compression), M_RANGE(0, 9)},
+    {"png-filter", OPT_INT(png_filter), M_RANGE(0, 5)},
+    {"webp-lossless", OPT_BOOL(webp_lossless)},
+    {"webp-quality", OPT_INT(webp_quality), M_RANGE(0, 100)},
+    {"webp-compression", OPT_INT(webp_compression), M_RANGE(0, 6)},
+#if HAVE_JPEGXL
+    {"jxl-distance", OPT_DOUBLE(jxl_distance), M_RANGE(0.0, 15.0)},
+    {"jxl-effort", OPT_INT(jxl_effort), M_RANGE(1, 9)},
+#endif
+#if HAVE_AVIF_MUXER
+    {"avif-encoder", OPT_STRING(avif_encoder)},
+    {"avif-opts", OPT_KEYVALUELIST(avif_opts)},
+    {"avif-pixfmt", OPT_STRING(avif_pixfmt)},
+#endif
+    {"high-bit-depth", OPT_BOOL(high_bit_depth)},
+    {"tag-colorspace", OPT_BOOL(tag_csp)},
+    {0},
+};
+
+struct image_writer_ctx {
+    struct mp_log *log;
+    const struct image_writer_opts *opts;
+    struct mp_imgfmt_desc original_format;
+};
+
+static enum AVPixelFormat replace_j_format(enum AVPixelFormat fmt)
+{
+    switch (fmt) {
+    case AV_PIX_FMT_YUV420P: return AV_PIX_FMT_YUVJ420P;
+    case AV_PIX_FMT_YUV422P: return AV_PIX_FMT_YUVJ422P;
+    case AV_PIX_FMT_YUV444P: return AV_PIX_FMT_YUVJ444P;
+    }
+    return fmt;
+}
+
+static void prepare_avframe(AVFrame *pic, AVCodecContext *avctx,
+                            mp_image_t *image, bool tag_csp,
+                            struct mp_log *log)
+{
+    for (int n = 0; n < 4; n++) {
+        pic->data[n] = image->planes[n];
+        pic->linesize[n] = image->stride[n];
+    }
+    pic->format = avctx->pix_fmt;
+    pic->width = avctx->width;
+    pic->height = avctx->height;
+    avctx->color_range = pic->color_range =
+        mp_csp_levels_to_avcol_range(image->params.color.levels);
+
+    if (!tag_csp)
+        return;
+    avctx->color_primaries = pic->color_primaries =
+        mp_csp_prim_to_avcol_pri(image->params.color.primaries);
+    avctx->color_trc = pic->color_trc =
+        mp_csp_trc_to_avcol_trc(image->params.color.gamma);
+    avctx->colorspace = pic->colorspace =
+        mp_csp_to_avcol_spc(image->params.color.space);
+    avctx->chroma_sample_location = pic->chroma_location =
+        mp_chroma_location_to_av(image->params.chroma_location);
+    mp_dbg(log, "mapped color params:\n"
+        "  trc = %s\n"
+        "  primaries = %s\n"
+        "  range = %s\n"
+        "  colorspace = %s\n"
+        "  chroma_location = %s\n",
+        av_color_transfer_name(avctx->color_trc),
+        av_color_primaries_name(avctx->color_primaries),
+        av_color_range_name(avctx->color_range),
+        av_color_space_name(avctx->colorspace),
+        av_chroma_location_name(avctx->chroma_sample_location)
+    );
+}
+
+static bool write_lavc(struct image_writer_ctx *ctx, mp_image_t *image, const char *filename)
+{
+    FILE *fp = fopen(filename, "wb");
+    if (!fp) {
+        MP_ERR(ctx, "Error opening '%s' for writing!\n", filename);
+        return false;
+    }
+
+    bool success = false;
+    AVFrame *pic = NULL;
+    AVPacket *pkt = NULL;
+
+    const AVCodec *codec;
+    if (ctx->opts->format == AV_CODEC_ID_WEBP) {
+        codec = avcodec_find_encoder_by_name("libwebp"); // non-animated encoder
+    } else {
+        codec = avcodec_find_encoder(ctx->opts->format);
+    }
+
+    AVCodecContext *avctx = NULL;
+    if (!codec)
+        goto print_open_fail;
+    avctx = avcodec_alloc_context3(codec);
+    if (!avctx)
+        goto print_open_fail;
+
+    avctx->time_base = AV_TIME_BASE_Q;
+    avctx->width = image->w;
+    avctx->height = image->h;
+    avctx->pix_fmt = imgfmt2pixfmt(image->imgfmt);
+    if (codec->id == AV_CODEC_ID_MJPEG) {
+        // Annoying deprecated garbage for the jpg encoder.
+        if (image->params.color.levels == MP_CSP_LEVELS_PC)
+            avctx->pix_fmt = replace_j_format(avctx->pix_fmt);
+    }
+    if (avctx->pix_fmt == AV_PIX_FMT_NONE) {
+        MP_ERR(ctx, "Image format %s not supported by lavc.\n",
+               mp_imgfmt_to_name(image->imgfmt));
+        goto error_exit;
+    }
+
+    if (codec->id == AV_CODEC_ID_MJPEG) {
+        avctx->flags |= AV_CODEC_FLAG_QSCALE;
+        // jpeg_quality is set below
+    } else if (codec->id == AV_CODEC_ID_PNG) {
+        avctx->compression_level = ctx->opts->png_compression;
+        av_opt_set_int(avctx, "pred", ctx->opts->png_filter,
+                       AV_OPT_SEARCH_CHILDREN);
+    } else if (codec->id == AV_CODEC_ID_WEBP) {
+        avctx->compression_level = ctx->opts->webp_compression;
+        av_opt_set_int(avctx, "lossless", ctx->opts->webp_lossless,
+                       AV_OPT_SEARCH_CHILDREN);
+        av_opt_set_int(avctx, "quality", ctx->opts->webp_quality,
+                       AV_OPT_SEARCH_CHILDREN);
+#if HAVE_JPEGXL
+    } else if (codec->id == AV_CODEC_ID_JPEGXL) {
+        av_opt_set_double(avctx, "distance", ctx->opts->jxl_distance,
+                          AV_OPT_SEARCH_CHILDREN);
+        av_opt_set_int(avctx, "effort", ctx->opts->jxl_effort,
+                       AV_OPT_SEARCH_CHILDREN);
+#endif
+    }
+
+    if (avcodec_open2(avctx, codec, NULL) < 0) {
+     print_open_fail:
+        MP_ERR(ctx, "Could not open libavcodec encoder for saving images\n");
+        goto error_exit;
+    }
+
+    pic = av_frame_alloc();
+    if (!pic)
+        goto error_exit;
+    prepare_avframe(pic, avctx, image, ctx->opts->tag_csp, ctx->log);
+    if (codec->id == AV_CODEC_ID_MJPEG) {
+        int qscale = 1 + (100 - ctx->opts->jpeg_quality) * 30 / 100;
+        pic->quality = qscale * FF_QP2LAMBDA;
+    }
+
+    int ret = avcodec_send_frame(avctx, pic);
+    if (ret < 0)
+        goto error_exit;
+    ret = avcodec_send_frame(avctx, NULL); // send EOF
+    if (ret < 0)
+        goto error_exit;
+    pkt = av_packet_alloc();
+    if (!pkt)
+        goto error_exit;
+    ret = avcodec_receive_packet(avctx, pkt);
+    if (ret < 0)
+        goto error_exit;
+
+    success = fwrite(pkt->data, pkt->size, 1, fp) == 1;
+
+error_exit:
+    avcodec_free_context(&avctx);
+    av_frame_free(&pic);
+    av_packet_free(&pkt);
+    return !fclose(fp) && success;
+}
+
+#if HAVE_JPEG
+
+static void write_jpeg_error_exit(j_common_ptr cinfo)
+{
+  // NOTE: do not write error message, too much effort to connect the libjpeg
+  //       log callbacks with mplayer's log function mp_msp()
+
+  // Return control to the setjmp point
+  longjmp(*(jmp_buf*)cinfo->client_data, 1);
+}
+
+static bool write_jpeg(struct image_writer_ctx *ctx, mp_image_t *image,
+                       const char *filename)
+{
+    FILE *fp = fopen(filename, "wb");
+    if (!fp) {
+        MP_ERR(ctx, "Error opening '%s' for writing!\n", filename);
+        return false;
+    }
+
+    struct jpeg_compress_struct cinfo;
+    struct jpeg_error_mgr jerr;
+
+    cinfo.err = jpeg_std_error(&jerr);
+    jerr.error_exit = write_jpeg_error_exit;
+
+    jmp_buf error_return_jmpbuf;
+    cinfo.client_data = &error_return_jmpbuf;
+    if (setjmp(cinfo.client_data)) {
+        jpeg_destroy_compress(&cinfo);
+        fclose(fp);
+        return false;
+    }
+
+    jpeg_create_compress(&cinfo);
+    jpeg_stdio_dest(&cinfo, fp);
+
+    cinfo.image_width = image->w;
+    cinfo.image_height = image->h;
+    cinfo.input_components = 3;
+    cinfo.in_color_space = JCS_RGB;
+
+    cinfo.write_JFIF_header = TRUE;
+    cinfo.JFIF_major_version = 1;
+    cinfo.JFIF_minor_version = 2;
+
+    jpeg_set_defaults(&cinfo);
+    jpeg_set_quality(&cinfo, ctx->opts->jpeg_quality, 0);
+
+    if (ctx->opts->jpeg_source_chroma) {
+        cinfo.comp_info[0].h_samp_factor = 1 << ctx->original_format.chroma_xs;
+        cinfo.comp_info[0].v_samp_factor = 1 << ctx->original_format.chroma_ys;
+    }
+
+    jpeg_start_compress(&cinfo, TRUE);
+
+    while (cinfo.next_scanline < cinfo.image_height) {
+        JSAMPROW row_pointer[1];
+        row_pointer[0] = image->planes[0] +
+                         (ptrdiff_t)cinfo.next_scanline * image->stride[0];
+        jpeg_write_scanlines(&cinfo, row_pointer,1);
+    }
+
+    jpeg_finish_compress(&cinfo);
+
+    jpeg_destroy_compress(&cinfo);
+
+    return !fclose(fp);
+}
+
+#endif
+
+#if HAVE_AVIF_MUXER
+
+static void log_side_data(struct image_writer_ctx *ctx, AVPacketSideData *data,
+                          size_t size)
+{
+    if (!mp_msg_test(ctx->log, MSGL_DEBUG))
+        return;
+    char dbgbuff[129];
+    if (size)
+        MP_DBG(ctx, "write_avif() packet side data:\n");
+    for (int i = 0; i < size; i++) {
+        AVPacketSideData *sd = &data[i];
+        for (int k = 0; k < MPMIN(sd->size, 64); k++)
+            snprintf(dbgbuff + k*2, 3, "%02x", (int)sd->data[k]);
+        MP_DBG(ctx, "  [%d] = {[%s], '%s'}\n",
+               i, av_packet_side_data_name(sd->type), dbgbuff);
+    }
+}
+
+static bool write_avif(struct image_writer_ctx *ctx, mp_image_t *image,
+                       const char *filename)
+{
+    const AVCodec *codec = NULL;
+    const AVOutputFormat *ofmt = NULL;
+    AVCodecContext *avctx = NULL;
+    AVIOContext *avioctx = NULL;
+    AVFormatContext *fmtctx = NULL;
+    AVStream *stream = NULL;
+    AVFrame *pic = NULL;
+    AVPacket *pkt = NULL;
+    int ret;
+    bool success = false;
+
+    codec = avcodec_find_encoder_by_name(ctx->opts->avif_encoder);
+    if (!codec) {
+        MP_ERR(ctx, "Could not find encoder '%s', for saving images\n",
+               ctx->opts->avif_encoder);
+        goto free_data;
+    }
+
+    ofmt = av_guess_format("avif", NULL, NULL);
+    if (!ofmt) {
+        MP_ERR(ctx, "Could not guess output format 'avif'\n");
+        goto free_data;
+    }
+
+    avctx = avcodec_alloc_context3(codec);
+    if (!avctx) {
+        MP_ERR(ctx, "Failed to allocate AVContext.\n");
+        goto free_data;
+    }
+
+    avctx->width = image->w;
+    avctx->height = image->h;
+    avctx->time_base = (AVRational){1, 30};
+    avctx->pkt_timebase = (AVRational){1, 30};
+    avctx->codec_type = AVMEDIA_TYPE_VIDEO;
+    avctx->pix_fmt = imgfmt2pixfmt(image->imgfmt);
+    if (avctx->pix_fmt == AV_PIX_FMT_NONE) {
+        MP_ERR(ctx, "Image format %s not supported by lavc.\n",
+               mp_imgfmt_to_name(image->imgfmt));
+        goto free_data;
+    }
+
+    av_opt_set_int(avctx, "still-picture", 1, AV_OPT_SEARCH_CHILDREN);
+
+    AVDictionary *avd = NULL;
+    mp_set_avdict(&avd, ctx->opts->avif_opts);
+    av_opt_set_dict2(avctx, &avd, AV_OPT_SEARCH_CHILDREN);
+    av_dict_free(&avd);
+
+    pic = av_frame_alloc();
+    if (!pic) {
+        MP_ERR(ctx, "Could not allocate AVFrame\n");
+        goto free_data;
+    }
+
+    prepare_avframe(pic, avctx, image, ctx->opts->tag_csp, ctx->log);
+    // Not setting this flag caused ffmpeg to output avif that was not passing
+    // standard checks but ffmpeg would still read and not complain...
+    avctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
+
+    ret = avcodec_open2(avctx, codec, NULL);
+    if (ret < 0) {
+        MP_ERR(ctx, "Could not open libavcodec encoder for saving images\n");
+        goto free_data;
+    }
+
+    ret = avio_open(&avioctx, filename, AVIO_FLAG_WRITE);
+    if (ret < 0) {
+        MP_ERR(ctx, "Could not open file '%s' for saving images\n", filename);
+        goto free_data;
+    }
+
+    fmtctx = avformat_alloc_context();
+    if (!fmtctx) {
+        MP_ERR(ctx, "Could not allocate format context\n");
+        goto free_data;
+    }
+    fmtctx->pb = avioctx;
+    fmtctx->oformat = ofmt;
+
+    stream = avformat_new_stream(fmtctx, codec);
+    if (!stream) {
+        MP_ERR(ctx, "Could not allocate stream\n");
+        goto free_data;
+    }
+
+    ret = avcodec_parameters_from_context(stream->codecpar, avctx);
+    if (ret < 0) {
+        MP_ERR(ctx, "Could not copy parameters from context\n");
+        goto free_data;
+    }
+
+    ret = avformat_init_output(fmtctx, NULL);
+    if (ret < 0) {
+        MP_ERR(ctx, "Could not initialize output\n");
+        goto free_data;
+    }
+
+    ret = avformat_write_header(fmtctx, NULL);
+    if (ret < 0) {
+        MP_ERR(ctx, "Could not write format header\n");
+        goto free_data;
+    }
+
+    pkt = av_packet_alloc();
+    if (!pkt) {
+        MP_ERR(ctx, "Could not allocate packet\n");
+        goto free_data;
+    }
+
+    ret = avcodec_send_frame(avctx, pic);
+    if (ret < 0) {
+        MP_ERR(ctx, "Error sending frame\n");
+        goto free_data;
+    }
+    ret = avcodec_send_frame(avctx, NULL); // send EOF
+    if (ret < 0)
+        goto free_data;
+
+    int pts = 0;
+    log_side_data(ctx, avctx->coded_side_data, avctx->nb_coded_side_data);
+    while (ret >= 0) {
+        ret = avcodec_receive_packet(avctx, pkt);
+        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
+            break;
+        if (ret < 0) {
+            MP_ERR(ctx, "Error receiving packet\n");
+            goto free_data;
+        }
+        pkt->dts = pkt->pts = ++pts;
+        pkt->stream_index = stream->index;
+        log_side_data(ctx, pkt->side_data, pkt->side_data_elems);
+
+        ret = av_write_frame(fmtctx, pkt);
+        if (ret < 0) {
+            MP_ERR(ctx, "Error writing frame\n");
+            goto free_data;
+        }
+        av_packet_unref(pkt);
+    }
+
+    ret = av_write_trailer(fmtctx);
+    if (ret < 0) {
+        MP_ERR(ctx, "Could not write trailer\n");
+        goto free_data;
+    }
+    MP_DBG(ctx, "write_avif(): avio_size() = %"PRIi64"\n", avio_size(avioctx));
+
+    success = true;
+
+free_data:
+    success = !avio_closep(&avioctx) && success;
+    avformat_free_context(fmtctx);
+    avcodec_free_context(&avctx);
+    av_packet_free(&pkt);
+    av_frame_free(&pic);
+
+    return success;
+}
+
+#endif
+
+static int get_encoder_format(const AVCodec *codec, int srcfmt, bool highdepth)
+{
+    const enum AVPixelFormat *pix_fmts = codec->pix_fmts;
+    int current = 0;
+    for (int n = 0; pix_fmts && pix_fmts[n] != AV_PIX_FMT_NONE; n++) {
+        int fmt = pixfmt2imgfmt(pix_fmts[n]);
+        if (!fmt)
+            continue;
+        if (!highdepth) {
+            // Ignore formats larger than 8 bit per pixel. (Or which are unknown.)
+            struct mp_regular_imgfmt rdesc;
+            if (!mp_get_regular_imgfmt(&rdesc, fmt)) {
+                int ofmt = mp_find_other_endian(fmt);
+                if (!mp_get_regular_imgfmt(&rdesc, ofmt))
+                    continue;
+            }
+            if (rdesc.component_size > 1)
+                continue;
+        }
+        current = current ? mp_imgfmt_select_best(current, fmt, srcfmt) : fmt;
+    }
+    return current;
+}
+
+static int get_target_format(struct image_writer_ctx *ctx)
+{
+    const AVCodec *codec = avcodec_find_encoder(ctx->opts->format);
+    if (!codec)
+        goto unknown;
+
+    int srcfmt = ctx->original_format.id;
+
+    int target = get_encoder_format(codec, srcfmt, ctx->opts->high_bit_depth);
+    if (!target) {
+        mp_dbg(ctx->log, "Falling back to high-depth format.\n");
+        target = get_encoder_format(codec, srcfmt, true);
+    }
+
+    if (!target)
+        goto unknown;
+
+    return target;
+
+unknown:
+    return IMGFMT_RGB0;
+}
+
+const char *image_writer_file_ext(const struct image_writer_opts *opts)
+{
+    struct image_writer_opts defs = image_writer_opts_defaults;
+
+    if (!opts)
+        opts = &defs;
+
+    return m_opt_choice_str(mp_image_writer_formats, opts->format);
+}
+
+bool image_writer_high_depth(const struct image_writer_opts *opts)
+{
+    return opts->format == AV_CODEC_ID_PNG
+#if HAVE_JPEGXL
+           || opts->format == AV_CODEC_ID_JPEGXL
+#endif
+#if HAVE_AVIF_MUXER
+           || opts->format == AV_CODEC_ID_AV1
+#endif
+    ;
+}
+
+bool image_writer_flexible_csp(const struct image_writer_opts *opts)
+{
+    if (!opts->tag_csp)
+        return false;
+    return false
+#if HAVE_JPEGXL
+        || opts->format == AV_CODEC_ID_JPEGXL
+#endif
+#if HAVE_AVIF_MUXER
+        || opts->format == AV_CODEC_ID_AV1
+#endif
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59, 58, 100)
+        // This version added support for cICP tag writing
+        || opts->format == AV_CODEC_ID_PNG
+#endif
+    ;
+}
+
+int image_writer_format_from_ext(const char *ext)
+{
+    for (int n = 0; mp_image_writer_formats[n].name; n++) {
+        if (ext && strcmp(mp_image_writer_formats[n].name, ext) == 0)
+            return mp_image_writer_formats[n].value;
+    }
+    return 0;
+}
+
+static struct mp_image *convert_image(struct mp_image *image, int destfmt,
+                                      enum mp_csp_levels yuv_levels,
+                                      const struct image_writer_opts *opts,
+                                      struct mpv_global *global,
+                                      struct mp_log *log)
+{
+    int d_w, d_h;
+    mp_image_params_get_dsize(&image->params, &d_w, &d_h);
+
+    struct mp_image_params p = {
+        .imgfmt = destfmt,
+        .w = d_w,
+        .h = d_h,
+        .p_w = 1,
+        .p_h = 1,
+        .color = image->params.color,
+    };
+    mp_image_params_guess_csp(&p);
+
+    if (!image_writer_flexible_csp(opts)) {
+        // If our format can't tag csps, set something sane
+        p.color.primaries = MP_CSP_PRIM_BT_709;
+        p.color.gamma = MP_CSP_TRC_AUTO;
+        p.color.light = MP_CSP_LIGHT_DISPLAY;
+        p.color.hdr = (struct pl_hdr_metadata){0};
+        if (p.color.space != MP_CSP_RGB) {
+            p.color.levels = yuv_levels;
+            p.color.space = MP_CSP_BT_601;
+            p.chroma_location = MP_CHROMA_CENTER;
+        }
+        mp_image_params_guess_csp(&p);
+    }
+
+    if (mp_image_params_equal(&p, &image->params))
+        return mp_image_new_ref(image);
+
+    mp_dbg(log, "will convert image to %s\n", mp_imgfmt_to_name(p.imgfmt));
+
+    struct mp_image *src = image;
+    if (mp_image_crop_valid(&src->params) &&
+        (mp_rect_w(src->params.crop) != src->w ||
+         mp_rect_h(src->params.crop) != src->h))
+    {
+        src = mp_image_new_ref(src);
+        if (!src) {
+            mp_err(log, "mp_image_new_ref failed!\n");
+            return NULL;
+        }
+        mp_image_crop_rc(src, src->params.crop);
+    }
+
+    struct mp_image *dst = mp_image_alloc(p.imgfmt, p.w, p.h);
+    if (!dst) {
+        mp_err(log, "Out of memory.\n");
+        return NULL;
+    }
+    mp_image_copy_attributes(dst, src);
+
+    dst->params = p;
+
+    struct mp_sws_context *sws = mp_sws_alloc(NULL);
+    sws->log = log;
+    if (global)
+        mp_sws_enable_cmdline_opts(sws, global);
+    bool ok = mp_sws_scale(sws, dst, src) >= 0;
+    talloc_free(sws);
+
+    if (src != image)
+        talloc_free(src);
+
+    if (!ok) {
+        mp_err(log, "Error when converting image.\n");
+        talloc_free(dst);
+        return NULL;
+    }
+
+    return dst;
+}
+
+bool write_image(struct mp_image *image, const struct image_writer_opts *opts,
+                 const char *filename, struct mpv_global *global,
+                 struct mp_log *log)
+{
+    struct image_writer_opts defs = image_writer_opts_defaults;
+    if (!opts)
+        opts = &defs;
+
+    mp_dbg(log, "input: %s\n", mp_image_params_to_str(&image->params));
+
+    struct image_writer_ctx ctx = { log, opts, image->fmt };
+    bool (*write)(struct image_writer_ctx *, mp_image_t *, const char *) = write_lavc;
+    int destfmt = 0;
+
+#if HAVE_JPEG
+    if (opts->format == AV_CODEC_ID_MJPEG) {
+        write = write_jpeg;
+        destfmt = IMGFMT_RGB24;
+    }
+#endif
+#if HAVE_AVIF_MUXER
+    if (opts->format == AV_CODEC_ID_AV1) {
+        write = write_avif;
+        destfmt = mp_imgfmt_from_name(bstr0(opts->avif_pixfmt));
+    }
+#endif
+    if (opts->format == AV_CODEC_ID_WEBP && !opts->webp_lossless) {
+        // For lossy images, libwebp has its own RGB->YUV conversion.
+        // We don't want that, so force YUV/YUVA here.
+        int alpha = image->fmt.flags & MP_IMGFLAG_ALPHA;
+        destfmt = alpha ? pixfmt2imgfmt(AV_PIX_FMT_YUVA420P) : IMGFMT_420P;
+    }
+
+    if (!destfmt)
+        destfmt = get_target_format(&ctx);
+
+    enum mp_csp_levels levels; // Ignored if destfmt is a RGB format
+    if (opts->format == AV_CODEC_ID_WEBP) {
+        levels = MP_CSP_LEVELS_TV;
+    } else {
+        levels = MP_CSP_LEVELS_PC;
+    }
+
+    struct mp_image *dst = convert_image(image, destfmt, levels, opts, global, log);
+    if (!dst)
+        return false;
+
+    bool success = write(&ctx, dst, filename);
+    if (!success)
+        mp_err(log, "Error writing file '%s'!\n", filename);
+
+    talloc_free(dst);
+    return success;
+}
+
+void dump_png(struct mp_image *image, const char *filename, struct mp_log *log)
+{
+    struct image_writer_opts opts = image_writer_opts_defaults;
+    opts.format = AV_CODEC_ID_PNG;
+    write_image(image, &opts, filename, NULL, log);
+}