hevc: simplify rounding
[ffmpeg.git] / libavfilter / vf_drawtext.c
1 /*
2  * Copyright (c) 2011 Stefano Sabatini
3  * Copyright (c) 2010 S.N. Hemanth Meenakshisundaram
4  * Copyright (c) 2003 Gustavo Sverzut Barbieri <gsbarbieri@yahoo.com.br>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22
23 /**
24  * @file
25  * drawtext filter, based on the original vhook/drawtext.c
26  * filter by Gustavo Sverzut Barbieri
27  */
28
29 #include "config.h"
30
31 #if HAVE_SYS_TIME_H
32 #include <sys/time.h>
33 #endif
34 #include <sys/types.h>
35 #include <sys/stat.h>
36 #include <time.h>
37 #if HAVE_UNISTD_H
38 #include <unistd.h>
39 #endif
40
41 #if CONFIG_LIBFONTCONFIG
42 #include <fontconfig/fontconfig.h>
43 #endif
44
45 #include "libavutil/avstring.h"
46 #include "libavutil/bprint.h"
47 #include "libavutil/common.h"
48 #include "libavutil/file.h"
49 #include "libavutil/eval.h"
50 #include "libavutil/opt.h"
51 #include "libavutil/random_seed.h"
52 #include "libavutil/parseutils.h"
53 #include "libavutil/timecode.h"
54 #include "libavutil/tree.h"
55 #include "libavutil/lfg.h"
56 #include "avfilter.h"
57 #include "drawutils.h"
58 #include "formats.h"
59 #include "internal.h"
60 #include "video.h"
61
62 #include <ft2build.h>
63 #include FT_FREETYPE_H
64 #include FT_GLYPH_H
65 #include FT_STROKER_H
66
67 static const char *const var_names[] = {
68     "dar",
69     "hsub", "vsub",
70     "line_h", "lh",           ///< line height, same as max_glyph_h
71     "main_h", "h", "H",       ///< height of the input video
72     "main_w", "w", "W",       ///< width  of the input video
73     "max_glyph_a", "ascent",  ///< max glyph ascent
74     "max_glyph_d", "descent", ///< min glyph descent
75     "max_glyph_h",            ///< max glyph height
76     "max_glyph_w",            ///< max glyph width
77     "n",                      ///< number of frame
78     "sar",
79     "t",                      ///< timestamp expressed in seconds
80     "text_h", "th",           ///< height of the rendered text
81     "text_w", "tw",           ///< width  of the rendered text
82     "x",
83     "y",
84     "pict_type",
85     NULL
86 };
87
88 static const char *const fun2_names[] = {
89     "rand"
90 };
91
92 static double drand(void *opaque, double min, double max)
93 {
94     return min + (max-min) / UINT_MAX * av_lfg_get(opaque);
95 }
96
97 typedef double (*eval_func2)(void *, double a, double b);
98
99 static const eval_func2 fun2[] = {
100     drand,
101     NULL
102 };
103
104 enum var_name {
105     VAR_DAR,
106     VAR_HSUB, VAR_VSUB,
107     VAR_LINE_H, VAR_LH,
108     VAR_MAIN_H, VAR_h, VAR_H,
109     VAR_MAIN_W, VAR_w, VAR_W,
110     VAR_MAX_GLYPH_A, VAR_ASCENT,
111     VAR_MAX_GLYPH_D, VAR_DESCENT,
112     VAR_MAX_GLYPH_H,
113     VAR_MAX_GLYPH_W,
114     VAR_N,
115     VAR_SAR,
116     VAR_T,
117     VAR_TEXT_H, VAR_TH,
118     VAR_TEXT_W, VAR_TW,
119     VAR_X,
120     VAR_Y,
121     VAR_PICT_TYPE,
122     VAR_VARS_NB
123 };
124
125 enum expansion_mode {
126     EXP_NONE,
127     EXP_NORMAL,
128     EXP_STRFTIME,
129 };
130
131 typedef struct DrawTextContext {
132     const AVClass *class;
133     enum expansion_mode exp_mode;   ///< expansion mode to use for the text
134     int reinit;                     ///< tells if the filter is being reinited
135 #if CONFIG_LIBFONTCONFIG
136     uint8_t *font;              ///< font to be used
137 #endif
138     uint8_t *fontfile;              ///< font to be used
139     uint8_t *text;                  ///< text to be drawn
140     AVBPrint expanded_text;         ///< used to contain the expanded text
141     int ft_load_flags;              ///< flags used for loading fonts, see FT_LOAD_*
142     FT_Vector *positions;           ///< positions for each element in the text
143     size_t nb_positions;            ///< number of elements of positions array
144     char *textfile;                 ///< file with text to be drawn
145     int x;                          ///< x position to start drawing text
146     int y;                          ///< y position to start drawing text
147     int max_glyph_w;                ///< max glyph width
148     int max_glyph_h;                ///< max glyph height
149     int shadowx, shadowy;
150     int borderw;                    ///< border width
151     unsigned int fontsize;          ///< font size to use
152
153     short int draw_box;             ///< draw box around text - true or false
154     int use_kerning;                ///< font kerning is used - true/false
155     int tabsize;                    ///< tab size
156     int fix_bounds;                 ///< do we let it go out of frame bounds - t/f
157
158     FFDrawContext dc;
159     FFDrawColor fontcolor;          ///< foreground color
160     FFDrawColor shadowcolor;        ///< shadow color
161     FFDrawColor bordercolor;        ///< border color
162     FFDrawColor boxcolor;           ///< background color
163
164     FT_Library library;             ///< freetype font library handle
165     FT_Face face;                   ///< freetype font face handle
166     FT_Stroker stroker;             ///< freetype stroker handle
167     struct AVTreeNode *glyphs;      ///< rendered glyphs, stored using the UTF-32 char code
168     char *x_expr;                   ///< expression for x position
169     char *y_expr;                   ///< expression for y position
170     AVExpr *x_pexpr, *y_pexpr;      ///< parsed expressions for x and y
171     int64_t basetime;               ///< base pts time in the real world for display
172     double var_values[VAR_VARS_NB];
173 #if FF_API_DRAWTEXT_OLD_TIMELINE
174     char   *draw_expr;              ///< expression for draw
175     AVExpr *draw_pexpr;             ///< parsed expression for draw
176     int draw;                       ///< set to zero to prevent drawing
177 #endif
178     AVLFG  prng;                    ///< random
179     char       *tc_opt_string;      ///< specified timecode option string
180     AVRational  tc_rate;            ///< frame rate for timecode
181     AVTimecode  tc;                 ///< timecode context
182     int tc24hmax;                   ///< 1 if timecode is wrapped to 24 hours, 0 otherwise
183     int reload;                     ///< reload text file for each frame
184     int start_number;               ///< starting frame number for n/frame_num var
185     AVDictionary *metadata;
186 } DrawTextContext;
187
188 #define OFFSET(x) offsetof(DrawTextContext, x)
189 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
190
191 static const AVOption drawtext_options[]= {
192     {"fontfile",    "set font file",        OFFSET(fontfile),           AV_OPT_TYPE_STRING, {.str=NULL},  CHAR_MIN, CHAR_MAX, FLAGS},
193     {"text",        "set text",             OFFSET(text),               AV_OPT_TYPE_STRING, {.str=NULL},  CHAR_MIN, CHAR_MAX, FLAGS},
194     {"textfile",    "set text file",        OFFSET(textfile),           AV_OPT_TYPE_STRING, {.str=NULL},  CHAR_MIN, CHAR_MAX, FLAGS},
195     {"fontcolor",   "set foreground color", OFFSET(fontcolor.rgba),     AV_OPT_TYPE_COLOR,  {.str="black"}, CHAR_MIN, CHAR_MAX, FLAGS},
196     {"boxcolor",    "set box color",        OFFSET(boxcolor.rgba),      AV_OPT_TYPE_COLOR,  {.str="white"}, CHAR_MIN, CHAR_MAX, FLAGS},
197     {"bordercolor", "set border color",     OFFSET(bordercolor.rgba),   AV_OPT_TYPE_COLOR,  {.str="black"}, CHAR_MIN, CHAR_MAX, FLAGS},
198     {"shadowcolor", "set shadow color",     OFFSET(shadowcolor.rgba),   AV_OPT_TYPE_COLOR,  {.str="black"}, CHAR_MIN, CHAR_MAX, FLAGS},
199     {"box",         "set box",              OFFSET(draw_box),           AV_OPT_TYPE_INT,    {.i64=0},     0,        1       , FLAGS},
200     {"fontsize",    "set font size",        OFFSET(fontsize),           AV_OPT_TYPE_INT,    {.i64=0},     0,        INT_MAX , FLAGS},
201     {"x",           "set x expression",     OFFSET(x_expr),             AV_OPT_TYPE_STRING, {.str="0"},   CHAR_MIN, CHAR_MAX, FLAGS},
202     {"y",           "set y expression",     OFFSET(y_expr),             AV_OPT_TYPE_STRING, {.str="0"},   CHAR_MIN, CHAR_MAX, FLAGS},
203     {"shadowx",     "set x",                OFFSET(shadowx),            AV_OPT_TYPE_INT,    {.i64=0},     INT_MIN,  INT_MAX , FLAGS},
204     {"shadowy",     "set y",                OFFSET(shadowy),            AV_OPT_TYPE_INT,    {.i64=0},     INT_MIN,  INT_MAX , FLAGS},
205     {"borderw",     "set border width",     OFFSET(borderw),            AV_OPT_TYPE_INT,    {.i64=0},     INT_MIN,  INT_MAX , FLAGS},
206     {"tabsize",     "set tab size",         OFFSET(tabsize),            AV_OPT_TYPE_INT,    {.i64=4},     0,        INT_MAX , FLAGS},
207     {"basetime",    "set base time",        OFFSET(basetime),           AV_OPT_TYPE_INT64,  {.i64=AV_NOPTS_VALUE}, INT64_MIN, INT64_MAX , FLAGS},
208 #if FF_API_DRAWTEXT_OLD_TIMELINE
209     {"draw",        "if false do not draw (deprecated)", OFFSET(draw_expr), AV_OPT_TYPE_STRING, {.str=NULL},   CHAR_MIN, CHAR_MAX, FLAGS},
210 #endif
211 #if CONFIG_LIBFONTCONFIG
212     { "font",        "Font name",            OFFSET(font),               AV_OPT_TYPE_STRING, { .str = "Sans" },           .flags = FLAGS },
213 #endif
214
215     {"expansion", "set the expansion mode", OFFSET(exp_mode), AV_OPT_TYPE_INT, {.i64=EXP_NORMAL}, 0, 2, FLAGS, "expansion"},
216         {"none",     "set no expansion",                    OFFSET(exp_mode), AV_OPT_TYPE_CONST, {.i64=EXP_NONE},     0, 0, FLAGS, "expansion"},
217         {"normal",   "set normal expansion",                OFFSET(exp_mode), AV_OPT_TYPE_CONST, {.i64=EXP_NORMAL},   0, 0, FLAGS, "expansion"},
218         {"strftime", "set strftime expansion (deprecated)", OFFSET(exp_mode), AV_OPT_TYPE_CONST, {.i64=EXP_STRFTIME}, 0, 0, FLAGS, "expansion"},
219
220     {"timecode",        "set initial timecode",             OFFSET(tc_opt_string), AV_OPT_TYPE_STRING,   {.str=NULL}, CHAR_MIN, CHAR_MAX, FLAGS},
221     {"tc24hmax",        "set 24 hours max (timecode only)", OFFSET(tc24hmax),      AV_OPT_TYPE_INT,      {.i64=0},           0,        1, FLAGS},
222     {"timecode_rate",   "set rate (timecode only)",         OFFSET(tc_rate),       AV_OPT_TYPE_RATIONAL, {.dbl=0},           0,  INT_MAX, FLAGS},
223     {"r",               "set rate (timecode only)",         OFFSET(tc_rate),       AV_OPT_TYPE_RATIONAL, {.dbl=0},           0,  INT_MAX, FLAGS},
224     {"rate",            "set rate (timecode only)",         OFFSET(tc_rate),       AV_OPT_TYPE_RATIONAL, {.dbl=0},           0,  INT_MAX, FLAGS},
225     {"reload",     "reload text file for each frame",                       OFFSET(reload),     AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS},
226     {"fix_bounds", "if true, check and fix text coords to avoid clipping",  OFFSET(fix_bounds), AV_OPT_TYPE_INT, {.i64=1}, 0, 1, FLAGS},
227     {"start_number", "start frame number for n/frame_num variable", OFFSET(start_number), AV_OPT_TYPE_INT, {.i64=0}, 0, INT_MAX, FLAGS},
228
229     /* FT_LOAD_* flags */
230     { "ft_load_flags", "set font loading flags for libfreetype", OFFSET(ft_load_flags), AV_OPT_TYPE_FLAGS, { .i64 = FT_LOAD_DEFAULT }, 0, INT_MAX, FLAGS, "ft_load_flags" },
231         { "default",                     NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_DEFAULT },                     .flags = FLAGS, .unit = "ft_load_flags" },
232         { "no_scale",                    NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_NO_SCALE },                    .flags = FLAGS, .unit = "ft_load_flags" },
233         { "no_hinting",                  NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_NO_HINTING },                  .flags = FLAGS, .unit = "ft_load_flags" },
234         { "render",                      NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_RENDER },                      .flags = FLAGS, .unit = "ft_load_flags" },
235         { "no_bitmap",                   NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_NO_BITMAP },                   .flags = FLAGS, .unit = "ft_load_flags" },
236         { "vertical_layout",             NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_VERTICAL_LAYOUT },             .flags = FLAGS, .unit = "ft_load_flags" },
237         { "force_autohint",              NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_FORCE_AUTOHINT },              .flags = FLAGS, .unit = "ft_load_flags" },
238         { "crop_bitmap",                 NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_CROP_BITMAP },                 .flags = FLAGS, .unit = "ft_load_flags" },
239         { "pedantic",                    NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_PEDANTIC },                    .flags = FLAGS, .unit = "ft_load_flags" },
240         { "ignore_global_advance_width", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH }, .flags = FLAGS, .unit = "ft_load_flags" },
241         { "no_recurse",                  NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_NO_RECURSE },                  .flags = FLAGS, .unit = "ft_load_flags" },
242         { "ignore_transform",            NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_IGNORE_TRANSFORM },            .flags = FLAGS, .unit = "ft_load_flags" },
243         { "monochrome",                  NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_MONOCHROME },                  .flags = FLAGS, .unit = "ft_load_flags" },
244         { "linear_design",               NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_LINEAR_DESIGN },               .flags = FLAGS, .unit = "ft_load_flags" },
245         { "no_autohint",                 NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_NO_AUTOHINT },                 .flags = FLAGS, .unit = "ft_load_flags" },
246     { NULL }
247 };
248
249 AVFILTER_DEFINE_CLASS(drawtext);
250
251 #undef __FTERRORS_H__
252 #define FT_ERROR_START_LIST {
253 #define FT_ERRORDEF(e, v, s) { (e), (s) },
254 #define FT_ERROR_END_LIST { 0, NULL } };
255
256 struct ft_error
257 {
258     int err;
259     const char *err_msg;
260 } static ft_errors[] =
261 #include FT_ERRORS_H
262
263 #define FT_ERRMSG(e) ft_errors[e].err_msg
264
265 typedef struct Glyph {
266     FT_Glyph glyph;
267     FT_Glyph border_glyph;
268     uint32_t code;
269     FT_Bitmap bitmap; ///< array holding bitmaps of font
270     FT_Bitmap border_bitmap; ///< array holding bitmaps of font border
271     FT_BBox bbox;
272     int advance;
273     int bitmap_left;
274     int bitmap_top;
275 } Glyph;
276
277 static int glyph_cmp(void *key, const void *b)
278 {
279     const Glyph *a = key, *bb = b;
280     int64_t diff = (int64_t)a->code - (int64_t)bb->code;
281     return diff > 0 ? 1 : diff < 0 ? -1 : 0;
282 }
283
284 /**
285  * Load glyphs corresponding to the UTF-32 codepoint code.
286  */
287 static int load_glyph(AVFilterContext *ctx, Glyph **glyph_ptr, uint32_t code)
288 {
289     DrawTextContext *s = ctx->priv;
290     FT_BitmapGlyph bitmapglyph;
291     Glyph *glyph;
292     struct AVTreeNode *node = NULL;
293     int ret;
294
295     /* load glyph into s->face->glyph */
296     if (FT_Load_Char(s->face, code, s->ft_load_flags))
297         return AVERROR(EINVAL);
298
299     glyph = av_mallocz(sizeof(*glyph));
300     if (!glyph) {
301         ret = AVERROR(ENOMEM);
302         goto error;
303     }
304     glyph->code  = code;
305
306     if (FT_Get_Glyph(s->face->glyph, &glyph->glyph)) {
307         ret = AVERROR(EINVAL);
308         goto error;
309     }
310     if (s->borderw) {
311         glyph->border_glyph = glyph->glyph;
312         if (FT_Glyph_StrokeBorder(&glyph->border_glyph, s->stroker, 0, 0) ||
313             FT_Glyph_To_Bitmap(&glyph->border_glyph, FT_RENDER_MODE_NORMAL, 0, 1)) {
314             ret = AVERROR_EXTERNAL;
315             goto error;
316         }
317         bitmapglyph = (FT_BitmapGlyph) glyph->border_glyph;
318         glyph->border_bitmap = bitmapglyph->bitmap;
319     }
320     if (FT_Glyph_To_Bitmap(&glyph->glyph, FT_RENDER_MODE_NORMAL, 0, 1)) {
321         ret = AVERROR_EXTERNAL;
322         goto error;
323     }
324     bitmapglyph = (FT_BitmapGlyph) glyph->glyph;
325
326     glyph->bitmap      = bitmapglyph->bitmap;
327     glyph->bitmap_left = bitmapglyph->left;
328     glyph->bitmap_top  = bitmapglyph->top;
329     glyph->advance     = s->face->glyph->advance.x >> 6;
330
331     /* measure text height to calculate text_height (or the maximum text height) */
332     FT_Glyph_Get_CBox(glyph->glyph, ft_glyph_bbox_pixels, &glyph->bbox);
333
334     /* cache the newly created glyph */
335     if (!(node = av_tree_node_alloc())) {
336         ret = AVERROR(ENOMEM);
337         goto error;
338     }
339     av_tree_insert(&s->glyphs, glyph, glyph_cmp, &node);
340
341     if (glyph_ptr)
342         *glyph_ptr = glyph;
343     return 0;
344
345 error:
346     if (glyph)
347         av_freep(&glyph->glyph);
348
349     av_freep(&glyph);
350     av_freep(&node);
351     return ret;
352 }
353
354 static int load_font_file(AVFilterContext *ctx, const char *path, int index)
355 {
356     DrawTextContext *s = ctx->priv;
357     int err;
358
359     err = FT_New_Face(s->library, path, index, &s->face);
360     if (err) {
361         av_log(ctx, AV_LOG_ERROR, "Could not load font \"%s\": %s\n",
362                s->fontfile, FT_ERRMSG(err));
363         return AVERROR(EINVAL);
364     }
365     return 0;
366 }
367
368 #if CONFIG_LIBFONTCONFIG
369 static int load_font_fontconfig(AVFilterContext *ctx)
370 {
371     DrawTextContext *s = ctx->priv;
372     FcConfig *fontconfig;
373     FcPattern *pat, *best;
374     FcResult result = FcResultMatch;
375     FcChar8 *filename;
376     int index;
377     double size;
378     int err = AVERROR(ENOENT);
379
380     fontconfig = FcInitLoadConfigAndFonts();
381     if (!fontconfig) {
382         av_log(ctx, AV_LOG_ERROR, "impossible to init fontconfig\n");
383         return AVERROR_UNKNOWN;
384     }
385     pat = FcNameParse(s->fontfile ? s->fontfile :
386                           (uint8_t *)(intptr_t)"default");
387     if (!pat) {
388         av_log(ctx, AV_LOG_ERROR, "could not parse fontconfig pat");
389         return AVERROR(EINVAL);
390     }
391
392     FcPatternAddString(pat, FC_FAMILY, s->font);
393     if (s->fontsize)
394         FcPatternAddDouble(pat, FC_SIZE, (double)s->fontsize);
395
396     FcDefaultSubstitute(pat);
397
398     if (!FcConfigSubstitute(fontconfig, pat, FcMatchPattern)) {
399         av_log(ctx, AV_LOG_ERROR, "could not substitue fontconfig options"); /* very unlikely */
400         FcPatternDestroy(pat);
401         return AVERROR(ENOMEM);
402     }
403
404     best = FcFontMatch(fontconfig, pat, &result);
405     FcPatternDestroy(pat);
406
407     if (!best || result != FcResultMatch) {
408         av_log(ctx, AV_LOG_ERROR,
409                "Cannot find a valid font for the family %s\n",
410                s->font);
411         goto fail;
412     }
413
414     if (
415         FcPatternGetInteger(best, FC_INDEX, 0, &index   ) != FcResultMatch ||
416         FcPatternGetDouble (best, FC_SIZE,  0, &size    ) != FcResultMatch) {
417         av_log(ctx, AV_LOG_ERROR, "impossible to find font information");
418         return AVERROR(EINVAL);
419     }
420
421     if (FcPatternGetString(best, FC_FILE, 0, &filename) != FcResultMatch) {
422         av_log(ctx, AV_LOG_ERROR, "No file path for %s\n",
423                s->font);
424         goto fail;
425     }
426
427     av_log(ctx, AV_LOG_INFO, "Using \"%s\"\n", filename);
428     if (!s->fontsize)
429         s->fontsize = size + 0.5;
430
431     err = load_font_file(ctx, filename, index);
432     if (err)
433         return err;
434     FcConfigDestroy(fontconfig);
435 fail:
436     FcPatternDestroy(best);
437     return err;
438 }
439 #endif
440
441 static int load_font(AVFilterContext *ctx)
442 {
443     DrawTextContext *s = ctx->priv;
444     int err;
445
446     /* load the face, and set up the encoding, which is by default UTF-8 */
447     err = load_font_file(ctx, s->fontfile, 0);
448     if (!err)
449         return 0;
450 #if CONFIG_LIBFONTCONFIG
451     err = load_font_fontconfig(ctx);
452     if (!err)
453         return 0;
454 #endif
455     return err;
456 }
457
458 static int load_textfile(AVFilterContext *ctx)
459 {
460     DrawTextContext *s = ctx->priv;
461     int err;
462     uint8_t *textbuf;
463     uint8_t *tmp;
464     size_t textbuf_size;
465
466     if ((err = av_file_map(s->textfile, &textbuf, &textbuf_size, 0, ctx)) < 0) {
467         av_log(ctx, AV_LOG_ERROR,
468                "The text file '%s' could not be read or is empty\n",
469                s->textfile);
470         return err;
471     }
472
473     if (!(tmp = av_realloc(s->text, textbuf_size + 1))) {
474         av_file_unmap(textbuf, textbuf_size);
475         return AVERROR(ENOMEM);
476     }
477     s->text = tmp;
478     memcpy(s->text, textbuf, textbuf_size);
479     s->text[textbuf_size] = 0;
480     av_file_unmap(textbuf, textbuf_size);
481
482     return 0;
483 }
484
485 static av_cold int init(AVFilterContext *ctx)
486 {
487     int err;
488     DrawTextContext *s = ctx->priv;
489     Glyph *glyph;
490
491 #if FF_API_DRAWTEXT_OLD_TIMELINE
492     if (s->draw_expr)
493         av_log(ctx, AV_LOG_WARNING, "'draw' option is deprecated and will be removed soon, "
494                "you are encouraged to use the generic timeline support through the 'enable' option\n");
495 #endif
496
497     if (!s->fontfile && !CONFIG_LIBFONTCONFIG) {
498         av_log(ctx, AV_LOG_ERROR, "No font filename provided\n");
499         return AVERROR(EINVAL);
500     }
501
502     if (s->textfile) {
503         if (s->text) {
504             av_log(ctx, AV_LOG_ERROR,
505                    "Both text and text file provided. Please provide only one\n");
506             return AVERROR(EINVAL);
507         }
508         if ((err = load_textfile(ctx)) < 0)
509             return err;
510     }
511
512     if (s->reload && !s->textfile)
513         av_log(ctx, AV_LOG_WARNING, "No file to reload\n");
514
515     if (s->tc_opt_string) {
516         int ret = av_timecode_init_from_string(&s->tc, s->tc_rate,
517                                                s->tc_opt_string, ctx);
518         if (ret < 0)
519             return ret;
520         if (s->tc24hmax)
521             s->tc.flags |= AV_TIMECODE_FLAG_24HOURSMAX;
522         if (!s->text)
523             s->text = av_strdup("");
524     }
525
526     if (!s->text) {
527         av_log(ctx, AV_LOG_ERROR,
528                "Either text, a valid file or a timecode must be provided\n");
529         return AVERROR(EINVAL);
530     }
531
532     if ((err = FT_Init_FreeType(&(s->library)))) {
533         av_log(ctx, AV_LOG_ERROR,
534                "Could not load FreeType: %s\n", FT_ERRMSG(err));
535         return AVERROR(EINVAL);
536     }
537
538     err = load_font(ctx);
539     if (err)
540         return err;
541     if (!s->fontsize)
542         s->fontsize = 16;
543     if ((err = FT_Set_Pixel_Sizes(s->face, 0, s->fontsize))) {
544         av_log(ctx, AV_LOG_ERROR, "Could not set font size to %d pixels: %s\n",
545                s->fontsize, FT_ERRMSG(err));
546         return AVERROR(EINVAL);
547     }
548
549     if (s->borderw) {
550         if (FT_Stroker_New(s->library, &s->stroker)) {
551             av_log(ctx, AV_LOG_ERROR, "Coult not init FT stroker\n");
552             return AVERROR_EXTERNAL;
553         }
554         FT_Stroker_Set(s->stroker, s->borderw << 6, FT_STROKER_LINECAP_ROUND,
555                        FT_STROKER_LINEJOIN_ROUND, 0);
556     }
557
558     s->use_kerning = FT_HAS_KERNING(s->face);
559
560     /* load the fallback glyph with code 0 */
561     load_glyph(ctx, NULL, 0);
562
563     /* set the tabsize in pixels */
564     if ((err = load_glyph(ctx, &glyph, ' ')) < 0) {
565         av_log(ctx, AV_LOG_ERROR, "Could not set tabsize.\n");
566         return err;
567     }
568     s->tabsize *= glyph->advance;
569
570     if (s->exp_mode == EXP_STRFTIME &&
571         (strchr(s->text, '%') || strchr(s->text, '\\')))
572         av_log(ctx, AV_LOG_WARNING, "expansion=strftime is deprecated.\n");
573
574     av_bprint_init(&s->expanded_text, 0, AV_BPRINT_SIZE_UNLIMITED);
575
576     return 0;
577 }
578
579 static int query_formats(AVFilterContext *ctx)
580 {
581     ff_set_common_formats(ctx, ff_draw_supported_pixel_formats(0));
582     return 0;
583 }
584
585 static int glyph_enu_free(void *opaque, void *elem)
586 {
587     Glyph *glyph = elem;
588
589     FT_Done_Glyph(glyph->glyph);
590     FT_Done_Glyph(glyph->border_glyph);
591     av_free(elem);
592     return 0;
593 }
594
595 static av_cold void uninit(AVFilterContext *ctx)
596 {
597     DrawTextContext *s = ctx->priv;
598
599     av_expr_free(s->x_pexpr);
600     av_expr_free(s->y_pexpr);
601 #if FF_API_DRAWTEXT_OLD_TIMELINE
602     av_expr_free(s->draw_pexpr);
603     s->x_pexpr = s->y_pexpr = s->draw_pexpr = NULL;
604 #endif
605     av_freep(&s->positions);
606     s->nb_positions = 0;
607
608
609     av_tree_enumerate(s->glyphs, NULL, NULL, glyph_enu_free);
610     av_tree_destroy(s->glyphs);
611     s->glyphs = NULL;
612
613     FT_Done_Face(s->face);
614     FT_Stroker_Done(s->stroker);
615     FT_Done_FreeType(s->library);
616
617     av_bprint_finalize(&s->expanded_text, NULL);
618 }
619
620 static inline int is_newline(uint32_t c)
621 {
622     return c == '\n' || c == '\r' || c == '\f' || c == '\v';
623 }
624
625 static int config_input(AVFilterLink *inlink)
626 {
627     AVFilterContext *ctx = inlink->dst;
628     DrawTextContext *s = ctx->priv;
629     int ret;
630
631     ff_draw_init(&s->dc, inlink->format, 0);
632     ff_draw_color(&s->dc, &s->fontcolor,   s->fontcolor.rgba);
633     ff_draw_color(&s->dc, &s->shadowcolor, s->shadowcolor.rgba);
634     ff_draw_color(&s->dc, &s->bordercolor, s->bordercolor.rgba);
635     ff_draw_color(&s->dc, &s->boxcolor,    s->boxcolor.rgba);
636
637     s->var_values[VAR_w]     = s->var_values[VAR_W]     = s->var_values[VAR_MAIN_W] = inlink->w;
638     s->var_values[VAR_h]     = s->var_values[VAR_H]     = s->var_values[VAR_MAIN_H] = inlink->h;
639     s->var_values[VAR_SAR]   = inlink->sample_aspect_ratio.num ? av_q2d(inlink->sample_aspect_ratio) : 1;
640     s->var_values[VAR_DAR]   = (double)inlink->w / inlink->h * s->var_values[VAR_SAR];
641     s->var_values[VAR_HSUB]  = 1 << s->dc.hsub_max;
642     s->var_values[VAR_VSUB]  = 1 << s->dc.vsub_max;
643     s->var_values[VAR_X]     = NAN;
644     s->var_values[VAR_Y]     = NAN;
645     s->var_values[VAR_T]     = NAN;
646
647     av_lfg_init(&s->prng, av_get_random_seed());
648
649     av_expr_free(s->x_pexpr);
650     av_expr_free(s->y_pexpr);
651 #if FF_API_DRAWTEXT_OLD_TIMELINE
652     av_expr_free(s->draw_pexpr);
653     s->x_pexpr = s->y_pexpr = s->draw_pexpr = NULL;
654 #else
655     s->x_pexpr = s->y_pexpr = NULL;
656 #endif
657
658     if ((ret = av_expr_parse(&s->x_pexpr, s->x_expr, var_names,
659                              NULL, NULL, fun2_names, fun2, 0, ctx)) < 0 ||
660         (ret = av_expr_parse(&s->y_pexpr, s->y_expr, var_names,
661                              NULL, NULL, fun2_names, fun2, 0, ctx)) < 0)
662
663         return AVERROR(EINVAL);
664 #if FF_API_DRAWTEXT_OLD_TIMELINE
665     if (s->draw_expr &&
666         (ret = av_expr_parse(&s->draw_pexpr, s->draw_expr, var_names,
667                              NULL, NULL, fun2_names, fun2, 0, ctx)) < 0)
668         return ret;
669 #endif
670
671     return 0;
672 }
673
674 static int command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
675 {
676     DrawTextContext *s = ctx->priv;
677
678     if (!strcmp(cmd, "reinit")) {
679         int ret;
680         uninit(ctx);
681         s->reinit = 1;
682         if ((ret = av_set_options_string(ctx, arg, "=", ":")) < 0)
683             return ret;
684         if ((ret = init(ctx)) < 0)
685             return ret;
686         return config_input(ctx->inputs[0]);
687     }
688
689     return AVERROR(ENOSYS);
690 }
691
692 static int func_pict_type(AVFilterContext *ctx, AVBPrint *bp,
693                           char *fct, unsigned argc, char **argv, int tag)
694 {
695     DrawTextContext *s = ctx->priv;
696
697     av_bprintf(bp, "%c", av_get_picture_type_char(s->var_values[VAR_PICT_TYPE]));
698     return 0;
699 }
700
701 static int func_pts(AVFilterContext *ctx, AVBPrint *bp,
702                     char *fct, unsigned argc, char **argv, int tag)
703 {
704     DrawTextContext *s = ctx->priv;
705     const char *fmt;
706     double pts = s->var_values[VAR_T];
707     int ret;
708
709     fmt = argc >= 1 ? argv[0] : "flt";
710     if (argc >= 2) {
711         int64_t delta;
712         if ((ret = av_parse_time(&delta, argv[1], 1)) < 0) {
713             av_log(ctx, AV_LOG_ERROR, "Invalid delta '%s'\n", argv[1]);
714             return ret;
715         }
716         pts += (double)delta / AV_TIME_BASE;
717     }
718     if (!strcmp(fmt, "flt")) {
719         av_bprintf(bp, "%.6f", s->var_values[VAR_T]);
720     } else if (!strcmp(fmt, "hms")) {
721         if (isnan(pts)) {
722             av_bprintf(bp, " ??:??:??.???");
723         } else {
724             int64_t ms = round(pts * 1000);
725             char sign = ' ';
726             if (ms < 0) {
727                 sign = '-';
728                 ms = -ms;
729             }
730             av_bprintf(bp, "%c%02d:%02d:%02d.%03d", sign,
731                        (int)(ms / (60 * 60 * 1000)),
732                        (int)(ms / (60 * 1000)) % 60,
733                        (int)(ms / 1000) % 60,
734                        (int)ms % 1000);
735         }
736     } else {
737         av_log(ctx, AV_LOG_ERROR, "Invalid format '%s'\n", fmt);
738         return AVERROR(EINVAL);
739     }
740     return 0;
741 }
742
743 static int func_frame_num(AVFilterContext *ctx, AVBPrint *bp,
744                           char *fct, unsigned argc, char **argv, int tag)
745 {
746     DrawTextContext *s = ctx->priv;
747
748     av_bprintf(bp, "%d", (int)s->var_values[VAR_N]);
749     return 0;
750 }
751
752 static int func_metadata(AVFilterContext *ctx, AVBPrint *bp,
753                          char *fct, unsigned argc, char **argv, int tag)
754 {
755     DrawTextContext *s = ctx->priv;
756     AVDictionaryEntry *e = av_dict_get(s->metadata, argv[0], NULL, 0);
757
758     if (e && e->value)
759         av_bprintf(bp, "%s", e->value);
760     return 0;
761 }
762
763 #if !HAVE_LOCALTIME_R
764 static void localtime_r(const time_t *t, struct tm *tm)
765 {
766     *tm = *localtime(t);
767 }
768 #endif
769
770 static int func_strftime(AVFilterContext *ctx, AVBPrint *bp,
771                          char *fct, unsigned argc, char **argv, int tag)
772 {
773     const char *fmt = argc ? argv[0] : "%Y-%m-%d %H:%M:%S";
774     time_t now;
775     struct tm tm;
776
777     time(&now);
778     if (tag == 'L')
779         localtime_r(&now, &tm);
780     else
781         tm = *gmtime(&now);
782     av_bprint_strftime(bp, fmt, &tm);
783     return 0;
784 }
785
786 static int func_eval_expr(AVFilterContext *ctx, AVBPrint *bp,
787                           char *fct, unsigned argc, char **argv, int tag)
788 {
789     DrawTextContext *s = ctx->priv;
790     double res;
791     int ret;
792
793     ret = av_expr_parse_and_eval(&res, argv[0], var_names, s->var_values,
794                                  NULL, NULL, fun2_names, fun2,
795                                  &s->prng, 0, ctx);
796     if (ret < 0)
797         av_log(ctx, AV_LOG_ERROR,
798                "Expression '%s' for the expr text expansion function is not valid\n",
799                argv[0]);
800     else
801         av_bprintf(bp, "%f", res);
802
803     return ret;
804 }
805
806 static const struct drawtext_function {
807     const char *name;
808     unsigned argc_min, argc_max;
809     int tag;                            /**< opaque argument to func */
810     int (*func)(AVFilterContext *, AVBPrint *, char *, unsigned, char **, int);
811 } functions[] = {
812     { "expr",      1, 1, 0,   func_eval_expr },
813     { "e",         1, 1, 0,   func_eval_expr },
814     { "pict_type", 0, 0, 0,   func_pict_type },
815     { "pts",       0, 2, 0,   func_pts      },
816     { "gmtime",    0, 1, 'G', func_strftime },
817     { "localtime", 0, 1, 'L', func_strftime },
818     { "frame_num", 0, 0, 0,   func_frame_num },
819     { "n",         0, 0, 0,   func_frame_num },
820     { "metadata",  1, 1, 0,   func_metadata },
821 };
822
823 static int eval_function(AVFilterContext *ctx, AVBPrint *bp, char *fct,
824                          unsigned argc, char **argv)
825 {
826     unsigned i;
827
828     for (i = 0; i < FF_ARRAY_ELEMS(functions); i++) {
829         if (strcmp(fct, functions[i].name))
830             continue;
831         if (argc < functions[i].argc_min) {
832             av_log(ctx, AV_LOG_ERROR, "%%{%s} requires at least %d arguments\n",
833                    fct, functions[i].argc_min);
834             return AVERROR(EINVAL);
835         }
836         if (argc > functions[i].argc_max) {
837             av_log(ctx, AV_LOG_ERROR, "%%{%s} requires at most %d arguments\n",
838                    fct, functions[i].argc_max);
839             return AVERROR(EINVAL);
840         }
841         break;
842     }
843     if (i >= FF_ARRAY_ELEMS(functions)) {
844         av_log(ctx, AV_LOG_ERROR, "%%{%s} is not known\n", fct);
845         return AVERROR(EINVAL);
846     }
847     return functions[i].func(ctx, bp, fct, argc, argv, functions[i].tag);
848 }
849
850 static int expand_function(AVFilterContext *ctx, AVBPrint *bp, char **rtext)
851 {
852     const char *text = *rtext;
853     char *argv[16] = { NULL };
854     unsigned argc = 0, i;
855     int ret;
856
857     if (*text != '{') {
858         av_log(ctx, AV_LOG_ERROR, "Stray %% near '%s'\n", text);
859         return AVERROR(EINVAL);
860     }
861     text++;
862     while (1) {
863         if (!(argv[argc++] = av_get_token(&text, ":}"))) {
864             ret = AVERROR(ENOMEM);
865             goto end;
866         }
867         if (!*text) {
868             av_log(ctx, AV_LOG_ERROR, "Unterminated %%{} near '%s'\n", *rtext);
869             ret = AVERROR(EINVAL);
870             goto end;
871         }
872         if (argc == FF_ARRAY_ELEMS(argv))
873             av_freep(&argv[--argc]); /* error will be caught later */
874         if (*text == '}')
875             break;
876         text++;
877     }
878
879     if ((ret = eval_function(ctx, bp, argv[0], argc - 1, argv + 1)) < 0)
880         goto end;
881     ret = 0;
882     *rtext = (char *)text + 1;
883
884 end:
885     for (i = 0; i < argc; i++)
886         av_freep(&argv[i]);
887     return ret;
888 }
889
890 static int expand_text(AVFilterContext *ctx)
891 {
892     DrawTextContext *s = ctx->priv;
893     char *text = s->text;
894     AVBPrint *bp = &s->expanded_text;
895     int ret;
896
897     av_bprint_clear(bp);
898     while (*text) {
899         if (*text == '\\' && text[1]) {
900             av_bprint_chars(bp, text[1], 1);
901             text += 2;
902         } else if (*text == '%') {
903             text++;
904             if ((ret = expand_function(ctx, bp, &text)) < 0)
905                 return ret;
906         } else {
907             av_bprint_chars(bp, *text, 1);
908             text++;
909         }
910     }
911     if (!av_bprint_is_complete(bp))
912         return AVERROR(ENOMEM);
913     return 0;
914 }
915
916 static int draw_glyphs(DrawTextContext *s, AVFrame *frame,
917                        int width, int height,
918                        FFDrawColor *color, int x, int y, int borderw)
919 {
920     char *text = s->expanded_text.str;
921     uint32_t code = 0;
922     int i, x1, y1;
923     uint8_t *p;
924     Glyph *glyph = NULL;
925
926     for (i = 0, p = text; *p; i++) {
927         FT_Bitmap bitmap;
928         Glyph dummy = { 0 };
929         GET_UTF8(code, *p++, continue;);
930
931         /* skip new line chars, just go to new line */
932         if (code == '\n' || code == '\r' || code == '\t')
933             continue;
934
935         dummy.code = code;
936         glyph = av_tree_find(s->glyphs, &dummy, (void *)glyph_cmp, NULL);
937
938         bitmap = borderw ? glyph->border_bitmap : glyph->bitmap;
939
940         if (glyph->bitmap.pixel_mode != FT_PIXEL_MODE_MONO &&
941             glyph->bitmap.pixel_mode != FT_PIXEL_MODE_GRAY)
942             return AVERROR(EINVAL);
943
944         x1 = s->positions[i].x+s->x+x - borderw;
945         y1 = s->positions[i].y+s->y+y - borderw;
946
947         ff_blend_mask(&s->dc, color,
948                       frame->data, frame->linesize, width, height,
949                       bitmap.buffer, bitmap.pitch,
950                       bitmap.width, bitmap.rows,
951                       bitmap.pixel_mode == FT_PIXEL_MODE_MONO ? 0 : 3,
952                       0, x1, y1);
953     }
954
955     return 0;
956 }
957
958 static int draw_text(AVFilterContext *ctx, AVFrame *frame,
959                      int width, int height)
960 {
961     DrawTextContext *s = ctx->priv;
962     AVFilterLink *inlink = ctx->inputs[0];
963
964     uint32_t code = 0, prev_code = 0;
965     int x = 0, y = 0, i = 0, ret;
966     int max_text_line_w = 0, len;
967     int box_w, box_h;
968     char *text;
969     uint8_t *p;
970     int y_min = 32000, y_max = -32000;
971     int x_min = 32000, x_max = -32000;
972     FT_Vector delta;
973     Glyph *glyph = NULL, *prev_glyph = NULL;
974     Glyph dummy = { 0 };
975
976     time_t now = time(0);
977     struct tm ltime;
978     AVBPrint *bp = &s->expanded_text;
979
980     av_bprint_clear(bp);
981
982     if(s->basetime != AV_NOPTS_VALUE)
983         now= frame->pts*av_q2d(ctx->inputs[0]->time_base) + s->basetime/1000000;
984
985     switch (s->exp_mode) {
986     case EXP_NONE:
987         av_bprintf(bp, "%s", s->text);
988         break;
989     case EXP_NORMAL:
990         if ((ret = expand_text(ctx)) < 0)
991             return ret;
992         break;
993     case EXP_STRFTIME:
994         localtime_r(&now, &ltime);
995         av_bprint_strftime(bp, s->text, &ltime);
996         break;
997     }
998
999     if (s->tc_opt_string) {
1000         char tcbuf[AV_TIMECODE_STR_SIZE];
1001         av_timecode_make_string(&s->tc, tcbuf, inlink->frame_count);
1002         av_bprint_clear(bp);
1003         av_bprintf(bp, "%s%s", s->text, tcbuf);
1004     }
1005
1006     if (!av_bprint_is_complete(bp))
1007         return AVERROR(ENOMEM);
1008     text = s->expanded_text.str;
1009     if ((len = s->expanded_text.len) > s->nb_positions) {
1010         if (!(s->positions =
1011               av_realloc(s->positions, len*sizeof(*s->positions))))
1012             return AVERROR(ENOMEM);
1013         s->nb_positions = len;
1014     }
1015
1016     x = 0;
1017     y = 0;
1018
1019     /* load and cache glyphs */
1020     for (i = 0, p = text; *p; i++) {
1021         GET_UTF8(code, *p++, continue;);
1022
1023         /* get glyph */
1024         dummy.code = code;
1025         glyph = av_tree_find(s->glyphs, &dummy, glyph_cmp, NULL);
1026         if (!glyph) {
1027             load_glyph(ctx, &glyph, code);
1028         }
1029
1030         y_min = FFMIN(glyph->bbox.yMin, y_min);
1031         y_max = FFMAX(glyph->bbox.yMax, y_max);
1032         x_min = FFMIN(glyph->bbox.xMin, x_min);
1033         x_max = FFMAX(glyph->bbox.xMax, x_max);
1034     }
1035     s->max_glyph_h = y_max - y_min;
1036     s->max_glyph_w = x_max - x_min;
1037
1038     /* compute and save position for each glyph */
1039     glyph = NULL;
1040     for (i = 0, p = text; *p; i++) {
1041         GET_UTF8(code, *p++, continue;);
1042
1043         /* skip the \n in the sequence \r\n */
1044         if (prev_code == '\r' && code == '\n')
1045             continue;
1046
1047         prev_code = code;
1048         if (is_newline(code)) {
1049
1050             max_text_line_w = FFMAX(max_text_line_w, x);
1051             y += s->max_glyph_h;
1052             x = 0;
1053             continue;
1054         }
1055
1056         /* get glyph */
1057         prev_glyph = glyph;
1058         dummy.code = code;
1059         glyph = av_tree_find(s->glyphs, &dummy, glyph_cmp, NULL);
1060
1061         /* kerning */
1062         if (s->use_kerning && prev_glyph && glyph->code) {
1063             FT_Get_Kerning(s->face, prev_glyph->code, glyph->code,
1064                            ft_kerning_default, &delta);
1065             x += delta.x >> 6;
1066         }
1067
1068         /* save position */
1069         s->positions[i].x = x + glyph->bitmap_left;
1070         s->positions[i].y = y - glyph->bitmap_top + y_max;
1071         if (code == '\t') x  = (x / s->tabsize + 1)*s->tabsize;
1072         else              x += glyph->advance;
1073     }
1074
1075     max_text_line_w = FFMAX(x, max_text_line_w);
1076
1077     s->var_values[VAR_TW] = s->var_values[VAR_TEXT_W] = max_text_line_w;
1078     s->var_values[VAR_TH] = s->var_values[VAR_TEXT_H] = y + s->max_glyph_h;
1079
1080     s->var_values[VAR_MAX_GLYPH_W] = s->max_glyph_w;
1081     s->var_values[VAR_MAX_GLYPH_H] = s->max_glyph_h;
1082     s->var_values[VAR_MAX_GLYPH_A] = s->var_values[VAR_ASCENT ] = y_max;
1083     s->var_values[VAR_MAX_GLYPH_D] = s->var_values[VAR_DESCENT] = y_min;
1084
1085     s->var_values[VAR_LINE_H] = s->var_values[VAR_LH] = s->max_glyph_h;
1086
1087     s->x = s->var_values[VAR_X] = av_expr_eval(s->x_pexpr, s->var_values, &s->prng);
1088     s->y = s->var_values[VAR_Y] = av_expr_eval(s->y_pexpr, s->var_values, &s->prng);
1089     s->x = s->var_values[VAR_X] = av_expr_eval(s->x_pexpr, s->var_values, &s->prng);
1090 #if FF_API_DRAWTEXT_OLD_TIMELINE
1091     if (s->draw_pexpr){
1092     s->draw = av_expr_eval(s->draw_pexpr, s->var_values, &s->prng);
1093
1094     if(!s->draw)
1095         return 0;
1096     }
1097     if (ctx->is_disabled)
1098         return 0;
1099 #endif
1100
1101     box_w = FFMIN(width - 1 , max_text_line_w);
1102     box_h = FFMIN(height - 1, y + s->max_glyph_h);
1103
1104     /* draw box */
1105     if (s->draw_box)
1106         ff_blend_rectangle(&s->dc, &s->boxcolor,
1107                            frame->data, frame->linesize, width, height,
1108                            s->x, s->y, box_w, box_h);
1109
1110     if (s->shadowx || s->shadowy) {
1111         if ((ret = draw_glyphs(s, frame, width, height,
1112                                &s->shadowcolor, s->shadowx, s->shadowy, 0)) < 0)
1113             return ret;
1114     }
1115
1116     if (s->borderw) {
1117         if ((ret = draw_glyphs(s, frame, width, height,
1118                                &s->bordercolor, 0, 0, s->borderw)) < 0)
1119             return ret;
1120     }
1121     if ((ret = draw_glyphs(s, frame, width, height,
1122                            &s->fontcolor, 0, 0, 0)) < 0)
1123         return ret;
1124
1125     return 0;
1126 }
1127
1128 static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
1129 {
1130     AVFilterContext *ctx = inlink->dst;
1131     AVFilterLink *outlink = ctx->outputs[0];
1132     DrawTextContext *s = ctx->priv;
1133     int ret;
1134
1135     if (s->reload)
1136         if ((ret = load_textfile(ctx)) < 0)
1137             return ret;
1138
1139     s->var_values[VAR_N] = inlink->frame_count+s->start_number;
1140     s->var_values[VAR_T] = frame->pts == AV_NOPTS_VALUE ?
1141         NAN : frame->pts * av_q2d(inlink->time_base);
1142
1143     s->var_values[VAR_PICT_TYPE] = frame->pict_type;
1144     s->metadata = av_frame_get_metadata(frame);
1145
1146     draw_text(ctx, frame, frame->width, frame->height);
1147
1148     av_log(ctx, AV_LOG_DEBUG, "n:%d t:%f text_w:%d text_h:%d x:%d y:%d\n",
1149            (int)s->var_values[VAR_N], s->var_values[VAR_T],
1150            (int)s->var_values[VAR_TEXT_W], (int)s->var_values[VAR_TEXT_H],
1151            s->x, s->y);
1152
1153     return ff_filter_frame(outlink, frame);
1154 }
1155
1156 static const AVFilterPad avfilter_vf_drawtext_inputs[] = {
1157     {
1158         .name           = "default",
1159         .type           = AVMEDIA_TYPE_VIDEO,
1160         .filter_frame   = filter_frame,
1161         .config_props   = config_input,
1162         .needs_writable = 1,
1163     },
1164     { NULL }
1165 };
1166
1167 static const AVFilterPad avfilter_vf_drawtext_outputs[] = {
1168     {
1169         .name = "default",
1170         .type = AVMEDIA_TYPE_VIDEO,
1171     },
1172     { NULL }
1173 };
1174
1175 AVFilter ff_vf_drawtext = {
1176     .name          = "drawtext",
1177     .description   = NULL_IF_CONFIG_SMALL("Draw text on top of video frames using libfreetype library."),
1178     .priv_size     = sizeof(DrawTextContext),
1179     .priv_class    = &drawtext_class,
1180     .init          = init,
1181     .uninit        = uninit,
1182     .query_formats = query_formats,
1183     .inputs        = avfilter_vf_drawtext_inputs,
1184     .outputs       = avfilter_vf_drawtext_outputs,
1185     .process_command = command,
1186 #if FF_API_DRAWTEXT_OLD_TIMELINE
1187     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
1188 #else
1189     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
1190 #endif
1191 };