FFmpeg: libavfilter/vf_drawtext.c Source File

206 { "ft_load_flags", "set font loading flags for libfreetype", OFFSET(ft_load_flags), AV_OPT_TYPE_FLAGS, { .i64 = FT_LOAD_DEFAULT | FT_LOAD_RENDER}, 0, INT_MAX, FLAGS, "ft_load_flags" },

207 { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_DEFAULT }, .flags = FLAGS, .unit = "ft_load_flags" },

208 { "no_scale", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_NO_SCALE }, .flags = FLAGS, .unit = "ft_load_flags" },

209 { "no_hinting", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_NO_HINTING }, .flags = FLAGS, .unit = "ft_load_flags" },

210 { "render", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_RENDER }, .flags = FLAGS, .unit = "ft_load_flags" },

211 { "no_bitmap", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_NO_BITMAP }, .flags = FLAGS, .unit = "ft_load_flags" },

212 { "vertical_layout", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_VERTICAL_LAYOUT }, .flags = FLAGS, .unit = "ft_load_flags" },

213 { "force_autohint", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_FORCE_AUTOHINT }, .flags = FLAGS, .unit = "ft_load_flags" },

214 { "crop_bitmap", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_CROP_BITMAP }, .flags = FLAGS, .unit = "ft_load_flags" },

215 { "pedantic", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_PEDANTIC }, .flags = FLAGS, .unit = "ft_load_flags" },

216 { "ignore_global_advance_width", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH }, .flags = FLAGS, .unit = "ft_load_flags" },

217 { "no_recurse", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_NO_RECURSE }, .flags = FLAGS, .unit = "ft_load_flags" },

218 { "ignore_transform", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_IGNORE_TRANSFORM }, .flags = FLAGS, .unit = "ft_load_flags" },

219 { "monochrome", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_MONOCHROME }, .flags = FLAGS, .unit = "ft_load_flags" },

220 { "linear_design", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_LINEAR_DESIGN }, .flags = FLAGS, .unit = "ft_load_flags" },

221 { "no_autohint", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FT_LOAD_NO_AUTOHINT }, .flags = FLAGS, .unit = "ft_load_flags" },

222 { NULL},

223 };

224

225 AVFILTER_DEFINE_CLASS(drawtext);

226

227 #undef __FTERRORS_H__

228 #define FT_ERROR_START_LIST {

229 #define FT_ERRORDEF(e, v, s) { (e), (s) },

230 #define FT_ERROR_END_LIST { 0, NULL } };

231

232 struct ft_error

233 {

234 int err;

235 const char *err_msg;

236 } static ft_errors[] =

237 #include FT_ERRORS_H

238

239 #define FT_ERRMSG(e) ft_errors[e].err_msg

240

241 typedef struct {

242 FT_Glyph *glyph;

243 uint32_t code;

244 FT_Bitmap bitmap; ///< array holding bitmaps of font

245 FT_BBox bbox;

246 int advance;

247 int bitmap_left;

248 int bitmap_top;

249 } Glyph;

250

251 static int glyph_cmp(void *key, const void *b)

252 {

253 const Glyph *a = key, *bb = b;

254 int64_t diff = (int64_t)a->code - (int64_t)bb->code;

255 return diff > 0 ? 1 : diff < 0 ? -1 : 0;

256 }

257

258 /**

259 * Load glyphs corresponding to the UTF-32 codepoint code.

260 */

261 static int load_glyph(AVFilterContext *ctx, Glyph **glyph_ptr, uint32_t code)

