virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2024-12-18 03:19:31 +02:00
Code Issues Releases Activity
35420ab7fd
FFmpeg/libavfilter/vf_drawtext.c
Andreas Rheinhardt b4f5201967 avfilter: Replace query_formats callback with union of list and callback 
If one looks at the many query_formats callbacks in existence,
one will immediately recognize that there is one type of default
callback for video and a slightly different default callback for
audio: It is "return ff_set_common_formats_from_list(ctx, pix_fmts);"
for video with a filter-specific pix_fmts list. For audio, it is
the same with a filter-specific sample_fmts list together with
ff_set_common_all_samplerates() and ff_set_common_all_channel_counts().

This commit allows to remove the boilerplate query_formats callbacks
by replacing said callback with a union consisting the old callback
and pointers for pixel and sample format arrays. For the not uncommon
case in which these lists only contain a single entry (besides the
sentinel) enum AVPixelFormat and enum AVSampleFormat fields are also
added to the union to store them directly in the AVFilter,
thereby avoiding a relocation.

The state of said union will be contained in a new, dedicated AVFilter
field (the nb_inputs and nb_outputs fields have been shrunk to uint8_t
in order to create a hole for this new field; this is no problem, as
the maximum of all the nb_inputs is four; for nb_outputs it is only
two).

The state's default value coincides with the earlier default of
query_formats being unset, namely that the filter accepts all formats
(and also sample rates and channel counts/layouts for audio)
provided that these properties agree coincide for all inputs and
outputs.

By using different union members for audio and video filters
the type-unsafety of using the same functions for audio and video
lists will furthermore be more confined to formats.c than before.

When the new fields are used, they will also avoid allocations:
Currently something nearly equivalent to ff_default_query_formats()
is called after every successful call to a query_formats callback;
yet in the common case that the newly allocated AVFilterFormats
are not used at all (namely if there are no free links) these newly
allocated AVFilterFormats are freed again without ever being used.
Filters no longer using the callback will not exhibit this any more.

Reviewed-by: Paul B Mahol <onemda@gmail.com>
Reviewed-by: Nicolas George <george@nsup.org>
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2021-10-05 17:48:25 +02:00

1644 lines
55 KiB
C
Raw Blame History

