Statistics
| Branch: | Revision:

ffmpeg / vhook / drawtext.c @ a20db8a3

History | View | Annotate | Download (14.6 KB)

1
/*
2
 * drawtext.c: print text over the screen
3
 ******************************************************************************
4
 * Options:
5
 * -f <filename>    font filename (MANDATORY!!!)
6
 * -s <pixel_size>  font size in pixels [default 16]
7
 * -b               print background
8
 * -o               outline glyphs (use the bg color)
9
 * -x <pos>         x position ( >= 0) [default 0]
10
 * -y <pos>         y position ( >= 0) [default 0]
11
 * -t <text>        text to print (will be passed to strftime())
12
 *                  MANDATORY: will be used even when -T is used.
13
 *                  in this case, -t will be used if some error
14
 *                  occurs
15
 * -T <filename>    file with the text (re-read every frame)
16
 * -c <#RRGGBB>     foreground color ('internet' way) [default #ffffff]
17
 * -C <#RRGGBB>     background color ('internet' way) [default #000000]
18
 *
19
 ******************************************************************************
20
 * Features:
21
 * - True Type, Type1 and others via FreeType2 library
22
 * - Font kerning (better output)
23
 * - Line Wrap (if the text doesn't fit, the next char go to the next line)
24
 * - Background box
25
 * - Outline
26
 ******************************************************************************
27
 * Author: Gustavo Sverzut Barbieri <gsbarbieri@yahoo.com.br>
28
 *
29
 * This file is part of FFmpeg.
30
 *
31
 * FFmpeg is free software; you can redistribute it and/or
32
 * modify it under the terms of the GNU Lesser General Public
33
 * License as published by the Free Software Foundation; either
34
 * version 2.1 of the License, or (at your option) any later version.
35
 *
36
 * FFmpeg is distributed in the hope that it will be useful,
37
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
38
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
39
 * Lesser General Public License for more details.
40
 *
41
 * You should have received a copy of the GNU Lesser General Public
42
 * License along with FFmpeg; if not, write to the Free Software
43
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
44
 */
45

    
46
#define MAXSIZE_TEXT 1024
47

    
48
#include "framehook.h"
49

    
50
#include <stdio.h>
51
#include <stdlib.h>
52
#include <fcntl.h>
53
#include <stdarg.h>
54
#include <string.h>
55
#include <unistd.h>
56
#undef time
57
#include <sys/time.h>
58
#include <time.h>
59

    
60
#include <ft2build.h>
61
#include FT_FREETYPE_H
62
#include FT_GLYPH_H
63

    
64
#define SCALEBITS 10
65
#define ONE_HALF  (1 << (SCALEBITS - 1))
66
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
67

    
68
#define RGB_TO_YUV(rgb_color, yuv_color) do { \
69
  yuv_color[0] = (FIX(0.29900)    * rgb_color[0] + FIX(0.58700) * rgb_color[1] + FIX(0.11400) * rgb_color[2] + ONE_HALF) >> SCALEBITS; \
70
  yuv_color[2] = ((FIX(0.50000)   * rgb_color[0] - FIX(0.41869) * rgb_color[1] - FIX(0.08131) * rgb_color[2] + ONE_HALF - 1) >> SCALEBITS) + 128; \
71
  yuv_color[1] = ((- FIX(0.16874) * rgb_color[0] - FIX(0.33126) * rgb_color[1] + FIX(0.50000) * rgb_color[2] + ONE_HALF - 1) >> SCALEBITS) + 128; \
72
} while (0)
73

    
74
#define COPY_3(dst,src) { \
75
    dst[0]=src[0]; \
76
    dst[1]=src[1]; \
77
    dst[2]=src[2]; \
78
}
79

    
80

    
81

    
82
#define SET_PIXEL(picture, yuv_color, x, y) { \
83
    picture->data[0][ (x) + (y)*picture->linesize[0] ] = yuv_color[0]; \
84
    picture->data[1][ ((x/2) + (y/2)*picture->linesize[1]) ] = yuv_color[1]; \