262 {

263 DrawTextContext *s = ctx->priv;

264 Glyph *glyph;

265 struct AVTreeNode *node = NULL;

266 int ret;

267

268 /* load glyph into s->face->glyph */

269 if (FT_Load_Char(s->face, code, s->ft_load_flags))

270 return AVERROR(EINVAL);

271

272 /* save glyph */

273 if (!(glyph = av_mallocz(sizeof(*glyph))) ||

274 !(glyph->glyph = av_mallocz(sizeof(*glyph->glyph)))) {

275 ret = AVERROR(ENOMEM);

276 goto error;

277 }

278 glyph->code = code;

279

280 if (FT_Get_Glyph(s->face->glyph, glyph->glyph)) {

281 ret = AVERROR(EINVAL);

282 goto error;

283 }

284

285 glyph->bitmap = s->face->glyph->bitmap;

286 glyph->bitmap_left = s->face->glyph->bitmap_left;

287 glyph->bitmap_top = s->face->glyph->bitmap_top;

288 glyph->advance = s->face->glyph->advance.x >> 6;

289

290 /* measure text height to calculate text_height (or the maximum text height) */

291 FT_Glyph_Get_CBox(*glyph->glyph, ft_glyph_bbox_pixels, &glyph->bbox);

292

293 /* cache the newly created glyph */

294 if (!(node = av_tree_node_alloc())) {

295 ret = AVERROR(ENOMEM);

296 goto error;

297 }

298 av_tree_insert(&s->glyphs, glyph, glyph_cmp, &node);

299

300 if (glyph_ptr)

301 *glyph_ptr = glyph;

302 return 0;

303

304 error:

305 if (glyph)

306 av_freep(&glyph->glyph);

307 av_freep(&glyph);

308 av_freep(&node);

309 return ret;

310 }

311

312 static int load_font_file(AVFilterContext *ctx, const char *path, int index,

313 const char **error)

314 {

315 DrawTextContext *s = ctx->priv;

316 int err;

317

318 err = FT_New_Face(s->library, path, index, &s->face);

319 if (err) {

320 *error = FT_ERRMSG(err);

321 return AVERROR(EINVAL);

322 }

323 return 0;

324 }

325

326 #if CONFIG_FONTCONFIG

327 static int load_font_fontconfig(AVFilterContext *ctx, const char **error)

328 {

329 DrawTextContext *s = ctx->priv;

330 FcConfig *fontconfig;

331 FcPattern *pattern, *fpat;

332 FcResult result = FcResultMatch;

333 FcChar8 *filename;

334 int err, index;

335 double size;

336

337 fontconfig = FcInitLoadConfigAndFonts();

338 if (!fontconfig) {

339 *error = "impossible to init fontconfig\n";

340 return AVERROR(EINVAL);

341 }

342 pattern = FcNameParse(s->fontfile ? s->fontfile :

343 (uint8_t *)(intptr_t)"default");

344 if (!pattern) {

345 *error = "could not parse fontconfig pattern";

346 return AVERROR(EINVAL);

347 }

348 if (!FcConfigSubstitute(fontconfig, pattern, FcMatchPattern)) {

349 *error = "could not substitue fontconfig options"; /* very unlikely */

350 return AVERROR(EINVAL);

351 }

352 FcDefaultSubstitute(pattern);

353 fpat = FcFontMatch(fontconfig, pattern, &result);

354 if (!fpat || result != FcResultMatch) {

355 *error = "impossible to find a matching font";

356 return AVERROR(EINVAL);

357 }

358 if (FcPatternGetString (fpat, FC_FILE, 0, &filename) != FcResultMatch ||

359 FcPatternGetInteger(fpat, FC_INDEX, 0, &index ) != FcResultMatch ||

360 FcPatternGetDouble (fpat, FC_SIZE, 0, &size ) != FcResultMatch) {

361 *error = "impossible to find font information";

362 return AVERROR(EINVAL);

363 }

364 av_log(ctx, AV_LOG_INFO, "Using \"%s\"\n", filename);

365 if (!s->fontsize)

366 s->fontsize = size + 0.5;

367 err = load_font_file(ctx, filename, index, error);

368 if (err)

369 return err;

370 FcPatternDestroy(fpat);

371 FcPatternDestroy(pattern);

372 FcConfigDestroy(fontconfig);

373 return 0;

374 }

375 #endif

376

377 static int load_font(AVFilterContext *ctx)

378 {

379 DrawTextContext *s = ctx->priv;

380 int err;

381 const char *error = "unknown error\n";

382

383 /* load the face, and set up the encoding, which is by default UTF-8 */

384 err = load_font_file(ctx, s->fontfile, 0, &error);

385 if (!err)

386 return 0;

387 #if CONFIG_FONTCONFIG

388 err = load_font_fontconfig(ctx, &error);

389 if (!err)

390 return 0;

391 #endif

392 av_log(ctx, AV_LOG_ERROR, "Could not load font \"%s\": %s\n",

393 s->fontfile, error);

394 return err;

395 }

396