/*
* Copyright (c) 2011 Stefano Sabatini
* Copyright (c) 2010 S.N. Hemanth Meenakshisundaram
* Copyright (c) 2003 Gustavo Sverzut Barbieri <gsbarbieri@yahoo.com.br>
*
* 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
* drawtext filter, based on the original vhook/drawtext.c
* filter by Gustavo Sverzut Barbieri
*/
#include "config.h"
#if HAVE_SYS_TIME_H
#include <sys/time.h>
#endif
#include <sys/types.h>
#include <sys/stat.h>
#include <time.h>
#if HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <fenv.h>
#if CONFIG_LIBFONTCONFIG
#include <fontconfig/fontconfig.h>
#endif
#include "libavutil/avstring.h"
#include "libavutil/bprint.h"
#include "libavutil/common.h"
#include "libavutil/file.h"
#include "libavutil/eval.h"
#include "libavutil/opt.h"
#include "libavutil/random_seed.h"
#include "libavutil/parseutils.h"
#include "libavutil/timecode.h"
#include "libavutil/time_internal.h"
#include "libavutil/tree.h"
#include "libavutil/lfg.h"
#include "libavutil/detection_bbox.h"
#include "avfilter.h"
#include "drawutils.h"
#include "formats.h"
#include "internal.h"
#include "video.h"
#if CONFIG_LIBFRIBIDI
#include <fribidi.h>
#endif
#include <ft2build.h>
#include FT_FREETYPE_H
#include FT_GLYPH_H
#include FT_STROKER_H
static const char *const var_names[] = {
"dar",
"hsub", "vsub",
"line_h", "lh", ///< line height, same as max_glyph_h
"main_h", "h", "H", ///< height of the input video
"main_w", "w", "W", ///< width of the input video
"max_glyph_a", "ascent", ///< max glyph ascent
"max_glyph_d", "descent", ///< min glyph descent
"max_glyph_h", ///< max glyph height
"max_glyph_w", ///< max glyph width
"n", ///< number of frame
"sar",
"t", ///< timestamp expressed in seconds
"text_h", "th", ///< height of the rendered text
"text_w", "tw", ///< width of the rendered text
"x",
"y",
"pict_type",
"pkt_pos",
"pkt_duration",
"pkt_size",
NULL
};
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);
}
typedef double (*eval_func2)(void *, double a, double b);
static const eval_func2 fun2[] = {
drand,
NULL
};
enum var_name {
VAR_DAR,
VAR_HSUB, VAR_VSUB,
VAR_LINE_H, VAR_LH,
VAR_MAIN_H, VAR_h, VAR_H,
VAR_MAIN_W, VAR_w, VAR_W,
VAR_MAX_GLYPH_A, VAR_ASCENT,
VAR_MAX_GLYPH_D, VAR_DESCENT,
VAR_MAX_GLYPH_H,
VAR_MAX_GLYPH_W,
VAR_N,
VAR_SAR,
VAR_T,
VAR_TEXT_H, VAR_TH,
VAR_TEXT_W, VAR_TW,
VAR_X,
VAR_Y,
VAR_PICT_TYPE,
VAR_PKT_POS,
VAR_PKT_DURATION,
VAR_PKT_SIZE,
VAR_VARS_NB
};
enum expansion_mode {
EXP_NONE,
EXP_NORMAL,
EXP_STRFTIME,
};
typedef struct DrawTextContext {
const AVClass *class;
int exp_mode; ///< expansion mode to use for the text
int reinit; ///< tells if the filter is being reinited
#if CONFIG_LIBFONTCONFIG
uint8_t *font; ///< font to be used
#endif
uint8_t *fontfile; ///< font to be used
uint8_t *text; ///< text to be drawn
AVBPrint expanded_text; ///< used to contain the expanded text
uint8_t *fontcolor_expr; ///< fontcolor expression to evaluate
AVBPrint expanded_fontcolor; ///< used to contain the expanded fontcolor spec
int ft_load_flags; ///< flags used for loading fonts, see FT_LOAD_*
FT_Vector *positions; ///< positions for each element in the text
size_t nb_positions; ///< number of elements of positions array
char *textfile; ///< file with text to be drawn
int x; ///< x position to start drawing text
int y; ///< y position to start drawing text
int max_glyph_w; ///< max glyph width
int max_glyph_h; ///< max glyph height
int shadowx, shadowy;
int borderw; ///< border width
char *fontsize_expr; ///< expression for fontsize
AVExpr *fontsize_pexpr; ///< parsed expressions for fontsize
unsigned int fontsize; ///< font size to use
unsigned int default_fontsize; ///< default font size to use
int line_spacing; ///< lines spacing in pixels
short int draw_box; ///< draw box around text - true or false
int boxborderw; ///< box border width
int use_kerning; ///< font kerning is used - true/false
int tabsize; ///< tab size
int fix_bounds; ///< do we let it go out of frame bounds - t/f
FFDrawContext dc;
FFDrawColor fontcolor; ///< foreground color
FFDrawColor shadowcolor; ///< shadow color
FFDrawColor bordercolor; ///< border color
FFDrawColor boxcolor; ///< background color
FT_Library library; ///< freetype font library handle
FT_Face face; ///< freetype font face handle
FT_Stroker stroker; ///< freetype stroker handle
struct AVTreeNode *glyphs; ///< rendered glyphs, stored using the UTF-32 char code
char *x_expr; ///< expression for x position
char *y_expr; ///< expression for y position
AVExpr *x_pexpr, *y_pexpr; ///< parsed expressions for x and y
int64_t basetime; ///< base pts time in the real world for display
double var_values[VAR_VARS_NB];
char *a_expr;
AVExpr *a_pexpr;
int alpha;
AVLFG prng; ///< random
char *tc_opt_string; ///< specified timecode option string
AVRational tc_rate; ///< frame rate for timecode
AVTimecode tc; ///< timecode context
int tc24hmax; ///< 1 if timecode is wrapped to 24 hours, 0 otherwise
int reload; ///< reload text file for each frame
int start_number; ///< starting frame number for n/frame_num var
char *text_source_string; ///< the string to specify text data source
enum AVFrameSideDataType text_source;
#if CONFIG_LIBFRIBIDI
int text_shaping; ///< 1 to shape the text before drawing it
#endif
AVDictionary *metadata;
} DrawTextContext;
#define OFFSET(x) offsetof(DrawTextContext, x)
#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
static const AVOption drawtext_options[]= {
{"fontfile", "set font file", OFFSET(fontfile), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS},
{"text", "set text", OFFSET(text), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS},
{"textfile", "set text file", OFFSET(textfile), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS},
{"fontcolor", "set foreground color", OFFSET(fontcolor.rgba), AV_OPT_TYPE_COLOR, {.str="black"}, 0, 0, FLAGS},
{"fontcolor_expr", "set foreground color expression", OFFSET(fontcolor_expr), AV_OPT_TYPE_STRING, {.str=""}, 0, 0, FLAGS},
{"boxcolor", "set box color", OFFSET(boxcolor.rgba), AV_OPT_TYPE_COLOR, {.str="white"}, 0, 0, FLAGS},
{"bordercolor", "set border color", OFFSET(bordercolor.rgba), AV_OPT_TYPE_COLOR, {.str="black"}, 0, 0, FLAGS},
{"shadowcolor", "set shadow color", OFFSET(shadowcolor.rgba), AV_OPT_TYPE_COLOR, {.str="black"}, 0, 0, FLAGS},
{"box", "set box", OFFSET(draw_box), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1 , FLAGS},
{"boxborderw", "set box border width", OFFSET(boxborderw), AV_OPT_TYPE_INT, {.i64=0}, INT_MIN, INT_MAX , FLAGS},
{"line_spacing", "set line spacing in pixels", OFFSET(line_spacing), AV_OPT_TYPE_INT, {.i64=0}, INT_MIN, INT_MAX,FLAGS},
{"fontsize", "set font size", OFFSET(fontsize_expr), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0 , FLAGS},
{"x", "set x expression", OFFSET(x_expr), AV_OPT_TYPE_STRING, {.str="0"}, 0, 0, FLAGS},
{"y", "set y expression", OFFSET(y_expr), AV_OPT_TYPE_STRING, {.str="0"}, 0, 0, FLAGS},
{"shadowx", "set shadow x offset", OFFSET(shadowx), AV_OPT_TYPE_INT, {.i64=0}, INT_MIN, INT_MAX , FLAGS},
{"shadowy", "set shadow y offset", OFFSET(shadowy), AV_OPT_TYPE_INT, {.i64=0}, INT_MIN, INT_MAX , FLAGS},
{"borderw", "set border width", OFFSET(borderw), AV_OPT_TYPE_INT, {.i64=0}, INT_MIN, INT_MAX , FLAGS},
{"tabsize", "set tab size", OFFSET(tabsize), AV_OPT_TYPE_INT, {.i64=4}, 0, INT_MAX , FLAGS},
{"basetime", "set base time", OFFSET(basetime), AV_OPT_TYPE_INT64, {.i64=AV_NOPTS_VALUE}, INT64_MIN, INT64_MAX , FLAGS},
#if CONFIG_LIBFONTCONFIG
{ "font", "Font name", OFFSET(font), AV_OPT_TYPE_STRING, { .str = "Sans" }, .flags = FLAGS },
#endif
{"expansion", "set the expansion mode", OFFSET(exp_mode), AV_OPT_TYPE_INT, {.i64=EXP_NORMAL}, 0, 2, FLAGS, "expansion"},
{"none", "set no expansion", OFFSET(exp_mode), AV_OPT_TYPE_CONST, {.i64=EXP_NONE}, 0, 0, FLAGS, "expansion"},
{"normal", "set normal expansion", OFFSET(exp_mode), AV_OPT_TYPE_CONST, {.i64=EXP_NORMAL}, 0, 0, FLAGS, "expansion"},
{"strftime", "set strftime expansion (deprecated)", OFFSET(exp_mode), AV_OPT_TYPE_CONST, {.i64=EXP_STRFTIME}, 0, 0, FLAGS, "expansion"},
{"timecode", "set initial timecode", OFFSET(tc_opt_string), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS},
{"tc24hmax", "set 24 hours max (timecode only)", OFFSET(tc24hmax), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
{"timecode_rate", "set rate (timecode only)", OFFSET(tc_rate), AV_OPT_TYPE_RATIONAL, {.dbl=0}, 0, INT_MAX, FLAGS},
{"r", "set rate (timecode only)", OFFSET(tc_rate), AV_OPT_TYPE_RATIONAL, {.dbl=0}, 0, INT_MAX, FLAGS},
{"rate", "set rate (timecode only)", OFFSET(tc_rate), AV_OPT_TYPE_RATIONAL, {.dbl=0}, 0, INT_MAX, FLAGS},
{"reload", "reload text file for each frame", OFFSET(reload), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
{ "alpha", "apply alpha while rendering", OFFSET(a_expr), AV_OPT_TYPE_STRING, { .str = "1" }, .flags = FLAGS },
{"fix_bounds", "check and fix text coords to avoid clipping", OFFSET(fix_bounds), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
{"start_number", "start frame number for n/frame_num variable", OFFSET(start_number), AV_OPT_TYPE_INT, {.i64=0}, 0, INT_MAX, FLAGS},
{"text_source", "the source of text", OFFSET(text_source_string), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 1, FLAGS },
#if CONFIG_LIBFRIBIDI
{"text_shaping", "attempt to shape text before drawing", OFFSET(text_shaping), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, FLAGS},
#endif
/* FT_LOAD_* flags */
{ "ft_load_flags", "set font loading flags for libfreetype", OFFSET(ft_load_flags), AV_OPT_TYPE_FLAGS, { .i64 = FT_LOAD_DEFAULT }, 0, INT_MAX, FLAGS, "ft_load_flags" },
{ "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_DEFAULT }, .flags = FLAGS, .unit = "ft_load_flags" },
{ "no_scale", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_NO_SCALE }, .flags = FLAGS, .unit = "ft_load_flags" },
{ "no_hinting", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_NO_HINTING }, .flags = FLAGS, .unit = "ft_load_flags" },
{ "render", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_RENDER }, .flags = FLAGS, .unit = "ft_load_flags" },
{ "no_bitmap", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_NO_BITMAP }, .flags = FLAGS, .unit = "ft_load_flags" },
{ "vertical_layout", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_VERTICAL_LAYOUT }, .flags = FLAGS, .unit = "ft_load_flags" },
{ "force_autohint", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_FORCE_AUTOHINT }, .flags = FLAGS, .unit = "ft_load_flags" },
{ "crop_bitmap", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_CROP_BITMAP }, .flags = FLAGS, .unit = "ft_load_flags" },
{ "pedantic", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_PEDANTIC }, .flags = FLAGS, .unit = "ft_load_flags" },
{ "ignore_global_advance_width", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH }, .flags = FLAGS, .unit = "ft_load_flags" },
{ "no_recurse", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_NO_RECURSE }, .flags = FLAGS, .unit = "ft_load_flags" },
{ "ignore_transform", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_IGNORE_TRANSFORM }, .flags = FLAGS, .unit = "ft_load_flags" },
{ "monochrome", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_MONOCHROME }, .flags = FLAGS, .unit = "ft_load_flags" },
{ "linear_design", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_LINEAR_DESIGN }, .flags = FLAGS, .unit = "ft_load_flags" },
{ "no_autohint", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_NO_AUTOHINT }, .flags = FLAGS, .unit = "ft_load_flags" },
{ NULL }
};
AVFILTER_DEFINE_CLASS(drawtext);
#undef __FTERRORS_H__
#define FT_ERROR_START_LIST {
#define FT_ERRORDEF(e, v, s) { (e), (s) },
#define FT_ERROR_END_LIST { 0, NULL } };
static const struct ft_error {
int err;
const char *err_msg;
} ft_errors[] =
#include FT_ERRORS_H
#define FT_ERRMSG(e) ft_errors[e].err_msg
typedef struct Glyph {
FT_Glyph glyph;
FT_Glyph border_glyph;
uint32_t code;
unsigned int fontsize;
FT_Bitmap bitmap; ///< array holding bitmaps of font
FT_Bitmap border_bitmap; ///< array holding bitmaps of font border
FT_BBox bbox;
int advance;
int bitmap_left;
int bitmap_top;
} Glyph;
static int glyph_cmp(const void *key, const void *b)
{
const Glyph *a = key, *bb = b;
int64_t diff = (int64_t)a->code - (int64_t)bb->code;
if (diff != 0)
return diff > 0 ? 1 : -1;
else
return FFDIFFSIGN((int64_t)a->fontsize, (int64_t)bb->fontsize);
}
/**
* Load glyphs corresponding to the UTF-32 codepoint code.
*/
static int load_glyph(AVFilterContext *ctx, Glyph **glyph_ptr, uint32_t code)
{
DrawTextContext *s = ctx->priv;
FT_BitmapGlyph bitmapglyph;
Glyph *glyph;
struct AVTreeNode *node = NULL;
int ret;
/* load glyph into s->face->glyph */
if (FT_Load_Char(s->face, code, s->ft_load_flags))
return AVERROR(EINVAL);
glyph = av_mallocz(sizeof(*glyph));
if (!glyph) {
ret = AVERROR(ENOMEM);
goto error;
}
glyph->code = code;
glyph->fontsize = s->fontsize;
if (FT_Get_Glyph(s->face->glyph, &glyph->glyph)) {
ret = AVERROR(EINVAL);
goto error;
}
if (s->borderw) {
glyph->border_glyph = glyph->glyph;
if (FT_Glyph_StrokeBorder(&glyph->border_glyph, s->stroker, 0, 0) ||
FT_Glyph_To_Bitmap(&glyph->border_glyph, FT_RENDER_MODE_NORMAL, 0, 1)) {
ret = AVERROR_EXTERNAL;
goto error;
}
bitmapglyph = (FT_BitmapGlyph) glyph->border_glyph;
glyph->border_bitmap = bitmapglyph->bitmap;
}
if (FT_Glyph_To_Bitmap(&glyph->glyph, FT_RENDER_MODE_NORMAL, 0, 1)) {
ret = AVERROR_EXTERNAL;
goto error;
}
bitmapglyph = (FT_BitmapGlyph) glyph->glyph;
glyph->bitmap = bitmapglyph->bitmap;
glyph->bitmap_left = bitmapglyph->left;
glyph->bitmap_top = bitmapglyph->top;
glyph->advance = s->face->glyph->advance.x >> 6;
/* measure text height to calculate text_height (or the maximum text height) */
FT_Glyph_Get_CBox(glyph->glyph, ft_glyph_bbox_pixels, &glyph->bbox);
/* cache the newly created glyph */
if (!(node = av_tree_node_alloc())) {
ret = AVERROR(ENOMEM);
goto error;
}
av_tree_insert(&s->glyphs, glyph, glyph_cmp, &node);
if (glyph_ptr)
*glyph_ptr = glyph;
return 0;
error:
if (glyph)
av_freep(&glyph->glyph);
av_freep(&glyph);
av_freep(&node);
return ret;
}
static av_cold int set_fontsize(AVFilterContext *ctx, unsigned int fontsize)
{
int err;
DrawTextContext *s = ctx->priv;
if ((err = FT_Set_Pixel_Sizes(s->face, 0, fontsize))) {
av_log(ctx, AV_LOG_ERROR, "Could not set font size to %d pixels: %s\n",
fontsize, FT_ERRMSG(err));
return AVERROR(EINVAL);
}
s->fontsize = fontsize;
return 0;
}
static av_cold int parse_fontsize(AVFilterContext *ctx)
{
DrawTextContext *s = ctx->priv;
int err;
if (s->fontsize_pexpr)
return 0;
if (s->fontsize_expr == NULL)
return AVERROR(EINVAL);
if ((err = av_expr_parse(&s->fontsize_pexpr, s->fontsize_expr, var_names,
NULL, NULL, fun2_names, fun2, 0, ctx)) < 0)
return err;
return 0;
}
static av_cold int update_fontsize(AVFilterContext *ctx)
{
DrawTextContext *s = ctx->priv;
unsigned int fontsize = s->default_fontsize;
int err;
double size, roundedsize;
// if no fontsize specified use the default
if (s->fontsize_expr != NULL) {
if ((err = parse_fontsize(ctx)) < 0)
return err;
size = av_expr_eval(s->fontsize_pexpr, s->var_values, &s->prng);
if (!isnan(size)) {
roundedsize = round(size);
// test for overflow before cast
if (!(roundedsize > INT_MIN && roundedsize < INT_MAX)) {
av_log(ctx, AV_LOG_ERROR, "fontsize overflow\n");
return AVERROR(EINVAL);
}
fontsize = roundedsize;
}
}
if (fontsize == 0)
fontsize = 1;
// no change
if (fontsize == s->fontsize)
return 0;
return set_fontsize(ctx, fontsize);
}
static int load_font_file(AVFilterContext *ctx, const char *path, int index)
{
DrawTextContext *s = ctx->priv;
int err;
err = FT_New_Face(s->library, path, index, &s->face);
if (err) {
#if !CONFIG_LIBFONTCONFIG
av_log(ctx, AV_LOG_ERROR, "Could not load font \"%s\": %s\n",
s->fontfile, FT_ERRMSG(err));
#endif
return AVERROR(EINVAL);
}
return 0;
}
#if CONFIG_LIBFONTCONFIG
static int load_font_fontconfig(AVFilterContext *ctx)
{
DrawTextContext *s = ctx->priv;
FcConfig *fontconfig;
FcPattern *pat, *best;
FcResult result = FcResultMatch;
FcChar8 *filename;
int index;
double size;
int err = AVERROR(ENOENT);
int parse_err;
fontconfig = FcInitLoadConfigAndFonts();
if (!fontconfig) {
av_log(ctx, AV_LOG_ERROR, "impossible to init fontconfig\n");
return AVERROR_UNKNOWN;
}
pat = FcNameParse(s->fontfile ? s->fontfile :
(uint8_t *)(intptr_t)"default");
if (!pat) {
av_log(ctx, AV_LOG_ERROR, "could not parse fontconfig pat");
return AVERROR(EINVAL);
}
FcPatternAddString(pat, FC_FAMILY, s->font);
parse_err = parse_fontsize(ctx);
if (!parse_err) {
double size = av_expr_eval(s->fontsize_pexpr, s->var_values, &s->prng);
if (isnan(size)) {
av_log(ctx, AV_LOG_ERROR, "impossible to find font information");
return AVERROR(EINVAL);
}
FcPatternAddDouble(pat, FC_SIZE, size);
}
FcDefaultSubstitute(pat);
if (!FcConfigSubstitute(fontconfig, pat, FcMatchPattern)) {
av_log(ctx, AV_LOG_ERROR, "could not substitue fontconfig options"); /* very unlikely */
FcPatternDestroy(pat);
return AVERROR(ENOMEM);
}
best = FcFontMatch(fontconfig, pat, &result);
FcPatternDestroy(pat);
if (!best || result != FcResultMatch) {
av_log(ctx, AV_LOG_ERROR,
"Cannot find a valid font for the family %s\n",
s->font);
goto fail;
}
if (
FcPatternGetInteger(best, FC_INDEX, 0, &index ) != FcResultMatch ||
FcPatternGetDouble (best, FC_SIZE, 0, &size ) != FcResultMatch) {
av_log(ctx, AV_LOG_ERROR, "impossible to find font information");
return AVERROR(EINVAL);
}
if (FcPatternGetString(best, FC_FILE, 0, &filename) != FcResultMatch) {
av_log(ctx, AV_LOG_ERROR, "No file path for %s\n",
s->font);
goto fail;
}
av_log(ctx, AV_LOG_INFO, "Using \"%s\"\n", filename);
if (parse_err)
s->default_fontsize = size + 0.5;
err = load_font_file(ctx, filename, index);
if (err)
return err;
FcConfigDestroy(fontconfig);
fail:
FcPatternDestroy(best);
return err;
}
#endif
static int load_font(AVFilterContext *ctx)
{
DrawTextContext *s = ctx->priv;
int err;
/* load the face, and set up the encoding, which is by default UTF-8 */
err = load_font_file(ctx, s->fontfile, 0);
if (!err)
return 0;
#if CONFIG_LIBFONTCONFIG
err = load_font_fontconfig(ctx);
if (!err)
return 0;
#endif
return err;
}
static inline int is_newline(uint32_t c)
{
return c == '\n' || c == '\r' || c == '\f' || c == '\v';
}
static int load_textfile(AVFilterContext *ctx)
{
DrawTextContext *s = ctx->priv;
int err;
uint8_t *textbuf;
uint8_t *tmp;
size_t textbuf_size;
if ((err = av_file_map(s->textfile, &textbuf, &textbuf_size, 0, ctx)) < 0) {
av_log(ctx, AV_LOG_ERROR,
"The text file '%s' could not be read or is empty\n",
s->textfile);
return err;
}
if (textbuf_size > 0 && is_newline(textbuf[textbuf_size - 1]))
textbuf_size--;
if (textbuf_size > SIZE_MAX - 1 || !(tmp = av_realloc(s->text, textbuf_size + 1))) {
av_file_unmap(textbuf, textbuf_size);
return AVERROR(ENOMEM);
}
s->text = tmp;
memcpy(s->text, textbuf, textbuf_size);
s->text[textbuf_size] = 0;
av_file_unmap(textbuf, textbuf_size);
return 0;
}
#if CONFIG_LIBFRIBIDI
static int shape_text(AVFilterContext *ctx)
{
DrawTextContext *s = ctx->priv;
uint8_t *tmp;
int ret = AVERROR(ENOMEM);
static const FriBidiFlags flags = FRIBIDI_FLAGS_DEFAULT |
FRIBIDI_FLAGS_ARABIC;
FriBidiChar *unicodestr = NULL;
FriBidiStrIndex len;
FriBidiParType direction = FRIBIDI_PAR_LTR;
FriBidiStrIndex line_start = 0;
FriBidiStrIndex line_end = 0;
FriBidiLevel *embedding_levels = NULL;
FriBidiArabicProp *ar_props = NULL;
FriBidiCharType *bidi_types = NULL;
FriBidiStrIndex i,j;
len = strlen(s->text);
if (!(unicodestr = av_malloc_array(len, sizeof(*unicodestr)))) {
goto out;
}
len = fribidi_charset_to_unicode(FRIBIDI_CHAR_SET_UTF8,
s->text, len, unicodestr);
bidi_types = av_malloc_array(len, sizeof(*bidi_types));
if (!bidi_types) {
goto out;
}
fribidi_get_bidi_types(unicodestr, len, bidi_types);
embedding_levels = av_malloc_array(len, sizeof(*embedding_levels));
if (!embedding_levels) {
goto out;
}
if (!fribidi_get_par_embedding_levels(bidi_types, len, &direction,
embedding_levels)) {
goto out;
}
ar_props = av_malloc_array(len, sizeof(*ar_props));
if (!ar_props) {
goto out;
}
fribidi_get_joining_types(unicodestr, len, ar_props);
fribidi_join_arabic(bidi_types, len, embedding_levels, ar_props);
fribidi_shape(flags, embedding_levels, len, ar_props, unicodestr);
for (line_end = 0, line_start = 0; line_end < len; line_end++) {
if (is_newline(unicodestr[line_end]) || line_end == len - 1) {
if (!fribidi_reorder_line(flags, bidi_types,
line_end - line_start + 1, line_start,
direction, embedding_levels, unicodestr,
NULL)) {
goto out;
}
line_start = line_end + 1;
}
}
/* Remove zero-width fill chars put in by libfribidi */
for (i = 0, j = 0; i < len; i++)
if (unicodestr[i] != FRIBIDI_CHAR_FILL)
unicodestr[j++] = unicodestr[i];
len = j;
if (!(tmp = av_realloc(s->text, (len * 4 + 1) * sizeof(*s->text)))) {
/* Use len * 4, as a unicode character can be up to 4 bytes in UTF-8 */
goto out;
}
s->text = tmp;
len = fribidi_unicode_to_charset(FRIBIDI_CHAR_SET_UTF8,
unicodestr, len, s->text);
ret = 0;
out:
av_free(unicodestr);
av_free(embedding_levels);
av_free(ar_props);
av_free(bidi_types);
return ret;
}
#endif
static enum AVFrameSideDataType text_source_string_parse(const char *text_source_string)
{
av_assert0(text_source_string);
if (!strcmp(text_source_string, "side_data_detection_bboxes")) {
return AV_FRAME_DATA_DETECTION_BBOXES;
} else {
return AVERROR(EINVAL);
}
}
static av_cold int init(AVFilterContext *ctx)
{
int err;
DrawTextContext *s = ctx->priv;
Glyph *glyph;
av_expr_free(s->fontsize_pexpr);
s->fontsize_pexpr = NULL;
s->fontsize = 0;
s->default_fontsize = 16;
if (!s->fontfile && !CONFIG_LIBFONTCONFIG) {
av_log(ctx, AV_LOG_ERROR, "No font filename provided\n");
return AVERROR(EINVAL);
}
if (s->textfile) {
if (s->text) {
av_log(ctx, AV_LOG_ERROR,
"Both text and text file provided. Please provide only one\n");
return AVERROR(EINVAL);
}
if ((err = load_textfile(ctx)) < 0)
return err;
}
if (s->reload && !s->textfile)
av_log(ctx, AV_LOG_WARNING, "No file to reload\n");
if (s->tc_opt_string) {
int ret = av_timecode_init_from_string(&s->tc, s->tc_rate,
s->tc_opt_string, ctx);
if (ret < 0)
return ret;
if (s->tc24hmax)
s->tc.flags |= AV_TIMECODE_FLAG_24HOURSMAX;
if (!s->text)
s->text = av_strdup("");
}
if (s->text_source_string) {
s->text_source = text_source_string_parse(s->text_source_string);
if ((int)s->text_source < 0) {
av_log(ctx, AV_LOG_ERROR, "Error text source: %s\n", s->text_source_string);
return AVERROR(EINVAL);
}
}
if (s->text_source == AV_FRAME_DATA_DETECTION_BBOXES) {
if (s->text) {
av_log(ctx, AV_LOG_WARNING, "Multiple texts provided, will use text_source only\n");
av_free(s->text);
}
s->text = av_mallocz(AV_DETECTION_BBOX_LABEL_NAME_MAX_SIZE *
(AV_NUM_DETECTION_BBOX_CLASSIFY + 1));
if (!s->text)
return AVERROR(ENOMEM);
}
if (!s->text) {
av_log(ctx, AV_LOG_ERROR,
"Either text, a valid file, a timecode or text source must be provided\n");
return AVERROR(EINVAL);
}
#if CONFIG_LIBFRIBIDI
if (s->text_shaping)
if ((err = shape_text(ctx)) < 0)
return err;
#endif
if ((err = FT_Init_FreeType(&(s->library)))) {
av_log(ctx, AV_LOG_ERROR,
"Could not load FreeType: %s\n", FT_ERRMSG(err));
return AVERROR(EINVAL);
}
if ((err = load_font(ctx)) < 0)
return err;
if ((err = update_fontsize(ctx)) < 0)
return err;
if (s->borderw) {
if (FT_Stroker_New(s->library, &s->stroker)) {
av_log(ctx, AV_LOG_ERROR, "Coult not init FT stroker\n");
return AVERROR_EXTERNAL;
}
FT_Stroker_Set(s->stroker, s->borderw << 6, FT_STROKER_LINECAP_ROUND,
FT_STROKER_LINEJOIN_ROUND, 0);
}
s->use_kerning = FT_HAS_KERNING(s->face);
/* load the fallback glyph with code 0 */
load_glyph(ctx, NULL, 0);
/* set the tabsize in pixels */
if ((err = load_glyph(ctx, &glyph, ' ')) < 0) {
av_log(ctx, AV_LOG_ERROR, "Could not set tabsize.\n");
return err;
}
s->tabsize *= glyph->advance;
if (s->exp_mode == EXP_STRFTIME &&
(strchr(s->text, '%') || strchr(s->text, '\\')))
av_log(ctx, AV_LOG_WARNING, "expansion=strftime is deprecated.\n");
av_bprint_init(&s->expanded_text, 0, AV_BPRINT_SIZE_UNLIMITED);
av_bprint_init(&s->expanded_fontcolor, 0, AV_BPRINT_SIZE_UNLIMITED);
return 0;
}
static int query_formats(AVFilterContext *ctx)
{
return ff_set_common_formats(ctx, ff_draw_supported_pixel_formats(0));
}
static int glyph_enu_free(void *opaque, void *elem)
{
Glyph *glyph = elem;
FT_Done_Glyph(glyph->glyph);
FT_Done_Glyph(glyph->border_glyph);
av_free(elem);
return 0;
}
static av_cold void uninit(AVFilterContext *ctx)
{
DrawTextContext *s = ctx->priv;
av_expr_free(s->x_pexpr);
av_expr_free(s->y_pexpr);
av_expr_free(s->a_pexpr);
av_expr_free(s->fontsize_pexpr);
s->x_pexpr = s->y_pexpr = s->a_pexpr = s->fontsize_pexpr = NULL;
av_freep(&s->positions);
s->nb_positions = 0;
av_tree_enumerate(s->glyphs, NULL, NULL, glyph_enu_free);
av_tree_destroy(s->glyphs);
s->glyphs = NULL;
FT_Done_Face(s->face);
FT_Stroker_Done(s->stroker);
FT_Done_FreeType(s->library);
av_bprint_finalize(&s->expanded_text, NULL);
av_bprint_finalize(&s->expanded_fontcolor, NULL);
}
static int config_input(AVFilterLink *inlink)
{
AVFilterContext *ctx = inlink->dst;
DrawTextContext *s = ctx->priv;
char *expr;
int ret;
ff_draw_init(&s->dc, inlink->format, FF_DRAW_PROCESS_ALPHA);
ff_draw_color(&s->dc, &s->fontcolor, s->fontcolor.rgba);
ff_draw_color(&s->dc, &s->shadowcolor, s->shadowcolor.rgba);
ff_draw_color(&s->dc, &s->bordercolor, s->bordercolor.rgba);
ff_draw_color(&s->dc, &s->boxcolor, s->boxcolor.rgba);
s->var_values[VAR_w] = s->var_values[VAR_W] = s->var_values[VAR_MAIN_W] = inlink->w;
s->var_values[VAR_h] = s->var_values[VAR_H] = s->var_values[VAR_MAIN_H] = inlink->h;
s->var_values[VAR_SAR] = inlink->sample_aspect_ratio.num ? av_q2d(inlink->sample_aspect_ratio) : 1;
s->var_values[VAR_DAR] = (double)inlink->w / inlink->h * s->var_values[VAR_SAR];
s->var_values[VAR_HSUB] = 1 << s->dc.hsub_max;
s->var_values[VAR_VSUB] = 1 << s->dc.vsub_max;
s->var_values[VAR_X] = NAN;
s->var_values[VAR_Y] = NAN;
s->var_values[VAR_T] = NAN;
av_lfg_init(&s->prng, av_get_random_seed());
av_expr_free(s->x_pexpr);
av_expr_free(s->y_pexpr);
av_expr_free(s->a_pexpr);
s->x_pexpr = s->y_pexpr = s->a_pexpr = NULL;
if ((ret = av_expr_parse(&s->x_pexpr, expr = s->x_expr, var_names,
NULL, NULL, fun2_names, fun2, 0, ctx)) < 0 ||
(ret = av_expr_parse(&s->y_pexpr, expr = s->y_expr, var_names,
NULL, NULL, fun2_names, fun2, 0, ctx)) < 0 ||
(ret = av_expr_parse(&s->a_pexpr, expr = s->a_expr, var_names,
NULL, NULL, fun2_names, fun2, 0, ctx)) < 0) {
av_log(ctx, AV_LOG_ERROR, "Failed to parse expression: %s \n", expr);
return AVERROR(EINVAL);
}
return 0;
}
static int command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
{
DrawTextContext *old = ctx->priv;
DrawTextContext *new = NULL;
int ret;
if (!strcmp(cmd, "reinit")) {
new = av_mallocz(sizeof(DrawTextContext));
if (!new)
return AVERROR(ENOMEM);
new->class = &drawtext_class;
ret = av_opt_copy(new, old);
if (ret < 0)
goto fail;
ctx->priv = new;
ret = av_set_options_string(ctx, arg, "=", ":");
if (ret < 0) {
ctx->priv = old;
goto fail;
}
ret = init(ctx);
if (ret < 0) {
uninit(ctx);
ctx->priv = old;
goto fail;
}
new->reinit = 1;
ctx->priv = old;
uninit(ctx);
av_freep(&old);
ctx->priv = new;
return config_input(ctx->inputs[0]);
} else
return AVERROR(ENOSYS);
fail:
av_log(ctx, AV_LOG_ERROR, "Failed to process command. Continuing with existing parameters.\n");
av_freep(&new);
return ret;
}
static int func_pict_type(AVFilterContext *ctx, AVBPrint *bp,
char *fct, unsigned argc, char **argv, int tag)
{
DrawTextContext *s = ctx->priv;
av_bprintf(bp, "%c", av_get_picture_type_char(s->var_values[VAR_PICT_TYPE]));
return 0;
}
static int func_pts(AVFilterContext *ctx, AVBPrint *bp,
char *fct, unsigned argc, char **argv, int tag)
{
DrawTextContext *s = ctx->priv;
const char *fmt;
double pts = s->var_values[VAR_T];
int ret;
fmt = argc >= 1 ? argv[0] : "flt";
if (argc >= 2) {
int64_t delta;
if ((ret = av_parse_time(&delta, argv[1], 1)) < 0) {
av_log(ctx, AV_LOG_ERROR, "Invalid delta '%s'\n", argv[1]);
return ret;
}
pts += (double)delta / AV_TIME_BASE;
}
if (!strcmp(fmt, "flt")) {
av_bprintf(bp, "%.6f", pts);
} else if (!strcmp(fmt, "hms")) {
if (isnan(pts)) {
av_bprintf(bp, " ??:??:??.???");
} else {
int64_t ms = llrint(pts * 1000);
char sign = ' ';
if (ms < 0) {
sign = '-';
ms = -ms;
}
if (argc >= 3) {
if (!strcmp(argv[2], "24HH")) {
ms %= 24 * 60 * 60 * 1000;
} else {
av_log(ctx, AV_LOG_ERROR, "Invalid argument '%s'\n", argv[2]);
return AVERROR(EINVAL);
}
}
av_bprintf(bp, "%c%02d:%02d:%02d.%03d", sign,
(int)(ms / (60 * 60 * 1000)),
(int)(ms / (60 * 1000)) % 60,
(int)(ms / 1000) % 60,
(int)(ms % 1000));
}
} else if (!strcmp(fmt, "localtime") ||
!strcmp(fmt, "gmtime")) {
struct tm tm;
time_t ms = (time_t)pts;
const char *timefmt = argc >= 3 ? argv[2] : "%Y-%m-%d %H:%M:%S";
if (!strcmp(fmt, "localtime"))
localtime_r(&ms, &tm);
else
gmtime_r(&ms, &tm);
av_bprint_strftime(bp, timefmt, &tm);
} else {
av_log(ctx, AV_LOG_ERROR, "Invalid format '%s'\n", fmt);
return AVERROR(EINVAL);
}
return 0;
}
static int func_frame_num(AVFilterContext *ctx, AVBPrint *bp,
char *fct, unsigned argc, char **argv, int tag)
{
DrawTextContext *s = ctx->priv;
av_bprintf(bp, "%d", (int)s->var_values[VAR_N]);
return 0;
}
static int func_metadata(AVFilterContext *ctx, AVBPrint *bp,
char *fct, unsigned argc, char **argv, int tag)
{
DrawTextContext *s = ctx->priv;
AVDictionaryEntry *e = av_dict_get(s->metadata, argv[0], NULL, 0);
if (e && e->value)
av_bprintf(bp, "%s", e->value);
else if (argc >= 2)
av_bprintf(bp, "%s", argv[1]);
return 0;
}
static int func_strftime(AVFilterContext *ctx, AVBPrint *bp,
char *fct, unsigned argc, char **argv, int tag)
{
const char *fmt = argc ? argv[0] : "%Y-%m-%d %H:%M:%S";
time_t now;
struct tm tm;
time(&now);
if (tag == 'L')
localtime_r(&now, &tm);
else
tm = *gmtime_r(&now, &tm);
av_bprint_strftime(bp, fmt, &tm);
return 0;
}
static int func_eval_expr(AVFilterContext *ctx, AVBPrint *bp,
char *fct, unsigned argc, char **argv, int tag)
{
DrawTextContext *s = ctx->priv;
double res;
int ret;
ret = av_expr_parse_and_eval(&res, argv[0], var_names, s->var_values,
NULL, NULL, fun2_names, fun2,
&s->prng, 0, ctx);
if (ret < 0)
av_log(ctx, AV_LOG_ERROR,
"Expression '%s' for the expr text expansion function is not valid\n",
argv[0]);
else
av_bprintf(bp, "%f", res);
return ret;
}
static int func_eval_expr_int_format(AVFilterContext *ctx, AVBPrint *bp,
char *fct, unsigned argc, char **argv, int tag)
{
DrawTextContext *s = ctx->priv;
double res;
int intval;
int ret;
unsigned int positions = 0;
char fmt_str[30] = "%";
/*
* argv[0] expression to be converted to `int`
* argv[1] format: 'x', 'X', 'd' or 'u'
* argv[2] positions printed (optional)
*/
ret = av_expr_parse_and_eval(&res, argv[0], var_names, s->var_values,
NULL, NULL, fun2_names, fun2,
&s->prng, 0, ctx);
if (ret < 0) {
av_log(ctx, AV_LOG_ERROR,
"Expression '%s' for the expr text expansion function is not valid\n",
argv[0]);
return ret;
}
if (!strchr("xXdu", argv[1][0])) {
av_log(ctx, AV_LOG_ERROR, "Invalid format '%c' specified,"
" allowed values: 'x', 'X', 'd', 'u'\n", argv[1][0]);
return AVERROR(EINVAL);
}
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);
}
}
feclearexcept(FE_ALL_EXCEPT);
intval = res;
#if defined(FE_INVALID) && defined(FE_OVERFLOW) && defined(FE_UNDERFLOW)
if ((ret = fetestexcept(FE_INVALID|FE_OVERFLOW|FE_UNDERFLOW))) {
av_log(ctx, AV_LOG_ERROR, "Conversion of floating-point result to int failed. Control register: 0x%08x. Conversion result: %d\n", ret, intval);
return AVERROR(EINVAL);
}
#endif
if (argc == 3)
av_strlcatf(fmt_str, sizeof(fmt_str), "0%u", positions);
av_strlcatf(fmt_str, sizeof(fmt_str), "%c", argv[1][0]);
av_log(ctx, AV_LOG_DEBUG, "Formatting value %f (expr '%s') with spec '%s'\n",
res, argv[0], fmt_str);
av_bprintf(bp, fmt_str, intval);
return 0;
}
static const struct drawtext_function {
const char *name;
unsigned argc_min, argc_max;
int tag; /**< opaque argument to func */
int (*func)(AVFilterContext *, AVBPrint *, char *, unsigned, char **, int);
} functions[] = {
{ "expr", 1, 1, 0, func_eval_expr },
{ "e", 1, 1, 0, func_eval_expr },
{ "expr_int_format", 2, 3, 0, func_eval_expr_int_format },
{ "eif", 2, 3, 0, func_eval_expr_int_format },
{ "pict_type", 0, 0, 0, func_pict_type },
{ "pts", 0, 3, 0, func_pts },
{ "gmtime", 0, 1, 'G', func_strftime },
{ "localtime", 0, 1, 'L', func_strftime },
{ "frame_num", 0, 0, 0, func_frame_num },
{ "n", 0, 0, 0, func_frame_num },
{ "metadata", 1, 2, 0, func_metadata },
};
static int eval_function(AVFilterContext *ctx, AVBPrint *bp, char *fct,
unsigned argc, char **argv)
{
unsigned i;
for (i = 0; i < FF_ARRAY_ELEMS(functions); i++) {
if (strcmp(fct, functions[i].name))
continue;
if (argc < functions[i].argc_min) {
av_log(ctx, AV_LOG_ERROR, "%%{%s} requires at least %d arguments\n",
fct, functions[i].argc_min);
return AVERROR(EINVAL);
}
if (argc > functions[i].argc_max) {
av_log(ctx, AV_LOG_ERROR, "%%{%s} requires at most %d arguments\n",
fct, functions[i].argc_max);
return AVERROR(EINVAL);
}
break;
}
if (i >= FF_ARRAY_ELEMS(functions)) {
av_log(ctx, AV_LOG_ERROR, "%%{%s} is not known\n", fct);
return AVERROR(EINVAL);
}
return functions[i].func(ctx, bp, fct, argc, argv, functions[i].tag);
}
static int expand_function(AVFilterContext *ctx, AVBPrint *bp, char **rtext)
{
const char *text = *rtext;
char *argv[16] = { NULL };
unsigned argc = 0, i;
int ret;
if (*text != '{') {
av_log(ctx, AV_LOG_ERROR, "Stray %% near '%s'\n", text);
return AVERROR(EINVAL);
}
text++;
while (1) {
if (!(argv[argc++] = av_get_token(&text, ":}"))) {
ret = AVERROR(ENOMEM);
goto end;
}
if (!*text) {
av_log(ctx, AV_LOG_ERROR, "Unterminated %%{} near '%s'\n", *rtext);
ret = AVERROR(EINVAL);
goto end;
}
if (argc == FF_ARRAY_ELEMS(argv))
av_freep(&argv[--argc]); /* error will be caught later */
if (*text == '}')
break;
text++;
}
if ((ret = eval_function(ctx, bp, argv[0], argc - 1, argv + 1)) < 0)
goto end;
ret = 0;
*rtext = (char *)text + 1;
end:
for (i = 0; i < argc; i++)
av_freep(&argv[i]);
return ret;
}
static int expand_text(AVFilterContext *ctx, char *text, AVBPrint *bp)
{
int ret;
av_bprint_clear(bp);
while (*text) {
if (*text == '\\' && text[1]) {
av_bprint_chars(bp, text[1], 1);
text += 2;
} else if (*text == '%') {
text++;
if ((ret = expand_function(ctx, bp, &text)) < 0)
return ret;
} else {
av_bprint_chars(bp, *text, 1);
text++;
}
}
if (!av_bprint_is_complete(bp))
return AVERROR(ENOMEM);
return 0;
}
static int draw_glyphs(DrawTextContext *s, AVFrame *frame,
int width, int height,
FFDrawColor *color,
int x, int y, int borderw)
{
char *text = s->expanded_text.str;
uint32_t code = 0;
int i, x1, y1;
uint8_t *p;
Glyph *glyph = NULL;
for (i = 0, p = text; *p; i++) {
FT_Bitmap bitmap;
Glyph dummy = { 0 };
GET_UTF8(code, *p ? *p++ : 0, code = 0xfffd; goto continue_on_invalid;);
continue_on_invalid:
/* skip new line chars, just go to new line */
if (code == '\n' || code == '\r' || code == '\t')
continue;
dummy.code = code;
dummy.fontsize = s->fontsize;
glyph = av_tree_find(s->glyphs, &dummy, glyph_cmp, NULL);
bitmap = borderw ? glyph->border_bitmap : glyph->bitmap;
if (glyph->bitmap.pixel_mode != FT_PIXEL_MODE_MONO &&
glyph->bitmap.pixel_mode != FT_PIXEL_MODE_GRAY)
return AVERROR(EINVAL);
x1 = s->positions[i].x+s->x+x - borderw;
y1 = s->positions[i].y+s->y+y - borderw;
ff_blend_mask(&s->dc, color,
frame->data, frame->linesize, width, height,
bitmap.buffer, bitmap.pitch,
bitmap.width, bitmap.rows,
bitmap.pixel_mode == FT_PIXEL_MODE_MONO ? 0 : 3,
0, x1, y1);
}
return 0;
}
static void update_color_with_alpha(DrawTextContext *s, FFDrawColor *color, const FFDrawColor incolor)
{
*color = incolor;
color->rgba[3] = (color->rgba[3] * s->alpha) / 255;
ff_draw_color(&s->dc, color, color->rgba);
}
static void update_alpha(DrawTextContext *s)
{
double alpha = av_expr_eval(s->a_pexpr, s->var_values, &s->prng);
if (isnan(alpha))
return;
if (alpha >= 1.0)
s->alpha = 255;
else if (alpha <= 0)
s->alpha = 0;
else
s->alpha = 256 * alpha;
}
static int draw_text(AVFilterContext *ctx, AVFrame *frame,
int width, int height)
{
DrawTextContext *s = ctx->priv;
AVFilterLink *inlink = ctx->inputs[0];
uint32_t code = 0, prev_code = 0;
int x = 0, y = 0, i = 0, ret;
int max_text_line_w = 0, len;
int box_w, box_h;
char *text;
uint8_t *p;
int y_min = 32000, y_max = -32000;
int x_min = 32000, x_max = -32000;
FT_Vector delta;
Glyph *glyph = NULL, *prev_glyph = NULL;
Glyph dummy = { 0 };
time_t now = time(0);
struct tm ltime;
AVBPrint *bp = &s->expanded_text;
FFDrawColor fontcolor;
FFDrawColor shadowcolor;
FFDrawColor bordercolor;
FFDrawColor boxcolor;
av_bprint_clear(bp);
if(s->basetime != AV_NOPTS_VALUE)
now= frame->pts*av_q2d(ctx->inputs[0]->time_base) + s->basetime/1000000;
switch (s->exp_mode) {
case EXP_NONE:
av_bprintf(bp, "%s", s->text);
break;
case EXP_NORMAL:
if ((ret = expand_text(ctx, s->text, &s->expanded_text)) < 0)
return ret;
break;
case EXP_STRFTIME:
localtime_r(&now, &ltime);
av_bprint_strftime(bp, s->text, &ltime);
break;
}
if (s->tc_opt_string) {
char tcbuf[AV_TIMECODE_STR_SIZE];
av_timecode_make_string(&s->tc, tcbuf, inlink->frame_count_out);
av_bprint_clear(bp);
av_bprintf(bp, "%s%s", s->text, tcbuf);
}
if (!av_bprint_is_complete(bp))
return AVERROR(ENOMEM);
text = s->expanded_text.str;
if ((len = s->expanded_text.len) > s->nb_positions) {
if (!(s->positions =
av_realloc(s->positions, len*sizeof(*s->positions))))
return AVERROR(ENOMEM);
s->nb_positions = len;
}
if (s->fontcolor_expr[0]) {
/* If expression is set, evaluate and replace the static value */
av_bprint_clear(&s->expanded_fontcolor);
if ((ret = expand_text(ctx, s->fontcolor_expr, &s->expanded_fontcolor)) < 0)
return ret;
if (!av_bprint_is_complete(&s->expanded_fontcolor))
return AVERROR(ENOMEM);
av_log(s, AV_LOG_DEBUG, "Evaluated fontcolor is '%s'\n", s->expanded_fontcolor.str);
ret = av_parse_color(s->fontcolor.rgba, s->expanded_fontcolor.str, -1, s);
if (ret)
return ret;
ff_draw_color(&s->dc, &s->fontcolor, s->fontcolor.rgba);
}
x = 0;
y = 0;
if ((ret = update_fontsize(ctx)) < 0)
return ret;
/* load and cache glyphs */
for (i = 0, p = text; *p; i++) {
GET_UTF8(code, *p ? *p++ : 0, code = 0xfffd; goto continue_on_invalid;);
continue_on_invalid:
/* get glyph */
dummy.code = code;
dummy.fontsize = s->fontsize;
glyph = av_tree_find(s->glyphs, &dummy, glyph_cmp, NULL);
if (!glyph) {
ret = load_glyph(ctx, &glyph, code);
if (ret < 0)
return ret;
}
y_min = FFMIN(glyph->bbox.yMin, y_min);
y_max = FFMAX(glyph->bbox.yMax, y_max);
x_min = FFMIN(glyph->bbox.xMin, x_min);
x_max = FFMAX(glyph->bbox.xMax, x_max);
}
s->max_glyph_h = y_max - y_min;
s->max_glyph_w = x_max - x_min;
/* compute and save position for each glyph */
glyph = NULL;
for (i = 0, p = text; *p; i++) {
GET_UTF8(code, *p ? *p++ : 0, code = 0xfffd; goto continue_on_invalid2;);
continue_on_invalid2:
/* skip the \n in the sequence \r\n */
if (prev_code == '\r' && code == '\n')
continue;
prev_code = code;
if (is_newline(code)) {
max_text_line_w = FFMAX(max_text_line_w, x);
y += s->max_glyph_h + s->line_spacing;
x = 0;
continue;
}
/* get glyph */
prev_glyph = glyph;
dummy.code = code;
dummy.fontsize = s->fontsize;
glyph = av_tree_find(s->glyphs, &dummy, glyph_cmp, NULL);
/* kerning */
if (s->use_kerning && prev_glyph && glyph->code) {
FT_Get_Kerning(s->face, prev_glyph->code, glyph->code,
ft_kerning_default, &delta);
x += delta.x >> 6;
}
/* save position */
s->positions[i].x = x + glyph->bitmap_left;
s->positions[i].y = y - glyph->bitmap_top + y_max;
if (code == '\t') x = (x / s->tabsize + 1)*s->tabsize;
else x += glyph->advance;
}
max_text_line_w = FFMAX(x, max_text_line_w);
s->var_values[VAR_TW] = s->var_values[VAR_TEXT_W] = max_text_line_w;
s->var_values[VAR_TH] = s->var_values[VAR_TEXT_H] = y + s->max_glyph_h;
s->var_values[VAR_MAX_GLYPH_W] = s->max_glyph_w;
s->var_values[VAR_MAX_GLYPH_H] = s->max_glyph_h;
s->var_values[VAR_MAX_GLYPH_A] = s->var_values[VAR_ASCENT ] = y_max;
s->var_values[VAR_MAX_GLYPH_D] = s->var_values[VAR_DESCENT] = y_min;
s->var_values[VAR_LINE_H] = s->var_values[VAR_LH] = s->max_glyph_h;
if (s->text_source == AV_FRAME_DATA_DETECTION_BBOXES) {
s->var_values[VAR_X] = s->x;
s->var_values[VAR_Y] = s->y;
} else {
s->x = s->var_values[VAR_X] = av_expr_eval(s->x_pexpr, s->var_values, &s->prng);
s->y = s->var_values[VAR_Y] = av_expr_eval(s->y_pexpr, s->var_values, &s->prng);
/* It is necessary if x is expressed from y */
s->x = s->var_values[VAR_X] = av_expr_eval(s->x_pexpr, s->var_values, &s->prng);
}
update_alpha(s);
update_color_with_alpha(s, &fontcolor , s->fontcolor );
update_color_with_alpha(s, &shadowcolor, s->shadowcolor);
update_color_with_alpha(s, &bordercolor, s->bordercolor);
update_color_with_alpha(s, &boxcolor , s->boxcolor );
box_w = max_text_line_w;
box_h = y + s->max_glyph_h;
if (s->fix_bounds) {
/* calculate footprint of text effects */
int boxoffset = s->draw_box ? FFMAX(s->boxborderw, 0) : 0;
int borderoffset = s->borderw ? FFMAX(s->borderw, 0) : 0;
int offsetleft = FFMAX3(boxoffset, borderoffset,
(s->shadowx < 0 ? FFABS(s->shadowx) : 0));
int offsettop = FFMAX3(boxoffset, borderoffset,
(s->shadowy < 0 ? FFABS(s->shadowy) : 0));
int offsetright = FFMAX3(boxoffset, borderoffset,
(s->shadowx > 0 ? s->shadowx : 0));
int offsetbottom = FFMAX3(boxoffset, borderoffset,
(s->shadowy > 0 ? s->shadowy : 0));
if (s->x - offsetleft < 0) s->x = offsetleft;
if (s->y - offsettop < 0) s->y = offsettop;
if (s->x + box_w + offsetright > width)
s->x = FFMAX(width - box_w - offsetright, 0);
if (s->y + box_h + offsetbottom > height)
s->y = FFMAX(height - box_h - offsetbottom, 0);
}
/* draw box */
if (s->draw_box)
ff_blend_rectangle(&s->dc, &boxcolor,
frame->data, frame->linesize, width, height,
s->x - s->boxborderw, s->y - s->boxborderw,
box_w + s->boxborderw * 2, box_h + s->boxborderw * 2);
if (s->shadowx || s->shadowy) {
if ((ret = draw_glyphs(s, frame, width, height,
&shadowcolor, s->shadowx, s->shadowy, 0)) < 0)
return ret;
}
if (s->borderw) {
if ((ret = draw_glyphs(s, frame, width, height,
&bordercolor, 0, 0, s->borderw)) < 0)
return ret;
}
if ((ret = draw_glyphs(s, frame, width, height,
&fontcolor, 0, 0, 0)) < 0)
return ret;
return 0;
}
static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
{
AVFilterContext *ctx = inlink->dst;
AVFilterLink *outlink = ctx->outputs[0];
DrawTextContext *s = ctx->priv;
int ret;
const AVDetectionBBoxHeader *header = NULL;
const AVDetectionBBox *bbox;
AVFrameSideData *sd;
int loop = 1;
if (s->text_source == AV_FRAME_DATA_DETECTION_BBOXES) {
sd = av_frame_get_side_data(frame, AV_FRAME_DATA_DETECTION_BBOXES);
if (sd) {
header = (AVDetectionBBoxHeader *)sd->data;
loop = header->nb_bboxes;
} else {
av_log(s, AV_LOG_WARNING, "No detection bboxes.\n");
return ff_filter_frame(outlink, frame);
}
}
if (s->reload) {
if ((ret = load_textfile(ctx)) < 0) {
av_frame_free(&frame);
return ret;
}
#if CONFIG_LIBFRIBIDI
if (s->text_shaping)
if ((ret = shape_text(ctx)) < 0) {
av_frame_free(&frame);
return ret;
}
#endif
}
s->var_values[VAR_N] = inlink->frame_count_out + s->start_number;
s->var_values[VAR_T] = frame->pts == AV_NOPTS_VALUE ?
NAN : frame->pts * av_q2d(inlink->time_base);
s->var_values[VAR_PICT_TYPE] = frame->pict_type;
s->var_values[VAR_PKT_POS] = frame->pkt_pos;
s->var_values[VAR_PKT_DURATION] = frame->pkt_duration * av_q2d(inlink->time_base);
s->var_values[VAR_PKT_SIZE] = frame->pkt_size;
s->metadata = frame->metadata;
for (int i = 0; i < loop; i++) {
if (header) {
bbox = av_get_detection_bbox(header, i);
strcpy(s->text, bbox->detect_label);
for (int j = 0; j < bbox->classify_count; j++) {
strcat(s->text, ", ");
strcat(s->text, bbox->classify_labels[j]);
}
s->x = bbox->x;
s->y = bbox->y - s->fontsize;
}
draw_text(ctx, frame, frame->width, frame->height);
}
av_log(ctx, AV_LOG_DEBUG, "n:%d t:%f text_w:%d text_h:%d x:%d y:%d\n",
(int)s->var_values[VAR_N], s->var_values[VAR_T],
(int)s->var_values[VAR_TEXT_W], (int)s->var_values[VAR_TEXT_H],
s->x, s->y);
return ff_filter_frame(outlink, frame);
}
static const AVFilterPad avfilter_vf_drawtext_inputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
.flags = AVFILTERPAD_FLAG_NEEDS_WRITABLE,
.filter_frame = filter_frame,
.config_props = config_input,
},
};
static const AVFilterPad avfilter_vf_drawtext_outputs[] = {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
},
};
const AVFilter ff_vf_drawtext = {
.name = "drawtext",
.description = NULL_IF_CONFIG_SMALL("Draw text on top of video frames using libfreetype library."),
.priv_size = sizeof(DrawTextContext),
.priv_class = &drawtext_class,
.init = init,
.uninit = uninit,
FILTER_INPUTS(avfilter_vf_drawtext_inputs),
FILTER_OUTPUTS(avfilter_vf_drawtext_outputs),
FILTER_QUERY_FUNC(query_formats),
.process_command = command,
.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
};
Reference in New Issue View Git Blame Copy Permalink