85
    picture->data[2][ ((x/2) + (y/2)*picture->linesize[2]) ] = yuv_color[2]; \
86
}
87

    
88
#define GET_PIXEL(picture, yuv_color, x, y) { \
89
    yuv_color[0] = picture->data[0][ (x) + (y)*picture->linesize[0] ]; \
90
    yuv_color[1] = picture->data[1][ (x/2) + (y/2)*picture->linesize[1] ]; \
91
    yuv_color[2] = picture->data[2][ (x/2) + (y/2)*picture->linesize[2] ]; \
92
}
93

    
94

    
95
typedef struct {
96
  unsigned char *text;
97
  char *file;
98
  unsigned int x;
99
  unsigned int y;
100
  int bg;
101
  int outline;
102
  unsigned char bgcolor[3]; /* YUV */
103
  unsigned char fgcolor[3]; /* YUV */
104
  FT_Library library;
105
  FT_Face    face;
106
  FT_Glyph   glyphs[ 255 ];
107
  FT_Bitmap  bitmaps[ 255 ];
108
  int        advance[ 255 ];
109
  int        bitmap_left[ 255 ];
110
  int        bitmap_top[ 255 ];
111
  unsigned int glyphs_index[ 255 ];
112
  int        text_height;
113
  int        baseline;
114
  int use_kerning;
115
} ContextInfo;
116

    
117

    
118
void Release(void *ctx)
119
{
120
    if (ctx)
121
        av_free(ctx);
122
}
123

    
124

    
125
static int ParseColor(char *text, unsigned char yuv_color[3])
126
{
127
  char tmp[3];
128
  unsigned char rgb_color[3];
129
  int i;
130

    
131
  tmp[2] = '\0';
132

    
133
  if ((!text) || (strlen(text) != 7) || (text[0] != '#') )
134
    return -1;
135

    
136
  for (i=0; i < 3; i++)
137
    {
138
      tmp[0] = text[i*2+1];
139
      tmp[1] = text[i*2+2];
140

    
141
      rgb_color[i] = strtol(tmp, NULL, 16);
142
    }
143

    
144
  RGB_TO_YUV(rgb_color, yuv_color);
145

    
146
  return 0;
147
}
148

    
149
int Configure(void **ctxp, int argc, char *argv[])
150
{
151
    int c;
152
    int error;
153
    ContextInfo *ci=NULL;
154
    char *font=NULL;
155
    unsigned int size=16;
156
    FT_BBox bbox;
157
    int yMax, yMin;
158
    *ctxp = av_mallocz(sizeof(ContextInfo));
159
    ci = (ContextInfo *) *ctxp;
160

    
161
    /* configure Context Info */
162
    ci->text = NULL;
163
    ci->file = NULL;
164
    ci->x = ci->y = 0;
165
    ci->fgcolor[0]=255;
166
    ci->fgcolor[1]=128;
167
    ci->fgcolor[2]=128;
168
    ci->bgcolor[0]=0;
169
    ci->fgcolor[1]=128;
170
    ci->fgcolor[2]=128;
171
    ci->bg = 0;
172
    ci->outline = 0;
173
    ci->text_height = 0;
174

    
175
    optind = 1;
176
    while ((c = getopt(argc, argv, "f:t:T:x:y:s:c:C:bo")) > 0) {
177
      switch (c) {
178
      case 'f':
179
        font = optarg;
180
        break;
181
      case 't':
182
        ci->text = av_strdup(optarg);
183
        break;
184
      case 'T':
185
        ci->file = av_strdup(optarg);
186
        break;
187
      case 'x':
188
        ci->x = (unsigned int) atoi(optarg);
189
        break;
190
      case 'y':
191
        ci->y = (unsigned int) atoi(optarg);
192
        break;
193
      case 's':
194
        size = (unsigned int) atoi(optarg);
195
        break;
196
      case 'c':
197
        if (ParseColor(optarg, ci->fgcolor) == -1)
198
          {
199
            av_log(NULL, AV_LOG_ERROR, "Invalid foreground color: '%s'. You must specify the color in the internet way(packaged hex): #RRGGBB, ie: -c #ffffff (for white foreground)\n", optarg);
200
            return -1;
201
          }
202
        break;
203
      case 'C':
204
        if (ParseColor(optarg, ci->bgcolor) == -1)
205
          {
206
            av_log(NULL, AV_LOG_ERROR, "Invalid background color: '%s'. You must specify the color in the internet way(packaged hex): #RRGGBB, ie: -C #ffffff (for white background)\n", optarg);
207
            return -1;
208
          }
209
        break;
210
      case 'b':
211
        ci->bg=1;
212
        break;
213
      case 'o':
214
        ci->outline=1;
215
        break;
216
      case '?':
217
        av_log(NULL, AV_LOG_ERROR, "Unrecognized argument '%s'\n", argv[optind]);
218
        return -1;
219
      }
220
    }
221

    
222
    if (!ci->text)
223
      {
224
        av_log(NULL, AV_LOG_ERROR, "No text provided (-t text)\n");
225
        return -1;
226
      }
227

    
228
    if (ci->file)
229
      {
230
        FILE *fp;
231
        if ((fp=fopen(ci->file, "r")) == NULL)
232
          {
233
            av_log(NULL, AV_LOG_INFO, "WARNING: The file could not be opened. Using text provided with -t switch: %s", strerror(errno));
234
          }
235
        else
236
          {
237
            fclose(fp);
238
          }
239
      }
240

    
241
    if (!font)
242
      {
243
        av_log(NULL, AV_LOG_ERROR, "No font file provided! (-f filename)\n");
244
        return -1;
245
      }
246

    
247
    if ((error = FT_Init_FreeType(&(ci->library))) != 0)
248
      {
249
        av_log(NULL, AV_LOG_ERROR, "Could not load FreeType (error# %d).\n", error);
250
        return -1;
251
      }
252

    
253
    if ((error = FT_New_Face( ci->library, font, 0, &(ci->face) )) != 0)
254
      {
255
        av_log(NULL, AV_LOG_ERROR, "Could not load face: %s  (error# %d).\n", font, error);
256
        return -1;
257
      }
258

    
259
    if ((error = FT_Set_Pixel_Sizes( ci->face, 0, size)) != 0)
260
      {
261
        av_log(NULL, AV_LOG_ERROR, "Could not set font size to %d pixels (error# %d).\n", size, error);
262
        return -1;
263
      }
264

    
265
    ci->use_kerning = FT_HAS_KERNING(ci->face);
266

    
267
    /* load and cache glyphs */
268
    yMax = -32000;
269
    yMin =  32000;
270
    for (c=0; c < 256; c++)
271
      {
272
        /* Load char */
273
        error = FT_Load_Char( ci->face, (unsigned char) c, FT_LOAD_RENDER | FT_LOAD_MONOCHROME );
274
        if (error) continue;  /* ignore errors */
275

    
276
        /* Save bitmap */
277
        ci->bitmaps[c] = ci->face->glyph->bitmap;
278
        /* Save bitmap left */
279
        ci->bitmap_left[c] = ci->face->glyph->bitmap_left;
280
        /* Save bitmap top */
281
        ci->bitmap_top[c] = ci->face->glyph->bitmap_top;
282

    
283
        /* Save advance */
284
        ci->advance[c] = ci->face->glyph->advance.x >> 6;
285

    
286
        /* Save glyph */
287
        error = FT_Get_Glyph( ci->face->glyph, &(ci->glyphs[c]) );
288
        /* Save glyph index */
289
        ci->glyphs_index[c] = FT_Get_Char_Index( ci->face, (unsigned char) c );
290

    
291
        /* Measure text height to calculate text_height (or the maximum text height) */
292
        FT_Glyph_Get_CBox( ci->glyphs[ c ], ft_glyph_bbox_pixels, &bbox );
293
        if (bbox.yMax > yMax)
294
          yMax = bbox.yMax;
295
        if (bbox.yMin < yMin)
296
          yMin = bbox.yMin;
297

    
298
      }
299

    
300
    ci->text_height = yMax - yMin;
301
    ci->baseline = yMax;
302

    
303
    return 0;
304
}
305

    
306

    
307

    
308

    
309
static inline void draw_glyph(AVPicture *picture, FT_Bitmap *bitmap, unsigned int x, unsigned int y, unsigned int width, unsigned int height, unsigned char yuv_fgcolor[3], unsigned char yuv_bgcolor[3], int outline)
310
{
311
  int r, c;
312
  int spixel, dpixel[3], in_glyph=0;
313

    
314
  if (bitmap->pixel_mode == ft_pixel_mode_mono)
315
    {
316
      in_glyph = 0;
317
      for (r=0; (r < bitmap->rows) && (r+y < height); r++)
318
        {
319
          for (c=0; (c < bitmap->width) && (c+x < width); c++)
320
            {
321
              /* pixel in the picture (destination) */
322
              GET_PIXEL(picture, dpixel, (c+x), (y+r));
323

    
324
              /* pixel in the glyph bitmap (source) */
325
              spixel = bitmap->buffer[r*bitmap->pitch +c/8] & (0x80>>(c%8));
326

    
327
              if (spixel)
328
                COPY_3(dpixel, yuv_fgcolor);
329

    
330
              if (outline)
331
                {
332
                  /* border detection: */
333
                  if ( (!in_glyph) && (spixel) )
334
                    /* left border detected */
335
                    {
336
                      in_glyph = 1;
337
                      /* draw left pixel border */
338
                      if (c-1 >= 0)
339
                        SET_PIXEL(picture, yuv_bgcolor, (c+x-1), (y+r));
340
                    }
341
                  else if ( (in_glyph) && (!spixel) )
342
                    /* right border detected */
343
                    {
344
                      in_glyph = 0;
345
                      /* 'draw' right pixel border */
346
                      COPY_3(dpixel, yuv_bgcolor);
347
                    }
348

    
349
                  if (in_glyph)
350
                    /* see if we have a top/bottom border */
351
                    {
352
                      /* top */
353
                      if ( (r-1 >= 0) && (! bitmap->buffer[(r-1)*bitmap->pitch +c/8] & (0x80>>(c%8))) )
354
                        /* we have a top border */
355
                        SET_PIXEL(picture, yuv_bgcolor, (c+x), (y+r-1));
356

    
357
                      /* bottom */
358
                      if ( (r+1 < height) && (! bitmap->buffer[(r+1)*bitmap->pitch +c/8] & (0x80>>(c%8))) )
359
                        /* we have a bottom border */
360
                        SET_PIXEL(picture, yuv_bgcolor, (c+x), (y+r+1));
361

    
362
                    }
363
                }
364

    
365
              SET_PIXEL(picture, dpixel, (c+x), (y+r));
366
            }
367
        }
368
    }
369
}
370

    
371

    
372
static inline void draw_box(AVPicture *picture, unsigned int x, unsigned int y, unsigned int width, unsigned int height, unsigned char yuv_color[3])
373
{
374
  int i, j;
375

    
376
  for (j = 0; (j < height); j++)
377
    for (i = 0; (i < width); i++)
378
      {
379
        SET_PIXEL(picture, yuv_color, (i+x), (y+j));
380
      }
381

    
382
}
383

    
384

    
385

    
386

    
387
void Process(void *ctx, AVPicture *picture, enum PixelFormat pix_fmt, int width, int height, int64_t pts)
388
{
389
  ContextInfo *ci = (ContextInfo *) ctx;
390
  FT_Face face = ci->face;
391
  FT_GlyphSlot  slot = face->glyph;
392
  unsigned char *text = ci->text;
393
  unsigned char c;
394
  int x = 0, y = 0, i=0, size=0;
395
  unsigned char buff[MAXSIZE_TEXT];
396
  unsigned char tbuff[MAXSIZE_TEXT];
397
  time_t now = time(0);
398
  int str_w, str_w_max;
399
  FT_Vector pos[MAXSIZE_TEXT];
400
  FT_Vector delta;
401

    
402
  if (ci->file)
403
    {
404
      int fd = open(ci->file, O_RDONLY);
405

    
406
      if (fd < 0)
407
        {
408
          text = ci->text;
409
          av_log(NULL, AV_LOG_INFO, "WARNING: The file could not be opened. Using text provided with -t switch: %s", strerror(errno));
410
        }
411
      else
412
        {
413
          int l = read(fd, tbuff, sizeof(tbuff) - 1);
414

    
415
          if (l >= 0)
416
            {
417
              tbuff[l] = 0;
418
              text = tbuff;
419
            }
420
          else
421
            {
422
              text = ci->text;
423
              av_log(NULL, AV_LOG_INFO, "WARNING: The file could not be read. Using text provided with -t switch: %s", strerror(errno));
424
            }
425
          close(fd);
426
        }
427
    }
428
  else
429
    {
430
      text = ci->text;
431
    }
432

    
433
  strftime(buff, sizeof(buff), text, localtime(&now));
434

    
435
  text = buff;
436

    
437
  size = strlen(text);
438

    
439

    
440

    
441

    
442
  /* measure string size and save glyphs position*/
443
  str_w = str_w_max = 0;
444
  x = ci->x;
445
  y = ci->y;
446
  for (i=0; i < size; i++)
447
    {
448
      c = text[i];
449

    
450
      /* kerning */
451
      if ( (ci->use_kerning) && (i > 0) && (ci->glyphs_index[c]) )
452
        {
453
          FT_Get_Kerning( ci->face,
454
                          ci->glyphs_index[ text[i-1] ],
455
                          ci->glyphs_index[c],
456
                          ft_kerning_default,
457
                          &delta );
458

    
459
          x += delta.x >> 6;
460
        }
461

    
462
      if (( (x + ci->advance[ c ]) >= width ) || ( c == '\n' ))
463
        {
464
          str_w = width - ci->x - 1;
465

    
466
          y += ci->text_height;
467
          x = ci->x;
468
        }
469

    
470

    
471
      /* save position */
472
      pos[i].x = x + ci->bitmap_left[c];
473
      pos[i].y = y - ci->bitmap_top[c] + ci->baseline;
474

    
475

    
476
      x += ci->advance[c];
477

    
478

    
479
      if (str_w > str_w_max)
480
        str_w_max = str_w;
481

    
482
    }
483

    
484

    
485

    
486

    
487
  if (ci->bg)
488
    {
489
      /* Check if it doesn't pass the limits */
490
      if ( str_w_max + ci->x >= width )
491
        str_w_max = width - ci->x - 1;
492
      if ( y >= height )
493
        y = height - 1 - 2*ci->y;
494

    
495
      /* Draw Background */
496
      draw_box( picture, ci->x, ci->y, str_w_max, y - ci->y, ci->bgcolor );
497
    }
498

    
499

    
500

    
501
  /* Draw Glyphs */
502
  for (i=0; i < size; i++)
503
    {
504
      c = text[i];
505

    
506
      if (
507
          ( (c == '_') && (text == ci->text) ) || /* skip '_' (consider as space)
508
                                                     IF text was specified in cmd line
509
                                                     (which doesn't like nested quotes)  */
510
          ( c == '\n' ) /* Skip new line char, just go to new line */
511
          )
512
        continue;
513

    
514
        /* now, draw to our target surface */
515
        draw_glyph( picture,
516
                    &(ci->bitmaps[ c ]),
517
                    pos[i].x,
518
                    pos[i].y,
519
                    width,
520
                    height,
521
                    ci->fgcolor,
522
                    ci->bgcolor,
523
                    ci->outline );
524

    
525
      /* increment pen position */
526
      x += slot->advance.x >> 6;
527
    }
528

    
529

    
530
}
531