397 static int load_textfile(AVFilterContext *ctx)

398 {

399 DrawTextContext *s = ctx->priv;

400 int err;

401 uint8_t *textbuf;

402 size_t textbuf_size;

403

404 if ((err = av_file_map(s->textfile, &textbuf, &textbuf_size, 0, ctx)) < 0) {

405 av_log(ctx, AV_LOG_ERROR,

406 "The text file '%s' could not be read or is empty\n",

407 s->textfile);

408 return err;

409 }

410

411 if (!(s->text = av_realloc(s->text, textbuf_size + 1)))

412 return AVERROR(ENOMEM);

413 memcpy(s->text, textbuf, textbuf_size);

414 s->text[textbuf_size] = 0;

415 av_file_unmap(textbuf, textbuf_size);

416

417 return 0;

418 }

419

420 static av_cold int init(AVFilterContext *ctx)

421 {

422 int err;

423 DrawTextContext *s = ctx->priv;

424 Glyph *glyph;

425

426 if (!s->fontfile && !CONFIG_FONTCONFIG) {

427 av_log(ctx, AV_LOG_ERROR, "No font filename provided\n");

428 return AVERROR(EINVAL);

429 }

430

431 if (s->textfile) {

432 if (s->text) {

433 av_log(ctx, AV_LOG_ERROR,

434 "Both text and text file provided. Please provide only one\n");

435 return AVERROR(EINVAL);

436 }

437 if ((err = load_textfile(ctx)) < 0)

438 return err;

439 }

440

441 if (s->reload && !s->textfile)

442 av_log(ctx, AV_LOG_WARNING, "No file to reload\n");

443

444 if (s->tc_opt_string) {

445 int ret = av_timecode_init_from_string(&s->tc, s->tc_rate,

446 s->tc_opt_string, ctx);

447 if (ret < 0)

448 return ret;

449 if (s->tc24hmax)

450 s->tc.flags |= AV_TIMECODE_FLAG_24HOURSMAX;

451 if (!s->text)

452 s->text = av_strdup("");

453 }

454

455 if (!s->text) {

456 av_log(ctx, AV_LOG_ERROR,

457 "Either text, a valid file or a timecode must be provided\n");

458 return AVERROR(EINVAL);

459 }

460

461 if ((err = FT_Init_FreeType(&(s->library)))) {

462 av_log(ctx, AV_LOG_ERROR,

463 "Could not load FreeType: %s\n", FT_ERRMSG(err));

464 return AVERROR(EINVAL);

465 }

466

467 err = load_font(ctx);

468 if (err)

469 return err;

470 if (!s->fontsize)

471 s->fontsize = 16;

472 if ((err = FT_Set_Pixel_Sizes(s->face, 0, s->fontsize))) {

473 av_log(ctx, AV_LOG_ERROR, "Could not set font size to %d pixels: %s\n",

474 s->fontsize, FT_ERRMSG(err));

475 return AVERROR(EINVAL);

476 }

477

478 s->use_kerning = FT_HAS_KERNING(s->face);

479

480 /* load the fallback glyph with code 0 */

481 load_glyph(ctx, NULL, 0);

482

483 /* set the tabsize in pixels */

484 if ((err = load_glyph(ctx, &glyph, ' ')) < 0) {

485 av_log(ctx, AV_LOG_ERROR, "Could not set tabsize.\n");

486 return err;

487 }

488 s->tabsize *= glyph->advance;

489

490 if (s->exp_mode == EXP_STRFTIME &&

491 (strchr(s->text, '%') || strchr(s->text, '\\')))

492 av_log(ctx, AV_LOG_WARNING, "expansion=strftime is deprecated.\n");

493

494 av_bprint_init(&s->expanded_text, 0, AV_BPRINT_SIZE_UNLIMITED);

495

496 return 0;

497 }

498

499 static int query_formats(AVFilterContext *ctx)

500 {

501 ff_set_common_formats(ctx, ff_draw_supported_pixel_formats(0));

502 return 0;

503 }

504

505 static int glyph_enu_free(void *opaque, void *elem)

506 {

507 Glyph *glyph = elem;

508

509 FT_Done_Glyph(*glyph->glyph);

510 av_freep(&glyph->glyph);

511 av_free(elem);

512 return 0;

513 }

514

