Something went wrong. Try again.
🎥 Command line media player
Something went wrong. Try again.
C
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729/* * 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 <libplacebo/utils/libav.h>
#include "common/msg.h"#include "config.h"
#if HAVE_JPEG#include <setjmp.h>#include <jpeglib.h>#endif
#include "osdep/io.h"#include "misc/path_utils.h"
#include "common/av_common.h"#include "common/msg.h"#include "image_writer.h"#include "mpv_talloc.h"#include "misc/lavc_compat.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_opts = (char*[]){ "usage", "allintra", "crf", "0", "cpu-used", "8", 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}, {"jxl", AV_CODEC_ID_JPEGXL}, {"avif", AV_CODEC_ID_AV1}, {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)}, {"jxl-distance", OPT_DOUBLE(jxl_distance), M_RANGE(0.0, 15.0)}, {"jxl-effort", OPT_INT(jxl_effort), M_RANGE(1, 9)}, {"avif-encoder", OPT_STRING(avif_encoder)}, {"avif-opts", OPT_KEYVALUELIST(avif_opts)}, {"avif-pixfmt", OPT_STRING(avif_pixfmt)}, {"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; pl_avframe_set_repr(pic, image->params.repr); avctx->colorspace = pic->colorspace; avctx->color_range = pic->color_range;
if (!tag_csp) return; pl_avframe_set_color(pic, image->params.color); avctx->color_primaries = pic->color_primaries; avctx->color_trc = pic->color_trc; avctx->chroma_sample_location = pic->chroma_location = pl_chroma_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, FILE *fp){ 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.repr.levels == PL_COLOR_LEVELS_FULL) 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); } 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); }
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 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, FILE *fp){ 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); 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 true;}
#endif
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, FILE *fp){ 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; }
avio_open_dyn_buf(&avioctx); MP_HANDLE_OOM(avioctx);
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));
uint8_t *buf = NULL; int written_size = avio_close_dyn_buf(avioctx, &buf); success = fwrite(buf, written_size, 1, fp) == 1; av_freep(&buf);
free_data: avformat_free_context(fmtctx); avcodec_free_context(&avctx); av_packet_free(&pkt); av_frame_free(&pic);
return success;}
static int get_encoder_format(const AVCodec *codec, int srcfmt, bool highdepth){ const enum AVPixelFormat *pix_fmts; int ret = mp_avcodec_get_supported_config(NULL, codec, AV_CODEC_CONFIG_PIX_FORMAT, (const void **)&pix_fmts); int current = 0; for (int n = 0; ret >= 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 || opts->format == AV_CODEC_ID_JPEGXL || opts->format == AV_CODEC_ID_AV1;}
bool image_writer_flexible_csp(const struct image_writer_opts *opts){ if (!opts->tag_csp) return false; return opts->format == AV_CODEC_ID_JPEGXL || opts->format == AV_CODEC_ID_AV1 || opts->format == AV_CODEC_ID_PNG;}
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 pl_color_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, .repr = image->params.repr, .chroma_location = image->params.chroma_location, .crop = {0, 0, d_w, d_h}, }; 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 = PL_COLOR_PRIM_BT_709; p.color.transfer = PL_COLOR_TRC_UNKNOWN; p.light = MP_CSP_LIGHT_DISPLAY; p.color.hdr = (struct pl_hdr_metadata){0}; if (p.repr.sys != PL_COLOR_SYSTEM_RGB) { p.repr.levels = yuv_levels; p.repr.sys = PL_COLOR_SYSTEM_BT_601; p.chroma_location = PL_CHROMA_CENTER; } mp_image_params_guess_csp(&p); }
if (mp_image_params_equal(&p, &image->params)) return mp_image_new_ref(image);
mp_verbose(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, bool overwrite){ struct image_writer_opts defs = image_writer_opts_defaults; if (!opts) opts = &defs;
mp_verbose(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 *, FILE *) = write_lavc; int destfmt = 0;
#if HAVE_JPEG if (opts->format == AV_CODEC_ID_MJPEG) { write = write_jpeg; destfmt = IMGFMT_RGB24; }#endif if (opts->format == AV_CODEC_ID_AV1) { write = write_avif; if (opts->avif_pixfmt && opts->avif_pixfmt[0]) destfmt = mp_imgfmt_from_name(bstr0(opts->avif_pixfmt)); } else 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 pl_color_levels levels; // Ignored if destfmt is a RGB format if (opts->format == AV_CODEC_ID_WEBP) { levels = PL_COLOR_LEVELS_LIMITED; } else { levels = PL_COLOR_LEVELS_FULL; }
struct mp_image *dst = convert_image(image, destfmt, levels, opts, global, log); if (!dst) return false;
bool success = false; FILE *fp = fopen(filename, overwrite ? "wb" : "wbx"); if (!fp) { mp_err(log, "Error creating '%s' for writing: %s!\n", filename, mp_strerror(errno)); goto done; }
success = write(&ctx, dst, fp); if (fclose(fp) || !success) { mp_err(log, "Error writing file '%s'!\n", filename); unlink(filename); }
done: 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, true);}