From patchwork Fri Mar 25 12:27:39 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Niklas Haas X-Patchwork-Id: 34960 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:ab0:5fda:0:0:0:0:0 with SMTP id g26csp1356580uaj; Fri, 25 Mar 2022 05:27:53 -0700 (PDT) X-Google-Smtp-Source: ABdhPJz0svlSmJVPugMcIeNTaODEh+hoAuuSl9xok7UEQUQ9/2P0rMX/tx08Lm3XXNVqmZviEkDg X-Received: by 2002:a17:906:5418:b0:6df:a07f:764b with SMTP id q24-20020a170906541800b006dfa07f764bmr10838787ejo.27.1648211273783; Fri, 25 Mar 2022 05:27:53 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1648211273; cv=none; d=google.com; s=arc-20160816; b=U2vtgyWvikIFtoqLjbSRy6HHU4BVvETmcIACWclvCVmLpO8H6kP9Hny7oFw81pyEV5 Bf8GvG21FeMwYnImYqWohTewuOpAFypfNqclKyd4E5LQkYg2BLgFnf+IGRXeURcnJLAP oGa4QfMiu5q/nYzaDIPooSTtZvf9qDrKqcbOY0QSeEaeYvHtDv4gZTT36PQwVpmJw3sS iLtaL7/hloDGqXy0nKsFcjey1cadJFbC3X/faxy58jiMSCWumj/EZ83ocBsFhe9FnB4l lxnxBatSWpQ7WZk3zpeDnDFd0zZ8XtC/ydJOVwaDFRgB5nYC78LWfyg2J8vmv1eGBn+G LYhw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:content-transfer-encoding:cc:reply-to :list-subscribe:list-help:list-post:list-archive:list-unsubscribe :list-id:precedence:subject:mime-version:message-id:date:to:from :dkim-signature:delivered-to; bh=fXfo56be/5aTG5WF1mdpCcR6EpNdBH5ltgi4z3lSIVY=; b=lQXhRFQ83VrvSSjI/dC4+1r1GYkTaLt+Lvw5qLLbXQEceFvCqqUebMeH8O/uk24/H/ CHh8KvWeeadHUySG85/ZH1o9tDpogrL9H8Fc08qfpPEl1Gf/ugNk9k4hBuMK2iGUz/5V bDEzU28JWtfAutWa7+2/demzandlxyd/snWs3D4XmpUE7CBiZHqUWtwrWuWOlcaGO6M1 VQ8+wmGZoXt4sFKUDpxBBC+fagQpetV6aMBcXc3Ku5tm6ZQIJ6mDpIOq7r+BBr71+0OI gmS0TI/fqeZ6HDWe/YzlCfw7hjAAdYzgFUmi/3v8D36VmoqBorWR1QfTrQPd0vjsUyTr AmrQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=neutral (body hash did not verify) header.i=@haasn.xyz header.s=mail header.b="B3wFO61/"; spf=pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) smtp.mailfrom=ffmpeg-devel-bounces@ffmpeg.org Return-Path: Received: from ffbox0-bg.mplayerhq.hu (ffbox0-bg.ffmpeg.org. [79.124.17.100]) by mx.google.com with ESMTP id t5-20020a170906178500b006e01f1d9677si2356907eje.532.2022.03.25.05.27.53; Fri, 25 Mar 2022 05:27:53 -0700 (PDT) Received-SPF: pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) client-ip=79.124.17.100; Authentication-Results: mx.google.com; dkim=neutral (body hash did not verify) header.i=@haasn.xyz header.s=mail header.b="B3wFO61/"; spf=pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) smtp.mailfrom=ffmpeg-devel-bounces@ffmpeg.org Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 5A4BD68B21A; Fri, 25 Mar 2022 14:27:49 +0200 (EET) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from haasn.dev (haasn.dev [78.46.187.166]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 6A19368B08F for ; Fri, 25 Mar 2022 14:27:43 +0200 (EET) Received: from haasn.dev (unknown [10.30.0.2]) by haasn.dev (Postfix) with ESMTP id 1668249960; Fri, 25 Mar 2022 13:27:43 +0100 (CET) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=haasn.xyz; s=mail; t=1648211263; bh=hfizkz+MV0ULytKkZ1P3GdiQfOCzB0h79bPugKmI/rY=; h=From:To:Cc:Subject:Date:From; b=B3wFO61/I8w4BdpbKjyEcoJLUIlC6YRllTZy2cwSiu5W8mckr7qL86ua5EJWopSsX IW6BmNvW0DHbF1nq8U9CBw/eC58JrRaSM9Lxs7tG1nI5SBWkGUozEEw+RytjrX1KFs I83WP9aDhPWtke9Zl6sHgb3OgVvgfF8oiEkKiCE0= From: Niklas Haas To: ffmpeg-devel@ffmpeg.org Date: Fri, 25 Mar 2022 13:27:39 +0100 Message-Id: <20220325122739.55611-1-ffmpeg@haasn.xyz> X-Mailer: git-send-email 2.35.1 MIME-Version: 1.0 Subject: [FFmpeg-devel] [PATCH] avfilter/vf_libplacebo: update for new tone mapping API X-BeenThere: ffmpeg-devel@ffmpeg.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: FFmpeg development discussions and patches List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: FFmpeg development discussions and patches Cc: Niklas Haas Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: GI68Dd6ULSpq From: Niklas Haas Upstream gained a new tone-mapping API, which we never switched to. We don't need a version bump for this because it was included as part of the v4.192 release we currently already depend on. The "tonemapping" was changed from an enum to a string, owing to the new (extensible) upstream tone mapping infrastructure. The old names still map cleanly to the new API, so this shouldn't break any typical users. Some of the remaining options can be moderately approximated with the new API, but specifically "desaturation_base" and "max_boost" cannot. Remove these entirely, rather than deprecating them. They have been non-functional for a while as a result of the upstream deprecation. Signed-off-by: Niklas Haas --- libavfilter/vf_libplacebo.c | 114 +++++++++++++++++++++++++++--------- 1 file changed, 85 insertions(+), 29 deletions(-) diff --git a/libavfilter/vf_libplacebo.c b/libavfilter/vf_libplacebo.c index 31ae28ac38..a2cb971e1f 100644 --- a/libavfilter/vf_libplacebo.c +++ b/libavfilter/vf_libplacebo.c @@ -91,12 +91,16 @@ typedef struct LibplaceboContext { /* pl_color_map_params */ int intent; - int tonemapping; + int gamut_mode; + char *tonemapping; float tonemapping_param; + int tonemapping_mode; + int inverse_tonemapping; + float crosstalk; + int tonemapping_lut_size; + /* for backwards compatibility */ float desat_str; float desat_exp; - float desat_base; - float max_boost; int gamut_warning; int gamut_clipping; @@ -184,6 +188,30 @@ static int find_scaler(AVFilterContext *avctx, return AVERROR(EINVAL); } +static int find_tone_mapper(AVFilterContext *avctx, + const struct pl_tone_map_function **opt, + const char *name) +{ + const struct pl_tone_map_function * const *func; + if (!strcmp(name, "help")) { + av_log(avctx, AV_LOG_INFO, "Available tone mapping functions:\n"); + for (func = pl_tone_map_functions; *func; func++) + av_log(avctx, AV_LOG_INFO, " %s (%s)\n", + (*func)->name, (*func)->description); + return AVERROR_EXIT; + } + + for (func = pl_tone_map_functions; *func; func++) { + if (!strcmp(name, (*func)->name)) { + *opt = *func; + return 0; + } + } + + av_log(avctx, AV_LOG_ERROR, "No such tone mapping function '%s'.\n", name); + return AVERROR(EINVAL); +} + static int libplacebo_init(AVFilterContext *avctx) { LibplaceboContext *s = avctx->priv; @@ -281,6 +309,7 @@ static int process_frames(AVFilterContext *avctx, AVFrame *out, AVFrame *in) int err = 0, ok; LibplaceboContext *s = avctx->priv; struct pl_render_params params; + struct pl_color_map_params color_params; struct pl_frame image, target; ok = pl_map_avframe_ex(s->gpu, &image, pl_avframe_params( .frame = in, @@ -336,18 +365,6 @@ static int process_frames(AVFilterContext *avctx, AVFrame *out, AVFrame *in) .overshoot_margin = s->overshoot, ), - .color_map_params = pl_color_map_params( - .intent = s->intent, - .tone_mapping_algo = s->tonemapping, - .tone_mapping_param = s->tonemapping_param, - .desaturation_strength = s->desat_str, - .desaturation_exponent = s->desat_exp, - .desaturation_base = s->desat_base, - .max_boost = s->max_boost, - .gamut_warning = s->gamut_warning, - .gamut_clipping = s->gamut_clipping, - ), - .dither_params = s->dithering < 0 ? NULL : pl_dither_params( .method = s->dithering, .lut_size = s->dither_lut_size, @@ -374,6 +391,39 @@ static int process_frames(AVFilterContext *avctx, AVFrame *out, AVFrame *in) RET(find_scaler(avctx, ¶ms.upscaler, s->upscaler)); RET(find_scaler(avctx, ¶ms.downscaler, s->downscaler)); + params.color_map_params = &color_params; + color_params = (struct pl_color_map_params) { + PL_COLOR_MAP_DEFAULTS + .intent = s->intent, + .gamut_mode = s->gamut_mode, + .tone_mapping_param = s->tonemapping_param, + .tone_mapping_mode = s->tonemapping_mode, + .inverse_tone_mapping = s->inverse_tonemapping, + .tone_mapping_crosstalk = s->crosstalk, + .lut_size = s->tonemapping_lut_size, + }; + + /* backwards compatibility with older API */ + if (color_params.tone_mapping_mode == PL_TONE_MAP_AUTO && + (s->desat_str >= 0.0f || s->desat_exp >= 0.0f)) { + float str = s->desat_str < 0.0f ? 0.9f : s->desat_str; + float exp = s->desat_exp < 0.0f ? 0.2f : s->desat_exp; + if (str >= 0.9f && exp <= 0.1f) { + color_params.tone_mapping_mode = PL_TONE_MAP_RGB; + } else if (str > 0.1f) { + color_params.tone_mapping_mode = PL_TONE_MAP_HYBRID; + } else { + color_params.tone_mapping_mode = PL_TONE_MAP_LUMA; + } + } + + if (s->gamut_warning) + color_params.gamut_mode = PL_GAMUT_WARN; + if (s->gamut_clipping) + color_params.gamut_mode = PL_GAMUT_DESATURATE; + + RET(find_tone_mapper(avctx, &color_params.tone_mapping_function, s->tonemapping)); + pl_render_image(s->renderer, &image, &target, ¶ms); pl_unmap_avframe(s->gpu, &image); pl_unmap_avframe(s->gpu, &target); @@ -616,21 +666,27 @@ static const AVOption libplacebo_options[] = { { "relative", "Relative colorimetric", 0, AV_OPT_TYPE_CONST, {.i64 = PL_INTENT_RELATIVE_COLORIMETRIC}, 0, 0, STATIC, "intent" }, { "absolute", "Absolute colorimetric", 0, AV_OPT_TYPE_CONST, {.i64 = PL_INTENT_ABSOLUTE_COLORIMETRIC}, 0, 0, STATIC, "intent" }, { "saturation", "Saturation mapping", 0, AV_OPT_TYPE_CONST, {.i64 = PL_INTENT_SATURATION}, 0, 0, STATIC, "intent" }, - { "tonemapping", "Tone-mapping algorithm", OFFSET(tonemapping), AV_OPT_TYPE_INT, {.i64 = PL_TONE_MAPPING_BT_2390}, 0, PL_TONE_MAPPING_ALGORITHM_COUNT - 1, DYNAMIC, "tonemap" }, - { "clip", "Hard-clipping", 0, AV_OPT_TYPE_CONST, {.i64 = PL_TONE_MAPPING_CLIP}, 0, 0, STATIC, "tonemap" }, - { "mobius", "Mobius tone-mapping", 0, AV_OPT_TYPE_CONST, {.i64 = PL_TONE_MAPPING_MOBIUS}, 0, 0, STATIC, "tonemap" }, - { "reinhard", "Reinhard tone-mapping", 0, AV_OPT_TYPE_CONST, {.i64 = PL_TONE_MAPPING_REINHARD}, 0, 0, STATIC, "tonemap" }, - { "hable", "Hable/Filmic tone-mapping", 0, AV_OPT_TYPE_CONST, {.i64 = PL_TONE_MAPPING_HABLE}, 0, 0, STATIC, "tonemap" }, - { "gamma", "Gamma tone-mapping", 0, AV_OPT_TYPE_CONST, {.i64 = PL_TONE_MAPPING_GAMMA}, 0, 0, STATIC, "tonemap" }, - { "linear", "Linear tone-mapping", 0, AV_OPT_TYPE_CONST, {.i64 = PL_TONE_MAPPING_LINEAR}, 0, 0, STATIC, "tonemap" }, - { "bt.2390", "ITU-R BT.2390 tone-mapping", 0, AV_OPT_TYPE_CONST, {.i64 = PL_TONE_MAPPING_BT_2390}, 0, 0, STATIC, "tonemap" }, + { "gamut_mode", "Gamut-mapping mode", OFFSET(gamut_mode), AV_OPT_TYPE_INT, {.i64 = PL_GAMUT_CLIP}, 0, PL_GAMUT_MODE_COUNT, DYNAMIC, "gamut_mode" }, + { "clip", "Hard-clip gamut boundary", 0, AV_OPT_TYPE_CONST, {.i64 = PL_GAMUT_CLIP}, 0, 0, STATIC, "gamut_mode" }, + { "warn", "Highlight out-of-gamut colors", 0, AV_OPT_TYPE_CONST, {.i64 = PL_GAMUT_WARN}, 0, 0, STATIC, "gamut_mode" }, + { "darken", "Darken image to fit gamut", 0, AV_OPT_TYPE_CONST, {.i64 = PL_GAMUT_DARKEN}, 0, 0, STATIC, "gamut_mode" }, + { "desaturate", "Colorimetrically desaturate colors", 0, AV_OPT_TYPE_CONST, {.i64 = PL_GAMUT_DESATURATE}, 0, 0, STATIC, "gamut_mode" }, + { "tonemapping", "Tone-mapping algorithm", OFFSET(tonemapping), AV_OPT_TYPE_STRING, {.str = "auto"}, .flags = DYNAMIC, "tonemap" }, { "tonemapping_param", "Tunable parameter for some tone-mapping functions", OFFSET(tonemapping_param), AV_OPT_TYPE_FLOAT, {.dbl = 0.0}, 0.0, 100.0, .flags = DYNAMIC }, - { "desaturation_strength", "Desaturation strength", OFFSET(desat_str), AV_OPT_TYPE_FLOAT, {.dbl = 0.90}, 0.0, 1.0, DYNAMIC }, - { "desaturation_exponent", "Desaturation exponent", OFFSET(desat_exp), AV_OPT_TYPE_FLOAT, {.dbl = 0.2}, 0.0, 10.0, DYNAMIC }, - { "desaturation_base", "Desaturation base", OFFSET(desat_base), AV_OPT_TYPE_FLOAT, {.dbl = 0.18}, 0.0, 10.0, DYNAMIC }, - { "max_boost", "Tone-mapping maximum boost", OFFSET(max_boost), AV_OPT_TYPE_FLOAT, {.dbl = 1.0}, 1.0, 10.0, DYNAMIC }, - { "gamut_warning", "Highlight out-of-gamut colors", OFFSET(gamut_warning), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DYNAMIC }, - { "gamut_clipping", "Enable colorimetric gamut clipping", OFFSET(gamut_clipping), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, DYNAMIC }, + { "tonemapping_mode", "Tone-mapping mode", OFFSET(tonemapping_mode), AV_OPT_TYPE_INT, {.i64 = PL_TONE_MAP_AUTO}, 0, PL_TONE_MAP_MODE_COUNT, DYNAMIC, "tonemap_mode" }, + { "auto", "Automatic selection", 0, AV_OPT_TYPE_CONST, {.i64 = PL_TONE_MAP_AUTO}, 0, 0, STATIC, "tonemap_mode" }, + { "rgb", "Per-channel (RGB)", 0, AV_OPT_TYPE_CONST, {.i64 = PL_TONE_MAP_RGB}, 0, 0, STATIC, "tonemap_mode" }, + { "max", "Maximum component", 0, AV_OPT_TYPE_CONST, {.i64 = PL_TONE_MAP_MAX}, 0, 0, STATIC, "tonemap_mode" }, + { "hybrid", "Hybrid of Luma/RGB", 0, AV_OPT_TYPE_CONST, {.i64 = PL_TONE_MAP_HYBRID}, 0, 0, STATIC, "tonemap_mode" }, + { "luma", "Luminance", 0, AV_OPT_TYPE_CONST, {.i64 = PL_TONE_MAP_LUMA}, 0, 0, STATIC, "tonemap_mode" }, + { "inverse_tonemapping", "Inverse tone mapping (range expansion)", OFFSET(inverse_tonemapping), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DYNAMIC }, + { "tonemapping_crosstalk", "Crosstalk factor for tone-mapping", OFFSET(crosstalk), AV_OPT_TYPE_FLOAT, {.dbl = 0.04}, 0.0, 0.30, DYNAMIC }, + { "tonemapping_lut_size", "Tone-mapping LUT size", OFFSET(tonemapping_lut_size), AV_OPT_TYPE_INT, {.i64 = 256}, 2, 1024, DYNAMIC }, + /* deprecated options for backwards compatibility, defaulting to -1 to not override the new defaults */ + { "desaturation_strength", "Desaturation strength", OFFSET(desat_str), AV_OPT_TYPE_FLOAT, {.dbl = -1.0}, -1.0, 1.0, DYNAMIC | AV_OPT_FLAG_DEPRECATED }, + { "desaturation_exponent", "Desaturation exponent", OFFSET(desat_exp), AV_OPT_TYPE_FLOAT, {.dbl = -1.0}, -1.0, 10.0, DYNAMIC | AV_OPT_FLAG_DEPRECATED }, + { "gamut_warning", "Highlight out-of-gamut colors", OFFSET(gamut_warning), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DYNAMIC | AV_OPT_FLAG_DEPRECATED }, + { "gamut_clipping", "Enable colorimetric gamut clipping", OFFSET(gamut_clipping), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DYNAMIC | AV_OPT_FLAG_DEPRECATED }, { "dithering", "Dither method to use", OFFSET(dithering), AV_OPT_TYPE_INT, {.i64 = PL_DITHER_BLUE_NOISE}, -1, PL_DITHER_METHOD_COUNT - 1, DYNAMIC, "dither" }, { "none", "Disable dithering", 0, AV_OPT_TYPE_CONST, {.i64 = -1}, 0, 0, STATIC, "dither" },