515 static av_cold void uninit(AVFilterContext *ctx)

516 {

517 DrawTextContext *s = ctx->priv;

518

519 av_expr_free(s->x_pexpr);

520 av_expr_free(s->y_pexpr);

521 av_expr_free(s->draw_pexpr);

522 s->x_pexpr = s->y_pexpr = s->draw_pexpr = NULL;

523 av_freep(&s->positions);

524 s->nb_positions = 0;

525

526

527 av_tree_enumerate(s->glyphs, NULL, NULL, glyph_enu_free);

528 av_tree_destroy(s->glyphs);

529 s->glyphs = NULL;

530

531 FT_Done_Face(s->face);

532 FT_Done_FreeType(s->library);

533

534 av_bprint_finalize(&s->expanded_text, NULL);

535 }

536

537 static inline int is_newline(uint32_t c)

538 {

539 return c == '\n' || c == '\r' || c == '\f' || c == '\v';

540 }

541

542 static int config_input(AVFilterLink *inlink)

543 {

544 AVFilterContext *ctx = inlink->dst;

545 DrawTextContext *s = ctx->priv;

546 int ret;

547

548 ff_draw_init(&s->dc, inlink->format, 0);

549 ff_draw_color(&s->dc, &s->fontcolor, s->fontcolor.rgba);

550 ff_draw_color(&s->dc, &s->shadowcolor, s->shadowcolor.rgba);

551 ff_draw_color(&s->dc, &s->boxcolor, s->boxcolor.rgba);

552

553 s->var_values[VAR_w] = s->var_values[VAR_W] = s->var_values[VAR_MAIN_W] = inlink->w;

554 s->var_values[VAR_h] = s->var_values[VAR_H] = s->var_values[VAR_MAIN_H] = inlink->h;

555 s->var_values[VAR_SAR] = inlink->sample_aspect_ratio.num ? av_q2d(inlink->sample_aspect_ratio) : 1;

556 s->var_values[VAR_DAR] = (double)inlink->w / inlink->h * s->var_values[VAR_SAR];

557 s->var_values[VAR_HSUB] = 1 << s->dc.hsub_max;

558 s->var_values[VAR_VSUB] = 1 << s->dc.vsub_max;

559 s->var_values[VAR_X] = NAN;

560 s->var_values[VAR_Y] = NAN;

561 s->var_values[VAR_T] = NAN;

562

563 av_lfg_init(&s->prng, av_get_random_seed());

564

565 av_expr_free(s->x_pexpr);

566 av_expr_free(s->y_pexpr);

567 av_expr_free(s->draw_pexpr);

568 s->x_pexpr = s->y_pexpr = s->draw_pexpr = NULL;

569 if ((ret = av_expr_parse(&s->x_pexpr, s->x_expr, var_names,

570 NULL, NULL, fun2_names, fun2, 0, ctx)) < 0 ||

571 (ret = av_expr_parse(&s->y_pexpr, s->y_expr, var_names,

572 NULL, NULL, fun2_names, fun2, 0, ctx)) < 0 ||

573 (ret = av_expr_parse(&s->draw_pexpr, s->draw_expr, var_names,

574 NULL, NULL, fun2_names, fun2, 0, ctx)) < 0)

575

576 return AVERROR(EINVAL);

577

578 return 0;

579 }

580

581 static int command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)

582 {

583 DrawTextContext *s = ctx->priv;

584

585 if (!strcmp(cmd, "reinit")) {

586 int ret;

587 uninit(ctx);

588 s->reinit = 1;

589 if ((ret = init(ctx)) < 0)

590 return ret;

591 return config_input(ctx->inputs[0]);

592 }

593

594 return AVERROR(ENOSYS);

595 }

596

597 static int func_pict_type(AVFilterContext *ctx, AVBPrint *bp,

598 char *fct, unsigned argc, char **argv, int tag)

599 {

600 DrawTextContext *s = ctx->priv;

601

602 av_bprintf(bp, "%c", av_get_picture_type_char(s->var_values[VAR_PICT_TYPE]));

603 return 0;

604 }

605

606 static int func_pts(AVFilterContext *ctx, AVBPrint *bp,

607 char *fct, unsigned argc, char **argv, int tag)

608 {

609 DrawTextContext *s = ctx->priv;

610

611 av_bprintf(bp, "%.6f", s->var_values[VAR_T]);

612 return 0;

613 }

