FFmpeg
vf_drawtext.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2023 Francesco Carusi
3  * Copyright (c) 2011 Stefano Sabatini
4  * Copyright (c) 2010 S.N. Hemanth Meenakshisundaram
5  * Copyright (c) 2003 Gustavo Sverzut Barbieri <gsbarbieri@yahoo.com.br>
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23 
24 /**
25  * @file
26  * drawtext filter, based on the original vhook/drawtext.c
27  * filter by Gustavo Sverzut Barbieri
28  */
29 
30 #include "config.h"
31 
32 #if HAVE_SYS_TIME_H
33 #include <sys/time.h>
34 #endif
35 #include <sys/types.h>
36 #include <sys/stat.h>
37 #include <time.h>
38 #if HAVE_UNISTD_H
39 #include <unistd.h>
40 #endif
41 #include <fenv.h>
42 
43 #if CONFIG_LIBFONTCONFIG
44 #include <fontconfig/fontconfig.h>
45 #endif
46 
47 #include "libavutil/avstring.h"
48 #include "libavutil/bprint.h"
49 #include "libavutil/common.h"
50 #include "libavutil/eval.h"
51 #include "libavutil/mem.h"
52 #include "libavutil/opt.h"
53 #include "libavutil/random_seed.h"
54 #include "libavutil/parseutils.h"
55 #include "libavutil/time.h"
56 #include "libavutil/timecode.h"
57 #include "libavutil/time_internal.h"
58 #include "libavutil/tree.h"
59 #include "libavutil/lfg.h"
60 #include "libavutil/detection_bbox.h"
61 #include "avfilter.h"
62 #include "drawutils.h"
63 #include "formats.h"
64 #include "internal.h"
65 #include "textutils.h"
66 #include "video.h"
67 
68 #if CONFIG_LIBFRIBIDI
69 #include <fribidi.h>
70 #endif
71 
72 #include <ft2build.h>
73 #include FT_FREETYPE_H
74 #include FT_GLYPH_H
75 #include FT_STROKER_H
76 
77 #include <hb.h>
78 #include <hb-ft.h>
79 
80 // Ceiling operation for positive integers division
81 #define POS_CEIL(x, y) ((x)/(y) + ((x)%(y) != 0))
82 
83 static const char *const var_names[] = {
84  "dar",
85  "hsub", "vsub",
86  "line_h", "lh", ///< line height
87  "main_h", "h", "H", ///< height of the input video
88  "main_w", "w", "W", ///< width of the input video
89  "max_glyph_a", "ascent", ///< max glyph ascender
90  "max_glyph_d", "descent", ///< min glyph descender
91  "max_glyph_h", ///< max glyph height
92  "max_glyph_w", ///< max glyph width
93  "font_a", ///< font-defined ascent
94  "font_d", ///< font-defined descent
95  "top_a", ///< max glyph ascender of the top line
96  "bottom_d", ///< max glyph descender of the bottom line
97  "n", ///< number of frame
98  "sar",
99  "t", ///< timestamp expressed in seconds
100  "text_h", "th", ///< height of the rendered text
101  "text_w", "tw", ///< width of the rendered text
102  "x",
103  "y",
104  "pict_type",
105 #if FF_API_FRAME_PKT
106  "pkt_pos",
107 #endif
108 #if FF_API_FRAME_PKT
109  "pkt_size",
110 #endif
111  "duration",
112  NULL
113 };
114 
115 static const char *const fun2_names[] = {
116  "rand"
117 };
118 
119 static double drand(void *opaque, double min, double max)
120 {
121  return min + (max-min) / UINT_MAX * av_lfg_get(opaque);
122 }
123 
124 typedef double (*eval_func2)(void *, double a, double b);
125 
126 static const eval_func2 fun2[] = {
127  drand,
128  NULL
129 };
130 
131 enum var_name {
132  VAR_DAR,
133  VAR_HSUB, VAR_VSUB,
134  VAR_LINE_H, VAR_LH,
135  VAR_MAIN_H, VAR_h, VAR_H,
136  VAR_MAIN_W, VAR_w, VAR_W,
137  VAR_MAX_GLYPH_A, VAR_ASCENT,
138  VAR_MAX_GLYPH_D, VAR_DESCENT,
139  VAR_MAX_GLYPH_H,
140  VAR_MAX_GLYPH_W,
141  VAR_FONT_A,
142  VAR_FONT_D,
143  VAR_TOP_A,
144  VAR_BOTTOM_D,
145  VAR_N,
146  VAR_SAR,
147  VAR_T,
148  VAR_TEXT_H, VAR_TH,
149  VAR_TEXT_W, VAR_TW,
150  VAR_X,
151  VAR_Y,
152  VAR_PICT_TYPE,
153 #if FF_API_FRAME_PKT
154  VAR_PKT_POS,
155 #endif
156 #if FF_API_FRAME_PKT
157  VAR_PKT_SIZE,
158 #endif
159  VAR_DURATION,
160  VAR_VARS_NB
161 };
162 
163 enum expansion_mode {
164  EXP_NONE,
165  EXP_NORMAL,
166  EXP_STRFTIME,
167 };
168 
169 enum y_alignment {
170  YA_TEXT,
171  YA_BASELINE,
172  YA_FONT,
173 };
174 
175 enum text_alignment {
176  TA_LEFT = (1 << 0),
177  TA_RIGHT = (1 << 1),
178  TA_TOP = (1 << 2),
179  TA_BOTTOM = (1 << 3),
180 };
181 
182 typedef struct HarfbuzzData {
183  hb_buffer_t* buf;
184  hb_font_t* font;
185  unsigned int glyph_count;
186  hb_glyph_info_t* glyph_info;
187  hb_glyph_position_t* glyph_pos;
188 } HarfbuzzData;
189 
190 /** Information about a single glyph in a text line */
191 typedef struct GlyphInfo {
192  uint32_t code; ///< the glyph code point
193  int x; ///< the x position of the glyph
194  int y; ///< the y position of the glyph
195  int shift_x64; ///< the horizontal shift of the glyph in 26.6 units
196  int shift_y64; ///< the vertical shift of the glyph in 26.6 units
197 } GlyphInfo;
198 
199 /** Information about a single line of text */
200 typedef struct TextLine {
201  int offset_left64; ///< offset between the origin and
202  /// the leftmost pixel of the first glyph
203  int offset_right64; ///< maximum offset between the origin and
204  /// the rightmost pixel of the last glyph
205  int width64; ///< width of the line
206  HarfbuzzData hb_data; ///< libharfbuzz data of this text line
207  GlyphInfo* glyphs; ///< array of glyphs in this text line
208  int cluster_offset; ///< the offset at which this line begins
209 } TextLine;
210 
211 /** A glyph as loaded and rendered using libfreetype */
212 typedef struct Glyph {
213  FT_Glyph glyph;
214  FT_Glyph border_glyph;
215  uint32_t code;
216  unsigned int fontsize;
217  /** Glyph bitmaps with 1/4 pixel precision in both directions */
218  FT_BitmapGlyph bglyph[16];
219  /** Outlined glyph bitmaps with 1/4 pixel precision in both directions */
220  FT_BitmapGlyph border_bglyph[16];
221  FT_BBox bbox;
222 } Glyph;
223 
224 /** Global text metrics */
225 typedef struct TextMetrics {
226  int offset_top64; ///< ascender amount of the first line (in 26.6 units)
227  int offset_bottom64; ///< descender amount of the last line (in 26.6 units)
228  int offset_left64; ///< maximum offset between the origin and
229  /// the leftmost pixel of the first glyph
230  /// of each line (in 26.6 units)
231  int offset_right64; ///< maximum offset between the origin and
232  /// the rightmost pixel of the last glyph
233  /// of each line (in 26.6 units)
234  int line_height64; ///< the font-defined line height
235  int width; ///< width of the longest line - ceil(width64/64)
236  int height; ///< total height of the text - ceil(height64/64)
237 
238  int min_y64; ///< minimum value of bbox.yMin among glyphs (in 26.6 units)
239  int max_y64; ///< maximum value of bbox.yMax among glyphs (in 26.6 units)
240  int min_x64; ///< minimum value of bbox.xMin among glyphs (in 26.6 units)
241  int max_x64; ///< maximum value of bbox.xMax among glyphs (in 26.6 units)
242 
243  // Position of the background box (without borders)
244  int rect_x; ///< x position of the box
245  int rect_y; ///< y position of the box
246 } TextMetrics;
247 
248 typedef struct DrawTextContext {
249  const AVClass *class;
250  int exp_mode; ///< expansion mode to use for the text
251  FFExpandTextContext expand_text; ///< expand text in case exp_mode == NORMAL
252  int reinit; ///< tells if the filter is being reinited
253 #if CONFIG_LIBFONTCONFIG
254  uint8_t *font; ///< font to be used
255 #endif
256  uint8_t *fontfile; ///< font to be used
257  uint8_t *text; ///< text to be drawn
258  AVBPrint expanded_text; ///< used to contain the expanded text
259  uint8_t *fontcolor_expr; ///< fontcolor expression to evaluate
260  AVBPrint expanded_fontcolor; ///< used to contain the expanded fontcolor spec
261  int ft_load_flags; ///< flags used for loading fonts, see FT_LOAD_*
262  char *textfile; ///< file with text to be drawn
263  double x; ///< x position to start drawing text
264  double y; ///< y position to start drawing text
265  int max_glyph_w; ///< max glyph width
266  int max_glyph_h; ///< max glyph height
267  int shadowx, shadowy;
268  int borderw; ///< border width
269  char *fontsize_expr; ///< expression for fontsize
270  AVExpr *fontsize_pexpr; ///< parsed expressions for fontsize
271  unsigned int fontsize; ///< font size to use
272  unsigned int default_fontsize; ///< default font size to use
273 
274  int line_spacing; ///< lines spacing in pixels
275  short int draw_box; ///< draw box around text - true or false
276  char *boxborderw; ///< box border width (padding)
277  /// allowed formats: "all", "vert|oriz", "top|right|bottom|left"
278  int bb_top; ///< the size of the top box border
279  int bb_right; ///< the size of the right box border
280  int bb_bottom; ///< the size of the bottom box border
281  int bb_left; ///< the size of the left box border
282  int box_width; ///< the width of box
283  int box_height; ///< the height of box
284  int tabsize; ///< tab size
285  int fix_bounds; ///< do we let it go out of frame bounds - t/f
286 
287  FFDrawContext dc;
288  FFDrawColor fontcolor; ///< foreground color
289  FFDrawColor shadowcolor; ///< shadow color
290  FFDrawColor bordercolor; ///< border color
291  FFDrawColor boxcolor; ///< background color
292 
293  FT_Library library; ///< freetype font library handle
294  FT_Face face; ///< freetype font face handle
295  FT_Stroker stroker; ///< freetype stroker handle
296  struct AVTreeNode *glyphs; ///< rendered glyphs, stored using the UTF-32 char code
297  char *x_expr; ///< expression for x position
298  char *y_expr; ///< expression for y position
299  AVExpr *x_pexpr, *y_pexpr; ///< parsed expressions for x and y
300  int64_t basetime; ///< base pts time in the real world for display
301  double var_values[VAR_VARS_NB];
302  char *a_expr;
303  AVExpr *a_pexpr;
304  int alpha;
305  AVLFG prng; ///< random
306  char *tc_opt_string; ///< specified timecode option string
307  AVRational tc_rate; ///< frame rate for timecode
308  AVTimecode tc; ///< timecode context
309  int tc24hmax; ///< 1 if timecode is wrapped to 24 hours, 0 otherwise
310  int reload; ///< reload text file at specified frame interval
311  int start_number; ///< starting frame number for n/frame_num var
312  char *text_source_string; ///< the string to specify text data source
313  enum AVFrameSideDataType text_source;
314 #if CONFIG_LIBFRIBIDI
315  int text_shaping; ///< 1 to shape the text before drawing it
316 #endif
317  AVDictionary *metadata;
318 
319  int boxw; ///< the value of the boxw parameter
320  int boxh; ///< the value of the boxh parameter
321  int text_align; ///< the horizontal and vertical text alignment
322  int y_align; ///< the value of the y_align parameter
323 
324  TextLine *lines; ///< computed information about text lines
325  int line_count; ///< the number of text lines
326  uint32_t *tab_clusters; ///< the position of tab characters in the text
327  int tab_count; ///< the number of tab characters
328  int blank_advance64; ///< the size of the space character
329  int tab_warning_printed; ///< ensure the tab warning to be printed only once
330 } DrawTextContext;
331 
332 #define OFFSET(x) offsetof(DrawTextContext, x)
333 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
334 #define TFLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
335 
336 static const AVOption drawtext_options[]= {
337  {"fontfile", "set font file", OFFSET(fontfile), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS},
338  {"text", "set text", OFFSET(text), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, TFLAGS},
339  {"textfile", "set text file", OFFSET(textfile), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS},
340  {"fontcolor", "set foreground color", OFFSET(fontcolor.rgba), AV_OPT_TYPE_COLOR, {.str="black"}, 0, 0, TFLAGS},
341  {"fontcolor_expr", "set foreground color expression", OFFSET(fontcolor_expr), AV_OPT_TYPE_STRING, {.str=""}, 0, 0, FLAGS},
342  {"boxcolor", "set box color", OFFSET(boxcolor.rgba), AV_OPT_TYPE_COLOR, {.str="white"}, 0, 0, TFLAGS},
343  {"bordercolor", "set border color", OFFSET(bordercolor.rgba), AV_OPT_TYPE_COLOR, {.str="black"}, 0, 0, TFLAGS},
344  {"shadowcolor", "set shadow color", OFFSET(shadowcolor.rgba), AV_OPT_TYPE_COLOR, {.str="black"}, 0, 0, TFLAGS},
345  {"box", "set box", OFFSET(draw_box), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, TFLAGS},
346  {"boxborderw", "set box borders width", OFFSET(boxborderw), AV_OPT_TYPE_STRING, {.str="0"}, 0, 0, TFLAGS},
347  {"line_spacing", "set line spacing in pixels", OFFSET(line_spacing), AV_OPT_TYPE_INT, {.i64=0}, INT_MIN, INT_MAX, TFLAGS},
348  {"fontsize", "set font size", OFFSET(fontsize_expr), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, TFLAGS},
349  {"text_align", "set text alignment", OFFSET(text_align), AV_OPT_TYPE_FLAGS, {.i64=0}, 0, (TA_LEFT|TA_RIGHT|TA_TOP|TA_BOTTOM), TFLAGS, .unit = "text_align"},
350  { "left", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = TA_LEFT }, .flags = TFLAGS, .unit = "text_align" },
351  { "L", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = TA_LEFT }, .flags = TFLAGS, .unit = "text_align" },
352  { "right", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = TA_RIGHT }, .flags = TFLAGS, .unit = "text_align" },
353  { "R", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = TA_RIGHT }, .flags = TFLAGS, .unit = "text_align" },
354  { "center", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = (TA_LEFT|TA_RIGHT) }, .flags = TFLAGS, .unit = "text_align" },
355  { "C", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = (TA_LEFT|TA_RIGHT) }, .flags = TFLAGS, .unit = "text_align" },
356  { "top", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = TA_TOP }, .flags = TFLAGS, .unit = "text_align" },
357  { "T", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = TA_TOP }, .flags = TFLAGS, .unit = "text_align" },
358  { "bottom", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = TA_BOTTOM }, .flags = TFLAGS, .unit = "text_align" },
359  { "B", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = TA_BOTTOM }, .flags = TFLAGS, .unit = "text_align" },
360  { "middle", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = (TA_TOP|TA_BOTTOM) }, .flags = TFLAGS, .unit = "text_align" },
361  { "M", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = (TA_TOP|TA_BOTTOM) }, .flags = TFLAGS, .unit = "text_align" },
362  {"x", "set x expression", OFFSET(x_expr), AV_OPT_TYPE_STRING, {.str="0"}, 0, 0, TFLAGS},
363  {"y", "set y expression", OFFSET(y_expr), AV_OPT_TYPE_STRING, {.str="0"}, 0, 0, TFLAGS},
364  {"boxw", "set box width", OFFSET(boxw), AV_OPT_TYPE_INT, {.i64=0}, 0, INT_MAX, TFLAGS},
365  {"boxh", "set box height", OFFSET(boxh), AV_OPT_TYPE_INT, {.i64=0}, 0, INT_MAX, TFLAGS},
366  {"shadowx", "set shadow x offset", OFFSET(shadowx), AV_OPT_TYPE_INT, {.i64=0}, INT_MIN, INT_MAX, TFLAGS},
367  {"shadowy", "set shadow y offset", OFFSET(shadowy), AV_OPT_TYPE_INT, {.i64=0}, INT_MIN, INT_MAX, TFLAGS},
368  {"borderw", "set border width", OFFSET(borderw), AV_OPT_TYPE_INT, {.i64=0}, INT_MIN, INT_MAX, TFLAGS},
369  {"tabsize", "set tab size", OFFSET(tabsize), AV_OPT_TYPE_INT, {.i64=4}, 0, INT_MAX, TFLAGS},
370  {"basetime", "set base time", OFFSET(basetime), AV_OPT_TYPE_INT64, {.i64=AV_NOPTS_VALUE}, INT64_MIN, INT64_MAX, FLAGS},
371 #if CONFIG_LIBFONTCONFIG
372  { "font", "Font name", OFFSET(font), AV_OPT_TYPE_STRING, { .str = "Sans" }, .flags = FLAGS },
373 #endif
374 
375  {"expansion", "set the expansion mode", OFFSET(exp_mode), AV_OPT_TYPE_INT, {.i64=EXP_NORMAL}, 0, 2, FLAGS, .unit = "expansion"},
376  {"none", "set no expansion", OFFSET(exp_mode), AV_OPT_TYPE_CONST, {.i64=EXP_NONE}, 0, 0, FLAGS, .unit = "expansion"},
377  {"normal", "set normal expansion", OFFSET(exp_mode), AV_OPT_TYPE_CONST, {.i64=EXP_NORMAL}, 0, 0, FLAGS, .unit = "expansion"},
378  {"strftime", "set strftime expansion (deprecated)", OFFSET(exp_mode), AV_OPT_TYPE_CONST, {.i64=EXP_STRFTIME}, 0, 0, FLAGS, .unit = "expansion"},
379  {"y_align", "set the y alignment", OFFSET(y_align), AV_OPT_TYPE_INT, {.i64=YA_TEXT}, 0, 2, TFLAGS, .unit = "y_align"},
380  {"text", "y is referred to the top of the first text line", OFFSET(y_align), AV_OPT_TYPE_CONST, {.i64=YA_TEXT}, 0, 0, FLAGS, .unit = "y_align"},
381  {"baseline", "y is referred to the baseline of the first line", OFFSET(y_align), AV_OPT_TYPE_CONST, {.i64=YA_BASELINE}, 0, 0, FLAGS, .unit = "y_align"},
382  {"font", "y is referred to the font defined line metrics", OFFSET(y_align), AV_OPT_TYPE_CONST, {.i64=YA_FONT}, 0, 0, FLAGS, .unit = "y_align"},
383 
384  {"timecode", "set initial timecode", OFFSET(tc_opt_string), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS},
385  {"tc24hmax", "set 24 hours max (timecode only)", OFFSET(tc24hmax), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
386  {"timecode_rate", "set rate (timecode only)", OFFSET(tc_rate), AV_OPT_TYPE_RATIONAL, {.dbl=0}, 0, INT_MAX, FLAGS},
387  {"r", "set rate (timecode only)", OFFSET(tc_rate), AV_OPT_TYPE_RATIONAL, {.dbl=0}, 0, INT_MAX, FLAGS},
388  {"rate", "set rate (timecode only)", OFFSET(tc_rate), AV_OPT_TYPE_RATIONAL, {.dbl=0}, 0, INT_MAX, FLAGS},
389  {"reload", "reload text file at specified frame interval", OFFSET(reload), AV_OPT_TYPE_INT, {.i64=0}, 0, INT_MAX, FLAGS},
390  {"alpha", "apply alpha while rendering", OFFSET(a_expr), AV_OPT_TYPE_STRING, {.str = "1"}, .flags = TFLAGS},
391  {"fix_bounds", "check and fix text coords to avoid clipping", OFFSET(fix_bounds), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, FLAGS},
392  {"start_number", "start frame number for n/frame_num variable", OFFSET(start_number), AV_OPT_TYPE_INT, {.i64=0}, 0, INT_MAX, FLAGS},
393  {"text_source", "the source of text", OFFSET(text_source_string), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 1, FLAGS },
394 
395 #if CONFIG_LIBFRIBIDI
396  {"text_shaping", "attempt to shape text before drawing", OFFSET(text_shaping), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, FLAGS},
397 #endif
398 
399  /* FT_LOAD_* flags */
400  { "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, .unit = "ft_load_flags" },
401  { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_DEFAULT }, .flags = FLAGS, .unit = "ft_load_flags" },
402  { "no_scale", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_NO_SCALE }, .flags = FLAGS, .unit = "ft_load_flags" },
403  { "no_hinting", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_NO_HINTING }, .flags = FLAGS, .unit = "ft_load_flags" },
404  { "render", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_RENDER }, .flags = FLAGS, .unit = "ft_load_flags" },
405  { "no_bitmap", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_NO_BITMAP }, .flags = FLAGS, .unit = "ft_load_flags" },
406  { "vertical_layout", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_VERTICAL_LAYOUT }, .flags = FLAGS, .unit = "ft_load_flags" },
407  { "force_autohint", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_FORCE_AUTOHINT }, .flags = FLAGS, .unit = "ft_load_flags" },
408  { "crop_bitmap", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_CROP_BITMAP }, .flags = FLAGS, .unit = "ft_load_flags" },
409  { "pedantic", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_PEDANTIC }, .flags = FLAGS, .unit = "ft_load_flags" },
410  { "ignore_global_advance_width", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH }, .flags = FLAGS, .unit = "ft_load_flags" },
411  { "no_recurse", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_NO_RECURSE }, .flags = FLAGS, .unit = "ft_load_flags" },
412  { "ignore_transform", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_IGNORE_TRANSFORM }, .flags = FLAGS, .unit = "ft_load_flags" },
413  { "monochrome", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_MONOCHROME }, .flags = FLAGS, .unit = "ft_load_flags" },
414  { "linear_design", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_LINEAR_DESIGN }, .flags = FLAGS, .unit = "ft_load_flags" },
415  { "no_autohint", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_NO_AUTOHINT }, .flags = FLAGS, .unit = "ft_load_flags" },
416  { NULL }
417 };
418 
419 AVFILTER_DEFINE_CLASS(drawtext);
420 
421 #undef __FTERRORS_H__
422 #define FT_ERROR_START_LIST {
423 #define FT_ERRORDEF(e, v, s) { (e), (s) },
424 #define FT_ERROR_END_LIST { 0, NULL } };
425 
426 static const struct ft_error {
427  int err;
428  const char *err_msg;
429 } ft_errors[] =
430 #include FT_ERRORS_H
431 
432 #define FT_ERRMSG(e) ft_errors[e].err_msg
433 
434 static int glyph_cmp(const void *key, const void *b)
435 {
436  const Glyph *a = key, *bb = b;
437  int64_t diff = (int64_t)a->code - (int64_t)bb->code;
438 
439  if (diff != 0)
440  return diff > 0 ? 1 : -1;
441  else
442  return FFDIFFSIGN((int64_t)a->fontsize, (int64_t)bb->fontsize);
443 }
444 
445 static av_cold int set_fontsize(AVFilterContext *ctx, unsigned int fontsize)
446 {
447  int err;
448  DrawTextContext *s = ctx->priv;
449 
450  if ((err = FT_Set_Pixel_Sizes(s->face, 0, fontsize))) {
451  av_log(ctx, AV_LOG_ERROR, "Could not set font size to %d pixels: %s\n",
452  fontsize, FT_ERRMSG(err));
453  return AVERROR(EINVAL);
454  }
455 
456  s->fontsize = fontsize;
457 
458  return 0;
459 }
460 
461 static av_cold int parse_fontsize(AVFilterContext *ctx)
462 {
463  DrawTextContext *s = ctx->priv;
464  int err;
465 
466  if (s->fontsize_pexpr)
467  return 0;
468 
469  if (s->fontsize_expr == NULL)
470  return AVERROR(EINVAL);
471 
472  if ((err = av_expr_parse(&s->fontsize_pexpr, s->fontsize_expr, var_names,
473  NULL, NULL, fun2_names, fun2, 0, ctx)) < 0)
474  return err;
475 
476  return 0;
477 }
478 
479 static av_cold int update_fontsize(AVFilterContext *ctx)
480 {
481  DrawTextContext *s = ctx->priv;
482  unsigned int fontsize = s->default_fontsize;
483  int err;
484  double size, roundedsize;
485 
486  // if no fontsize specified use the default
487  if (s->fontsize_expr != NULL) {
488  if ((err = parse_fontsize(ctx)) < 0)
489  return err;
490 
491  size = av_expr_eval(s->fontsize_pexpr, s->var_values, &s->prng);
492  if (!isnan(size)) {
493  roundedsize = round(size);
494  // test for overflow before cast
495  if (!(roundedsize > INT_MIN && roundedsize < INT_MAX)) {
496  av_log(ctx, AV_LOG_ERROR, "fontsize overflow\n");
497  return AVERROR(EINVAL);
498  }
499  fontsize = roundedsize;
500  }
501  }
502 
503  if (fontsize == 0)
504  fontsize = 1;
505 
506  // no change
507  if (fontsize == s->fontsize)
508  return 0;
509 
510  return set_fontsize(ctx, fontsize);
511 }
512 
513 static int load_font_file(AVFilterContext *ctx, const char *path, int index)
514 {
515  DrawTextContext *s = ctx->priv;
516  int err;
517 
518  err = FT_New_Face(s->library, path, index, &s->face);
519  if (err) {
520 #if !CONFIG_LIBFONTCONFIG
521  av_log(ctx, AV_LOG_ERROR, "Could not load font \"%s\": %s\n",
522  s->fontfile, FT_ERRMSG(err));
523 #endif
524  return AVERROR(EINVAL);
525  }
526  return 0;
527 }
528 
529 #if CONFIG_LIBFONTCONFIG
530 static int load_font_fontconfig(AVFilterContext *ctx)
531 {
532  DrawTextContext *s = ctx->priv;
533  FcConfig *fontconfig;
534  FcPattern *pat, *best;
535  FcResult result = FcResultMatch;
536  FcChar8 *filename;
537  int index;
538  double size;
539  int err = AVERROR(ENOENT);
540  int parse_err;
541 
542  fontconfig = FcInitLoadConfigAndFonts();
543  if (!fontconfig) {
544  av_log(ctx, AV_LOG_ERROR, "impossible to init fontconfig\n");
545  return AVERROR_UNKNOWN;
546  }
547  pat = FcNameParse(s->fontfile ? s->fontfile :
548  (uint8_t *)(intptr_t)"default");
549  if (!pat) {
550  av_log(ctx, AV_LOG_ERROR, "could not parse fontconfig pat");
551  return AVERROR(EINVAL);
552  }
553 
554  FcPatternAddString(pat, FC_FAMILY, s->font);
555 
556  parse_err = parse_fontsize(ctx);
557  if (!parse_err) {
558  double size = av_expr_eval(s->fontsize_pexpr, s->var_values, &s->prng);
559 
560  if (isnan(size)) {
561  av_log(ctx, AV_LOG_ERROR, "impossible to find font information");
562  return AVERROR(EINVAL);
563  }
564 
565  FcPatternAddDouble(pat, FC_SIZE, size);
566  }
567 
568  FcDefaultSubstitute(pat);
569 
570  if (!FcConfigSubstitute(fontconfig, pat, FcMatchPattern)) {
571  av_log(ctx, AV_LOG_ERROR, "could not substitue fontconfig options"); /* very unlikely */
572  FcPatternDestroy(pat);
573  return AVERROR(ENOMEM);
574  }
575 
576  best = FcFontMatch(fontconfig, pat, &result);
577  FcPatternDestroy(pat);
578 
579  if (!best || result != FcResultMatch) {
580  av_log(ctx, AV_LOG_ERROR,
581  "Cannot find a valid font for the family %s\n",
582  s->font);
583  goto fail;
584  }
585 
586  if (
587  FcPatternGetInteger(best, FC_INDEX, 0, &index ) != FcResultMatch ||
588  FcPatternGetDouble (best, FC_SIZE, 0, &size ) != FcResultMatch) {
589  av_log(ctx, AV_LOG_ERROR, "impossible to find font information");
590  return AVERROR(EINVAL);
591  }
592 
593  if (FcPatternGetString(best, FC_FILE, 0, &filename) != FcResultMatch) {
594  av_log(ctx, AV_LOG_ERROR, "No file path for %s\n",
595  s->font);
596  goto fail;
597  }
598 
599  av_log(ctx, AV_LOG_VERBOSE, "Using \"%s\"\n", filename);
600  if (parse_err)
601  s->default_fontsize = size + 0.5;
602 
603  err = load_font_file(ctx, filename, index);
604  if (err)
605  return err;
606  FcConfigDestroy(fontconfig);
607 fail:
608  FcPatternDestroy(best);
609  return err;
610 }
611 #endif
612 
613 static int load_font(AVFilterContext *ctx)
614 {
615  DrawTextContext *s = ctx->priv;
616  int err;
617 
618  /* load the face, and set up the encoding, which is by default UTF-8 */
619  err = load_font_file(ctx, s->fontfile, 0);
620  if (!err)
621  return 0;
622 #if CONFIG_LIBFONTCONFIG
623  err = load_font_fontconfig(ctx);
624  if (!err)
625  return 0;
626 #endif
627  return err;
628 }
629 
630 #if CONFIG_LIBFRIBIDI
631 static int shape_text(AVFilterContext *ctx)
632 {
633  DrawTextContext *s = ctx->priv;
634  uint8_t *tmp;
635  int ret = AVERROR(ENOMEM);
636  static const FriBidiFlags flags = FRIBIDI_FLAGS_DEFAULT |
637  FRIBIDI_FLAGS_ARABIC;
638  FriBidiChar *unicodestr = NULL;
639  FriBidiStrIndex len;
640  FriBidiParType direction = FRIBIDI_PAR_LTR;
641  FriBidiStrIndex line_start = 0;
642  FriBidiStrIndex line_end = 0;
643  FriBidiLevel *embedding_levels = NULL;
644  FriBidiArabicProp *ar_props = NULL;
645  FriBidiCharType *bidi_types = NULL;
646  FriBidiStrIndex i,j;
647 
648  len = strlen(s->text);
649  if (!(unicodestr = av_malloc_array(len, sizeof(*unicodestr)))) {
650  goto out;
651  }
652  len = fribidi_charset_to_unicode(FRIBIDI_CHAR_SET_UTF8,
653  s->text, len, unicodestr);
654 
655  bidi_types = av_malloc_array(len, sizeof(*bidi_types));
656  if (!bidi_types) {
657  goto out;
658  }
659 
660  fribidi_get_bidi_types(unicodestr, len, bidi_types);
661 
662  embedding_levels = av_malloc_array(len, sizeof(*embedding_levels));
663  if (!embedding_levels) {
664  goto out;
665  }
666 
667  if (!fribidi_get_par_embedding_levels(bidi_types, len, &direction,
668  embedding_levels)) {
669  goto out;
670  }
671 
672  ar_props = av_malloc_array(len, sizeof(*ar_props));
673  if (!ar_props) {
674  goto out;
675  }
676 
677  fribidi_get_joining_types(unicodestr, len, ar_props);
678  fribidi_join_arabic(bidi_types, len, embedding_levels, ar_props);
679  fribidi_shape(flags, embedding_levels, len, ar_props, unicodestr);
680 
681  for (line_end = 0, line_start = 0; line_end < len; line_end++) {
682  if (ff_is_newline(unicodestr[line_end]) || line_end == len - 1) {
683  if (!fribidi_reorder_line(flags, bidi_types,
684  line_end - line_start + 1, line_start,
685  direction, embedding_levels, unicodestr,
686  NULL)) {
687  goto out;
688  }
689  line_start = line_end + 1;
690  }
691  }
692 
693  /* Remove zero-width fill chars put in by libfribidi */
694  for (i = 0, j = 0; i < len; i++)
695  if (unicodestr[i] != FRIBIDI_CHAR_FILL)
696  unicodestr[j++] = unicodestr[i];
697  len = j;
698 
699  if (!(tmp = av_realloc(s->text, (len * 4 + 1) * sizeof(*s->text)))) {
700  /* Use len * 4, as a unicode character can be up to 4 bytes in UTF-8 */
701  goto out;
702  }
703 
704  s->text = tmp;
705  len = fribidi_unicode_to_charset(FRIBIDI_CHAR_SET_UTF8,
706  unicodestr, len, s->text);
707 
708  ret = 0;
709 
710 out:
711  av_free(unicodestr);
712  av_free(embedding_levels);
713  av_free(ar_props);
714  av_free(bidi_types);
715  return ret;
716 }
717 #endif
718 
719 static enum AVFrameSideDataType text_source_string_parse(const char *text_source_string)
720 {
721  av_assert0(text_source_string);
722  if (!strcmp(text_source_string, "side_data_detection_bboxes")) {
723  return AV_FRAME_DATA_DETECTION_BBOXES;
724  } else {
725  return AVERROR(EINVAL);
726  }
727 }
728 
729 static inline int get_subpixel_idx(int shift_x64, int shift_y64)
730 {
731  int idx = (shift_x64 >> 2) + (shift_y64 >> 4);
732  return idx;
733 }
734 
735 // Loads and (optionally) renders a glyph
736 static int load_glyph(AVFilterContext *ctx, Glyph **glyph_ptr, uint32_t code, int8_t shift_x64, int8_t shift_y64)
737 {
738  DrawTextContext *s = ctx->priv;
739  Glyph dummy = { 0 };
740  Glyph *glyph;
741  FT_Vector shift;
742  struct AVTreeNode *node = NULL;
743  int ret = 0;
744 
745  /* get glyph */
746  dummy.code = code;
747  dummy.fontsize = s->fontsize;
748  glyph = av_tree_find(s->glyphs, &dummy, glyph_cmp, NULL);
749  if (!glyph) {
750  if (FT_Load_Glyph(s->face, code, s->ft_load_flags)) {
751  return AVERROR(EINVAL);
752  }
753  glyph = av_mallocz(sizeof(*glyph));
754  if (!glyph) {
755  ret = AVERROR(ENOMEM);
756  goto error;
757  }
758  glyph->code = code;
759  glyph->fontsize = s->fontsize;
760  if (FT_Get_Glyph(s->face->glyph, &glyph->glyph)) {
761  ret = AVERROR(EINVAL);
762  goto error;
763  }
764  if (s->borderw) {
765  glyph->border_glyph = glyph->glyph;
766  if (FT_Glyph_StrokeBorder(&glyph->border_glyph, s->stroker, 0, 0)) {
767  ret = AVERROR_EXTERNAL;
768  goto error;
769  }
770  }
771  /* measure text height to calculate text_height (or the maximum text height) */
772  FT_Glyph_Get_CBox(glyph->glyph, FT_GLYPH_BBOX_SUBPIXELS, &glyph->bbox);
773 
774  /* cache the newly created glyph */
775  if (!(node = av_tree_node_alloc())) {
776  ret = AVERROR(ENOMEM);
777  goto error;
778  }
779  av_tree_insert(&s->glyphs, glyph, glyph_cmp, &node);
780  } else {
781  if (s->borderw && !glyph->border_glyph) {
782  glyph->border_glyph = glyph->glyph;
783  if (FT_Glyph_StrokeBorder(&glyph->border_glyph, s->stroker, 0, 0)) {
784  ret = AVERROR_EXTERNAL;
785  goto error;
786  }
787  }
788  }
789 
790  // Check if a bitmap is needed
791  if (shift_x64 >= 0 && shift_y64 >= 0) {
792  // Get the bitmap subpixel index (0 -> 15)
793  int idx = get_subpixel_idx(shift_x64, shift_y64);
794  shift.x = shift_x64;
795  shift.y = shift_y64;
796 
797  if (!glyph->bglyph[idx]) {
798  FT_Glyph tmp_glyph = glyph->glyph;
799  if (FT_Glyph_To_Bitmap(&tmp_glyph, FT_RENDER_MODE_NORMAL, &shift, 0)) {
800  ret = AVERROR_EXTERNAL;
801  goto error;
802  }
803  glyph->bglyph[idx] = (FT_BitmapGlyph)tmp_glyph;
804  if (glyph->bglyph[idx]->bitmap.pixel_mode == FT_PIXEL_MODE_MONO) {
805  av_log(ctx, AV_LOG_ERROR, "Monocromatic (1bpp) fonts are not supported.\n");
806  ret = AVERROR(EINVAL);
807  goto error;
808  }
809  }
810  if (s->borderw && !glyph->border_bglyph[idx]) {
811  FT_Glyph tmp_glyph = glyph->border_glyph;
812  if (FT_Glyph_To_Bitmap(&tmp_glyph, FT_RENDER_MODE_NORMAL, &shift, 0)) {
813  ret = AVERROR_EXTERNAL;
814  goto error;
815  }
816  glyph->border_bglyph[idx] = (FT_BitmapGlyph)tmp_glyph;
817  }
818  }
819  if (glyph_ptr) {
820  *glyph_ptr = glyph;
821  }
822  return 0;
823 
824 error:
825  if (glyph && glyph->glyph)
826  FT_Done_Glyph(glyph->glyph);
827 
828  av_freep(&glyph);
829  av_freep(&node);
830  return ret;
831 }
832 
833 // Convert a string formatted as "n1|n2|...|nN" into an integer array
834 static int string_to_array(const char *source, int *result, int result_size)
835 {
836  int counter = 0, size = strlen(source) + 1;
837  char *saveptr, *curval, *dup = av_malloc(size);
838  if (!dup)
839  return 0;
840  av_strlcpy(dup, source, size);
841  if (result_size > 0 && (curval = av_strtok(dup, "|", &saveptr))) {
842  do {
843  result[counter++] = atoi(curval);
844  } while ((curval = av_strtok(NULL, "|", &saveptr)) && counter < result_size);
845  }
846  av_free(dup);
847  return counter;
848 }
849 
850 static int func_pict_type(void *ctx, AVBPrint *bp, const char *function_name, unsigned argc, char **argv)
851 {
852  DrawTextContext *s = ((AVFilterContext *)ctx)->priv;
853 
854  av_bprintf(bp, "%c", av_get_picture_type_char(s->var_values[VAR_PICT_TYPE]));
855  return 0;
856 }
857 
858 static int func_pts(void *ctx, AVBPrint *bp, const char *function_name, unsigned argc, char **argv)
859 {
860  DrawTextContext *s = ((AVFilterContext *)ctx)->priv;
861  const char *fmt;
862  const char *strftime_fmt = NULL;
863  const char *delta = NULL;
864  double pts = s->var_values[VAR_T];
865 
866  // argv: pts, FMT, [DELTA, 24HH | strftime_fmt]
867 
868  fmt = argc >= 1 ? argv[0] : "flt";
869  if (argc >= 2) {
870  delta = argv[1];
871  }
872  if (argc >= 3) {
873  if (!strcmp(fmt, "hms")) {
874  if (!strcmp(argv[2], "24HH")) {
875  av_log(ctx, AV_LOG_WARNING, "pts third argument 24HH is deprected, use pts:hms24hh instead\n");
876  fmt = "hms24";
877  } else {
878  av_log(ctx, AV_LOG_ERROR, "Invalid argument '%s', '24HH' was expected\n", argv[2]);
879  return AVERROR(EINVAL);
880  }
881  } else {
882  strftime_fmt = argv[2];
883  }
884  }
885 
886  return ff_print_pts(ctx, bp, pts, delta, fmt, strftime_fmt);
887 }
888 
889 static int func_frame_num(void *ctx, AVBPrint *bp, const char *function_name, unsigned argc, char **argv)
890 {
891  DrawTextContext *s = ((AVFilterContext *)ctx)->priv;
892 
893  av_bprintf(bp, "%d", (int)s->var_values[VAR_N]);
894  return 0;
895 }
896 
897 static int func_metadata(void *ctx, AVBPrint *bp, const char *function_name, unsigned argc, char **argv)
898 {
899  DrawTextContext *s = ((AVFilterContext *)ctx)->priv;
900  AVDictionaryEntry *e = av_dict_get(s->metadata, argv[0], NULL, 0);
901 
902  if (e && e->value)
903  av_bprintf(bp, "%s", e->value);
904  else if (argc >= 2)
905  av_bprintf(bp, "%s", argv[1]);
906  return 0;
907 }
908 
909 static int func_strftime(void *ctx, AVBPrint *bp, const char *function_name, unsigned argc, char **argv)
910 {
911  const char *strftime_fmt = argc ? argv[0] : NULL;
912 
913  return ff_print_time(ctx, bp, strftime_fmt, !strcmp(function_name, "localtime"));
914 }
915 
916 static int func_eval_expr(void *ctx, AVBPrint *bp, const char *function_name, unsigned argc, char **argv)
917 {
918  DrawTextContext *s = ((AVFilterContext *)ctx)->priv;
919 
920  return ff_print_eval_expr(ctx, bp, argv[0],
921  fun2_names, fun2,
922  var_names, s->var_values, &s->prng);
923 }
924 
925 static int func_eval_expr_int_format(void *ctx, AVBPrint *bp, const char *function_name, unsigned argc, char **argv)
926 {
927  DrawTextContext *s = ((AVFilterContext *)ctx)->priv;
928  int ret;
929  int positions = -1;
930 
931  /*
932  * argv[0] expression to be converted to `int`
933  * argv[1] format: 'x', 'X', 'd' or 'u'
934  * argv[2] positions printed (optional)
935  */
936 
937  if (argc == 3) {
938  ret = sscanf(argv[2], "%u", &positions);
939  if (ret != 1) {
940  av_log(ctx, AV_LOG_ERROR, "expr_int_format(): Invalid number of positions"
941  " to print: '%s'\n", argv[2]);
942  return AVERROR(EINVAL);
943  }
944  }
945 
946  return ff_print_formatted_eval_expr(ctx, bp, argv[0],
947  fun2_names, fun2,
948  var_names, s->var_values,
949  &s->prng,
950  argv[1][0], positions);
951 }
952 
953 static FFExpandTextFunction expand_text_functions[] = {
954  { "e", 1, 1, func_eval_expr },
955  { "eif", 2, 3, func_eval_expr_int_format },
956  { "expr", 1, 1, func_eval_expr },
957  { "expr_int_format", 2, 3, func_eval_expr_int_format },
958  { "frame_num", 0, 0, func_frame_num },
959  { "gmtime", 0, 1, func_strftime },
960  { "localtime", 0, 1, func_strftime },
961  { "metadata", 1, 2, func_metadata },
962  { "n", 0, 0, func_frame_num },
963  { "pict_type", 0, 0, func_pict_type },
964  { "pts", 0, 3, func_pts }
965 };
966 
967 static av_cold int init(AVFilterContext *ctx)
968 {
969  int err;
970  DrawTextContext *s = ctx->priv;
971 
972  av_expr_free(s->fontsize_pexpr);
973  s->fontsize_pexpr = NULL;
974 
975  s->fontsize = 0;
976  s->default_fontsize = 16;
977 
978  if (!s->fontfile && !CONFIG_LIBFONTCONFIG) {
979  av_log(ctx, AV_LOG_ERROR, "No font filename provided\n");
980  return AVERROR(EINVAL);
981  }
982 
983  if (s->textfile) {
984  if (s->text) {
985  av_log(ctx, AV_LOG_ERROR,
986  "Both text and text file provided. Please provide only one\n");
987  return AVERROR(EINVAL);
988  }
989  if ((err = ff_load_textfile(ctx, (const char *)s->textfile, &s->text, NULL)) < 0)
990  return err;
991  }
992 
993  if (s->reload && !s->textfile)
994  av_log(ctx, AV_LOG_WARNING, "No file to reload\n");
995 
996  if (s->tc_opt_string) {
997  int ret = av_timecode_init_from_string(&s->tc, s->tc_rate,
998  s->tc_opt_string, ctx);
999  if (ret < 0)
1000  return ret;
1001  if (s->tc24hmax)
1002  s->tc.flags |= AV_TIMECODE_FLAG_24HOURSMAX;
1003  if (!s->text)
1004  s->text = av_strdup("");
1005  }
1006 
1007  if (s->text_source_string) {
1008  s->text_source = text_source_string_parse(s->text_source_string);
1009  if ((int)s->text_source < 0) {
1010  av_log(ctx, AV_LOG_ERROR, "Error text source: %s\n", s->text_source_string);
1011  return AVERROR(EINVAL);
1012  }
1013  }
1014 
1015  if (s->text_source == AV_FRAME_DATA_DETECTION_BBOXES) {
1016  if (s->text) {
1017  av_log(ctx, AV_LOG_WARNING, "Multiple texts provided, will use text_source only\n");
1018  av_free(s->text);
1019  }
1020  s->text = av_mallocz(AV_DETECTION_BBOX_LABEL_NAME_MAX_SIZE *
1021  (AV_NUM_DETECTION_BBOX_CLASSIFY + 1));
1022  if (!s->text)
1023  return AVERROR(ENOMEM);
1024  }
1025 
1026  if (!s->text) {
1027  av_log(ctx, AV_LOG_ERROR,
1028  "Either text, a valid file, a timecode or text source must be provided\n");
1029  return AVERROR(EINVAL);
1030  }
1031 
1032  s->expand_text = (FFExpandTextContext) {
1033  .log_ctx = ctx,
1034  .functions = expand_text_functions,
1035  .functions_nb = FF_ARRAY_ELEMS(expand_text_functions)
1036  };
1037 
1038 #if CONFIG_LIBFRIBIDI
1039  if (s->text_shaping)
1040  if ((err = shape_text(ctx)) < 0)
1041  return err;
1042 #endif
1043 
1044  if ((err = FT_Init_FreeType(&(s->library)))) {
1045  av_log(ctx, AV_LOG_ERROR,
1046  "Could not load FreeType: %s\n", FT_ERRMSG(err));
1047  return AVERROR(EINVAL);
1048  }
1049 
1050  if ((err = load_font(ctx)) < 0)
1051  return err;
1052 
1053  if ((err = update_fontsize(ctx)) < 0)
1054  return err;
1055 
1056  // Always init the stroker, may be needed if borderw is set via command
1057  if (FT_Stroker_New(s->library, &s->stroker)) {
1058  av_log(ctx, AV_LOG_ERROR, "Could not init FT stroker\n");
1059  return AVERROR_EXTERNAL;
1060  }
1061 
1062  if (s->borderw) {
1063  FT_Stroker_Set(s->stroker, s->borderw << 6, FT_STROKER_LINECAP_ROUND,
1064  FT_STROKER_LINEJOIN_ROUND, 0);
1065  }
1066 
1067  /* load the fallback glyph with code 0 */
1068  load_glyph(ctx, NULL, 0, 0, 0);
1069 
1070  if (s->exp_mode == EXP_STRFTIME &&
1071  (strchr(s->text, '%') || strchr(s->text, '\\')))
1072  av_log(ctx, AV_LOG_WARNING, "expansion=strftime is deprecated.\n");
1073 
1074  av_bprint_init(&s->expanded_text, 0, AV_BPRINT_SIZE_UNLIMITED);
1075  av_bprint_init(&s->expanded_fontcolor, 0, AV_BPRINT_SIZE_UNLIMITED);
1076 
1077  return 0;
1078 }
1079 
1080 static int query_formats(AVFilterContext *ctx)
1081 {
1082  return ff_set_common_formats(ctx, ff_draw_supported_pixel_formats(0));
1083 }
1084 
1085 static int glyph_enu_border_free(void *opaque, void *elem)
1086 {
1087  Glyph *glyph = elem;
1088 
1089  if (glyph->border_glyph != NULL) {
1090  for (int t = 0; t < 16; ++t) {
1091  if (glyph->border_bglyph[t] != NULL) {
1092  FT_Done_Glyph((FT_Glyph)glyph->border_bglyph[t]);
1093  glyph->border_bglyph[t] = NULL;
1094  }
1095  }
1096  FT_Done_Glyph(glyph->border_glyph);
1097  glyph->border_glyph = NULL;
1098  }
1099  return 0;
1100 }
1101 
1102 static int glyph_enu_free(void *opaque, void *elem)
1103 {
1104  Glyph *glyph = elem;
1105 
1106  FT_Done_Glyph(glyph->glyph);
1107  FT_Done_Glyph(glyph->border_glyph);
1108  for (int t = 0; t < 16; ++t) {
1109  if (glyph->bglyph[t] != NULL) {
1110  FT_Done_Glyph((FT_Glyph)glyph->bglyph[t]);
1111  }
1112  if (glyph->border_bglyph[t] != NULL) {
1113  FT_Done_Glyph((FT_Glyph)glyph->border_bglyph[t]);
1114  }
1115  }
1116  av_free(elem);
1117  return 0;
1118 }
1119 
1120 static av_cold void uninit(AVFilterContext *ctx)
1121 {
1122  DrawTextContext *s = ctx->priv;
1123 
1124  av_expr_free(s->x_pexpr);
1125  av_expr_free(s->y_pexpr);
1126  av_expr_free(s->a_pexpr);
1127  av_expr_free(s->fontsize_pexpr);
1128 
1129  s->x_pexpr = s->y_pexpr = s->a_pexpr = s->fontsize_pexpr = NULL;
1130 
1131  av_tree_enumerate(s->glyphs, NULL, NULL, glyph_enu_free);
1132  av_tree_destroy(s->glyphs);
1133  s->glyphs = NULL;
1134 
1135  FT_Done_Face(s->face);
1136  FT_Stroker_Done(s->stroker);
1137  FT_Done_FreeType(s->library);
1138 
1139  av_bprint_finalize(&s->expanded_text, NULL);
1140  av_bprint_finalize(&s->expanded_fontcolor, NULL);
1141 }
1142 
1143 static int config_input(AVFilterLink *inlink)
1144 {
1145  AVFilterContext *ctx = inlink->dst;
1146  DrawTextContext *s = ctx->priv;
1147  char *expr;
1148  int ret;
1149 
1150  ff_draw_init2(&s->dc, inlink->format, inlink->colorspace, inlink->color_range, FF_DRAW_PROCESS_ALPHA);
1151  ff_draw_color(&s->dc, &s->fontcolor, s->fontcolor.rgba);
1152  ff_draw_color(&s->dc, &s->shadowcolor, s->shadowcolor.rgba);
1153  ff_draw_color(&s->dc, &s->bordercolor, s->bordercolor.rgba);
1154  ff_draw_color(&s->dc, &s->boxcolor, s->boxcolor.rgba);
1155 
1156  s->var_values[VAR_w] = s->var_values[VAR_W] = s->var_values[VAR_MAIN_W] = inlink->w;
1157  s->var_values[VAR_h] = s->var_values[VAR_H] = s->var_values[VAR_MAIN_H] = inlink->h;
1158  s->var_values[VAR_SAR] = inlink->sample_aspect_ratio.num ? av_q2d(inlink->sample_aspect_ratio) : 1;
1159  s->var_values[VAR_DAR] = (double)inlink->w / inlink->h * s->var_values[VAR_SAR];
1160  s->var_values[VAR_HSUB] = 1 << s->dc.hsub_max;
1161  s->var_values[VAR_VSUB] = 1 << s->dc.vsub_max;
1162  s->var_values[VAR_X] = NAN;
1163  s->var_values[VAR_Y] = NAN;
1164  s->var_values[VAR_T] = NAN;
1165 
1166  av_lfg_init(&s->prng, av_get_random_seed());
1167 
1168  av_expr_free(s->x_pexpr);
1169  av_expr_free(s->y_pexpr);
1170  av_expr_free(s->a_pexpr);
1171  s->x_pexpr = s->y_pexpr = s->a_pexpr = NULL;
1172 
1173  if ((ret = av_expr_parse(&s->x_pexpr, expr = s->x_expr, var_names,
1174  NULL, NULL, fun2_names, fun2, 0, ctx)) < 0 ||
1175  (ret = av_expr_parse(&s->y_pexpr, expr = s->y_expr, var_names,
1176  NULL, NULL, fun2_names, fun2, 0, ctx)) < 0 ||
1177  (ret = av_expr_parse(&s->a_pexpr, expr = s->a_expr, var_names,
1178  NULL, NULL, fun2_names, fun2, 0, ctx)) < 0) {
1179  av_log(ctx, AV_LOG_ERROR, "Failed to parse expression: %s \n", expr);
1180  return AVERROR(EINVAL);
1181  }
1182 
1183  return 0;
1184 }
1185 
1186 static int command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
1187 {
1188  DrawTextContext *old = ctx->priv;
1189  DrawTextContext *new = NULL;
1190  int ret;
1191 
1192  if (!strcmp(cmd, "reinit")) {
1193  new = av_mallocz(sizeof(DrawTextContext));
1194  if (!new)
1195  return AVERROR(ENOMEM);
1196 
1197  new->class = &drawtext_class;
1198  ret = av_opt_copy(new, old);
1199  if (ret < 0)
1200  goto fail;
1201 
1202  ctx->priv = new;
1203  ret = av_set_options_string(ctx, arg, "=", ":");
1204  if (ret < 0) {
1205  ctx->priv = old;
1206  goto fail;
1207  }
1208 
1209  ret = init(ctx);
1210  if (ret < 0) {
1211  uninit(ctx);
1212  ctx->priv = old;
1213  goto fail;
1214  }
1215 
1216  new->reinit = 1;
1217 
1218  ctx->priv = old;
1219  uninit(ctx);
1220  av_freep(&old);
1221 
1222  ctx->priv = new;
1223  return config_input(ctx->inputs[0]);
1224  } else {
1225  int old_borderw = old->borderw;
1226  if ((ret = ff_filter_process_command(ctx, cmd, arg, res, res_len, flags)) < 0) {
1227  return ret;
1228  }
1229  if (old->borderw != old_borderw) {
1230  FT_Stroker_Set(old->stroker, old->borderw << 6, FT_STROKER_LINECAP_ROUND,
1231  FT_STROKER_LINEJOIN_ROUND, 0);
1232  // Dispose the old border glyphs
1233  av_tree_enumerate(old->glyphs, NULL, NULL, glyph_enu_border_free);
1234  } else if (strcmp(cmd, "fontsize") == 0) {
1235  av_expr_free(old->fontsize_pexpr);
1236  old->fontsize_pexpr = NULL;
1237  old->blank_advance64 = 0;
1238  }
1239  return config_input(ctx->inputs[0]);
1240  }
1241 
1242 fail:
1243  av_log(ctx, AV_LOG_ERROR, "Failed to process command. Continuing with existing parameters.\n");
1244  av_freep(&new);
1245  return ret;
1246 }
1247 
1248 static void update_color_with_alpha(DrawTextContext *s, FFDrawColor *color, const FFDrawColor incolor)
1249 {
1250  *color = incolor;
1251  color->rgba[3] = (color->rgba[3] * s->alpha) / 255;
1252  ff_draw_color(&s->dc, color, color->rgba);
1253 }
1254 
1255 static void update_alpha(DrawTextContext *s)
1256 {
1257  double alpha = av_expr_eval(s->a_pexpr, s->var_values, &s->prng);
1258 
1259  if (isnan(alpha))
1260  return;
1261 
1262  if (alpha >= 1.0)
1263  s->alpha = 255;
1264  else if (alpha <= 0)
1265  s->alpha = 0;
1266  else
1267  s->alpha = 256 * alpha;
1268 }
1269 
1270 static int draw_glyphs(DrawTextContext *s, AVFrame *frame,
1271  FFDrawColor *color,
1272  TextMetrics *metrics,
1273  int x, int y, int borderw)
1274 {
1275  int g, l, x1, y1, w1, h1, idx;
1276  int dx = 0, dy = 0, pdx = 0;
1277  GlyphInfo *info;
1278  Glyph dummy = { 0 }, *glyph;
1279  FT_Bitmap bitmap;
1280  FT_BitmapGlyph b_glyph;
1281  uint8_t j_left = 0, j_right = 0, j_top = 0, j_bottom = 0;
1282  int line_w, offset_y = 0;
1283  int clip_x = 0, clip_y = 0;
1284 
1285  j_left = !!(s->text_align & TA_LEFT);
1286  j_right = !!(s->text_align & TA_RIGHT);
1287  j_top = !!(s->text_align & TA_TOP);
1288  j_bottom = !!(s->text_align & TA_BOTTOM);
1289 
1290  if (j_top && j_bottom) {
1291  offset_y = (s->box_height - metrics->height) / 2;
1292  } else if (j_bottom) {
1293  offset_y = s->box_height - metrics->height;
1294  }
1295 
1296  if ((!j_left || j_right) && !s->tab_warning_printed && s->tab_count > 0) {
1297  s->tab_warning_printed = 1;
1298  av_log(s, AV_LOG_WARNING, "Tab characters are only supported with left horizontal alignment\n");
1299  }
1300 
1301  clip_x = FFMIN(metrics->rect_x + s->box_width + s->bb_right, frame->width);
1302  clip_y = FFMIN(metrics->rect_y + s->box_height + s->bb_bottom, frame->height);
1303 
1304  for (l = 0; l < s->line_count; ++l) {
1305  TextLine *line = &s->lines[l];
1306  line_w = POS_CEIL(line->width64, 64);
1307  for (g = 0; g < line->hb_data.glyph_count; ++g) {
1308  info = &line->glyphs[g];
1309  dummy.fontsize = s->fontsize;
1310  dummy.code = info->code;
1311  glyph = av_tree_find(s->glyphs, &dummy, glyph_cmp, NULL);
1312  if (!glyph) {
1313  return AVERROR(EINVAL);
1314  }
1315 
1316  idx = get_subpixel_idx(info->shift_x64, info->shift_y64);
1317  b_glyph = borderw ? glyph->border_bglyph[idx] : glyph->bglyph[idx];
1318  bitmap = b_glyph->bitmap;
1319  x1 = x + info->x + b_glyph->left;
1320  y1 = y + info->y - b_glyph->top + offset_y;
1321  w1 = bitmap.width;
1322  h1 = bitmap.rows;
1323 
1324  if (j_left && j_right) {
1325  x1 += (s->box_width - line_w) / 2;
1326  } else if (j_right) {
1327  x1 += s->box_width - line_w;
1328  }
1329 
1330  // Offset of the glyph's bitmap in the visible region
1331  dx = dy = 0;
1332  if (x1 < metrics->rect_x - s->bb_left) {
1333  dx = metrics->rect_x - s->bb_left - x1;
1334  x1 = metrics->rect_x - s->bb_left;
1335  }
1336  if (y1 < metrics->rect_y - s->bb_top) {
1337  dy = metrics->rect_y - s->bb_top - y1;
1338  y1 = metrics->rect_y - s->bb_top;
1339  }
1340 
1341  // check if the glyph is empty or out of the clipping region
1342  if (dx >= w1 || dy >= h1 || x1 >= clip_x || y1 >= clip_y) {
1343  continue;
1344  }
1345 
1346  pdx = dx + dy * bitmap.pitch;
1347  w1 = FFMIN(clip_x - x1, w1 - dx);
1348  h1 = FFMIN(clip_y - y1, h1 - dy);
1349 
1350  ff_blend_mask(&s->dc, color, frame->data, frame->linesize, clip_x, clip_y,
1351  bitmap.buffer + pdx, bitmap.pitch, w1, h1, 3, 0, x1, y1);
1352  }
1353  }
1354 
1355  return 0;
1356 }
1357 
1358 // Shapes a line of text using libharfbuzz
1359 static int shape_text_hb(DrawTextContext *s, HarfbuzzData* hb, const char* text, int textLen)
1360 {
1361  hb->buf = hb_buffer_create();
1362  if(!hb_buffer_allocation_successful(hb->buf)) {
1363  return AVERROR(ENOMEM);
1364  }
1365  hb_buffer_set_direction(hb->buf, HB_DIRECTION_LTR);
1366  hb_buffer_set_script(hb->buf, HB_SCRIPT_LATIN);
1367  hb_buffer_set_language(hb->buf, hb_language_from_string("en", -1));
1368  hb_buffer_guess_segment_properties(hb->buf);
1369  hb->font = hb_ft_font_create(s->face, NULL);
1370  if(hb->font == NULL) {
1371  return AVERROR(ENOMEM);
1372  }
1373  hb_ft_font_set_funcs(hb->font);
1374  hb_buffer_add_utf8(hb->buf, text, textLen, 0, -1);
1375  hb_shape(hb->font, hb->buf, NULL, 0);
1376  hb->glyph_info = hb_buffer_get_glyph_infos(hb->buf, &hb->glyph_count);
1377  hb->glyph_pos = hb_buffer_get_glyph_positions(hb->buf, &hb->glyph_count);
1378 
1379  return 0;
1380 }
1381 
1382 static void hb_destroy(HarfbuzzData *hb)
1383 {
1384  hb_buffer_destroy(hb->buf);
1385  hb_font_destroy(hb->font);
1386  hb->buf = NULL;
1387  hb->font = NULL;
1388  hb->glyph_info = NULL;
1389  hb->glyph_pos = NULL;
1390 }
1391 
1392 static int measure_text(AVFilterContext *ctx, TextMetrics *metrics)
1393 {
1394  DrawTextContext *s = ctx->priv;
1395  char *text = s->expanded_text.str;
1396  char *textdup = NULL, *start = NULL;
1397  int num_chars = 0;
1398  int width64 = 0, w64 = 0;
1399  int cur_min_y64 = 0, first_max_y64 = -32000;
1400  int first_min_x64 = 32000, last_max_x64 = -32000;
1401  int min_y64 = 32000, max_y64 = -32000, min_x64 = 32000, max_x64 = -32000;
1402  int line_count = 0;
1403  uint32_t code = 0;
1404  Glyph *glyph = NULL;
1405 
1406  int i, tab_idx = 0, last_tab_idx = 0, line_offset = 0;
1407  char* p;
1408  int ret = 0;
1409 
1410  // Count the lines and the tab characters
1411  s->tab_count = 0;
1412  for (i = 0, p = text; 1; i++) {
1413  GET_UTF8(code, *p ? *p++ : 0, code = 0xfffd; goto continue_on_failed;);
1414 continue_on_failed:
1415  if (ff_is_newline(code) || code == 0) {
1416  ++line_count;
1417  if (code == 0) {
1418  break;
1419  }
1420  } else if (code == '\t') {
1421  ++s->tab_count;
1422  }
1423  }
1424 
1425  // Evaluate the width of the space character if needed to replace tabs
1426  if (s->tab_count > 0 && !s->blank_advance64) {
1427  HarfbuzzData hb_data;
1428  ret = shape_text_hb(s, &hb_data, " ", 1);
1429  if(ret != 0) {
1430  goto done;
1431  }
1432  s->blank_advance64 = hb_data.glyph_pos[0].x_advance;
1433  hb_destroy(&hb_data);
1434  }
1435 
1436  s->line_count = line_count;
1437  s->lines = av_mallocz(line_count * sizeof(TextLine));
1438  s->tab_clusters = av_mallocz(s->tab_count * sizeof(uint32_t));
1439  for (i = 0; i < s->tab_count; ++i) {
1440  s->tab_clusters[i] = -1;
1441  }
1442 
1443  start = textdup = av_strdup(text);
1444  if (textdup == NULL) {
1445  ret = AVERROR(ENOMEM);
1446  goto done;
1447  }
1448  line_count = 0;
1449  for (i = 0, p = textdup; 1; i++) {
1450  if (*p == '\t') {
1451  s->tab_clusters[tab_idx++] = i;
1452  *p = ' ';
1453  }
1454  GET_UTF8(code, *p ? *p++ : 0, code = 0xfffd; goto continue_on_failed2;);
1455 continue_on_failed2:
1456  if (ff_is_newline(code) || code == 0) {
1457  TextLine *cur_line = &s->lines[line_count];
1458  HarfbuzzData *hb = &cur_line->hb_data;
1459  cur_line->cluster_offset = line_offset;
1460  ret = shape_text_hb(s, hb, start, num_chars);
1461  if (ret != 0) {
1462  goto done;
1463  }
1464  w64 = 0;
1465  cur_min_y64 = 32000;
1466  for (int t = 0; t < hb->glyph_count; ++t) {
1467  uint8_t is_tab = last_tab_idx < s->tab_count &&
1468  hb->glyph_info[t].cluster == s->tab_clusters[last_tab_idx] - line_offset;
1469  if (is_tab) {
1470  ++last_tab_idx;
1471  }
1472  ret = load_glyph(ctx, &glyph, hb->glyph_info[t].codepoint, -1, -1);
1473  if (ret != 0) {
1474  goto done;
1475  }
1476  if (line_count == 0) {
1477  first_max_y64 = FFMAX(glyph->bbox.yMax, first_max_y64);
1478  }
1479  if (t == 0) {
1480  cur_line->offset_left64 = glyph->bbox.xMin;
1481  first_min_x64 = FFMIN(glyph->bbox.xMin, first_min_x64);
1482  }
1483  if (t == hb->glyph_count - 1) {
1484  // The following code measures the width of the line up to the last
1485  // character's horizontal advance
1486  int last_char_width = hb->glyph_pos[t].x_advance;
1487 
1488  // The following code measures the width of the line up to the rightmost
1489  // visible pixel of the last character
1490  // int last_char_width = glyph->bbox.xMax;
1491 
1492  w64 += last_char_width;
1493  last_max_x64 = FFMAX(last_char_width, last_max_x64);
1494  cur_line->offset_right64 = last_char_width;
1495  } else {
1496  if (is_tab) {
1497  int size = s->blank_advance64 * s->tabsize;
1498  w64 = (w64 / size + 1) * size;
1499  } else {
1500  w64 += hb->glyph_pos[t].x_advance;
1501  }
1502  }
1503  cur_min_y64 = FFMIN(glyph->bbox.yMin, cur_min_y64);
1504  min_y64 = FFMIN(glyph->bbox.yMin, min_y64);
1505  max_y64 = FFMAX(glyph->bbox.yMax, max_y64);
1506  min_x64 = FFMIN(glyph->bbox.xMin, min_x64);
1507  max_x64 = FFMAX(glyph->bbox.xMax, max_x64);
1508  }
1509 
1510  cur_line->width64 = w64;
1511 
1512  av_log(s, AV_LOG_DEBUG, " Line: %d -- glyphs count: %d - width64: %d - offset_left64: %d - offset_right64: %d)\n",
1513  line_count, hb->glyph_count, cur_line->width64, cur_line->offset_left64, cur_line->offset_right64);
1514 
1515  if (w64 > width64) {
1516  width64 = w64;
1517  }
1518  num_chars = -1;
1519  start = p;
1520  ++line_count;
1521  line_offset = i + 1;
1522  }
1523 
1524  if (code == 0) break;
1525  ++num_chars;
1526  }
1527 
1528  metrics->line_height64 = s->face->size->metrics.height;
1529 
1530  metrics->width = POS_CEIL(width64, 64);
1531  if (s->y_align == YA_FONT) {
1532  metrics->height = POS_CEIL(metrics->line_height64 * line_count, 64);
1533  } else {
1534  int height64 = (metrics->line_height64 + s->line_spacing * 64) *
1535  (FFMAX(0, line_count - 1)) + first_max_y64 - cur_min_y64;
1536  metrics->height = POS_CEIL(height64, 64);
1537  }
1538  metrics->offset_top64 = first_max_y64;
1539  metrics->offset_right64 = last_max_x64;
1540  metrics->offset_bottom64 = cur_min_y64;
1541  metrics->offset_left64 = first_min_x64;
1542  metrics->min_x64 = min_x64;
1543  metrics->min_y64 = min_y64;
1544  metrics->max_x64 = max_x64;
1545  metrics->max_y64 = max_y64;
1546 
1547 done:
1548  av_free(textdup);
1549  return ret;
1550 }
1551 
1552 static int draw_text(AVFilterContext *ctx, AVFrame *frame)
1553 {
1554  DrawTextContext *s = ctx->priv;
1555  AVFilterLink *inlink = ctx->inputs[0];
1556  int x = 0, y = 0, ret;
1557  int shift_x64, shift_y64;
1558  int x64, y64;
1559  Glyph *glyph = NULL;
1560 
1561  time_t now = time(0);
1562  struct tm ltime;
1563  AVBPrint *bp = &s->expanded_text;
1564 
1565  FFDrawColor fontcolor;
1566  FFDrawColor shadowcolor;
1567  FFDrawColor bordercolor;
1568  FFDrawColor boxcolor;
1569 
1570  int width = frame->width;
1571  int height = frame->height;
1572  int rec_x = 0, rec_y = 0, rec_width = 0, rec_height = 0;
1573  int is_outside = 0;
1574  int last_tab_idx = 0;
1575 
1576  TextMetrics metrics;
1577 
1578  av_bprint_clear(bp);
1579 
1580  if (s->basetime != AV_NOPTS_VALUE)
1581  now= frame->pts*av_q2d(ctx->inputs[0]->time_base) + s->basetime/1000000;
1582 
1583  switch (s->exp_mode) {
1584  case EXP_NONE:
1585  av_bprintf(bp, "%s", s->text);
1586  break;
1587  case EXP_NORMAL:
1588  if ((ret = ff_expand_text(&s->expand_text, s->text, &s->expanded_text)) < 0)
1589  return ret;
1590  break;
1591  case EXP_STRFTIME:
1592  localtime_r(&now, &ltime);
1593  av_bprint_strftime(bp, s->text, &ltime);
1594  break;
1595  }
1596 
1597  if (s->tc_opt_string) {
1598  char tcbuf[AV_TIMECODE_STR_SIZE];
1599  av_timecode_make_string(&s->tc, tcbuf, inlink->frame_count_out);
1600  av_bprint_clear(bp);
1601  av_bprintf(bp, "%s%s", s->text, tcbuf);
1602  }
1603 
1604  if (!av_bprint_is_complete(bp))
1605  return AVERROR(ENOMEM);
1606 
1607  if (s->fontcolor_expr[0]) {
1608  /* If expression is set, evaluate and replace the static value */
1609  av_bprint_clear(&s->expanded_fontcolor);
1610  if ((ret = ff_expand_text(&s->expand_text, s->fontcolor_expr, &s->expanded_fontcolor)) < 0)
1611  return ret;
1612  if (!av_bprint_is_complete(&s->expanded_fontcolor))
1613  return AVERROR(ENOMEM);
1614  av_log(s, AV_LOG_DEBUG, "Evaluated fontcolor is '%s'\n", s->expanded_fontcolor.str);
1615  ret = av_parse_color(s->fontcolor.rgba, s->expanded_fontcolor.str, -1, s);
1616  if (ret)
1617  return ret;
1618  ff_draw_color(&s->dc, &s->fontcolor, s->fontcolor.rgba);
1619  }
1620 
1621  if ((ret = update_fontsize(ctx)) < 0) {
1622  return ret;
1623  }
1624 
1625  if ((ret = measure_text(ctx, &metrics)) < 0) {
1626  return ret;
1627  }
1628 
1629  s->max_glyph_h = POS_CEIL(metrics.max_y64 - metrics.min_y64, 64);
1630  s->max_glyph_w = POS_CEIL(metrics.max_x64 - metrics.min_x64, 64);
1631 
1632  s->var_values[VAR_TW] = s->var_values[VAR_TEXT_W] = metrics.width;
1633  s->var_values[VAR_TH] = s->var_values[VAR_TEXT_H] = metrics.height;
1634 
1635  s->var_values[VAR_MAX_GLYPH_W] = s->max_glyph_w;
1636  s->var_values[VAR_MAX_GLYPH_H] = s->max_glyph_h;
1637  s->var_values[VAR_MAX_GLYPH_A] = s->var_values[VAR_ASCENT] = POS_CEIL(metrics.max_y64, 64);
1638  s->var_values[VAR_FONT_A] = s->face->size->metrics.ascender / 64;
1639  s->var_values[VAR_MAX_GLYPH_D] = s->var_values[VAR_DESCENT] = POS_CEIL(metrics.min_y64, 64);
1640  s->var_values[VAR_FONT_D] = -s->face->size->metrics.descender / 64;
1641 
1642  s->var_values[VAR_TOP_A] = POS_CEIL(metrics.offset_top64, 64);
1643  s->var_values[VAR_BOTTOM_D] = -POS_CEIL(metrics.offset_bottom64, 64);
1644  s->var_values[VAR_LINE_H] = s->var_values[VAR_LH] = metrics.line_height64 / 64.;
1645 
1646  if (s->text_source == AV_FRAME_DATA_DETECTION_BBOXES) {
1647  s->var_values[VAR_X] = s->x;
1648  s->var_values[VAR_Y] = s->y;
1649  } else {
1650  s->x = s->var_values[VAR_X] = av_expr_eval(s->x_pexpr, s->var_values, &s->prng);
1651  s->y = s->var_values[VAR_Y] = av_expr_eval(s->y_pexpr, s->var_values, &s->prng);
1652  /* It is necessary if x is expressed from y */
1653  s->x = s->var_values[VAR_X] = av_expr_eval(s->x_pexpr, s->var_values, &s->prng);
1654  }
1655 
1656  update_alpha(s);
1657  update_color_with_alpha(s, &fontcolor , s->fontcolor );
1658  update_color_with_alpha(s, &shadowcolor, s->shadowcolor);
1659  update_color_with_alpha(s, &bordercolor, s->bordercolor);
1660  update_color_with_alpha(s, &boxcolor , s->boxcolor );
1661 
1662  if (s->draw_box && s->boxborderw) {
1663  int bbsize[4];
1664  int count;
1665  count = string_to_array(s->boxborderw, bbsize, 4);
1666  if (count == 1) {
1667  s->bb_top = s->bb_right = s->bb_bottom = s->bb_left = bbsize[0];
1668  } else if (count == 2) {
1669  s->bb_top = s->bb_bottom = bbsize[0];
1670  s->bb_right = s->bb_left = bbsize[1];
1671  } else if (count == 3) {
1672  s->bb_top = bbsize[0];
1673  s->bb_right = s->bb_left = bbsize[1];
1674  s->bb_bottom = bbsize[2];
1675  } else if (count == 4) {
1676  s->bb_top = bbsize[0];
1677  s->bb_right = bbsize[1];
1678  s->bb_bottom = bbsize[2];
1679  s->bb_left = bbsize[3];
1680  }
1681  } else {
1682  s->bb_top = s->bb_right = s->bb_bottom = s->bb_left = 0;
1683  }
1684 
1685  if (s->fix_bounds) {
1686  /* calculate footprint of text effects */
1687  int borderoffset = s->borderw ? FFMAX(s->borderw, 0) : 0;
1688 
1689  int offsetleft = FFMAX3(FFMAX(s->bb_left, 0), borderoffset,
1690  (s->shadowx < 0 ? FFABS(s->shadowx) : 0));
1691  int offsettop = FFMAX3(FFMAX(s->bb_top, 0), borderoffset,
1692  (s->shadowy < 0 ? FFABS(s->shadowy) : 0));
1693  int offsetright = FFMAX3(FFMAX(s->bb_right, 0), borderoffset,
1694  (s->shadowx > 0 ? s->shadowx : 0));
1695  int offsetbottom = FFMAX3(FFMAX(s->bb_bottom, 0), borderoffset,
1696  (s->shadowy > 0 ? s->shadowy : 0));
1697 
1698  if (s->x - offsetleft < 0) s->x = offsetleft;
1699  if (s->y - offsettop < 0) s->y = offsettop;
1700 
1701  if (s->x + metrics.width + offsetright > width)
1702  s->x = FFMAX(width - metrics.width - offsetright, 0);
1703  if (s->y + metrics.height + offsetbottom > height)
1704  s->y = FFMAX(height - metrics.height - offsetbottom, 0);
1705  }
1706 
1707  x = 0;
1708  y = 0;
1709  x64 = (int)(s->x * 64.);
1710  if (s->y_align == YA_FONT) {
1711  y64 = (int)(s->y * 64. + s->face->size->metrics.ascender);
1712  } else if (s->y_align == YA_BASELINE) {
1713  y64 = (int)(s->y * 64.);
1714  } else {
1715  y64 = (int)(s->y * 64. + metrics.offset_top64);
1716  }
1717 
1718  for (int l = 0; l < s->line_count; ++l) {
1719  TextLine *line = &s->lines[l];
1720  HarfbuzzData *hb = &line->hb_data;
1721  line->glyphs = av_mallocz(hb->glyph_count * sizeof(GlyphInfo));
1722 
1723  for (int t = 0; t < hb->glyph_count; ++t) {
1724  GlyphInfo *g_info = &line->glyphs[t];
1725  uint8_t is_tab = last_tab_idx < s->tab_count &&
1726  hb->glyph_info[t].cluster == s->tab_clusters[last_tab_idx] - line->cluster_offset;
1727  int true_x, true_y;
1728  if (is_tab) {
1729  ++last_tab_idx;
1730  }
1731  true_x = x + hb->glyph_pos[t].x_offset;
1732  true_y = y + hb->glyph_pos[t].y_offset;
1733  shift_x64 = (((x64 + true_x) >> 4) & 0b0011) << 4;
1734  shift_y64 = ((4 - (((y64 + true_y) >> 4) & 0b0011)) & 0b0011) << 4;
1735 
1736  ret = load_glyph(ctx, &glyph, hb->glyph_info[t].codepoint, shift_x64, shift_y64);
1737  if (ret != 0) {
1738  return ret;
1739  }
1740  g_info->code = hb->glyph_info[t].codepoint;
1741  g_info->x = (x64 + true_x) >> 6;
1742  g_info->y = ((y64 + true_y) >> 6) + (shift_y64 > 0 ? 1 : 0);
1743  g_info->shift_x64 = shift_x64;
1744  g_info->shift_y64 = shift_y64;
1745 
1746  if (!is_tab) {
1747  x += hb->glyph_pos[t].x_advance;
1748  } else {
1749  int size = s->blank_advance64 * s->tabsize;
1750  x = (x / size + 1) * size;
1751  }
1752  y += hb->glyph_pos[t].y_advance;
1753  }
1754 
1755  y += metrics.line_height64 + s->line_spacing * 64;
1756  x = 0;
1757  }
1758 
1759  metrics.rect_x = s->x;
1760  if (s->y_align == YA_BASELINE) {
1761  metrics.rect_y = s->y - metrics.offset_top64 / 64;
1762  } else {
1763  metrics.rect_y = s->y;
1764  }
1765 
1766  s->box_width = s->boxw == 0 ? metrics.width : s->boxw;
1767  s->box_height = s->boxh == 0 ? metrics.height : s->boxh;
1768 
1769  if (!s->draw_box) {
1770  // Create a border for the clipping region to take into account subpixel
1771  // errors in text measurement and effects.
1772  int borderoffset = s->borderw ? FFMAX(s->borderw, 0) : 0;
1773  s->bb_left = borderoffset + (s->shadowx < 0 ? FFABS(s->shadowx) : 0) + 1;
1774  s->bb_top = borderoffset + (s->shadowy < 0 ? FFABS(s->shadowy) : 0) + 1;
1775  s->bb_right = borderoffset + (s->shadowx > 0 ? s->shadowx : 0) + 1;
1776  s->bb_bottom = borderoffset + (s->shadowy > 0 ? s->shadowy : 0) + 1;
1777  }
1778 
1779  /* Check if the whole box is out of the frame */
1780  is_outside = metrics.rect_x - s->bb_left >= width ||
1781  metrics.rect_y - s->bb_top >= height ||
1782  metrics.rect_x + s->box_width + s->bb_right <= 0 ||
1783  metrics.rect_y + s->box_height + s->bb_bottom <= 0;
1784 
1785  if (!is_outside) {
1786  /* draw box */
1787  if (s->draw_box) {
1788  rec_x = metrics.rect_x - s->bb_left;
1789  rec_y = metrics.rect_y - s->bb_top;
1790  rec_width = s->box_width + s->bb_right + s->bb_left;
1791  rec_height = s->box_height + s->bb_bottom + s->bb_top;
1792  ff_blend_rectangle(&s->dc, &boxcolor,
1793  frame->data, frame->linesize, width, height,
1794  rec_x, rec_y, rec_width, rec_height);
1795  }
1796 
1797  if (s->shadowx || s->shadowy) {
1798  if ((ret = draw_glyphs(s, frame, &shadowcolor, &metrics,
1799  s->shadowx, s->shadowy, s->borderw)) < 0) {
1800  return ret;
1801  }
1802  }
1803 
1804  if (s->borderw) {
1805  if ((ret = draw_glyphs(s, frame, &bordercolor, &metrics,
1806  0, 0, s->borderw)) < 0) {
1807  return ret;
1808  }
1809  }
1810 
1811  if ((ret = draw_glyphs(s, frame, &fontcolor, &metrics, 0,
1812  0, 0)) < 0) {
1813  return ret;
1814  }
1815  }
1816 
1817  // FREE data structures
1818  for (int l = 0; l < s->line_count; ++l) {
1819  TextLine *line = &s->lines[l];
1820  av_freep(&line->glyphs);
1821  hb_destroy(&line->hb_data);
1822  }
1823  av_freep(&s->lines);
1824  av_freep(&s->tab_clusters);
1825 
1826  return 0;
1827 }
1828 
1829 static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
1830 {
1831  AVFilterContext *ctx = inlink->dst;
1832  AVFilterLink *outlink = ctx->outputs[0];
1833  DrawTextContext *s = ctx->priv;
1834  int ret;
1835  const AVDetectionBBoxHeader *header = NULL;
1836  const AVDetectionBBox *bbox;
1837  AVFrameSideData *sd;
1838  int loop = 1;
1839 
1840  if (s->text_source == AV_FRAME_DATA_DETECTION_BBOXES) {
1841  sd = av_frame_get_side_data(frame, AV_FRAME_DATA_DETECTION_BBOXES);
1842  if (sd) {
1843  header = (AVDetectionBBoxHeader *)sd->data;
1844  loop = header->nb_bboxes;
1845  } else {
1846  av_log(s, AV_LOG_WARNING, "No detection bboxes.\n");
1847  return ff_filter_frame(outlink, frame);
1848  }
1849  }
1850 
1851  if (s->reload && !(inlink->frame_count_out % s->reload)) {
1852  if ((ret = ff_load_textfile(ctx, (const char *)s->textfile, &s->text, NULL)) < 0) {
1853  av_frame_free(&frame);
1854  return ret;
1855  }
1856 #if CONFIG_LIBFRIBIDI
1857  if (s->text_shaping)
1858  if ((ret = shape_text(ctx)) < 0) {
1859  av_frame_free(&frame);
1860  return ret;
1861  }
1862 #endif
1863  }
1864 
1865  s->var_values[VAR_N] = inlink->frame_count_out + s->start_number;
1866  s->var_values[VAR_T] = frame->pts == AV_NOPTS_VALUE ?
1867  NAN : frame->pts * av_q2d(inlink->time_base);
1868 
1869  s->var_values[VAR_PICT_TYPE] = frame->pict_type;
1870 #if FF_API_FRAME_PKT
1871 FF_DISABLE_DEPRECATION_WARNINGS
1872  s->var_values[VAR_PKT_POS] = frame->pkt_pos;
1873  s->var_values[VAR_PKT_SIZE] = frame->pkt_size;
1874 FF_ENABLE_DEPRECATION_WARNINGS
1875 #endif
1876  s->var_values[VAR_DURATION] = frame->duration * av_q2d(inlink->time_base);
1877 
1878  s->metadata = frame->metadata;
1879 
1880  for (int i = 0; i < loop; i++) {
1881  if (header) {
1882  bbox = av_get_detection_bbox(header, i);
1883  strcpy(s->text, bbox->detect_label);
1884  for (int j = 0; j < bbox->classify_count; j++) {
1885  strcat(s->text, ", ");
1886  strcat(s->text, bbox->classify_labels[j]);
1887  }
1888  s->x = bbox->x;
1889  s->y = bbox->y - s->fontsize;
1890  }
1891  draw_text(ctx, frame);
1892  }
1893 
1894  return ff_filter_frame(outlink, frame);
1895 }
1896 
1897 static const AVFilterPad avfilter_vf_drawtext_inputs[] = {
1898  {
1899  .name = "default",
1900  .type = AVMEDIA_TYPE_VIDEO,
1901  .flags = AVFILTERPAD_FLAG_NEEDS_WRITABLE,
1902  .filter_frame = filter_frame,
1903  .config_props = config_input,
1904  },
1905 };
1906 
1907 const AVFilter ff_vf_drawtext = {
1908  .name = "drawtext",
1909  .description = NULL_IF_CONFIG_SMALL("Draw text on top of video frames using libfreetype library."),
1910  .priv_size = sizeof(DrawTextContext),
1911  .priv_class = &drawtext_class,
1912  .init = init,
1913  .uninit = uninit,
1914  FILTER_INPUTS(avfilter_vf_drawtext_inputs),
1915  FILTER_OUTPUTS(ff_video_default_filterpad),
1916  FILTER_QUERY_FUNC(query_formats),
1917  .process_command = command,
1918  .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
1919 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
DrawTextContext::library
FT_Library library
freetype font library handle
Definition: vf_drawtext.c:293
OFFSET
#define OFFSET(x)
Definition: vf_drawtext.c:332
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
fun2_names
static const char *const fun2_names[]
Definition: vf_drawtext.c:115
VAR_N
@ VAR_N
Definition: vf_drawtext.c:145
VAR_TEXT_H
@ VAR_TEXT_H
Definition: vf_drawtext.c:148
VAR_MAIN_H
@ VAR_MAIN_H
Definition: vf_drawtext.c:135
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AV_BPRINT_SIZE_UNLIMITED
#define AV_BPRINT_SIZE_UNLIMITED
AV_TIMECODE_STR_SIZE
#define AV_TIMECODE_STR_SIZE
Definition: timecode.h:33
FFDrawColor
Definition: drawutils.h:50
VAR_LINE_H
@ VAR_LINE_H
Definition: vf_drawtext.c:134
VAR_Y
@ VAR_Y
Definition: vf_drawtext.c:151
VAR_MAX_GLYPH_H
@ VAR_MAX_GLYPH_H
Definition: vf_drawtext.c:139
ff_expand_text
int ff_expand_text(FFExpandTextContext *expand_text, char *text, AVBPrint *bp)
Expand text template.
Definition: textutils.c:123
HarfbuzzData::font
hb_font_t * font
Definition: vf_drawtext.c:184
DrawTextContext::a_expr
char * a_expr
Definition: vf_drawtext.c:302
av_bprint_is_complete
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
Definition: bprint.h:218
TextMetrics::height
int height
total height of the text - ceil(height64/64)
Definition: vf_drawtext.c:236
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
var_name
var_name
Definition: noise.c:47
out
FILE * out
Definition: movenc.c:55
color
Definition: vf_paletteuse.c:512
av_lfg_init
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
Definition: lfg.c:32
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
av_frame_get_side_data
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:947
VAR_TOP_A
@ VAR_TOP_A
Definition: vf_drawtext.c:143
ff_vf_drawtext
const AVFilter ff_vf_drawtext
Definition: vf_drawtext.c:1907
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
Definition: vf_drawtext.c:1829
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1015
av_parse_color
int av_parse_color(uint8_t *rgba_color, const char *color_string, int slen, void *log_ctx)
Put the RGBA values that correspond to color_string in rgba_color.
Definition: parseutils.c:356
av_tree_insert
void * av_tree_insert(AVTreeNode **tp, void *key, int(*cmp)(const void *key, const void *b), AVTreeNode **next)
Insert or remove an element.
Definition: tree.c:59
POS_CEIL
#define POS_CEIL(x, y)
Definition: vf_drawtext.c:81
DrawTextContext::default_fontsize
unsigned int default_fontsize
default font size to use
Definition: vf_drawtext.c:272
VAR_BOTTOM_D
@ VAR_BOTTOM_D
Definition: vf_drawtext.c:144
TA_RIGHT
@ TA_RIGHT
Definition: vf_drawtext.c:177
VAR_TW
@ VAR_TW
Definition: vf_drawtext.c:149
VAR_ASCENT
@ VAR_ASCENT
Definition: vf_drawtext.c:137
VAR_FONT_D
@ VAR_FONT_D
Definition: vf_drawtext.c:142
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
DrawTextContext::tc24hmax
int tc24hmax
1 if timecode is wrapped to 24 hours, 0 otherwise
Definition: vf_drawtext.c:309
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:160
draw_text
static int draw_text(AVFilterContext *ctx, AVFrame *frame)
Definition: vf_drawtext.c:1552
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
DrawTextContext::bordercolor
FFDrawColor bordercolor
border color
Definition: vf_drawtext.c:290
AVTreeNode::elem
void * elem
Definition: tree.c:28
DrawTextContext::bb_left
int bb_left
the size of the left box border
Definition: vf_drawtext.c:281
DrawTextContext::exp_mode
int exp_mode
expansion mode to use for the text
Definition: vf_drawtext.c:250
DrawTextContext::line_count
int line_count
the number of text lines
Definition: vf_drawtext.c:325
shape_text_hb
static int shape_text_hb(DrawTextContext *s, HarfbuzzData *hb, const char *text, int textLen)
Definition: vf_drawtext.c:1359
VAR_DESCENT
@ VAR_DESCENT
Definition: vf_drawtext.c:138
AVOption
AVOption.
Definition: opt.h:346
b
#define b
Definition: input.c:41
FILTER_QUERY_FUNC
#define FILTER_QUERY_FUNC(func)
Definition: internal.h:159
TextMetrics
Global text metrics.
Definition: vf_drawtext.c:225
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
max
#define max(a, b)
Definition: cuda_runtime.h:33
AVDictionary
Definition: dict.c:34
func_pts
static int func_pts(void *ctx, AVBPrint *bp, const char *function_name, unsigned argc, char **argv)
Definition: qrencode.c:195
DrawTextContext::stroker
FT_Stroker stroker
freetype stroker handle
Definition: vf_drawtext.c:295
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:170
av_tree_node_alloc
struct AVTreeNode * av_tree_node_alloc(void)
Allocate an AVTreeNode.
Definition: tree.c:34
VAR_MAX_GLYPH_W
@ VAR_MAX_GLYPH_W
Definition: vf_drawtext.c:140
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
AV_OPT_TYPE_RATIONAL
@ AV_OPT_TYPE_RATIONAL
Definition: opt.h:240
DrawTextContext::prng
AVLFG prng
random
Definition: vf_drawtext.c:305
DrawTextContext::box_height
int box_height
the height of box
Definition: vf_drawtext.c:283
AVDetectionBBox::y
int y
Definition: detection_bbox.h:32
video.h
DrawTextContext::lines
TextLine * lines
computed information about text lines
Definition: vf_drawtext.c:324
VAR_MAIN_W
@ VAR_MAIN_W
Definition: vf_drawtext.c:136
av_tree_enumerate
void av_tree_enumerate(AVTreeNode *t, void *opaque, int(*cmp)(void *opaque, void *elem), int(*enu)(void *opaque, void *elem))
Apply enu(opaque, &elem) to all the elements in the tree in a given range.
Definition: tree.c:155
TextLine::width64
int width64
width of the line
Definition: vf_drawtext.c:205
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
av_get_random_seed
uint32_t av_get_random_seed(void)
Get a seed to use in conjunction with random functions.
Definition: random_seed.c:167
TextMetrics::min_y64
int min_y64
minimum value of bbox.yMin among glyphs (in 26.6 units)
Definition: vf_drawtext.c:238
formats.h
DrawTextContext::start_number
int start_number
starting frame number for n/frame_num var
Definition: vf_drawtext.c:311
av_expr_parse
int av_expr_parse(AVExpr **expr, const char *s, const char *const *const_names, const char *const *func1_names, double(*const *funcs1)(void *, double), const char *const *func2_names, double(*const *funcs2)(void *, double, double), int log_offset, void *log_ctx)
Parse an expression.
Definition: eval.c:710
DrawTextContext::text
uint8_t * text
text to be drawn
Definition: vf_drawtext.c:257
DrawTextContext::expanded_text
AVBPrint expanded_text
used to contain the expanded text
Definition: vf_drawtext.c:258
VAR_H
@ VAR_H
Definition: vf_drawtext.c:135
DrawTextContext::fontsize
unsigned int fontsize
font size to use
Definition: vf_drawtext.c:271
DrawTextContext::x_expr
char * x_expr
expression for x position
Definition: vf_drawtext.c:297
positions
const static uint16_t positions[][14][3]
Definition: vf_vectorscope.c:817
AV_DETECTION_BBOX_LABEL_NAME_MAX_SIZE
#define AV_DETECTION_BBOX_LABEL_NAME_MAX_SIZE
Definition: detection_bbox.h:36
DrawTextContext::fontfile
uint8_t * fontfile
font to be used
Definition: vf_drawtext.c:256
AVDetectionBBox::detect_label
char detect_label[AV_DETECTION_BBOX_LABEL_NAME_MAX_SIZE]
Detect result with confidence.
Definition: detection_bbox.h:41
expansion_mode
expansion_mode
Definition: vf_drawtext.c:163
DrawTextContext::y_pexpr
AVExpr * y_pexpr
parsed expressions for x and y
Definition: vf_drawtext.c:299
fail
#define fail()
Definition: checkasm.h:179
VAR_VARS_NB
@ VAR_VARS_NB
Definition: vf_drawtext.c:160
GlyphInfo::y
int y
the y position of the glyph
Definition: vf_drawtext.c:194
DrawTextContext::expand_text
FFExpandTextContext expand_text
expand text in case exp_mode == NORMAL
Definition: vf_drawtext.c:251
timecode.h
Glyph::bglyph
FT_BitmapGlyph bglyph[16]
Glyph bitmaps with 1/4 pixel precision in both directions.
Definition: vf_drawtext.c:218
dummy
int dummy
Definition: motion.c:66
DrawTextContext::bb_top
int bb_top
the size of the top box border
Definition: vf_drawtext.c:278
EXP_NONE
@ EXP_NONE
Definition: vf_drawtext.c:164
av_timecode_make_string
char * av_timecode_make_string(const AVTimecode *tc, char *buf, int framenum)
Load timecode string in buf.
Definition: timecode.c:103
hb_destroy
static void hb_destroy(HarfbuzzData *hb)
Definition: vf_drawtext.c:1382
pts
static int64_t pts
Definition: transcode_aac.c:644
ff_blend_mask
void ff_blend_mask(FFDrawContext *draw, FFDrawColor *color, uint8_t *dst[], int dst_linesize[], int dst_w, int dst_h, const uint8_t *mask, int mask_linesize, int mask_w, int mask_h, int l2depth, unsigned endianness, int x0, int y0)
Blend an alpha mask with an uniform color.
Definition: drawutils.c:534
FFExpandTextFunction
Function used to expand a template sequence in the format %{FUNCTION_NAME[:PARAMS]},...
Definition: textutils.h:36
loop
static int loop
Definition: ffplay.c:335
av_expr_free
void av_expr_free(AVExpr *e)
Free a parsed expression previously created with av_expr_parse().
Definition: eval.c:358
AVFrameSideDataType
AVFrameSideDataType
Definition: frame.h:49
TextMetrics::offset_top64
int offset_top64
ascender amount of the first line (in 26.6 units)
Definition: vf_drawtext.c:226
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:33
FFDIFFSIGN
#define FFDIFFSIGN(x, y)
Comparator.
Definition: macros.h:45
av_get_detection_bbox
static av_always_inline AVDetectionBBox * av_get_detection_bbox(const AVDetectionBBoxHeader *header, unsigned int idx)
Definition: detection_bbox.h:84
TextMetrics::rect_y
int rect_y
y position of the box
Definition: vf_drawtext.c:245
DrawTextContext::var_values
double var_values[VAR_VARS_NB]
Definition: vf_drawtext.c:301
GET_UTF8
#define GET_UTF8(val, GET_BYTE, ERROR)
Convert a UTF-8 character (up to 4 bytes) to its 32-bit UCS-4 encoded form.
Definition: common.h:473
TextMetrics::min_x64
int min_x64
minimum value of bbox.xMin among glyphs (in 26.6 units)
Definition: vf_drawtext.c:240
FLAGS
#define FLAGS
Definition: vf_drawtext.c:333
avfilter_vf_drawtext_inputs
static const AVFilterPad avfilter_vf_drawtext_inputs[]
Definition: vf_drawtext.c:1897
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
ff_load_textfile
int ff_load_textfile(void *log_ctx, const char *textfile, unsigned char **text, size_t *text_size)
Definition: textutils.c:353
DrawTextContext::dc
FFDrawContext dc
Definition: vf_drawtext.c:287
ff_set_common_formats
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
A helper for query_formats() which sets all links to the same list of formats.
Definition: formats.c:868
update_alpha
static void update_alpha(DrawTextContext *s)
Definition: vf_drawtext.c:1255
ff_video_default_filterpad
const AVFilterPad ff_video_default_filterpad[1]
An AVFilterPad array whose only entry has name "default" and is of type AVMEDIA_TYPE_VIDEO.
Definition: video.c:37
DrawTextContext::face
FT_Face face
freetype font face handle
Definition: vf_drawtext.c:294
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:62
width
#define width
s
#define s(width, name)
Definition: cbs_vp9.c:198
VAR_X
@ VAR_X
Definition: vf_drawtext.c:150
av_lfg_get
static unsigned int av_lfg_get(AVLFG *c)
Get the next random unsigned 32-bit number using an ALFG.
Definition: lfg.h:53
VAR_TH
@ VAR_TH
Definition: vf_drawtext.c:148
DrawTextContext::fontcolor
FFDrawColor fontcolor
foreground color
Definition: vf_drawtext.c:288
g
const char * g
Definition: vf_curves.c:128
DrawTextContext::a_pexpr
AVExpr * a_pexpr
Definition: vf_drawtext.c:303
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
info
MIPS optimizations info
Definition: mips.txt:2
lfg.h
av_strtok
char * av_strtok(char *s, const char *delim, char **saveptr)
Split the string into several tokens which can be accessed by successive calls to av_strtok().
Definition: avstring.c:178
FF_DRAW_PROCESS_ALPHA
#define FF_DRAW_PROCESS_ALPHA
Process alpha pixel component.
Definition: drawutils.h:62
AV_OPT_TYPE_INT64
@ AV_OPT_TYPE_INT64
Definition: opt.h:236
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
av_set_options_string
int av_set_options_string(void *ctx, const char *opts, const char *key_val_sep, const char *pairs_sep)
Parse the key/value pairs list in opts.
Definition: opt.c:1778
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:49
TextMetrics::offset_right64
int offset_right64
maximum offset between the origin and the rightmost pixel of the last glyph of each line (in 26....
Definition: vf_drawtext.c:231
av_expr_eval
double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)
Evaluate a previously parsed expression.
Definition: eval.c:792
VAR_SAR
@ VAR_SAR
Definition: vf_drawtext.c:146
AVExpr
Definition: eval.c:158
TA_TOP
@ TA_TOP
Definition: vf_drawtext.c:178
func_frame_num
static int func_frame_num(void *ctx, AVBPrint *bp, const char *function_name, unsigned argc, char **argv)
Definition: qrencode.c:217
DrawTextContext::fontsize_pexpr
AVExpr * fontsize_pexpr
parsed expressions for fontsize
Definition: vf_drawtext.c:270
YA_TEXT
@ YA_TEXT
Definition: vf_drawtext.c:170
eval_func2
double(* eval_func2)(void *, double a, double b)
Definition: vf_drawtext.c:124
ft_error::err
int err
Definition: vf_drawtext.c:427
key
const char * key
Definition: hwcontext_opencl.c:189
VAR_T
@ VAR_T
Definition: vf_drawtext.c:147
NAN
#define NAN
Definition: mathematics.h:115
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:182
command
static int command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Definition: vf_drawtext.c:1186
arg
const char * arg
Definition: jacosubdec.c:67
Glyph
A glyph as loaded and rendered using libfreetype.
Definition: vf_drawtext.c:212
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:73
time_internal.h
DrawTextContext::blank_advance64
int blank_advance64
the size of the space character
Definition: vf_drawtext.c:328
VAR_VSUB
@ VAR_VSUB
Definition: vf_drawtext.c:133
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
result
and forward the result(frame or status change) to the corresponding input. If nothing is possible
DrawTextContext::tab_clusters
uint32_t * tab_clusters
the position of tab characters in the text
Definition: vf_drawtext.c:326
NULL
#define NULL
Definition: coverity.c:32
draw_glyphs
static int draw_glyphs(DrawTextContext *s, AVFrame *frame, FFDrawColor *color, TextMetrics *metrics, int x, int y, int borderw)
Definition: vf_drawtext.c:1270
VAR_PICT_TYPE
@ VAR_PICT_TYPE
Definition: vf_drawtext.c:152
DrawTextContext::text_align
int text_align
the horizontal and vertical text alignment
Definition: vf_drawtext.c:321
ff_print_formatted_eval_expr
int ff_print_formatted_eval_expr(void *log_ctx, AVBPrint *bp, const char *expr, const char *const *fun_names, const ff_eval_func2 *fun_values, const char *const *var_names, const double *var_values, void *eval_ctx, const char format, int positions)
Definition: textutils.c:303
TextMetrics::offset_left64
int offset_left64
maximum offset between the origin and the leftmost pixel of the first glyph of each line (in 26....
Definition: vf_drawtext.c:228
GlyphInfo::code
uint32_t code
the glyph code point
Definition: vf_drawtext.c:192
DrawTextContext::basetime
int64_t basetime
base pts time in the real world for display
Definition: vf_drawtext.c:300
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVDetectionBBox::classify_labels
char classify_labels[AV_NUM_DETECTION_BBOX_CLASSIFY][AV_DETECTION_BBOX_LABEL_NAME_MAX_SIZE]
Definition: detection_bbox.h:52
AVDetectionBBoxHeader
Definition: detection_bbox.h:56
DrawTextContext::fontsize_expr
char * fontsize_expr
expression for fontsize
Definition: vf_drawtext.c:269
isnan
#define isnan(x)
Definition: libm.h:340
TextLine
Information about a single line of text.
Definition: vf_drawtext.c:200
AV_OPT_TYPE_COLOR
@ AV_OPT_TYPE_COLOR
Definition: opt.h:250
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: vf_drawtext.c:1080
textutils.h
parseutils.h
AVTreeNode
Definition: tree.c:26
DrawTextContext::tc_rate
AVRational tc_rate
frame rate for timecode
Definition: vf_drawtext.c:307
DrawTextContext::x_pexpr
AVExpr * x_pexpr
Definition: vf_drawtext.c:299
double
double
Definition: af_crystalizer.c:131
time.h
Glyph::code
uint32_t code
Definition: vf_drawtext.c:215
VAR_MAX_GLYPH_A
@ VAR_MAX_GLYPH_A
Definition: vf_drawtext.c:137
av_bprint_strftime
void av_bprint_strftime(AVBPrint *buf, const char *fmt, const struct tm *tm)
Append a formatted date and time to a print buffer.
Definition: bprint.c:181
TextLine::cluster_offset
int cluster_offset
the offset at which this line begins
Definition: vf_drawtext.c:208
av_tree_destroy
void av_tree_destroy(AVTreeNode *t)
Definition: tree.c:146
DrawTextContext
Definition: vf_drawtext.c:248
HarfbuzzData
Definition: vf_drawtext.c:182
DrawTextContext::tabsize
int tabsize
tab size
Definition: vf_drawtext.c:284
index
int index
Definition: gxfenc.c:90
var_names
static const char *const var_names[]
Definition: vf_drawtext.c:83
HarfbuzzData::glyph_info
hb_glyph_info_t * glyph_info
Definition: vf_drawtext.c:186
DrawTextContext::reload
int reload
reload text file at specified frame interval
Definition: vf_drawtext.c:310
source
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a source
Definition: filter_design.txt:255
DrawTextContext::text_source_string
char * text_source_string
the string to specify text data source
Definition: vf_drawtext.c:312
av_opt_copy
int av_opt_copy(void *dst, const void *src)
Copy options from src object into dest object.
Definition: opt.c:2110
VAR_h
@ VAR_h
Definition: vf_drawtext.c:135
DrawTextContext::bb_right
int bb_right
the size of the right box border
Definition: vf_drawtext.c:279
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_drawtext.c:1120
eval.h
TextLine::offset_left64
int offset_left64
offset between the origin and the leftmost pixel of the first glyph
Definition: vf_drawtext.c:201
AVLFG
Context structure for the Lagged Fibonacci PRNG.
Definition: lfg.h:33
Glyph::fontsize
unsigned int fontsize
Definition: vf_drawtext.c:216
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:94
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:240
shift
static int shift(int a, int b)
Definition: bonk.c:261
ff_blend_rectangle
void ff_blend_rectangle(FFDrawContext *draw, FFDrawColor *color, uint8_t *dst[], int dst_linesize[], int dst_w, int dst_h, int x0, int y0, int w, int h)
Blend a rectangle with an uniform color.
Definition: drawutils.c:353
localtime_r
#define localtime_r
Definition: time_internal.h:46
ff_print_eval_expr
int ff_print_eval_expr(void *log_ctx, AVBPrint *bp, const char *expr, const char *const *fun_names, const ff_eval_func2 *fun_values, const char *const *var_names, const double *var_values, void *eval_ctx)
Definition: textutils.c:281
Glyph::glyph
FT_Glyph glyph
Definition: vf_drawtext.c:213
ff_draw_init2
int ff_draw_init2(FFDrawContext *draw, enum AVPixelFormat format, enum AVColorSpace csp, enum AVColorRange range, unsigned flags)
Init a draw context.
Definition: drawutils.c:80
size
int size
Definition: twinvq_data.h:10344
DrawTextContext::draw_box
short int draw_box
draw box around text - true or false
Definition: vf_drawtext.c:275
YA_FONT
@ YA_FONT
Definition: vf_drawtext.c:172
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
AVFrameSideData::data
uint8_t * data
Definition: frame.h:252
DrawTextContext::shadowy
int shadowy
Definition: vf_drawtext.c:267
drand
static double drand(void *opaque, double min, double max)
Definition: vf_drawtext.c:119
tree.h
TextMetrics::width
int width
width of the longest line - ceil(width64/64)
Definition: vf_drawtext.c:235
EXP_NORMAL
@ EXP_NORMAL
Definition: vf_drawtext.c:165
ff_filter_process_command
int ff_filter_process_command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Generic processing of user supplied commands that are set in the same way as the filter options.
Definition: avfilter.c:887
header
static const uint8_t header[24]
Definition: sdr2.c:68
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:165
VAR_TEXT_W
@ VAR_TEXT_W
Definition: vf_drawtext.c:149
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(drawtext)
AVDetectionBBox::classify_count
uint32_t classify_count
Definition: detection_bbox.h:51
height
#define height
TextMetrics::max_y64
int max_y64
maximum value of bbox.yMax among glyphs (in 26.6 units)
Definition: vf_drawtext.c:239
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
AV_TIMECODE_FLAG_24HOURSMAX
@ AV_TIMECODE_FLAG_24HOURSMAX
timecode wraps after 24 hours
Definition: timecode.h:37
HarfbuzzData::buf
hb_buffer_t * buf
Definition: vf_drawtext.c:183
DrawTextContext::expanded_fontcolor
AVBPrint expanded_fontcolor
used to contain the expanded fontcolor spec
Definition: vf_drawtext.c:260
update_color_with_alpha
static void update_color_with_alpha(DrawTextContext *s, FFDrawColor *color, const FFDrawColor incolor)
Definition: vf_drawtext.c:1248
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
line
Definition: graph2dot.c:48
HarfbuzzData::glyph_pos
hb_glyph_position_t * glyph_pos
Definition: vf_drawtext.c:187
VAR_LH
@ VAR_LH
Definition: vf_drawtext.c:134
fun2
static const eval_func2 fun2[]
Definition: vf_drawtext.c:126
measure_text
static int measure_text(AVFilterContext *ctx, TextMetrics *metrics)
Definition: vf_drawtext.c:1392
internal.h
AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
Some filters support a generic "enable" expression option that can be used to enable or disable a fil...
Definition: avfilter.h:147
text_alignment
text_alignment
Definition: vf_drawtext.c:175
TA_BOTTOM
@ TA_BOTTOM
Definition: vf_drawtext.c:179
ff_print_pts
int ff_print_pts(void *log_ctx, AVBPrint *bp, double pts, const char *delta, const char *fmt, const char *strftime_fmt)
Definition: textutils.c:149
av_get_picture_type_char
char av_get_picture_type_char(enum AVPictureType pict_type)
Return a single letter to describe the given picture type pict_type.
Definition: utils.c:40
DrawTextContext::tab_warning_printed
int tab_warning_printed
ensure the tab warning to be printed only once
Definition: vf_drawtext.c:329
glyph_enu_free
static int glyph_enu_free(void *opaque, void *elem)
Definition: vf_drawtext.c:1102
bprint.h
TextMetrics::rect_x
int rect_x
x position of the box
Definition: vf_drawtext.c:244
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
DrawTextContext::tab_count
int tab_count
the number of tab characters
Definition: vf_drawtext.c:327
round
static av_always_inline av_const double round(double x)
Definition: libm.h:444
GlyphInfo
Information about a single glyph in a text line.
Definition: vf_drawtext.c:191
ff_draw_supported_pixel_formats
AVFilterFormats * ff_draw_supported_pixel_formats(unsigned flags)
Return the list of pixel formats supported by the draw functions.
Definition: drawutils.c:647
TFLAGS
#define TFLAGS
Definition: vf_drawtext.c:334
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
TA_LEFT
@ TA_LEFT
Definition: vf_drawtext.c:176
common.h
delta
float delta
Definition: vorbis_enc_data.h:430
DrawTextContext::shadowx
int shadowx
Definition: vf_drawtext.c:267
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
Glyph::border_glyph
FT_Glyph border_glyph
Definition: vf_drawtext.c:214
init
static av_cold int init(AVFilterContext *ctx)
Definition: vf_drawtext.c:967
DrawTextContext::max_glyph_h
int max_glyph_h
max glyph height
Definition: vf_drawtext.c:266
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
FFDrawContext
Definition: drawutils.h:35
Glyph::border_bglyph
FT_BitmapGlyph border_bglyph[16]
Outlined glyph bitmaps with 1/4 pixel precision in both directions.
Definition: vf_drawtext.c:220
TextMetrics::max_x64
int max_x64
maximum value of bbox.xMax among glyphs (in 26.6 units)
Definition: vf_drawtext.c:241
DrawTextContext::borderw
int borderw
border width
Definition: vf_drawtext.c:268
VAR_MAX_GLYPH_D
@ VAR_MAX_GLYPH_D
Definition: vf_drawtext.c:138
len
int len
Definition: vorbis_enc_data.h:426
VAR_W
@ VAR_W
Definition: vf_drawtext.c:136
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:39
config_input
static int config_input(AVFilterLink *inlink)
Definition: vf_drawtext.c:1143
DrawTextContext::box_width
int box_width
the width of box
Definition: vf_drawtext.c:282
GlyphInfo::shift_y64
int shift_y64
the vertical shift of the glyph in 26.6 units
Definition: vf_drawtext.c:196
ff_draw_color
void ff_draw_color(FFDrawContext *draw, FFDrawColor *color, const uint8_t rgba[4])
Prepare a color.
Definition: drawutils.c:156
DrawTextContext::bb_bottom
int bb_bottom
the size of the bottom box border
Definition: vf_drawtext.c:280
AVFilter
Filter definition.
Definition: avfilter.h:166
DrawTextContext::tc
AVTimecode tc
timecode context
Definition: vf_drawtext.c:308
expand_text_functions
static FFExpandTextFunction expand_text_functions[]
Definition: qrencode.c:287
DrawTextContext::y_align
int y_align
the value of the y_align parameter
Definition: vf_drawtext.c:322
ret
ret
Definition: filter_design.txt:187
EXP_STRFTIME
@ EXP_STRFTIME
Definition: vf_drawtext.c:166
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:99
VAR_HSUB
@ VAR_HSUB
Definition: vf_drawtext.c:133
TextMetrics::offset_bottom64
int offset_bottom64
descender amount of the last line (in 26.6 units)
Definition: vf_drawtext.c:227
VAR_DURATION
@ VAR_DURATION
Definition: vf_drawtext.c:159
DrawTextContext::ft_load_flags
int ft_load_flags
flags used for loading fonts, see FT_LOAD_*
Definition: vf_drawtext.c:261
GlyphInfo::x
int x
the x position of the glyph
Definition: vf_drawtext.c:193
random_seed.h
DrawTextContext::alpha
int alpha
Definition: vf_drawtext.c:304
DrawTextContext::boxborderw
char * boxborderw
box border width (padding) allowed formats: "all", "vert|oriz", "top|right|bottom|left"
Definition: vf_drawtext.c:276
ft_errors
static const struct ft_error ft_errors[]
VAR_w
@ VAR_w
Definition: vf_drawtext.c:136
drawtext_options
static const AVOption drawtext_options[]
Definition: vf_drawtext.c:336
DrawTextContext::shadowcolor
FFDrawColor shadowcolor
shadow color
Definition: vf_drawtext.c:289
DrawTextContext::reinit
int reinit
tells if the filter is being reinited
Definition: vf_drawtext.c:252
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:235
avfilter.h
av_bprint_clear
void av_bprint_clear(AVBPrint *buf)
Reset the string to "" but keep internal allocated data.
Definition: bprint.c:232
FFExpandTextContext
in a text template, followed by any character, always expands to the second character.
Definition: textutils.h:66
AVDetectionBBox::x
int x
Distance in pixels from the left/top edge of the frame, together with width and height,...
Definition: detection_bbox.h:31
glyph_enu_border_free
static int glyph_enu_border_free(void *opaque, void *elem)
Definition: vf_drawtext.c:1085
Glyph::bbox
FT_BBox bbox
Definition: vf_drawtext.c:221
av_tree_find
void * av_tree_find(const AVTreeNode *t, void *key, int(*cmp)(const void *key, const void *b), void *next[2])
Definition: tree.c:39
AVFilterContext
An instance of a filter.
Definition: avfilter.h:407
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:272
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
DrawTextContext::glyphs
struct AVTreeNode * glyphs
rendered glyphs, stored using the UTF-32 char code
Definition: vf_drawtext.c:296
mem.h
DrawTextContext::textfile
char * textfile
file with text to be drawn
Definition: vf_drawtext.c:262
DrawTextContext::boxw
int boxw
the value of the boxw parameter
Definition: vf_drawtext.c:319
HarfbuzzData::glyph_count
unsigned int glyph_count
Definition: vf_drawtext.c:185
TextLine::glyphs
GlyphInfo * glyphs
array of glyphs in this text line
Definition: vf_drawtext.c:207
TextMetrics::line_height64
int line_height64
the font-defined line height
Definition: vf_drawtext.c:234
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:250
VAR_FONT_A
@ VAR_FONT_A
Definition: vf_drawtext.c:141
func_eval_expr
static int func_eval_expr(void *ctx, AVBPrint *bp, const char *function_name, unsigned argc, char **argv)
Definition: qrencode.c:248
GlyphInfo::shift_x64
int shift_x64
the horizontal shift of the glyph in 26.6 units
Definition: vf_drawtext.c:195
AV_NUM_DETECTION_BBOX_CLASSIFY
#define AV_NUM_DETECTION_BBOX_CLASSIFY
At most 4 classifications based on the detected bounding box.
Definition: detection_bbox.h:50
TextLine::offset_right64
int offset_right64
maximum offset between the origin and the rightmost pixel of the last glyph
Definition: vf_drawtext.c:203
DrawTextContext::text_source
enum AVFrameSideDataType text_source
Definition: vf_drawtext.c:313
TextLine::hb_data
HarfbuzzData hb_data
libharfbuzz data of this text line
Definition: vf_drawtext.c:206
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVDictionaryEntry
Definition: dict.h:89
YA_BASELINE
@ YA_BASELINE
Definition: vf_drawtext.c:171
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
func_strftime
static int func_strftime(void *ctx, AVBPrint *bp, const char *function_name, unsigned argc, char **argv)
Definition: qrencode.c:226
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:251
DrawTextContext::y
double y
y position to start drawing text
Definition: vf_drawtext.c:264
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:183
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
VAR_DAR
@ VAR_DAR
Definition: vf_drawtext.c:132
FFMAX3
#define FFMAX3(a, b, c)
Definition: macros.h:48
DrawTextContext::boxcolor
FFDrawColor boxcolor
background color
Definition: vf_drawtext.c:291
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Definition: opt.h:234
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
av_strlcpy
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:85
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
y_alignment
y_alignment
Definition: vf_drawtext.c:169
AVDetectionBBox
Definition: detection_bbox.h:26
DrawTextContext::x
double x
x position to start drawing text
Definition: vf_drawtext.c:263
av_timecode_init_from_string
int av_timecode_init_from_string(AVTimecode *tc, AVRational rate, const char *str, void *log_ctx)
Parse timecode representation (hh:mm:ss[:;.
Definition: timecode.c:252
DrawTextContext::metadata
AVDictionary * metadata
Definition: vf_drawtext.c:317
AVDictionaryEntry::value
char * value
Definition: dict.h:91
avstring.h
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:239
drawutils.h
ft_error::err_msg
const char * err_msg
Definition: vf_drawtext.c:428
ft_error
Definition: vf_drawtext.c:426
AVTimecode
Definition: timecode.h:41
FT_ERRMSG
#define FT_ERRMSG(e)
DrawTextContext::y_expr
char * y_expr
expression for y position
Definition: vf_drawtext.c:298
int
int
Definition: ffmpeg_filter.c:424
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:244
ff_print_time
int ff_print_time(void *log_ctx, AVBPrint *bp, const char *strftime_fmt, char localtime)
Definition: textutils.c:202
DrawTextContext::line_spacing
int line_spacing
lines spacing in pixels
Definition: vf_drawtext.c:274
detection_bbox.h
DrawTextContext::fontcolor_expr
uint8_t * fontcolor_expr
fontcolor expression to evaluate
Definition: vf_drawtext.c:259
drawtext
static void drawtext(AVFrame *pic, int x, int y, const char *txt, uint32_t color)
Definition: af_aiir.c:1044
AV_FRAME_DATA_DETECTION_BBOXES
@ AV_FRAME_DATA_DETECTION_BBOXES
Bounding boxes for object detection and classification, as described by AVDetectionBBoxHeader.
Definition: frame.h:194
DrawTextContext::max_glyph_w
int max_glyph_w
max glyph width
Definition: vf_drawtext.c:265
DrawTextContext::tc_opt_string
char * tc_opt_string
specified timecode option string
Definition: vf_drawtext.c:306
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:155
DrawTextContext::fix_bounds
int fix_bounds
do we let it go out of frame bounds - t/f
Definition: vf_drawtext.c:285
min
float min
Definition: vorbis_enc_data.h:429
DrawTextContext::boxh
int boxh
the value of the boxh parameter
Definition: vf_drawtext.c:320
AVFILTERPAD_FLAG_NEEDS_WRITABLE
#define AVFILTERPAD_FLAG_NEEDS_WRITABLE
The filter expects writable frames from its input link, duplicating data buffers if needed.
Definition: internal.h:52
Generated on Wed Apr 24 2024 19:22:34 for FFmpeg by   doxygen 1.8.17