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 "filters.h"
64 #include "formats.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 const 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(const AVFilterContext *ctx,
1081  AVFilterFormatsConfig **cfg_in,
1082  AVFilterFormatsConfig **cfg_out)
1083 {
1084  return ff_set_common_formats2(ctx, cfg_in, cfg_out,
1085  ff_draw_supported_pixel_formats(0));
1086 }
1087 
1088 static int glyph_enu_border_free(void *opaque, void *elem)
1089 {
1090  Glyph *glyph = elem;
1091 
1092  if (glyph->border_glyph != NULL) {
1093  for (int t = 0; t < 16; ++t) {
1094  if (glyph->border_bglyph[t] != NULL) {
1095  FT_Done_Glyph((FT_Glyph)glyph->border_bglyph[t]);
1096  glyph->border_bglyph[t] = NULL;
1097  }
1098  }
1099  FT_Done_Glyph(glyph->border_glyph);
1100  glyph->border_glyph = NULL;
1101  }
1102  return 0;
1103 }
1104 
1105 static int glyph_enu_free(void *opaque, void *elem)
1106 {
1107  Glyph *glyph = elem;
1108 
1109  FT_Done_Glyph(glyph->glyph);
1110  FT_Done_Glyph(glyph->border_glyph);
1111  for (int t = 0; t < 16; ++t) {
1112  if (glyph->bglyph[t] != NULL) {
1113  FT_Done_Glyph((FT_Glyph)glyph->bglyph[t]);
1114  }
1115  if (glyph->border_bglyph[t] != NULL) {
1116  FT_Done_Glyph((FT_Glyph)glyph->border_bglyph[t]);
1117  }
1118  }
1119  av_free(elem);
1120  return 0;
1121 }
1122 
1123 static av_cold void uninit(AVFilterContext *ctx)
1124 {
1125  DrawTextContext *s = ctx->priv;
1126 
1127  av_expr_free(s->x_pexpr);
1128  av_expr_free(s->y_pexpr);
1129  av_expr_free(s->a_pexpr);
1130  av_expr_free(s->fontsize_pexpr);
1131 
1132  s->x_pexpr = s->y_pexpr = s->a_pexpr = s->fontsize_pexpr = NULL;
1133 
1134  av_tree_enumerate(s->glyphs, NULL, NULL, glyph_enu_free);
1135  av_tree_destroy(s->glyphs);
1136  s->glyphs = NULL;
1137 
1138  FT_Done_Face(s->face);
1139  FT_Stroker_Done(s->stroker);
1140  FT_Done_FreeType(s->library);
1141 
1142  av_bprint_finalize(&s->expanded_text, NULL);
1143  av_bprint_finalize(&s->expanded_fontcolor, NULL);
1144 }
1145 
1146 static int config_input(AVFilterLink *inlink)
1147 {
1148  AVFilterContext *ctx = inlink->dst;
1149  DrawTextContext *s = ctx->priv;
1150  char *expr;
1151  int ret;
1152 
1153  ff_draw_init2(&s->dc, inlink->format, inlink->colorspace, inlink->color_range, FF_DRAW_PROCESS_ALPHA);
1154  ff_draw_color(&s->dc, &s->fontcolor, s->fontcolor.rgba);
1155  ff_draw_color(&s->dc, &s->shadowcolor, s->shadowcolor.rgba);
1156  ff_draw_color(&s->dc, &s->bordercolor, s->bordercolor.rgba);
1157  ff_draw_color(&s->dc, &s->boxcolor, s->boxcolor.rgba);
1158 
1159  s->var_values[VAR_w] = s->var_values[VAR_W] = s->var_values[VAR_MAIN_W] = inlink->w;
1160  s->var_values[VAR_h] = s->var_values[VAR_H] = s->var_values[VAR_MAIN_H] = inlink->h;
1161  s->var_values[VAR_SAR] = inlink->sample_aspect_ratio.num ? av_q2d(inlink->sample_aspect_ratio) : 1;
1162  s->var_values[VAR_DAR] = (double)inlink->w / inlink->h * s->var_values[VAR_SAR];
1163  s->var_values[VAR_HSUB] = 1 << s->dc.hsub_max;
1164  s->var_values[VAR_VSUB] = 1 << s->dc.vsub_max;
1165  s->var_values[VAR_X] = NAN;
1166  s->var_values[VAR_Y] = NAN;
1167  s->var_values[VAR_T] = NAN;
1168 
1169  av_lfg_init(&s->prng, av_get_random_seed());
1170 
1171  av_expr_free(s->x_pexpr);
1172  av_expr_free(s->y_pexpr);
1173  av_expr_free(s->a_pexpr);
1174  s->x_pexpr = s->y_pexpr = s->a_pexpr = NULL;
1175 
1176  if ((ret = av_expr_parse(&s->x_pexpr, expr = s->x_expr, var_names,
1177  NULL, NULL, fun2_names, fun2, 0, ctx)) < 0 ||
1178  (ret = av_expr_parse(&s->y_pexpr, expr = s->y_expr, var_names,
1179  NULL, NULL, fun2_names, fun2, 0, ctx)) < 0 ||
1180  (ret = av_expr_parse(&s->a_pexpr, expr = s->a_expr, var_names,
1181  NULL, NULL, fun2_names, fun2, 0, ctx)) < 0) {
1182  av_log(ctx, AV_LOG_ERROR, "Failed to parse expression: %s \n", expr);
1183  return AVERROR(EINVAL);
1184  }
1185 
1186  return 0;
1187 }
1188 
1189 static int command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
1190 {
1191  DrawTextContext *old = ctx->priv;
1192  DrawTextContext *new = NULL;
1193  int ret;
1194 
1195  if (!strcmp(cmd, "reinit")) {
1196  new = av_mallocz(sizeof(DrawTextContext));
1197  if (!new)
1198  return AVERROR(ENOMEM);
1199 
1200  new->class = &drawtext_class;
1201  ret = av_opt_copy(new, old);
1202  if (ret < 0)
1203  goto fail;
1204 
1205  ctx->priv = new;
1206  ret = av_set_options_string(ctx, arg, "=", ":");
1207  if (ret < 0) {
1208  ctx->priv = old;
1209  goto fail;
1210  }
1211 
1212  ret = init(ctx);
1213  if (ret < 0) {
1214  uninit(ctx);
1215  ctx->priv = old;
1216  goto fail;
1217  }
1218 
1219  new->reinit = 1;
1220 
1221  ctx->priv = old;
1222  uninit(ctx);
1223  av_freep(&old);
1224 
1225  ctx->priv = new;
1226  return config_input(ctx->inputs[0]);
1227  } else {
1228  int old_borderw = old->borderw;
1229  if ((ret = ff_filter_process_command(ctx, cmd, arg, res, res_len, flags)) < 0) {
1230  return ret;
1231  }
1232  if (old->borderw != old_borderw) {
1233  FT_Stroker_Set(old->stroker, old->borderw << 6, FT_STROKER_LINECAP_ROUND,
1234  FT_STROKER_LINEJOIN_ROUND, 0);
1235  // Dispose the old border glyphs
1236  av_tree_enumerate(old->glyphs, NULL, NULL, glyph_enu_border_free);
1237  } else if (strcmp(cmd, "fontsize") == 0) {
1238  av_expr_free(old->fontsize_pexpr);
1239  old->fontsize_pexpr = NULL;
1240  old->blank_advance64 = 0;
1241  }
1242  return config_input(ctx->inputs[0]);
1243  }
1244 
1245 fail:
1246  av_log(ctx, AV_LOG_ERROR, "Failed to process command. Continuing with existing parameters.\n");
1247  av_freep(&new);
1248  return ret;
1249 }
1250 
1251 static void update_color_with_alpha(DrawTextContext *s, FFDrawColor *color, const FFDrawColor incolor)
1252 {
1253  *color = incolor;
1254  color->rgba[3] = (color->rgba[3] * s->alpha) / 255;
1255  ff_draw_color(&s->dc, color, color->rgba);
1256 }
1257 
1258 static void update_alpha(DrawTextContext *s)
1259 {
1260  double alpha = av_expr_eval(s->a_pexpr, s->var_values, &s->prng);
1261 
1262  if (isnan(alpha))
1263  return;
1264 
1265  if (alpha >= 1.0)
1266  s->alpha = 255;
1267  else if (alpha <= 0)
1268  s->alpha = 0;
1269  else
1270  s->alpha = 256 * alpha;
1271 }
1272 
1273 static int draw_glyphs(DrawTextContext *s, AVFrame *frame,
1274  FFDrawColor *color,
1275  TextMetrics *metrics,
1276  int x, int y, int borderw)
1277 {
1278  int g, l, x1, y1, w1, h1, idx;
1279  int dx = 0, dy = 0, pdx = 0;
1280  GlyphInfo *info;
1281  Glyph dummy = { 0 }, *glyph;
1282  FT_Bitmap bitmap;
1283  FT_BitmapGlyph b_glyph;
1284  uint8_t j_left = 0, j_right = 0, j_top = 0, j_bottom = 0;
1285  int line_w, offset_y = 0;
1286  int clip_x = 0, clip_y = 0;
1287 
1288  j_left = !!(s->text_align & TA_LEFT);
1289  j_right = !!(s->text_align & TA_RIGHT);
1290  j_top = !!(s->text_align & TA_TOP);
1291  j_bottom = !!(s->text_align & TA_BOTTOM);
1292 
1293  if (j_top && j_bottom) {
1294  offset_y = (s->box_height - metrics->height) / 2;
1295  } else if (j_bottom) {
1296  offset_y = s->box_height - metrics->height;
1297  }
1298 
1299  if ((!j_left || j_right) && !s->tab_warning_printed && s->tab_count > 0) {
1300  s->tab_warning_printed = 1;
1301  av_log(s, AV_LOG_WARNING, "Tab characters are only supported with left horizontal alignment\n");
1302  }
1303 
1304  clip_x = FFMIN(metrics->rect_x + s->box_width + s->bb_right, frame->width);
1305  clip_y = FFMIN(metrics->rect_y + s->box_height + s->bb_bottom, frame->height);
1306 
1307  for (l = 0; l < s->line_count; ++l) {
1308  TextLine *line = &s->lines[l];
1309  line_w = POS_CEIL(line->width64, 64);
1310  for (g = 0; g < line->hb_data.glyph_count; ++g) {
1311  info = &line->glyphs[g];
1312  dummy.fontsize = s->fontsize;
1313  dummy.code = info->code;
1314  glyph = av_tree_find(s->glyphs, &dummy, glyph_cmp, NULL);
1315  if (!glyph) {
1316  return AVERROR(EINVAL);
1317  }
1318 
1319  idx = get_subpixel_idx(info->shift_x64, info->shift_y64);
1320  b_glyph = borderw ? glyph->border_bglyph[idx] : glyph->bglyph[idx];
1321  bitmap = b_glyph->bitmap;
1322  x1 = x + info->x + b_glyph->left;
1323  y1 = y + info->y - b_glyph->top + offset_y;
1324  w1 = bitmap.width;
1325  h1 = bitmap.rows;
1326 
1327  if (j_left && j_right) {
1328  x1 += (s->box_width - line_w) / 2;
1329  } else if (j_right) {
1330  x1 += s->box_width - line_w;
1331  }
1332 
1333  // Offset of the glyph's bitmap in the visible region
1334  dx = dy = 0;
1335  if (x1 < metrics->rect_x - s->bb_left) {
1336  dx = metrics->rect_x - s->bb_left - x1;
1337  x1 = metrics->rect_x - s->bb_left;
1338  }
1339  if (y1 < metrics->rect_y - s->bb_top) {
1340  dy = metrics->rect_y - s->bb_top - y1;
1341  y1 = metrics->rect_y - s->bb_top;
1342  }
1343 
1344  // check if the glyph is empty or out of the clipping region
1345  if (dx >= w1 || dy >= h1 || x1 >= clip_x || y1 >= clip_y) {
1346  continue;
1347  }
1348 
1349  pdx = dx + dy * bitmap.pitch;
1350  w1 = FFMIN(clip_x - x1, w1 - dx);
1351  h1 = FFMIN(clip_y - y1, h1 - dy);
1352 
1353  ff_blend_mask(&s->dc, color, frame->data, frame->linesize, clip_x, clip_y,
1354  bitmap.buffer + pdx, bitmap.pitch, w1, h1, 3, 0, x1, y1);
1355  }
1356  }
1357 
1358  return 0;
1359 }
1360 
1361 // Shapes a line of text using libharfbuzz
1362 static int shape_text_hb(DrawTextContext *s, HarfbuzzData* hb, const char* text, int textLen)
1363 {
1364  hb->buf = hb_buffer_create();
1365  if(!hb_buffer_allocation_successful(hb->buf)) {
1366  return AVERROR(ENOMEM);
1367  }
1368  hb_buffer_set_direction(hb->buf, HB_DIRECTION_LTR);
1369  hb_buffer_set_script(hb->buf, HB_SCRIPT_LATIN);
1370  hb_buffer_set_language(hb->buf, hb_language_from_string("en", -1));
1371  hb_buffer_guess_segment_properties(hb->buf);
1372  hb->font = hb_ft_font_create(s->face, NULL);
1373  if(hb->font == NULL) {
1374  return AVERROR(ENOMEM);
1375  }
1376  hb_ft_font_set_funcs(hb->font);
1377  hb_buffer_add_utf8(hb->buf, text, textLen, 0, -1);
1378  hb_shape(hb->font, hb->buf, NULL, 0);
1379  hb->glyph_info = hb_buffer_get_glyph_infos(hb->buf, &hb->glyph_count);
1380  hb->glyph_pos = hb_buffer_get_glyph_positions(hb->buf, &hb->glyph_count);
1381 
1382  return 0;
1383 }
1384 
1385 static void hb_destroy(HarfbuzzData *hb)
1386 {
1387  hb_buffer_destroy(hb->buf);
1388  hb_font_destroy(hb->font);
1389  hb->buf = NULL;
1390  hb->font = NULL;
1391  hb->glyph_info = NULL;
1392  hb->glyph_pos = NULL;
1393 }
1394 
1395 static int measure_text(AVFilterContext *ctx, TextMetrics *metrics)
1396 {
1397  DrawTextContext *s = ctx->priv;
1398  char *text = s->expanded_text.str;
1399  char *textdup = NULL, *start = NULL;
1400  int num_chars = 0;
1401  int width64 = 0, w64 = 0;
1402  int cur_min_y64 = 0, first_max_y64 = -32000;
1403  int first_min_x64 = 32000, last_max_x64 = -32000;
1404  int min_y64 = 32000, max_y64 = -32000, min_x64 = 32000, max_x64 = -32000;
1405  int line_count = 0;
1406  uint32_t code = 0;
1407  Glyph *glyph = NULL;
1408 
1409  int i, tab_idx = 0, last_tab_idx = 0, line_offset = 0;
1410  char* p;
1411  int ret = 0;
1412 
1413  // Count the lines and the tab characters
1414  s->tab_count = 0;
1415  for (i = 0, p = text; 1; i++) {
1416  GET_UTF8(code, *p ? *p++ : 0, code = 0xfffd; goto continue_on_failed;);
1417 continue_on_failed:
1418  if (ff_is_newline(code) || code == 0) {
1419  ++line_count;
1420  if (code == 0) {
1421  break;
1422  }
1423  } else if (code == '\t') {
1424  ++s->tab_count;
1425  }
1426  }
1427 
1428  // Evaluate the width of the space character if needed to replace tabs
1429  if (s->tab_count > 0 && !s->blank_advance64) {
1430  HarfbuzzData hb_data;
1431  ret = shape_text_hb(s, &hb_data, " ", 1);
1432  if(ret != 0) {
1433  goto done;
1434  }
1435  s->blank_advance64 = hb_data.glyph_pos[0].x_advance;
1436  hb_destroy(&hb_data);
1437  }
1438 
1439  s->line_count = line_count;
1440  s->lines = av_mallocz(line_count * sizeof(TextLine));
1441  s->tab_clusters = av_mallocz(s->tab_count * sizeof(uint32_t));
1442  for (i = 0; i < s->tab_count; ++i) {
1443  s->tab_clusters[i] = -1;
1444  }
1445 
1446  start = textdup = av_strdup(text);
1447  if (textdup == NULL) {
1448  ret = AVERROR(ENOMEM);
1449  goto done;
1450  }
1451  line_count = 0;
1452  for (i = 0, p = textdup; 1; i++) {
1453  if (*p == '\t') {
1454  s->tab_clusters[tab_idx++] = i;
1455  *p = ' ';
1456  }
1457  GET_UTF8(code, *p ? *p++ : 0, code = 0xfffd; goto continue_on_failed2;);
1458 continue_on_failed2:
1459  if (ff_is_newline(code) || code == 0) {
1460  TextLine *cur_line = &s->lines[line_count];
1461  HarfbuzzData *hb = &cur_line->hb_data;
1462  cur_line->cluster_offset = line_offset;
1463  ret = shape_text_hb(s, hb, start, num_chars);
1464  if (ret != 0) {
1465  goto done;
1466  }
1467  w64 = 0;
1468  cur_min_y64 = 32000;
1469  for (int t = 0; t < hb->glyph_count; ++t) {
1470  uint8_t is_tab = last_tab_idx < s->tab_count &&
1471  hb->glyph_info[t].cluster == s->tab_clusters[last_tab_idx] - line_offset;
1472  if (is_tab) {
1473  ++last_tab_idx;
1474  }
1475  ret = load_glyph(ctx, &glyph, hb->glyph_info[t].codepoint, -1, -1);
1476  if (ret != 0) {
1477  goto done;
1478  }
1479  if (line_count == 0) {
1480  first_max_y64 = FFMAX(glyph->bbox.yMax, first_max_y64);
1481  }
1482  if (t == 0) {
1483  cur_line->offset_left64 = glyph->bbox.xMin;
1484  first_min_x64 = FFMIN(glyph->bbox.xMin, first_min_x64);
1485  }
1486  if (t == hb->glyph_count - 1) {
1487  // The following code measures the width of the line up to the last
1488  // character's horizontal advance
1489  int last_char_width = hb->glyph_pos[t].x_advance;
1490 
1491  // The following code measures the width of the line up to the rightmost
1492  // visible pixel of the last character
1493  // int last_char_width = glyph->bbox.xMax;
1494 
1495  w64 += last_char_width;
1496  last_max_x64 = FFMAX(last_char_width, last_max_x64);
1497  cur_line->offset_right64 = last_char_width;
1498  } else {
1499  if (is_tab) {
1500  int size = s->blank_advance64 * s->tabsize;
1501  w64 = (w64 / size + 1) * size;
1502  } else {
1503  w64 += hb->glyph_pos[t].x_advance;
1504  }
1505  }
1506  cur_min_y64 = FFMIN(glyph->bbox.yMin, cur_min_y64);
1507  min_y64 = FFMIN(glyph->bbox.yMin, min_y64);
1508  max_y64 = FFMAX(glyph->bbox.yMax, max_y64);
1509  min_x64 = FFMIN(glyph->bbox.xMin, min_x64);
1510  max_x64 = FFMAX(glyph->bbox.xMax, max_x64);
1511  }
1512 
1513  cur_line->width64 = w64;
1514 
1515  av_log(s, AV_LOG_DEBUG, " Line: %d -- glyphs count: %d - width64: %d - offset_left64: %d - offset_right64: %d)\n",
1516  line_count, hb->glyph_count, cur_line->width64, cur_line->offset_left64, cur_line->offset_right64);
1517 
1518  if (w64 > width64) {
1519  width64 = w64;
1520  }
1521  num_chars = -1;
1522  start = p;
1523  ++line_count;
1524  line_offset = i + 1;
1525  }
1526 
1527  if (code == 0) break;
1528  ++num_chars;
1529  }
1530 
1531  metrics->line_height64 = s->face->size->metrics.height;
1532 
1533  metrics->width = POS_CEIL(width64, 64);
1534  if (s->y_align == YA_FONT) {
1535  metrics->height = POS_CEIL(metrics->line_height64 * line_count, 64);
1536  } else {
1537  int height64 = (metrics->line_height64 + s->line_spacing * 64) *
1538  (FFMAX(0, line_count - 1)) + first_max_y64 - cur_min_y64;
1539  metrics->height = POS_CEIL(height64, 64);
1540  }
1541  metrics->offset_top64 = first_max_y64;
1542  metrics->offset_right64 = last_max_x64;
1543  metrics->offset_bottom64 = cur_min_y64;
1544  metrics->offset_left64 = first_min_x64;
1545  metrics->min_x64 = min_x64;
1546  metrics->min_y64 = min_y64;
1547  metrics->max_x64 = max_x64;
1548  metrics->max_y64 = max_y64;
1549 
1550 done:
1551  av_free(textdup);
1552  return ret;
1553 }
1554 
1555 static int draw_text(AVFilterContext *ctx, AVFrame *frame)
1556 {
1557  DrawTextContext *s = ctx->priv;
1558  AVFilterLink *inlink = ctx->inputs[0];
1559  FilterLink *inl = ff_filter_link(inlink);
1560  int x = 0, y = 0, ret;
1561  int shift_x64, shift_y64;
1562  int x64, y64;
1563  Glyph *glyph = NULL;
1564 
1565  time_t now = time(0);
1566  struct tm ltime;
1567  AVBPrint *bp = &s->expanded_text;
1568 
1569  FFDrawColor fontcolor;
1570  FFDrawColor shadowcolor;
1571  FFDrawColor bordercolor;
1572  FFDrawColor boxcolor;
1573 
1574  int width = frame->width;
1575  int height = frame->height;
1576  int rec_x = 0, rec_y = 0, rec_width = 0, rec_height = 0;
1577  int is_outside = 0;
1578  int last_tab_idx = 0;
1579 
1580  TextMetrics metrics;
1581 
1582  av_bprint_clear(bp);
1583 
1584  if (s->basetime != AV_NOPTS_VALUE)
1585  now= frame->pts*av_q2d(ctx->inputs[0]->time_base) + s->basetime/1000000;
1586 
1587  switch (s->exp_mode) {
1588  case EXP_NONE:
1589  av_bprintf(bp, "%s", s->text);
1590  break;
1591  case EXP_NORMAL:
1592  if ((ret = ff_expand_text(&s->expand_text, s->text, &s->expanded_text)) < 0)
1593  return ret;
1594  break;
1595  case EXP_STRFTIME:
1596  localtime_r(&now, &ltime);
1597  av_bprint_strftime(bp, s->text, &ltime);
1598  break;
1599  }
1600 
1601  if (s->tc_opt_string) {
1602  char tcbuf[AV_TIMECODE_STR_SIZE];
1603  av_timecode_make_string(&s->tc, tcbuf, inl->frame_count_out);
1604  av_bprint_clear(bp);
1605  av_bprintf(bp, "%s%s", s->text, tcbuf);
1606  }
1607 
1608  if (!av_bprint_is_complete(bp))
1609  return AVERROR(ENOMEM);
1610 
1611  if (s->fontcolor_expr[0]) {
1612  /* If expression is set, evaluate and replace the static value */
1613  av_bprint_clear(&s->expanded_fontcolor);
1614  if ((ret = ff_expand_text(&s->expand_text, s->fontcolor_expr, &s->expanded_fontcolor)) < 0)
1615  return ret;
1616  if (!av_bprint_is_complete(&s->expanded_fontcolor))
1617  return AVERROR(ENOMEM);
1618  av_log(s, AV_LOG_DEBUG, "Evaluated fontcolor is '%s'\n", s->expanded_fontcolor.str);
1619  ret = av_parse_color(s->fontcolor.rgba, s->expanded_fontcolor.str, -1, s);
1620  if (ret)
1621  return ret;
1622  ff_draw_color(&s->dc, &s->fontcolor, s->fontcolor.rgba);
1623  }
1624 
1625  if ((ret = update_fontsize(ctx)) < 0) {
1626  return ret;
1627  }
1628 
1629  if ((ret = measure_text(ctx, &metrics)) < 0) {
1630  return ret;
1631  }
1632 
1633  s->max_glyph_h = POS_CEIL(metrics.max_y64 - metrics.min_y64, 64);
1634  s->max_glyph_w = POS_CEIL(metrics.max_x64 - metrics.min_x64, 64);
1635 
1636  s->var_values[VAR_TW] = s->var_values[VAR_TEXT_W] = metrics.width;
1637  s->var_values[VAR_TH] = s->var_values[VAR_TEXT_H] = metrics.height;
1638 
1639  s->var_values[VAR_MAX_GLYPH_W] = s->max_glyph_w;
1640  s->var_values[VAR_MAX_GLYPH_H] = s->max_glyph_h;
1641  s->var_values[VAR_MAX_GLYPH_A] = s->var_values[VAR_ASCENT] = POS_CEIL(metrics.max_y64, 64);
1642  s->var_values[VAR_FONT_A] = s->face->size->metrics.ascender / 64;
1643  s->var_values[VAR_MAX_GLYPH_D] = s->var_values[VAR_DESCENT] = POS_CEIL(metrics.min_y64, 64);
1644  s->var_values[VAR_FONT_D] = -s->face->size->metrics.descender / 64;
1645 
1646  s->var_values[VAR_TOP_A] = POS_CEIL(metrics.offset_top64, 64);
1647  s->var_values[VAR_BOTTOM_D] = -POS_CEIL(metrics.offset_bottom64, 64);
1648  s->var_values[VAR_LINE_H] = s->var_values[VAR_LH] = metrics.line_height64 / 64.;
1649 
1650  if (s->text_source == AV_FRAME_DATA_DETECTION_BBOXES) {
1651  s->var_values[VAR_X] = s->x;
1652  s->var_values[VAR_Y] = s->y;
1653  } else {
1654  s->x = s->var_values[VAR_X] = av_expr_eval(s->x_pexpr, s->var_values, &s->prng);
1655  s->y = s->var_values[VAR_Y] = av_expr_eval(s->y_pexpr, s->var_values, &s->prng);
1656  /* It is necessary if x is expressed from y */
1657  s->x = s->var_values[VAR_X] = av_expr_eval(s->x_pexpr, s->var_values, &s->prng);
1658  }
1659 
1660  update_alpha(s);
1661  update_color_with_alpha(s, &fontcolor , s->fontcolor );
1662  update_color_with_alpha(s, &shadowcolor, s->shadowcolor);
1663  update_color_with_alpha(s, &bordercolor, s->bordercolor);
1664  update_color_with_alpha(s, &boxcolor , s->boxcolor );
1665 
1666  if (s->draw_box && s->boxborderw) {
1667  int bbsize[4];
1668  int count;
1669  count = string_to_array(s->boxborderw, bbsize, 4);
1670  if (count == 1) {
1671  s->bb_top = s->bb_right = s->bb_bottom = s->bb_left = bbsize[0];
1672  } else if (count == 2) {
1673  s->bb_top = s->bb_bottom = bbsize[0];
1674  s->bb_right = s->bb_left = bbsize[1];
1675  } else if (count == 3) {
1676  s->bb_top = bbsize[0];
1677  s->bb_right = s->bb_left = bbsize[1];
1678  s->bb_bottom = bbsize[2];
1679  } else if (count == 4) {
1680  s->bb_top = bbsize[0];
1681  s->bb_right = bbsize[1];
1682  s->bb_bottom = bbsize[2];
1683  s->bb_left = bbsize[3];
1684  }
1685  } else {
1686  s->bb_top = s->bb_right = s->bb_bottom = s->bb_left = 0;
1687  }
1688 
1689  if (s->fix_bounds) {
1690  /* calculate footprint of text effects */
1691  int borderoffset = s->borderw ? FFMAX(s->borderw, 0) : 0;
1692 
1693  int offsetleft = FFMAX3(FFMAX(s->bb_left, 0), borderoffset,
1694  (s->shadowx < 0 ? FFABS(s->shadowx) : 0));
1695  int offsettop = FFMAX3(FFMAX(s->bb_top, 0), borderoffset,
1696  (s->shadowy < 0 ? FFABS(s->shadowy) : 0));
1697  int offsetright = FFMAX3(FFMAX(s->bb_right, 0), borderoffset,
1698  (s->shadowx > 0 ? s->shadowx : 0));
1699  int offsetbottom = FFMAX3(FFMAX(s->bb_bottom, 0), borderoffset,
1700  (s->shadowy > 0 ? s->shadowy : 0));
1701 
1702  if (s->x - offsetleft < 0) s->x = offsetleft;
1703  if (s->y - offsettop < 0) s->y = offsettop;
1704 
1705  if (s->x + metrics.width + offsetright > width)
1706  s->x = FFMAX(width - metrics.width - offsetright, 0);
1707  if (s->y + metrics.height + offsetbottom > height)
1708  s->y = FFMAX(height - metrics.height - offsetbottom, 0);
1709  }
1710 
1711  x = 0;
1712  y = 0;
1713  x64 = (int)(s->x * 64.);
1714  if (s->y_align == YA_FONT) {
1715  y64 = (int)(s->y * 64. + s->face->size->metrics.ascender);
1716  } else if (s->y_align == YA_BASELINE) {
1717  y64 = (int)(s->y * 64.);
1718  } else {
1719  y64 = (int)(s->y * 64. + metrics.offset_top64);
1720  }
1721 
1722  for (int l = 0; l < s->line_count; ++l) {
1723  TextLine *line = &s->lines[l];
1724  HarfbuzzData *hb = &line->hb_data;
1725  line->glyphs = av_mallocz(hb->glyph_count * sizeof(GlyphInfo));
1726 
1727  for (int t = 0; t < hb->glyph_count; ++t) {
1728  GlyphInfo *g_info = &line->glyphs[t];
1729  uint8_t is_tab = last_tab_idx < s->tab_count &&
1730  hb->glyph_info[t].cluster == s->tab_clusters[last_tab_idx] - line->cluster_offset;
1731  int true_x, true_y;
1732  if (is_tab) {
1733  ++last_tab_idx;
1734  }
1735  true_x = x + hb->glyph_pos[t].x_offset;
1736  true_y = y + hb->glyph_pos[t].y_offset;
1737  shift_x64 = (((x64 + true_x) >> 4) & 0b0011) << 4;
1738  shift_y64 = ((4 - (((y64 + true_y) >> 4) & 0b0011)) & 0b0011) << 4;
1739 
1740  ret = load_glyph(ctx, &glyph, hb->glyph_info[t].codepoint, shift_x64, shift_y64);
1741  if (ret != 0) {
1742  return ret;
1743  }
1744  g_info->code = hb->glyph_info[t].codepoint;
1745  g_info->x = (x64 + true_x) >> 6;
1746  g_info->y = ((y64 + true_y) >> 6) + (shift_y64 > 0 ? 1 : 0);
1747  g_info->shift_x64 = shift_x64;
1748  g_info->shift_y64 = shift_y64;
1749 
1750  if (!is_tab) {
1751  x += hb->glyph_pos[t].x_advance;
1752  } else {
1753  int size = s->blank_advance64 * s->tabsize;
1754  x = (x / size + 1) * size;
1755  }
1756  y += hb->glyph_pos[t].y_advance;
1757  }
1758 
1759  y += metrics.line_height64 + s->line_spacing * 64;
1760  x = 0;
1761  }
1762 
1763  metrics.rect_x = s->x;
1764  if (s->y_align == YA_BASELINE) {
1765  metrics.rect_y = s->y - metrics.offset_top64 / 64;
1766  } else {
1767  metrics.rect_y = s->y;
1768  }
1769 
1770  s->box_width = s->boxw == 0 ? metrics.width : s->boxw;
1771  s->box_height = s->boxh == 0 ? metrics.height : s->boxh;
1772 
1773  if (!s->draw_box) {
1774  // Create a border for the clipping region to take into account subpixel
1775  // errors in text measurement and effects.
1776  int borderoffset = s->borderw ? FFMAX(s->borderw, 0) : 0;
1777  s->bb_left = borderoffset + (s->shadowx < 0 ? FFABS(s->shadowx) : 0) + 1;
1778  s->bb_top = borderoffset + (s->shadowy < 0 ? FFABS(s->shadowy) : 0) + 1;
1779  s->bb_right = borderoffset + (s->shadowx > 0 ? s->shadowx : 0) + 1;
1780  s->bb_bottom = borderoffset + (s->shadowy > 0 ? s->shadowy : 0) + 1;
1781  }
1782 
1783  /* Check if the whole box is out of the frame */
1784  is_outside = metrics.rect_x - s->bb_left >= width ||
1785  metrics.rect_y - s->bb_top >= height ||
1786  metrics.rect_x + s->box_width + s->bb_right <= 0 ||
1787  metrics.rect_y + s->box_height + s->bb_bottom <= 0;
1788 
1789  if (!is_outside) {
1790  /* draw box */
1791  if (s->draw_box) {
1792  rec_x = metrics.rect_x - s->bb_left;
1793  rec_y = metrics.rect_y - s->bb_top;
1794  rec_width = s->box_width + s->bb_right + s->bb_left;
1795  rec_height = s->box_height + s->bb_bottom + s->bb_top;
1796  ff_blend_rectangle(&s->dc, &boxcolor,
1797  frame->data, frame->linesize, width, height,
1798  rec_x, rec_y, rec_width, rec_height);
1799  }
1800 
1801  if (s->shadowx || s->shadowy) {
1802  if ((ret = draw_glyphs(s, frame, &shadowcolor, &metrics,
1803  s->shadowx, s->shadowy, s->borderw)) < 0) {
1804  return ret;
1805  }
1806  }
1807 
1808  if (s->borderw) {
1809  if ((ret = draw_glyphs(s, frame, &bordercolor, &metrics,
1810  0, 0, s->borderw)) < 0) {
1811  return ret;
1812  }
1813  }
1814 
1815  if ((ret = draw_glyphs(s, frame, &fontcolor, &metrics, 0,
1816  0, 0)) < 0) {
1817  return ret;
1818  }
1819  }
1820 
1821  // FREE data structures
1822  for (int l = 0; l < s->line_count; ++l) {
1823  TextLine *line = &s->lines[l];
1824  av_freep(&line->glyphs);
1825  hb_destroy(&line->hb_data);
1826  }
1827  av_freep(&s->lines);
1828  av_freep(&s->tab_clusters);
1829 
1830  return 0;
1831 }
1832 
1833 static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
1834 {
1835  FilterLink *inl = ff_filter_link(inlink);
1836  AVFilterContext *ctx = inlink->dst;
1837  AVFilterLink *outlink = ctx->outputs[0];
1838  DrawTextContext *s = ctx->priv;
1839  int ret;
1840  const AVDetectionBBoxHeader *header = NULL;
1841  const AVDetectionBBox *bbox;
1842  AVFrameSideData *sd;
1843  int loop = 1;
1844 
1845  if (s->text_source == AV_FRAME_DATA_DETECTION_BBOXES) {
1846  sd = av_frame_get_side_data(frame, AV_FRAME_DATA_DETECTION_BBOXES);
1847  if (sd) {
1848  header = (AVDetectionBBoxHeader *)sd->data;
1849  loop = header->nb_bboxes;
1850  } else {
1851  av_log(s, AV_LOG_WARNING, "No detection bboxes.\n");
1852  return ff_filter_frame(outlink, frame);
1853  }
1854  }
1855 
1856  if (s->reload && !(inl->frame_count_out % s->reload)) {
1857  if ((ret = ff_load_textfile(ctx, (const char *)s->textfile, &s->text, NULL)) < 0) {
1858  av_frame_free(&frame);
1859  return ret;
1860  }
1861 #if CONFIG_LIBFRIBIDI
1862  if (s->text_shaping)
1863  if ((ret = shape_text(ctx)) < 0) {
1864  av_frame_free(&frame);
1865  return ret;
1866  }
1867 #endif
1868  }
1869 
1870  s->var_values[VAR_N] = inl->frame_count_out + s->start_number;
1871  s->var_values[VAR_T] = frame->pts == AV_NOPTS_VALUE ?
1872  NAN : frame->pts * av_q2d(inlink->time_base);
1873 
1874  s->var_values[VAR_PICT_TYPE] = frame->pict_type;
1875 #if FF_API_FRAME_PKT
1876 FF_DISABLE_DEPRECATION_WARNINGS
1877  s->var_values[VAR_PKT_POS] = frame->pkt_pos;
1878  s->var_values[VAR_PKT_SIZE] = frame->pkt_size;
1879 FF_ENABLE_DEPRECATION_WARNINGS
1880 #endif
1881  s->var_values[VAR_DURATION] = frame->duration * av_q2d(inlink->time_base);
1882 
1883  s->metadata = frame->metadata;
1884 
1885  for (int i = 0; i < loop; i++) {
1886  if (header) {
1887  bbox = av_get_detection_bbox(header, i);
1888  strcpy(s->text, bbox->detect_label);
1889  for (int j = 0; j < bbox->classify_count; j++) {
1890  strcat(s->text, ", ");
1891  strcat(s->text, bbox->classify_labels[j]);
1892  }
1893  s->x = bbox->x;
1894  s->y = bbox->y - s->fontsize;
1895  }
1896  draw_text(ctx, frame);
1897  }
1898 
1899  return ff_filter_frame(outlink, frame);
1900 }
1901 
1902 static const AVFilterPad avfilter_vf_drawtext_inputs[] = {
1903  {
1904  .name = "default",
1905  .type = AVMEDIA_TYPE_VIDEO,
1906  .flags = AVFILTERPAD_FLAG_NEEDS_WRITABLE,
1907  .filter_frame = filter_frame,
1908  .config_props = config_input,
1909  },
1910 };
1911 
1912 const AVFilter ff_vf_drawtext = {
1913  .name = "drawtext",
1914  .description = NULL_IF_CONFIG_SMALL("Draw text on top of video frames using libfreetype library."),
1915  .priv_size = sizeof(DrawTextContext),
1916  .priv_class = &drawtext_class,
1917  .init = init,
1918  .uninit = uninit,
1919  FILTER_INPUTS(avfilter_vf_drawtext_inputs),
1920  FILTER_OUTPUTS(ff_video_default_filterpad),
1921  FILTER_QUERY_FUNC2(query_formats),
1922  .process_command = command,
1923  .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
1924 };
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:215
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:51
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
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:513
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:951
VAR_TOP_A
@ VAR_TOP_A
Definition: vf_drawtext.c:143
ff_vf_drawtext
const AVFilter ff_vf_drawtext
Definition: vf_drawtext.c:1912
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
Definition: vf_drawtext.c:1833
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1062
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
ff_set_common_formats2
int ff_set_common_formats2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, AVFilterFormats *formats)
Definition: formats.c:1007
int64_t
long long int64_t
Definition: coverity.c:34
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:162
draw_text
static int draw_text(AVFilterContext *ctx, AVFrame *frame)
Definition: vf_drawtext.c:1555
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: filters.h:262
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
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:1362
VAR_DESCENT
@ VAR_DESCENT
Definition: vf_drawtext.c:138
AVOption
AVOption.
Definition: opt.h:429
b
#define b
Definition: input.c:41
TextMetrics
Global text metrics.
Definition: vf_drawtext.c:225
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:225
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:205
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
Underlying C type is AVRational.
Definition: opt.h:280
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
expand_text_functions
static const FFExpandTextFunction expand_text_functions[]
Definition: qrencode.c:287
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:188
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
hb_destroy
static void hb_destroy(HarfbuzzData *hb)
Definition: vf_drawtext.c:1385
pts
static int64_t pts
Definition: transcode_aac.c:644
ff_expand_text
int ff_expand_text(FFExpandTextContext *expand_text, const char *text, AVBPrint *bp)
Expand text template.
Definition: textutils.c:123
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:549
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: filters.h:38
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:488
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:1902
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
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
update_alpha
static void update_alpha(DrawTextContext *s)
Definition: vf_drawtext.c:1258
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
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:63
AV_OPT_TYPE_INT64
@ AV_OPT_TYPE_INT64
Underlying C type is int64_t.
Definition: opt.h:263
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
filters.h
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:1809
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
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
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: filters.h:263
VAR_T
@ VAR_T
Definition: vf_drawtext.c:147
NAN
#define NAN
Definition: mathematics.h:115
command
static int command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Definition: vf_drawtext.c:1189
query_formats
static int query_formats(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out)
Definition: vf_drawtext.c:1080
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:74
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:75
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:1273
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
Underlying C type is uint8_t[4].
Definition: opt.h:323
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:132
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
AVFilterFormatsConfig
Lists of formats / etc.
Definition: avfilter.h:111
ff_filter_link
static FilterLink * ff_filter_link(AVFilterLink *link)
Definition: filters.h:197
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:2143
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:1123
eval.h
AVFILTERPAD_FLAG_NEEDS_WRITABLE
#define AVFILTERPAD_FLAG_NEEDS_WRITABLE
The filter expects writable frames from its input link, duplicating data buffers if needed.
Definition: filters.h:57
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
height
#define height
Definition: dsp.h:85
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:368
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:95
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:267
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:901
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:166
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
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:1251
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:1395
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:182
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:1105
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:662
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
FILTER_QUERY_FUNC2
#define FILTER_QUERY_FUNC2(func)
Definition: filters.h:239
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:36
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: filters.h:44
config_input
static int config_input(AVFilterLink *inlink)
Definition: vf_drawtext.c:1146
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:171
DrawTextContext::bb_bottom
int bb_bottom
the size of the bottom box border
Definition: vf_drawtext.c:280
AVFilter
Filter definition.
Definition: avfilter.h:201
DrawTextContext::tc
AVTimecode tc
timecode context
Definition: vf_drawtext.c:308
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
Underlying C type is int.
Definition: opt.h:259
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:1088
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:457
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:265
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
Underlying C type is int.
Definition: opt.h:327
DrawTextContext::y
double y
y position to start drawing text
Definition: vf_drawtext.c:264
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
Underlying C type is unsigned int.
Definition: opt.h:255
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
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:253
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
Underlying C type is a uint8_t* that is either NULL or points to a C string allocated with the av_mal...
Definition: opt.h:276
width
#define width
Definition: dsp.h:85
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
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
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:1035
av_timecode_make_string
char * av_timecode_make_string(const AVTimecode *tc, char *buf, int framenum_arg)
Load timecode string in buf.
Definition: timecode.c:103
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
Generated on Wed Nov 6 2024 19:22:37 for FFmpeg by   doxygen 1.8.17