614

615 static int func_frame_num(AVFilterContext *ctx, AVBPrint *bp,

616 char *fct, unsigned argc, char **argv, int tag)

617 {

618 DrawTextContext *s = ctx->priv;

619

620 av_bprintf(bp, "%d", (int)s->var_values[VAR_N]);

621 return 0;

622 }

623

624 static int func_metadata(AVFilterContext *ctx, AVBPrint *bp,

625 char *fct, unsigned argc, char **argv, int tag)

626 {

627 DrawTextContext *s = ctx->priv;

628 AVDictionaryEntry *e = av_dict_get(s->metadata, argv[0], NULL, 0);

629

630 if (e && e->value)

631 av_bprintf(bp, "%s", e->value);

632 return 0;

633 }

634

635 #if !HAVE_LOCALTIME_R

636 static void localtime_r(const time_t *t, struct tm *tm)

637 {

638 *tm = *localtime(t);

639 }

640 #endif

641

642 static int func_strftime(AVFilterContext *ctx, AVBPrint *bp,

643 char *fct, unsigned argc, char **argv, int tag)

644 {

645 const char *fmt = argc ? argv[0] : "%Y-%m-%d %H:%M:%S";

646 time_t now;

647 struct tm tm;

648

649 time(&now);

650 if (tag == 'L')

651 localtime_r(&now, &tm);

652 else

653 tm = *gmtime(&now);

654 av_bprint_strftime(bp, fmt, &tm);

655 return 0;

656 }

657

658 static int func_eval_expr(AVFilterContext *ctx, AVBPrint *bp,

659 char *fct, unsigned argc, char **argv, int tag)

660 {

661 DrawTextContext *s = ctx->priv;

662 double res;

663 int ret;

664

665 ret = av_expr_parse_and_eval(&res, argv[0], var_names, s->var_values,

666 NULL, NULL, fun2_names, fun2,

667 &s->prng, 0, ctx);

668 if (ret < 0)

669 av_log(ctx, AV_LOG_ERROR,

670 "Expression '%s' for the expr text expansion function is not valid\n",

671 argv[0]);

672 else

673 av_bprintf(bp, "%f", res);

674

675 return ret;

676 }

677

678 static const struct drawtext_function {

679 const char *name;

680 unsigned argc_min, argc_max;

681 int tag; /**< opaque argument to func */

682 int (*func)(AVFilterContext *, AVBPrint *, char *, unsigned, char **, int);

683 } functions[] = {

684 { "expr", 1, 1, 0, func_eval_expr },

685 { "e", 1, 1, 0, func_eval_expr },

686 { "pict_type", 0, 0, 0, func_pict_type },

687 { "pts", 0, 0, 0, func_pts },

688 { "gmtime", 0, 1, 'G', func_strftime },

689 { "localtime", 0, 1, 'L', func_strftime },

690 { "frame_num", 0, 0, 0, func_frame_num },

691 { "n", 0, 0, 0, func_frame_num },

692 { "metadata", 1, 1, 0, func_metadata },

693 };

694

695 static int eval_function(AVFilterContext *ctx, AVBPrint *bp, char *fct,

696 unsigned argc, char **argv)

697 {

698 unsigned i;

699

700 for (i = 0; i < FF_ARRAY_ELEMS(functions); i++) {

701 if (strcmp(fct, functions[i].name))

702 continue;

703 if (argc < functions[i].argc_min) {

704 av_log(ctx, AV_LOG_ERROR, "%%{%s} requires at least %d arguments\n",

705 fct, functions[i].argc_min);

706 return AVERROR(EINVAL);

707 }

708 if (argc > functions[i].argc_max) {

709 av_log(ctx, AV_LOG_ERROR, "%%{%s} requires at most %d arguments\n",

710 fct, functions[i].argc_max);

711 return AVERROR(EINVAL);

712 }

713 break;

714 }

715 if (i >= FF_ARRAY_ELEMS(functions)) {

716 av_log(ctx, AV_LOG_ERROR, "%%{%s} is not known\n", fct);

717 return AVERROR(EINVAL);

718 }

719 return functions[i].func(ctx, bp, fct, argc, argv, functions[i].tag);

720 }

721

