summaryrefslogtreecommitdiffstats
path: root/video/image_writer.c
diff options
context:
space:
mode:
Diffstat (limited to 'video/image_writer.c')
-rw-r--r--video/image_writer.c471
1 files changed, 399 insertions, 72 deletions
diff --git a/video/image_writer.c b/video/image_writer.c
index 5438249c42..cc795735ef 100644
--- a/video/image_writer.c
+++ b/video/image_writer.c
@@ -18,11 +18,17 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include <inttypes.h>
+#include <unistd.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
@@ -31,27 +37,38 @@
#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 "video/fmt-conversion.h"
#include "video/img_format.h"
#include "video/mp_image.h"
-#include "video/fmt-conversion.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 = 1,
+ .high_bit_depth = true,
.png_compression = 7,
.png_filter = 5,
.jpeg_quality = 90,
- .jpeg_source_chroma = 1,
- .webp_lossless = 0,
+ .jpeg_source_chroma = true,
.webp_quality = 75,
.webp_compression = 4,
- .tag_csp = 0,
+ .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[] = {
@@ -59,22 +76,37 @@ const struct m_opt_choice_alternatives mp_image_writer_formats[] = {
{"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[] = {
- OPT_CHOICE_C("format", format, 0, mp_image_writer_formats),
- OPT_INTRANGE("jpeg-quality", jpeg_quality, 0, 0, 100),
- OPT_FLAG("jpeg-source-chroma", jpeg_source_chroma, 0),
- OPT_INTRANGE("png-compression", png_compression, 0, 0, 9),
- OPT_INTRANGE("png-filter", png_filter, 0, 0, 5),
- OPT_FLAG("webp-lossless", webp_lossless, 0),
- OPT_INTRANGE("webp-quality", webp_quality, 0, 0, 100),
- OPT_INTRANGE("webp-compression", webp_compression, 0, 0, 6),
- OPT_FLAG("high-bit-depth", high_bit_depth, 0),
- OPT_FLAG("tag-colorspace", tag_csp, 0),
+ {"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},
};
@@ -94,16 +126,50 @@ static enum AVPixelFormat replace_j_format(enum AVPixelFormat fmt)
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 = 0;
+ bool success = false;
AVFrame *pic = NULL;
- AVPacket pkt = {0};
- int got_output = 0;
+ AVPacket *pkt = NULL;
- av_init_packet(&pkt);
-
- struct AVCodec *codec;
+ const AVCodec *codec;
if (ctx->opts->format == AV_CODEC_ID_WEBP) {
codec = avcodec_find_encoder_by_name("libwebp"); // non-animated encoder
} else {
@@ -120,11 +186,10 @@ static bool write_lavc(struct image_writer_ctx *ctx, mp_image_t *image, FILE *fp
avctx->time_base = AV_TIME_BASE_Q;
avctx->width = image->w;
avctx->height = image->h;
- avctx->color_range = mp_csp_levels_to_avcol_range(image->params.color.levels);
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)
+ 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) {
@@ -132,7 +197,11 @@ static bool write_lavc(struct image_writer_ctx *ctx, mp_image_t *image, FILE *fp
mp_imgfmt_to_name(image->imgfmt));
goto error_exit;
}
- if (codec->id == AV_CODEC_ID_PNG) {
+
+ 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);
@@ -142,6 +211,13 @@ static bool write_lavc(struct image_writer_ctx *ctx, mp_image_t *image, FILE *fp
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) {
@@ -153,17 +229,10 @@ static bool write_lavc(struct image_writer_ctx *ctx, mp_image_t *image, FILE *fp
pic = av_frame_alloc();
if (!pic)
goto error_exit;
- 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;
- pic->color_range = avctx->color_range;
- if (ctx->opts->tag_csp) {
- pic->color_primaries = mp_csp_prim_to_avcol_pri(image->params.color.primaries);
- pic->color_trc = mp_csp_trc_to_avcol_trc(image->params.color.gamma);
+ 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);
@@ -172,18 +241,19 @@ static bool write_lavc(struct image_writer_ctx *ctx, mp_image_t *image, FILE *fp
ret = avcodec_send_frame(avctx, NULL); // send EOF
if (ret < 0)
goto error_exit;
- ret = avcodec_receive_packet(avctx, &pkt);
+ pkt = av_packet_alloc();
+ if (!pkt)
+ goto error_exit;
+ ret = avcodec_receive_packet(avctx, pkt);
if (ret < 0)
goto error_exit;
- got_output = 1;
- fwrite(pkt.data, pkt.size, 1, fp);
+ success = fwrite(pkt->data, pkt->size, 1, fp) == 1;
- success = !!got_output;
error_exit:
avcodec_free_context(&avctx);
av_frame_free(&pic);
- av_packet_unref(&pkt);
+ av_packet_free(&pkt);
return success;
}
@@ -251,7 +321,189 @@ static bool write_jpeg(struct image_writer_ctx *ctx, mp_image_t *image, FILE *fp
#endif
-static int get_encoder_format(struct AVCodec *codec, int srcfmt, bool highdepth)
+#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, 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;
+}
+
+#endif
+
+static int get_encoder_format(const AVCodec *codec, int srcfmt, bool highdepth)
{
const enum AVPixelFormat *pix_fmts = codec->pix_fmts;
int current = 0;
@@ -259,9 +511,17 @@ static int get_encoder_format(struct AVCodec *codec, int srcfmt, bool highdepth)
int fmt = pixfmt2imgfmt(pix_fmts[n]);
if (!fmt)
continue;
- // Ignore formats larger than 8 bit per pixel.
- if (!highdepth && IMGFMT_RGB_DEPTH(fmt) > 32)
- 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;
@@ -269,15 +529,17 @@ static int get_encoder_format(struct AVCodec *codec, int srcfmt, bool highdepth)
static int get_target_format(struct image_writer_ctx *ctx)
{
- struct AVCodec *codec = avcodec_find_encoder(ctx->opts->format);
+ 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)
+ if (!target) {
+ mp_dbg(ctx->log, "Falling back to high-depth format.\n");
target = get_encoder_format(codec, srcfmt, true);
+ }
if (!target)
goto unknown;
@@ -300,7 +562,32 @@ const char *image_writer_file_ext(const struct image_writer_opts *opts)
bool image_writer_high_depth(const struct image_writer_opts *opts)
{
- return opts->format == AV_CODEC_ID_PNG;
+ 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)
@@ -313,7 +600,8 @@ int image_writer_format_from_ext(const char *ext)
}
static struct mp_image *convert_image(struct mp_image *image, int destfmt,
- enum mp_csp_levels yuv_levels,
+ enum pl_color_levels yuv_levels,
+ const struct image_writer_opts *opts,
struct mpv_global *global,
struct mp_log *log)
{
@@ -326,28 +614,51 @@ static struct mp_image *convert_image(struct mp_image *image, int destfmt,
.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 RGB, just assume everything is correct.
- if (p.color.space != MP_CSP_RGB) {
- // Currently, assume what FFmpeg's jpg encoder or libwebp needs.
- // Of course this works only for non-HDR (no HDR support in libswscale).
- p.color.levels = yuv_levels;
- p.color.space = MP_CSP_BT_601;
- p.chroma_location = MP_CHROMA_CENTER;
+ 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, image);
+ mp_image_copy_attributes(dst, src);
dst->params = p;
@@ -355,9 +666,12 @@ static struct mp_image *convert_image(struct mp_image *image, int destfmt,
sws->log = log;
if (global)
mp_sws_enable_cmdline_opts(sws, global);
- bool ok = mp_sws_scale(sws, dst, image) >= 0;
+ 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);
@@ -368,13 +682,15 @@ static struct mp_image *convert_image(struct mp_image *image, int destfmt,
}
bool write_image(struct mp_image *image, const struct image_writer_opts *opts,
- const char *filename, struct mpv_global *global,
- struct mp_log *log)
+ 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;
@@ -385,6 +701,13 @@ bool write_image(struct mp_image *image, const struct image_writer_opts *opts,
destfmt = IMGFMT_RGB24;
}
#endif
+#if HAVE_AVIF_MUXER
+ 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));
+ }
+#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.
@@ -395,28 +718,32 @@ bool write_image(struct mp_image *image, const struct image_writer_opts *opts,
if (!destfmt)
destfmt = get_target_format(&ctx);
- enum mp_csp_levels levels; // Ignored if destfmt is a RGB format
+ enum pl_color_levels levels; // Ignored if destfmt is a RGB format
if (opts->format == AV_CODEC_ID_WEBP) {
- levels = MP_CSP_LEVELS_TV;
+ levels = PL_COLOR_LEVELS_LIMITED;
} else {
- levels = MP_CSP_LEVELS_PC;
+ levels = PL_COLOR_LEVELS_FULL;
}
- struct mp_image *dst = convert_image(image, destfmt, levels, global, log);
+ struct mp_image *dst = convert_image(image, destfmt, levels, opts, global, log);
if (!dst)
return false;
- FILE *fp = fopen(filename, "wb");
bool success = false;
- if (fp == NULL) {
- mp_err(log, "Error opening '%s' for writing!\n", filename);
- } else {
- success = write(&ctx, dst, fp);
- success = !fclose(fp) && success;
- if (!success)
- mp_err(log, "Error writing file '%s'!\n", filename);
+ 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;
}
@@ -425,5 +752,5 @@ 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);
+ write_image(image, &opts, filename, NULL, log, true);
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-18 17:42:37 +0000