From b16201db38d3e492635a9d202b0e654811a52ec5 Mon Sep 17 00:00:00 2001 From: Stefano Sabatini Date: Tue, 28 Nov 2023 23:58:15 +0100 Subject: [PATCH 2/2] lavfi: add qrencodesrc source Introduce qrencodesrc source. --- configure | 4 + doc/filters.texi | 219 +++++++++++++++ libavfilter/Makefile | 1 + libavfilter/allfilters.c | 1 + libavfilter/vsrc_qrencode.c | 547 ++++++++++++++++++++++++++++++++++++ 5 files changed, 772 insertions(+) create mode 100644 libavfilter/vsrc_qrencode.c diff --git a/configure b/configure index 838e627084..a2e9026c49 100755 --- a/configure +++ b/configure @@ -256,6 +256,7 @@ External library support: --enable-libopus enable Opus de/encoding via libopus [no] --enable-libplacebo enable libplacebo library [no] --enable-libpulse enable Pulseaudio input via libpulse [no] + --enable-libqrencode enable QR encode generation via libqrencode [no] --enable-librabbitmq enable RabbitMQ library [no] --enable-librav1e enable AV1 encoding via rav1e [no] --enable-librist enable RIST via librist [no] @@ -1879,6 +1880,7 @@ EXTERNAL_LIBRARY_LIST=" libopus libplacebo libpulse + libqrencode librabbitmq librav1e librist @@ -3769,6 +3771,7 @@ nnedi_filter_deps="gpl" ocr_filter_deps="libtesseract" ocv_filter_deps="libopencv" openclsrc_filter_deps="opencl" +qrencodesrc_filter_deps="libqrencode" overlay_opencl_filter_deps="opencl" overlay_qsv_filter_deps="libmfx" overlay_qsv_filter_select="qsvvpp" @@ -6812,6 +6815,7 @@ enabled libopus && { } enabled libplacebo && require_pkg_config libplacebo "libplacebo >= 4.192.0" libplacebo/vulkan.h pl_vulkan_create enabled libpulse && require_pkg_config libpulse libpulse pulse/pulseaudio.h pa_context_new +enabled libqrencode && require_pkg_config libqrencode libqrencode qrencode.h QRcode_encodeString enabled librabbitmq && require_pkg_config librabbitmq "librabbitmq >= 0.7.1" amqp.h amqp_new_connection enabled librav1e && require_pkg_config librav1e "rav1e >= 0.5.0" rav1e.h rav1e_context_new enabled librist && require_pkg_config librist "librist >= 0.2.7" librist/librist.h rist_receiver_create diff --git a/doc/filters.texi b/doc/filters.texi index de19d130cc..09aee86a46 100644 --- a/doc/filters.texi +++ b/doc/filters.texi @@ -28660,6 +28660,225 @@ ffplay -f lavfi life=s=300x200:mold=10:r=60:ratio=0.1:death_color=#C83232:life_c @end example @end itemize +@section qrencodesrc + +Generate a QR code using the libqrencode library (see +@url{https://fukuchi.org/works/qrencode/}). + +To enable the compilation of this source, you need to configure FFmpeg with with +@code{--enable-libqrencode}. + +The QR code is generated from the provided text or text pattern. The +corresponding QR code is scaled and put in the video output according to the +specified output size options. + +In case no text is specified, the QR code is not generated, but an empty colored +output is returned instead. + +This source accepts the following options: + +@table @option + +@item qrcode_width, w +@item padded_qrcode_width, W +Specify an expression for the width of the rendered QR code, with and without +padding. The @var{qrcode_width} expression can reference the value set by the +@var{padded_qrcode_width} expression, and vice versa. +By default @var{padded_qrcode_width} is set to @var{qrcode_width}, meaning that +there is no padding. + +@item rate, r +Specify the frame rate of the sourced video, as the number of frames +generated per second. It has to be a string in the format +@var{frame_rate_num}/@var{frame_rate_den}, an integer number, a floating point +number or a valid video frame rate abbreviation. The default value is +"25". + +@item case_sensitive, cs +Instruct libqrencode to use case sensitive encoding. This is enabled by +default. This can be disabled to reduce the QR encoding size. + +@item level, l +Specify the QR encoding error correction level. With an higher correction level, +the encoding size will increase but the code will be more robust to corruption. +Lower level is @var{L}. + +It accepts the following values: +@table @samp +@item L +@item M +@item Q +@item H +@end table + +@item expansion +Select how the input text is expanded. Can be either @code{none}, or +@code{normal} (default). See the @ref{qrencodesrc_expansion, Text expansion} +section below for details. + +@item text +@item textfile +Define the text to be rendered. In case neither is specified, no QR is encoded +(just an empty colored frame). + +In case expansion is enabled, the text is treated as a text template, using the +drawtext expansion mechanism. See section below. + +@item background_color, bc +@item foreground_color, fc +Set the QR code and background color. The default value of +@var{foreground_color} is "black", the default value of @var{background_color} +is "white". + +For the syntax of the color options, check the @ref{color syntax,,"Color" +section in the ffmpeg-utils manual,ffmpeg-utils}. +@end table + +@anchor{qrencodesrc_expansion} +@subsection Text expansion + +If @option{expansion} is set to @code{none}, the text is printed verbatim. + +If @option{expansion} is set to @code{normal} (which is the default), +the following expansion mechanism is used. + +The backslash character @samp{\}, followed by any character, always expands to +the second character. + +Sequences of the form @code{%@{...@}} are expanded. The text between the +braces is a function name, possibly followed by arguments separated by ':'. +If the arguments contain special characters or delimiters (':' or '@}'), +they should be escaped. + +Note that they probably must also be escaped as the value for the @option{text} +option in the filter argument string and as the filter argument in the +filtergraph description, and possibly also for the shell, that makes up to four +levels of escaping; using a text file with the @option{textfile} option avoids +these problems. + +The following functions are available: + +@table @command +@item n, frame_num +return the frame number + +@item pts +Return the timestamp of the current frame. + +It can take up to two arguments. + +The first argument is the format of the timestamp; it defaults to @code{flt} for +seconds as a decimal number with microsecond accuracy; @code{hms} stands for a +formatted @var{[-]HH:MM:SS.mmm} timestamp with millisecond accuracy. +@code{gmtime} stands for the timestamp of the frame formatted as UTC time; +@code{localtime} stands for the timestamp of the frame formatted as local time +zone time. If the format is set to @code{hms24hh}, the time is formatted in 24h +format (00-23). + +The second argument is an offset added to the timestamp. + +If the format is set to @code{localtime} or @code{gmtime}, a third argument may +be supplied: a @code{strftime} C function format string. By default, +@var{YYYY-MM-DD HH:MM:SS} format will be used. + +@item expr, e +Evaluate the expression's value and output as a double. + +It must take one argument specifying the expression to be evaluated, which +accepts the following constants: + +@table @option +@item n +the frame number + +@item q +the QR code width + +@item t +the time of the frame + +@item w +return the rendered QR code width + +@item W +return the rendered padded QR code width +@end table + +@item expr_formatted, ef +Evaluate the expression's value and output as a formatted string. + +The first argument is the expression to be evaluated, just as for the @var{expr} function. +The second argument specifies the output format. Allowed values are @samp{x}, +@samp{X}, @samp{d} and @samp{u}. They are treated exactly as in the +@code{printf} function. +The third parameter is optional and sets the number of positions taken by the output. +It can be used to add padding with zeros from the left. + +@item gmtime +The time at which the filter is running, expressed in UTC. +It can accept an argument: a @code{strftime} C function format string. +The format string is extended to support the variable @var{%[1-6]N} +which prints fractions of the second with optionally specified number of digits. + +@item localtime +The time at which the filter is running, expressed in the local time zone. +It can accept an argument: a @code{strftime} C function format string. +The format string is extended to support the variable @var{%[1-6]N} +which prints fractions of the second with optionally specified number of digits. + +@item rand(min, max) +return a random number included between @var{min} and @var{max} +@end table + +@subsection Examples + +@itemize +@item +Generate a QR code encoding the specified text with the default size: +@example +qrencodesrc=text=www.ffmpeg.org +@end example + +@item +Same as below, but select blue on pink colors: +@example +qrencodesrc=text=www.ffmpeg.org:bc=pink:fc=blue +@end example + +@item +Generate a QR code with width of 200 pixels and padding, making the padded width +4/3 of the QR code width: +@example +qrencodesrc=text=www.ffmpeg.org:w=200:W=4/3*w +@end example + +@item +Generate a QR code with padded width of 200 pixels and padding, making the QR +code width 3/4 of the padded width: +@example +qrencodesrc=text=www.ffmpeg.org:W=200:w=3/4*W +@end example + +@item +Generate a QR code encoding the frame number: +@example +qrencodesrc=text=%@{n@} +@end example + +@item +Generate a QR code encoding the GMT timestamp: +@example +qrencodesrc=text=%@{gmtime@} +@end example + +@item +Generate a QR code encoding the timestamp expressed as a float: +@example +qrencodesrc=text=%@{pts@} +@end example + +@end itemize + @anchor{allrgb} @anchor{allyuv} @anchor{color} diff --git a/libavfilter/Makefile b/libavfilter/Makefile index 1f9bbcc1af..b30e436fb3 100644 --- a/libavfilter/Makefile +++ b/libavfilter/Makefile @@ -598,6 +598,7 @@ OBJS-$(CONFIG_NULLSRC_FILTER) += vsrc_testsrc.o OBJS-$(CONFIG_OPENCLSRC_FILTER) += vf_program_opencl.o opencl.o OBJS-$(CONFIG_PAL75BARS_FILTER) += vsrc_testsrc.o OBJS-$(CONFIG_PAL100BARS_FILTER) += vsrc_testsrc.o +OBJS-$(CONFIG_QRENCODESRC_FILTER) += vsrc_qrencode.o textutils.o OBJS-$(CONFIG_RGBTESTSRC_FILTER) += vsrc_testsrc.o OBJS-$(CONFIG_SIERPINSKI_FILTER) += vsrc_sierpinski.o OBJS-$(CONFIG_SMPTEBARS_FILTER) += vsrc_testsrc.o diff --git a/libavfilter/allfilters.c b/libavfilter/allfilters.c index ed7c32be94..c5bf55ed53 100644 --- a/libavfilter/allfilters.c +++ b/libavfilter/allfilters.c @@ -560,6 +560,7 @@ extern const AVFilter ff_vsrc_mandelbrot; extern const AVFilter ff_vsrc_mptestsrc; extern const AVFilter ff_vsrc_nullsrc; extern const AVFilter ff_vsrc_openclsrc; +extern const AVFilter ff_vsrc_qrencodesrc; extern const AVFilter ff_vsrc_pal75bars; extern const AVFilter ff_vsrc_pal100bars; extern const AVFilter ff_vsrc_rgbtestsrc; diff --git a/libavfilter/vsrc_qrencode.c b/libavfilter/vsrc_qrencode.c new file mode 100644 index 0000000000..71e282eaa5 --- /dev/null +++ b/libavfilter/vsrc_qrencode.c @@ -0,0 +1,547 @@ +/* + * This file is part of FFmpeg. + * + * FFmpeg 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. + * + * FFmpeg 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 FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** + * @file QR encoder source. + * + * A QR code (quick-response code) is a type of two-dimensional matrix + * barcode, invented in 1994, by Japanese company Denso Wave for + * labelling automobile parts. + * + * This source uses the libqrencode library to generate QR code: + * https://fukuchi.org/works/qrencode/ + */ + +//#define DEBUG + +#include "libavutil/internal.h" +#include "libavutil/imgutils.h" +#include "libavutil/opt.h" +#include "libavutil/lfg.h" +#include "libavutil/random_seed.h" + +#include "avfilter.h" +#include "drawutils.h" +#include "internal.h" +#include "formats.h" +#include "textutils.h" +#include "video.h" +#include "libswscale/swscale.h" + +#include + +enum var_name { + VAR_n, + VAR_q, + VAR_t, + VAR_w, + VAR_W, + VAR_VARS_NB +}; + +static const char *const var_names[] = { + "n", ///< number of frame + "q", ///< width of the QR code + "t", ///< timestamp expressed in seconds + "w", ///< rendered width of the QR code + "W", ///< rendered width of the padded QR code + NULL +}; + +enum Expansion { + EXPANSION_NONE, + EXPANSION_NORMAL +}; + +typedef struct QREncodeContext { + const AVClass *class; + + char *rendered_qrcode_width_expr; + char *rendered_padded_qrcode_width_expr; + + int rendered_qrcode_width; + int rendered_padded_qrcode_width; + + unsigned char *text; + char *textfile; + uint64_t pts; + + int level; + char case_sensitive; + + uint8_t foreground_color[4]; + uint8_t background_color[4]; + + FFDrawContext draw; + FFDrawColor draw_foreground_color; ///< foreground color + FFDrawColor draw_background_color; ///< background color + + /* these are only used when nothing must be encoded */ + FFDrawContext draw0; + FFDrawColor draw0_background_color; ///< background color + + uint8_t *qrcode_data[4]; + int qrcode_linesize[4]; + uint8_t *qrcode_mask_data[4]; + int qrcode_mask_linesize[4]; + int qrcode_width; + int padded_qrcode_width; + + AVRational frame_rate; + + int expansion; ///< expansion mode to use for the text + FFExpandTextContext expand_text; ///< expand text in case expansion is enabled + AVBPrint expanded_text; ///< used to contain the expanded text + + double var_values[VAR_VARS_NB]; + AVLFG lfg; ///< random generator +} QREncodeContext; + +#define OFFSET(x) offsetof(QREncodeContext, x) +#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM + +static const AVOption qrencodesrc_options[] = { + { "rate", "set video rate", OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT_MAX, FLAGS }, + { "r", "set video rate", OFFSET(frame_rate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, INT_MAX, FLAGS }, + { "qrcode_width", "set rendered QR code width expression", OFFSET(rendered_qrcode_width_expr), AV_OPT_TYPE_STRING, {.str = "64"}, 0, INT_MAX, FLAGS }, + { "w", "set rendered QR code width expression", OFFSET(rendered_qrcode_width_expr), AV_OPT_TYPE_STRING, {.str = "64"}, 0, INT_MAX, FLAGS }, + { "padded_qrcode_width", "set rendered padded QR code width expression", OFFSET(rendered_padded_qrcode_width_expr), AV_OPT_TYPE_STRING, {.str = "w"}, 0, INT_MAX, FLAGS }, + { "W", "set rendered padded QR code width expression", OFFSET(rendered_padded_qrcode_width_expr), AV_OPT_TYPE_STRING, {.str = "w"}, 0, INT_MAX, FLAGS }, + { "case_sensitive", "generate code which is case sensitive", OFFSET(case_sensitive), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, FLAGS }, + { "cs", "generate code which is case sensitive", OFFSET(case_sensitive), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, FLAGS }, + + { "level", "error correction level, lowest is L", OFFSET(level), AV_OPT_TYPE_INT, { .i64 = AVCOL_SPC_UNSPECIFIED }, 0, QR_ECLEVEL_H, .flags = FLAGS, "level"}, + { "l", "error correction level, lowest is L", OFFSET(level), AV_OPT_TYPE_INT, { .i64 = AVCOL_SPC_UNSPECIFIED }, 0, QR_ECLEVEL_H, .flags = FLAGS, "level"}, + { "L", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QR_ECLEVEL_L }, 0, 0, FLAGS, "level" }, + { "M", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QR_ECLEVEL_M }, 0, 0, FLAGS, "level" }, + { "Q", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QR_ECLEVEL_Q }, 0, 0, FLAGS, "level" }, + { "H", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QR_ECLEVEL_H }, 0, 0, FLAGS, "level" }, + + {"expansion", "set the expansion mode", OFFSET(expansion), AV_OPT_TYPE_INT, {.i64=EXPANSION_NORMAL}, 0, 2, FLAGS, "expansion"}, + {"none", "set no expansion", OFFSET(expansion), AV_OPT_TYPE_CONST, {.i64 = EXPANSION_NONE}, 0, 0, FLAGS, "expansion"}, + {"normal", "set normal expansion", OFFSET(expansion), AV_OPT_TYPE_CONST, {.i64 = EXPANSION_NORMAL}, 0, 0, FLAGS, "expansion"}, + + { "foreground_color", "set QR foreground color", OFFSET(foreground_color), AV_OPT_TYPE_COLOR, {.str = "black"}, 0, 0, FLAGS }, + { "fc", "set QR foreground color", OFFSET(foreground_color), AV_OPT_TYPE_COLOR, {.str = "black"}, 0, 0, FLAGS }, + { "background_color", "set QR background color", OFFSET(background_color), AV_OPT_TYPE_COLOR, {.str = "white"}, 0, 0, FLAGS }, + { "bc", "set QR background color", OFFSET(background_color), AV_OPT_TYPE_COLOR, {.str = "white"}, 0, 0, FLAGS }, + + {"text", "set text to encode", OFFSET(text), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS}, + {"textfile", "set text file to encode", OFFSET(textfile), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS}, + { NULL } +}; + +AVFILTER_DEFINE_CLASS(qrencodesrc); + +static const char *const fun2_names[] = { + "rand" +}; + +static double drand(void *opaque, double min, double max) +{ + return min + (max-min) / UINT_MAX * av_lfg_get(opaque); +} + +static const ff_eval_func2 fun2[] = { + drand, + NULL +}; + +static int func_pts(void *ctx, AVBPrint *bp, const char *function_name, + unsigned argc, char **argv) +{ + QREncodeContext *qr = ((AVFilterContext *)ctx)->priv; + const char *fmt; + const char *strftime_fmt = NULL; + const char *delta = NULL; + double t = qr->var_values[VAR_t]; + + // argv: pts, FMT, [DELTA, strftime_fmt] + + fmt = argc >= 1 ? argv[0] : "flt"; + if (argc >= 2) { + delta = argv[1]; + } + if (argc >= 3) { + strftime_fmt = argv[2]; + } + + return ff_print_pts(ctx, bp, t, delta, fmt, strftime_fmt); +} + +static int func_frame_num(void *ctx, AVBPrint *bp, const char *function_name, + unsigned argc, char **argv) +{ + QREncodeContext *qr = ((AVFilterContext *)ctx)->priv; + + av_bprintf(bp, "%d", (int)qr->var_values[VAR_n]); + return 0; +} + +static int func_strftime(void *ctx, AVBPrint *bp, const char *function_name, + unsigned argc, char **argv) +{ + const char *strftime_fmt = argc ? argv[0] : NULL; + + return ff_print_time(ctx, bp, strftime_fmt, !strcmp(function_name, "localtime")); +} + +static int func_eval_expr(void *ctx, AVBPrint *bp, const char *function_name, + unsigned argc, char **argv) +{ + QREncodeContext *qr = ((AVFilterContext *)ctx)->priv; + + return ff_print_eval_expr(ctx, bp, argv[0], + fun2_names, fun2, + var_names, qr->var_values, &qr->lfg); +} + +static int func_eval_expr_formatted(void *ctx, AVBPrint *bp, const char *function_name, + unsigned argc, char **argv) +{ + QREncodeContext *qr = ((AVFilterContext *)ctx)->priv; + int ret; + int positions = -1; + + /* + * argv[0] expression to be converted to `int` + * argv[1] format: 'x', 'X', 'd' or 'u' + * argv[2] positions printed (optional) + */ + + if (argc == 3) { + ret = sscanf(argv[2], "%u", &positions); + if (ret != 1) { + av_log(ctx, AV_LOG_ERROR, "expr_int_format(): Invalid number of positions" + " to print: '%s'\n", argv[2]); + return AVERROR(EINVAL); + } + } + + return ff_print_formatted_eval_expr(ctx, bp, argv[0], + fun2_names, fun2, + var_names, qr->var_values, + &qr->lfg, + argv[1][0], positions); +} + +static FFExpandTextFunction expand_text_functions[] = { + { "expr", 1, 1, func_eval_expr }, + { "e", 1, 1, func_eval_expr }, + { "expr_formatted", 2, 3, func_eval_expr_formatted }, + { "ef", 2, 3, func_eval_expr_formatted }, + { "frame_num", 0, 0, func_frame_num }, + { "n", 0, 0, func_frame_num }, + { "gmtime", 0, 1, func_strftime }, + { "localtime", 0, 1, func_strftime }, + { "pts", 0, 3, func_pts } +}; + +static av_cold int init(AVFilterContext *ctx) +{ + QREncodeContext *qr = ctx->priv; + int ret; + + ff_draw_init(&qr->draw, AV_PIX_FMT_ARGB, FF_DRAW_PROCESS_ALPHA); + ff_draw_color(&qr->draw, &qr->draw_foreground_color, (const uint8_t *)&qr->foreground_color); + ff_draw_color(&qr->draw, &qr->draw_background_color, (const uint8_t *)&qr->background_color); + + av_lfg_init(&qr->lfg, av_get_random_seed()); + +#define RENDER_EXPR(var_name_, expr_name_) \ + ret = av_expr_parse_and_eval(&qr->var_values[VAR_##var_name_], \ + qr->expr_name_##_expr, \ + var_names, qr->var_values, \ + NULL, NULL, \ + fun2_names, fun2, \ + &qr->lfg, 0, ctx); \ + if (ret < 0) { \ + av_log(ctx, AV_LOG_ERROR, \ + "Could not evaluate expression '%s'\n", \ + qr->expr_name_##_expr); \ + return ret; \ + } + + RENDER_EXPR(w, rendered_qrcode_width); + RENDER_EXPR(W, rendered_padded_qrcode_width); + RENDER_EXPR(w, rendered_qrcode_width); + + qr->rendered_qrcode_width = qr->var_values[VAR_w]; + qr->rendered_padded_qrcode_width = qr->var_values[VAR_W]; + + if (qr->rendered_padded_qrcode_width < qr->rendered_qrcode_width) { + av_log(ctx, AV_LOG_ERROR, + "Resulting padded QR code width (%d) is lesser than the QR code width (%d)\n", + qr->rendered_padded_qrcode_width, qr->rendered_qrcode_width); + return AVERROR(EINVAL); + } + + qr->qrcode_width = -1; + + if (qr->textfile) { + if (qr->text) { + av_log(ctx, AV_LOG_ERROR, + "Both text and text file provided. Please provide only one\n"); + return AVERROR(EINVAL); + } + if ((ret = ff_load_textfile(ctx, (const char *)qr->textfile, &(qr->text), NULL)) < 0) + return ret; + } + + av_log(ctx, AV_LOG_VERBOSE, + "w:%d W:%d case_sensitive:%d level:%d\n", + (int)qr->rendered_qrcode_width, (int)qr->rendered_padded_qrcode_width, + qr->case_sensitive, qr->level); + + qr->expand_text = (FFExpandTextContext) { + .log_ctx = ctx, + .functions = expand_text_functions, + .functions_nb = FF_ARRAY_ELEMS(expand_text_functions) + }; + + av_bprint_init(&qr->expanded_text, 0, AV_BPRINT_SIZE_UNLIMITED); + + return 0; +} + +static av_cold void uninit(AVFilterContext *ctx) +{ + QREncodeContext *qr = ctx->priv; + + av_bprint_finalize(&qr->expanded_text, NULL); + av_freep(&qr->qrcode_data[0]); +} + +static int config_props(AVFilterLink *outlink) +{ + QREncodeContext *qr = outlink->src->priv; + + ff_draw_init(&qr->draw0, outlink->format, FF_DRAW_PROCESS_ALPHA); + ff_draw_color(&qr->draw0, &qr->draw0_background_color, (const uint8_t *)&qr->background_color); + + outlink->w = qr->rendered_padded_qrcode_width; + outlink->h = qr->rendered_padded_qrcode_width; + outlink->time_base = av_inv_q(qr->frame_rate); + outlink->frame_rate = qr->frame_rate; + + return 0; +} + +#ifdef DEBUG +static void show_qrcode(AVFilterContext *ctx, const QRcode *qrcode) +{ + int i, j; + char *line = av_malloc(qrcode->width + 1); + const char *p = qrcode->data; + + if (!line) + return; + for (i = 0; i < qrcode->width; i++) { + for (j = 0; j < qrcode->width; j++) + line[j] = (*p++)&1 ? '@' : ' '; + line[j] = 0; + av_log(ctx, AV_LOG_DEBUG, "%3d: %s\n", i, line); + } + av_free(line); +} +#endif + +static int draw_qrcode(AVFilterContext *ctx, AVFrame *picref) +{ + QREncodeContext *qr = ctx->priv; + struct SwsContext *sws = NULL; + QRcode *qrcode = NULL; + int i, j; + int ret; + int offset; + uint8_t *srcp; + uint8_t *dstp0, *dstp; + + if (!qr->expanded_text.str || qr->expanded_text.str[0] == 0) { + ff_fill_rectangle(&qr->draw0, &qr->draw0_background_color, + picref->data, picref->linesize, + 0, 0, qr->rendered_padded_qrcode_width, qr->rendered_padded_qrcode_width); + return 0; + } + + av_log(ctx, AV_LOG_DEBUG, "Encoding string '%s'\n", qr->expanded_text.str); + qrcode = QRcode_encodeString(qr->expanded_text.str, 1, qr->level, QR_MODE_8, + qr->case_sensitive); + if (!qrcode) { + ret = AVERROR(errno); + av_log(ctx, AV_LOG_ERROR, + "Failed to encode string with error \'%s\'\n", av_err2str(ret)); + goto error; + } + + av_log(ctx, AV_LOG_DEBUG, + "Encoded QR with width:%d version:%d\n", qrcode->width, qrcode->version); +#ifdef DEBUG + show_qrcode(ctx, (const QRcode *)qrcode); +#endif + + qr->var_values[VAR_q] = qrcode->width; + + if (qrcode->width != qr->qrcode_width) { + qr->qrcode_width = qrcode->width; + + // compute virtual non-rendered padded size + // Q/q = W/w + qr->padded_qrcode_width = + ((double)qr->rendered_padded_qrcode_width / qr->rendered_qrcode_width) * qrcode->width; + + ret = av_image_alloc(qr->qrcode_data, qr->qrcode_linesize, + qr->padded_qrcode_width, qr->padded_qrcode_width, + AV_PIX_FMT_ARGB, 16); + if (ret < 0) { + av_log(ctx, AV_LOG_ERROR, + "Failed to allocate image for QR code with width %d\n", qr->padded_qrcode_width); + goto error; + } + + ret = av_image_alloc(qr->qrcode_mask_data, qr->qrcode_mask_linesize, + qrcode->width, qrcode->width, + AV_PIX_FMT_GRAY8, 16); + if (ret < 0) { + av_log(ctx, AV_LOG_ERROR, "Failed to allocate image for QR code with width %d\n", qrcode->width); + goto error; + } + + } + + ff_fill_rectangle(&qr->draw, &qr->draw_background_color, + qr->qrcode_data, qr->qrcode_linesize, + 0, 0, qr->padded_qrcode_width, qr->padded_qrcode_width); + + /* fill mask */ + dstp0 = qr->qrcode_mask_data[0]; + srcp = qrcode->data; + + for (i = 0; i < qrcode->width; i++) { + dstp = dstp0; + for (j = 0; j < qrcode->width; j++) + *dstp++ = (*srcp++ & 1) ? 255 : 0; + dstp0 += qr->qrcode_mask_linesize[0]; + } + + offset = (qr->padded_qrcode_width - qr->qrcode_width) / 2; + ff_blend_mask(&qr->draw, &qr->draw_foreground_color, + qr->qrcode_data, qr->qrcode_linesize, + qr->padded_qrcode_width, qr->padded_qrcode_width, + qr->qrcode_mask_data[0], qr->qrcode_mask_linesize[0], qrcode->width, qrcode->width, + 3, 0, offset, offset); + + sws = sws_alloc_context(); + if (!sws) { + ret = AVERROR(ENOMEM); + goto error; + } + + av_opt_set_int(sws, "srcw", qr->padded_qrcode_width, 0); + av_opt_set_int(sws, "srch", qr->padded_qrcode_width, 0); + av_opt_set_int(sws, "src_format", AV_PIX_FMT_ARGB, 0); + av_opt_set_int(sws, "dstw", qr->rendered_padded_qrcode_width, 0); + av_opt_set_int(sws, "dsth", qr->rendered_padded_qrcode_width, 0); + av_opt_set_int(sws, "dst_format", picref->format, 0); + av_opt_set_int(sws, "sws_flags", SWS_POINT, 0); + + if ((ret = sws_init_context(sws, NULL, NULL)) < 0) + goto error; + + sws_scale(sws, + (const uint8_t *const *)&qr->qrcode_data, qr->qrcode_linesize, + 0, qr->padded_qrcode_width, + picref->data, picref->linesize); + +error: + sws_freeContext(sws); + QRcode_free(qrcode); + + return ret; +} + +static int request_frame(AVFilterLink *outlink) +{ + AVFilterContext *ctx = (AVFilterContext *)outlink->src; + QREncodeContext *qr = ctx->priv; + AVFrame *picref = + ff_get_video_buffer(outlink, qr->rendered_padded_qrcode_width, qr->rendered_padded_qrcode_width); + int ret; + + if (!picref) + return AVERROR(ENOMEM); + picref->sample_aspect_ratio = (AVRational) {1, 1}; + qr->var_values[VAR_n] = picref->pts = qr->pts++; + qr->var_values[VAR_t] = qr->pts * av_q2d(outlink->time_base); + + av_bprint_clear(&qr->expanded_text); + + switch (qr->expansion) { + case EXPANSION_NONE: + av_bprintf(&qr->expanded_text, "%s", qr->text); + break; + case EXPANSION_NORMAL: + if ((ret = ff_expand_text(&qr->expand_text, qr->text, &qr->expanded_text)) < 0) + return ret; + break; + } + + if ((ret = draw_qrcode(ctx, picref)) < 0) + return ret; + + return ff_filter_frame(outlink, picref); +} + +static int query_formats(AVFilterContext *ctx) +{ + enum AVPixelFormat pix_fmt; + FFDrawContext draw; + AVFilterFormats *fmts = NULL; + int ret; + + // this is needed to support both the no-draw and draw cases + // for the no-draw case we use FFDrawContext to write on the input picture ref + for (pix_fmt = 0; av_pix_fmt_desc_get(pix_fmt); pix_fmt++) + if (ff_draw_init(&draw, pix_fmt, 0) >= 0 && + sws_isSupportedOutput(pix_fmt) && + (ret = ff_add_format(&fmts, pix_fmt)) < 0) + return ret; + + return ff_set_common_formats(ctx, fmts); +} + +static const AVFilterPad qrencode_outputs[] = { + { + .name = "default", + .type = AVMEDIA_TYPE_VIDEO, + .request_frame = request_frame, + .config_props = config_props, + } +}; + +const AVFilter ff_vsrc_qrencodesrc = { + .name = "qrencodesrc", + .description = NULL_IF_CONFIG_SMALL("Generate a QR code."), + .priv_size = sizeof(QREncodeContext), + .priv_class = &qrencodesrc_class, + .init = init, + .uninit = uninit, + .inputs = NULL, + FILTER_OUTPUTS(qrencode_outputs), + FILTER_QUERY_FUNC(query_formats), +}; -- 2.34.1