722 static int expand_function(AVFilterContext *ctx, AVBPrint *bp, char **rtext)

723 {

724 const char *text = *rtext;

725 char *argv[16] = { NULL };

726 unsigned argc = 0, i;

727 int ret;

728

729 if (*text != '{') {

730 av_log(ctx, AV_LOG_ERROR, "Stray %% near '%s'\n", text);

731 return AVERROR(EINVAL);

732 }

733 text++;

734 while (1) {

735 if (!(argv[argc++] = av_get_token(&text, ":}"))) {

736 ret = AVERROR(ENOMEM);

737 goto end;

738 }

739 if (!*text) {

740 av_log(ctx, AV_LOG_ERROR, "Unterminated %%{} near '%s'\n", *rtext);

741 ret = AVERROR(EINVAL);

742 goto end;

743 }

744 if (argc == FF_ARRAY_ELEMS(argv))

745 av_freep(&argv[--argc]); /* error will be caught later */

746 if (*text == '}')

747 break;

748 text++;

749 }

750

751 if ((ret = eval_function(ctx, bp, argv[0], argc - 1, argv + 1)) < 0)

752 goto end;

753 ret = 0;

754 *rtext = (char *)text + 1;

755

756 end:

757 for (i = 0; i < argc; i++)

758 av_freep(&argv[i]);

759 return ret;

760 }

761

762 static int expand_text(AVFilterContext *ctx)

763 {

764 DrawTextContext *s = ctx->priv;

765 char *text = s->text;

766 AVBPrint *bp = &s->expanded_text;

767 int ret;

768

769 av_bprint_clear(bp);

770 while (*text) {

771 if (*text == '\\' && text[1]) {

772 av_bprint_chars(bp, text[1], 1);

773 text += 2;

774 } else if (*text == '%') {

775 text++;

776 if ((ret = expand_function(ctx, bp, &text)) < 0)

777 return ret;

778 } else {

779 av_bprint_chars(bp, *text, 1);

780 text++;

781 }

782 }

783 if (!av_bprint_is_complete(bp))

784 return AVERROR(ENOMEM);

785 return 0;

786 }

787

788 static int draw_glyphs(DrawTextContext *s, AVFrame *frame,

789 int width, int height, const uint8_t rgbcolor[4], FFDrawColor *color, int x, int y)

790 {

791 char *text = s->expanded_text.str;

792 uint32_t code = 0;

793 int i, x1, y1;

794 uint8_t *p;

795 Glyph *glyph = NULL;

796

797 for (i = 0, p = text; *p; i++) {

798 Glyph dummy = { 0 };

799 GET_UTF8(code, *p++, continue;);

800

801 /* skip new line chars, just go to new line */

802 if (code == '\n' || code == '\r' || code == '\t')

803 continue;

804

805 dummy.code = code;

806 glyph = av_tree_find(s->glyphs, &dummy, (void *)glyph_cmp, NULL);

807

808 if (glyph->bitmap.pixel_mode != FT_PIXEL_MODE_MONO &&

809 glyph->bitmap.pixel_mode != FT_PIXEL_MODE_GRAY)

810 return AVERROR(EINVAL);

811

812 x1 = s->positions[i].x+s->x+x;

813 y1 = s->positions[i].y+s->y+y;

814

815 ff_blend_mask(&s->dc, color,

816 frame->data, frame->linesize, width, height,

817 glyph->bitmap.buffer, glyph->bitmap.pitch,

818 glyph->bitmap.width, glyph->bitmap.rows,

819 glyph->bitmap.pixel_mode == FT_PIXEL_MODE_MONO ? 0 : 3,

820 0, x1, y1);

821 }

822

823 return 0;

824 }

825

826 static int draw_text(AVFilterContext *ctx, AVFrame *frame,

827 int width, int height)

828 {

829 DrawTextContext *s = ctx->priv;

830 AVFilterLink *inlink = ctx->inputs[0];

831

832 uint32_t code = 0, prev_code = 0;

833 int x = 0, y = 0, i = 0, ret;

834 int max_text_line_w = 0, len;

835 int box_w, box_h;

836 char *text = s->text;

837 uint8_t *p;

838 int y_min = 32000, y_max = -32000;

839 int x_min = 32000, x_max = -32000;

840 FT_Vector delta;

841 Glyph *glyph = NULL, *prev_glyph = NULL;

842 Glyph dummy = { 0 };

843

844 time_t now = time(0);

845 struct tm ltime;

846 AVBPrint *bp = &s->expanded_text;

847

848 av_bprint_clear(bp);

849

850 if(s->basetime != AV_NOPTS_VALUE)

851 now= frame->pts*av_q2d(ctx->inputs[0]->time_base) + s->basetime/1000000;

852

853 switch (s->exp_mode) {

854 case EXP_NONE:

855 av_bprintf(bp, "%s", s->text);

856 break;

857 case EXP_NORMAL:

858 if ((ret = expand_text(ctx)) < 0)

859 return ret;

860 break;

861 case EXP_STRFTIME:

862 localtime_r(&now, &ltime);

863 av_bprint_strftime(bp, s->text, &ltime);

864 break;

865 }

866

867 if (s->tc_opt_string) {

868 char tcbuf[AV_TIMECODE_STR_SIZE];

869 av_timecode_make_string(&s->tc, tcbuf, inlink->frame_count);

870 av_bprint_clear(bp);

871 av_bprintf(bp, "%s%s", s->text, tcbuf);

872 }

873

874 if (!av_bprint_is_complete(bp))

875 return AVERROR(ENOMEM);

876 text = s->expanded_text.str;

877 if ((len = s->expanded_text.len) > s->nb_positions) {

878 if (!(s->positions =

879 av_realloc(s->positions, len*sizeof(*s->positions))))

880 return AVERROR(ENOMEM);

881 s->nb_positions = len;

882 }

883

884 x = 0;

885 y = 0;

886

887 /* load and cache glyphs */

888 for (i = 0, p = text; *p; i++) {

889 GET_UTF8(code, *p++, continue;);

890

891 /* get glyph */

892 dummy.code = code;

893 glyph = av_tree_find(s->glyphs, &dummy, glyph_cmp, NULL);

894 if (!glyph) {

895 load_glyph(ctx, &glyph, code);

896 }

897

898 y_min = FFMIN(glyph->bbox.yMin, y_min);

899 y_max = FFMAX(glyph->bbox.yMax, y_max);

900 x_min = FFMIN(glyph->bbox.xMin, x_min);

901 x_max = FFMAX(glyph->bbox.xMax, x_max);

902 }

903 s->max_glyph_h = y_max - y_min;

904 s->max_glyph_w = x_max - x_min;

905

906 /* compute and save position for each glyph */

907 glyph = NULL;

908 for (i = 0, p = text; *p; i++) {

909 GET_UTF8(code, *p++, continue;);

910

911 /* skip the \n in the sequence \r\n */

912 if (prev_code == '\r' && code == '\n')

913 continue;

914

915 prev_code = code;

916 if (is_newline(code)) {

917

918 max_text_line_w = FFMAX(max_text_line_w, x);

919 y += s->max_glyph_h;

920 x = 0;

921 continue;

922 }

923

924 /* get glyph */

925 prev_glyph = glyph;

926 dummy.code = code;

927 glyph = av_tree_find(s->glyphs, &dummy, glyph_cmp, NULL);

928

929 /* kerning */

930 if (s->use_kerning && prev_glyph && glyph->code) {

931 FT_Get_Kerning(s->face, prev_glyph->code, glyph->code,

932 ft_kerning_default, &delta);

933 x += delta.x >> 6;

934 }

935

936 /* save position */

937 s->positions[i].x = x + glyph->bitmap_left;

938 s->positions[i].y = y - glyph->bitmap_top + y_max;

939 if (code == '\t') x = (x / s->tabsize + 1)*s->tabsize;

940 else x += glyph->advance;

941 }

942

943 max_text_line_w = FFMAX(x, max_text_line_w);

944

945 s->var_values[VAR_TW] = s->var_values[VAR_TEXT_W] = max_text_line_w;

946 s->var_values[VAR_TH] = s->var_values[VAR_TEXT_H] = y + s->max_glyph_h;

947

948 s->var_values[VAR_MAX_GLYPH_W] = s->max_glyph_w;

949 s->var_values[VAR_MAX_GLYPH_H] = s->max_glyph_h;

950 s->var_values[VAR_MAX_GLYPH_A] = s->var_values[VAR_ASCENT ] = y_max;

951 s->var_values[VAR_MAX_GLYPH_D] = s->var_values[VAR_DESCENT] = y_min;

952

953 s->var_values[VAR_LINE_H] = s->var_values[VAR_LH] = s->max_glyph_h;

954

955 s->x = s->var_values[VAR_X] = av_expr_eval(s->x_pexpr, s->var_values, &s->prng);

956 s->y = s->var_values[VAR_Y] = av_expr_eval(s->y_pexpr, s->var_values, &s->prng);

957 s->x = s->var_values[VAR_X] = av_expr_eval(s->x_pexpr, s->var_values, &s->prng);

958 s->draw = av_expr_eval(s->draw_pexpr, s->var_values, &s->prng);

959

960 if(!s->draw)

961 return 0;

962

963 box_w = FFMIN(width - 1 , max_text_line_w);

964 box_h = FFMIN(height - 1, y + s->max_glyph_h);

965

966 /* draw box */

967 if (s->draw_box)

968 ff_blend_rectangle(&s->dc, &s->boxcolor,

969 frame->data, frame->linesize, width, height,

970 s->x, s->y, box_w, box_h);

971

972 if (s->shadowx || s->shadowy) {

973 if ((ret = draw_glyphs(s, frame, width, height, s->shadowcolor.rgba,

974 &s->shadowcolor, s->shadowx, s->shadowy)) < 0)

975 return ret;

976 }

977

978 if ((ret = draw_glyphs(s, frame, width, height, s->fontcolor.rgba,

979 &s->fontcolor, 0, 0)) < 0)

980 return ret;

981

982 return 0;

983 }

984

985 static int filter_frame(AVFilterLink *inlink, AVFrame *frame)

986 {

987 AVFilterContext *ctx = inlink->dst;

988 AVFilterLink *outlink = ctx->outputs[0];

989 DrawTextContext *s = ctx->priv;

990 int ret;

991

992 if (s->reload)

993 if ((ret = load_textfile(ctx)) < 0)

994 return ret;

995

996 s->var_values[VAR_N] = inlink->frame_count+s->start_number;

997 s->var_values[VAR_T] = frame->pts == AV_NOPTS_VALUE ?

998 NAN : frame->pts * av_q2d(inlink->time_base);

999

1000 s->var_values[VAR_PICT_TYPE] = frame->pict_type;

1001 s->metadata = av_frame_get_metadata(frame);

1002

1003 draw_text(ctx, frame, frame->width, frame->height);

1004

1005 av_log(ctx, AV_LOG_DEBUG, "n:%d t:%f text_w:%d text_h:%d x:%d y:%d\n",

1006 (int)s->var_values[VAR_N], s->var_values[VAR_T],

1007 (int)s->var_values[VAR_TEXT_W], (int)s->var_values[VAR_TEXT_H],

1008 s->x, s->y);

1009

1010 return ff_filter_frame(outlink, frame);

1011 }

1012

1013 static const AVFilterPad avfilter_vf_drawtext_inputs[] = {

1014 {

1015 .name = "default",

1016 .type = AVMEDIA_TYPE_VIDEO,

1017 .get_video_buffer = ff_null_get_video_buffer,

1018 .filter_frame = filter_frame,

1019 .config_props = config_input,

1020 .needs_writable = 1,

1021 },

1022 { NULL }

1023 };

1024

1025 static const AVFilterPad avfilter_vf_drawtext_outputs[] = {

1026 {

1027 .name = "default",

1028 .type = AVMEDIA_TYPE_VIDEO,

1029 },

1030 { NULL }

1031 };

1032

1033 AVFilter avfilter_vf_drawtext = {

1034 .name = "drawtext",

1035 .description = NULL_IF_CONFIG_SMALL("Draw text on top of video frames using libfreetype library."),

1036 .priv_size = sizeof(DrawTextContext),

1037 .priv_class = &drawtext_class,

1038 .init = init,

1039 .uninit = uninit,

1040 .query_formats = query_formats,

1041

1042 .inputs = avfilter_vf_drawtext_inputs,

1043 .outputs = avfilter_vf_drawtext_outputs,

1044 .process_command = command,

1045 };

Generated on Wed Jul 10 2013 23:48:10 for FFmpeg by doxygen 1.8.2