FFmpeg
vf_subtitles.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2011 Baptiste Coudurier
3  * Copyright (c) 2011 Stefano Sabatini
4  * Copyright (c) 2012 Clément Bœsch
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  * Libass subtitles burning filter.
26  *
27  * @see{http://www.matroska.org/technical/specs/subtitles/ssa.html}
28  */
29 
30 #include <ass/ass.h>
31 
32 #include "config.h"
33 #if CONFIG_SUBTITLES_FILTER
34 # include "libavcodec/avcodec.h"
35 # include "libavformat/avformat.h"
36 #endif
37 #include "libavutil/avstring.h"
38 #include "libavutil/imgutils.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/parseutils.h"
41 #include "drawutils.h"
42 #include "avfilter.h"
43 #include "internal.h"
44 #include "formats.h"
45 #include "video.h"
46 
47 typedef struct AssContext {
48  const AVClass *class;
49  ASS_Library *library;
50  ASS_Renderer *renderer;
51  ASS_Track *track;
52  char *filename;
53  char *fontsdir;
54  char *charenc;
55  char *force_style;
57  int alpha;
59  int pix_step[4]; ///< steps per pixel for each plane of the main output
61  int shaping;
63 } AssContext;
64 
65 #define OFFSET(x) offsetof(AssContext, x)
66 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
67 
68 #define COMMON_OPTIONS \
69  {"filename", "set the filename of file to read", OFFSET(filename), AV_OPT_TYPE_STRING, {.str = NULL}, CHAR_MIN, CHAR_MAX, FLAGS }, \
70  {"f", "set the filename of file to read", OFFSET(filename), AV_OPT_TYPE_STRING, {.str = NULL}, CHAR_MIN, CHAR_MAX, FLAGS }, \
71  {"original_size", "set the size of the original video (used to scale fonts)", OFFSET(original_w), AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL}, CHAR_MIN, CHAR_MAX, FLAGS }, \
72  {"fontsdir", "set the directory containing the fonts to read", OFFSET(fontsdir), AV_OPT_TYPE_STRING, {.str = NULL}, CHAR_MIN, CHAR_MAX, FLAGS }, \
73  {"alpha", "enable processing of alpha channel", OFFSET(alpha), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, FLAGS }, \
74 
75 /* libass supports a log level ranging from 0 to 7 */
76 static const int ass_libavfilter_log_level_map[] = {
77  [0] = AV_LOG_FATAL, /* MSGL_FATAL */
78  [1] = AV_LOG_ERROR, /* MSGL_ERR */
79  [2] = AV_LOG_WARNING, /* MSGL_WARN */
80  [3] = AV_LOG_WARNING, /* <undefined> */
81  [4] = AV_LOG_INFO, /* MSGL_INFO */
82  [5] = AV_LOG_INFO, /* <undefined> */
83  [6] = AV_LOG_VERBOSE, /* MSGL_V */
84  [7] = AV_LOG_DEBUG, /* MSGL_DBG2 */
85 };
86 
87 static void ass_log(int ass_level, const char *fmt, va_list args, void *ctx)
88 {
89  const int ass_level_clip = av_clip(ass_level, 0,
91  const int level = ass_libavfilter_log_level_map[ass_level_clip];
92 
93  av_vlog(ctx, level, fmt, args);
94  av_log(ctx, level, "\n");
95 }
96 
98 {
99  AssContext *ass = ctx->priv;
100 
101  if (!ass->filename) {
102  av_log(ctx, AV_LOG_ERROR, "No filename provided!\n");
103  return AVERROR(EINVAL);
104  }
105 
106  ass->library = ass_library_init();
107  if (!ass->library) {
108  av_log(ctx, AV_LOG_ERROR, "Could not initialize libass.\n");
109  return AVERROR(EINVAL);
110  }
111  ass_set_message_cb(ass->library, ass_log, ctx);
112 
113  ass_set_fonts_dir(ass->library, ass->fontsdir);
114 
115  ass->renderer = ass_renderer_init(ass->library);
116  if (!ass->renderer) {
117  av_log(ctx, AV_LOG_ERROR, "Could not initialize libass renderer.\n");
118  return AVERROR(EINVAL);
119  }
120 
121  return 0;
122 }
123 
125 {
126  AssContext *ass = ctx->priv;
127 
128  if (ass->track)
129  ass_free_track(ass->track);
130  if (ass->renderer)
131  ass_renderer_done(ass->renderer);
132  if (ass->library)
133  ass_library_done(ass->library);
134 }
135 
137 {
139 }
140 
142 {
143  AssContext *ass = inlink->dst->priv;
144 
145  ff_draw_init(&ass->draw, inlink->format, ass->alpha ? FF_DRAW_PROCESS_ALPHA : 0);
146 
147  ass_set_frame_size (ass->renderer, inlink->w, inlink->h);
148  if (ass->original_w && ass->original_h)
149  ass_set_aspect_ratio(ass->renderer, (double)inlink->w / inlink->h,
150  (double)ass->original_w / ass->original_h);
151  if (ass->shaping != -1)
152  ass_set_shaper(ass->renderer, ass->shaping);
153 
154  return 0;
155 }
156 
157 /* libass stores an RGBA color in the format RRGGBBTT, where TT is the transparency level */
158 #define AR(c) ( (c)>>24)
159 #define AG(c) (((c)>>16)&0xFF)
160 #define AB(c) (((c)>>8) &0xFF)
161 #define AA(c) ((0xFF-(c)) &0xFF)
162 
163 static void overlay_ass_image(AssContext *ass, AVFrame *picref,
164  const ASS_Image *image)
165 {
166  for (; image; image = image->next) {
167  uint8_t rgba_color[] = {AR(image->color), AG(image->color), AB(image->color), AA(image->color)};
169  ff_draw_color(&ass->draw, &color, rgba_color);
170  ff_blend_mask(&ass->draw, &color,
171  picref->data, picref->linesize,
172  picref->width, picref->height,
173  image->bitmap, image->stride, image->w, image->h,
174  3, 0, image->dst_x, image->dst_y);
175  }
176 }
177 
179 {
180  AVFilterContext *ctx = inlink->dst;
181  AVFilterLink *outlink = ctx->outputs[0];
182  AssContext *ass = ctx->priv;
183  int detect_change = 0;
184  double time_ms = picref->pts * av_q2d(inlink->time_base) * 1000;
185  ASS_Image *image = ass_render_frame(ass->renderer, ass->track,
186  time_ms, &detect_change);
187 
188  if (detect_change)
189  av_log(ctx, AV_LOG_DEBUG, "Change happened at time ms:%f\n", time_ms);
190 
191  overlay_ass_image(ass, picref, image);
192 
193  return ff_filter_frame(outlink, picref);
194 }
195 
196 static const AVFilterPad ass_inputs[] = {
197  {
198  .name = "default",
199  .type = AVMEDIA_TYPE_VIDEO,
200  .filter_frame = filter_frame,
201  .config_props = config_input,
202  .needs_writable = 1,
203  },
204  { NULL }
205 };
206 
207 static const AVFilterPad ass_outputs[] = {
208  {
209  .name = "default",
210  .type = AVMEDIA_TYPE_VIDEO,
211  },
212  { NULL }
213 };
214 
215 #if CONFIG_ASS_FILTER
216 
217 static const AVOption ass_options[] = {
219  {"shaping", "set shaping engine", OFFSET(shaping), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, FLAGS, "shaping_mode"},
220  {"auto", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = -1}, INT_MIN, INT_MAX, FLAGS, "shaping_mode"},
221  {"simple", "simple shaping", 0, AV_OPT_TYPE_CONST, {.i64 = ASS_SHAPING_SIMPLE}, INT_MIN, INT_MAX, FLAGS, "shaping_mode"},
222  {"complex", "complex shaping", 0, AV_OPT_TYPE_CONST, {.i64 = ASS_SHAPING_COMPLEX}, INT_MIN, INT_MAX, FLAGS, "shaping_mode"},
223  {NULL},
224 };
225 
227 
228 static av_cold int init_ass(AVFilterContext *ctx)
229 {
230  AssContext *ass = ctx->priv;
231  int ret = init(ctx);
232 
233  if (ret < 0)
234  return ret;
235 
236  /* Initialize fonts */
237  ass_set_fonts(ass->renderer, NULL, NULL, 1, NULL, 1);
238 
239  ass->track = ass_read_file(ass->library, ass->filename, NULL);
240  if (!ass->track) {
241  av_log(ctx, AV_LOG_ERROR,
242  "Could not create a libass track when reading file '%s'\n",
243  ass->filename);
244  return AVERROR(EINVAL);
245  }
246  return 0;
247 }
248 
250  .name = "ass",
251  .description = NULL_IF_CONFIG_SMALL("Render ASS subtitles onto input video using the libass library."),
252  .priv_size = sizeof(AssContext),
253  .init = init_ass,
254  .uninit = uninit,
256  .inputs = ass_inputs,
257  .outputs = ass_outputs,
258  .priv_class = &ass_class,
259 };
260 #endif
261 
262 #if CONFIG_SUBTITLES_FILTER
263 
264 static const AVOption subtitles_options[] = {
266  {"charenc", "set input character encoding", OFFSET(charenc), AV_OPT_TYPE_STRING, {.str = NULL}, CHAR_MIN, CHAR_MAX, FLAGS},
267  {"stream_index", "set stream index", OFFSET(stream_index), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS},
268  {"si", "set stream index", OFFSET(stream_index), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS},
269  {"force_style", "force subtitle style", OFFSET(force_style), AV_OPT_TYPE_STRING, {.str = NULL}, CHAR_MIN, CHAR_MAX, FLAGS},
270  {NULL},
271 };
272 
273 static const char * const font_mimetypes[] = {
274  "application/x-truetype-font",
275  "application/vnd.ms-opentype",
276  "application/x-font-ttf",
277  NULL
278 };
279 
280 static int attachment_is_font(AVStream * st)
281 {
282  const AVDictionaryEntry *tag = NULL;
283  int n;
284 
285  tag = av_dict_get(st->metadata, "mimetype", NULL, AV_DICT_MATCH_CASE);
286 
287  if (tag) {
288  for (n = 0; font_mimetypes[n]; n++) {
289  if (av_strcasecmp(font_mimetypes[n], tag->value) == 0)
290  return 1;
291  }
292  }
293  return 0;
294 }
295 
296 AVFILTER_DEFINE_CLASS(subtitles);
297 
298 static av_cold int init_subtitles(AVFilterContext *ctx)
299 {
300  int j, ret, sid;
301  int k = 0;
305  AVCodec *dec = NULL;
306  const AVCodecDescriptor *dec_desc;
307  AVStream *st;
308  AVPacket pkt;
309  AssContext *ass = ctx->priv;
310 
311  /* Init libass */
312  ret = init(ctx);
313  if (ret < 0)
314  return ret;
315  ass->track = ass_new_track(ass->library);
316  if (!ass->track) {
317  av_log(ctx, AV_LOG_ERROR, "Could not create a libass track\n");
318  return AVERROR(EINVAL);
319  }
320 
321  /* Open subtitles file */
322  ret = avformat_open_input(&fmt, ass->filename, NULL, NULL);
323  if (ret < 0) {
324  av_log(ctx, AV_LOG_ERROR, "Unable to open %s\n", ass->filename);
325  goto end;
326  }
327  ret = avformat_find_stream_info(fmt, NULL);
328  if (ret < 0)
329  goto end;
330 
331  /* Locate subtitles stream */
332  if (ass->stream_index < 0)
333  ret = av_find_best_stream(fmt, AVMEDIA_TYPE_SUBTITLE, -1, -1, NULL, 0);
334  else {
335  ret = -1;
336  if (ass->stream_index < fmt->nb_streams) {
337  for (j = 0; j < fmt->nb_streams; j++) {
339  if (ass->stream_index == k) {
340  ret = j;
341  break;
342  }
343  k++;
344  }
345  }
346  }
347  }
348 
349  if (ret < 0) {
350  av_log(ctx, AV_LOG_ERROR, "Unable to locate subtitle stream in %s\n",
351  ass->filename);
352  goto end;
353  }
354  sid = ret;
355  st = fmt->streams[sid];
356 
357  /* Load attached fonts */
358  for (j = 0; j < fmt->nb_streams; j++) {
359  AVStream *st = fmt->streams[j];
361  attachment_is_font(st)) {
362  const AVDictionaryEntry *tag = NULL;
363  tag = av_dict_get(st->metadata, "filename", NULL,
365 
366  if (tag) {
367  av_log(ctx, AV_LOG_DEBUG, "Loading attached font: %s\n",
368  tag->value);
369  ass_add_font(ass->library, tag->value,
370  st->codecpar->extradata,
371  st->codecpar->extradata_size);
372  } else {
373  av_log(ctx, AV_LOG_WARNING,
374  "Font attachment has no filename, ignored.\n");
375  }
376  }
377  }
378 
379  /* Initialize fonts */
380  ass_set_fonts(ass->renderer, NULL, NULL, 1, NULL, 1);
381 
382  /* Open decoder */
384  if (!dec) {
385  av_log(ctx, AV_LOG_ERROR, "Failed to find subtitle codec %s\n",
387  return AVERROR(EINVAL);
388  }
389  dec_desc = avcodec_descriptor_get(st->codecpar->codec_id);
390  if (dec_desc && !(dec_desc->props & AV_CODEC_PROP_TEXT_SUB)) {
391  av_log(ctx, AV_LOG_ERROR,
392  "Only text based subtitles are currently supported\n");
393  return AVERROR_PATCHWELCOME;
394  }
395  if (ass->charenc)
396  av_dict_set(&codec_opts, "sub_charenc", ass->charenc, 0);
397  if (LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(57,26,100))
398  av_dict_set(&codec_opts, "sub_text_format", "ass", 0);
399 
400  dec_ctx = avcodec_alloc_context3(dec);
401  if (!dec_ctx)
402  return AVERROR(ENOMEM);
403 
404  ret = avcodec_parameters_to_context(dec_ctx, st->codecpar);
405  if (ret < 0)
406  goto end;
407 
408  /*
409  * This is required by the decoding process in order to rescale the
410  * timestamps: in the current API the decoded subtitles have their pts
411  * expressed in AV_TIME_BASE, and thus the lavc internals need to know the
412  * stream time base in order to achieve the rescaling.
413  *
414  * That API is old and needs to be reworked to match behaviour with A/V.
415  */
416  dec_ctx->pkt_timebase = st->time_base;
417 
418  ret = avcodec_open2(dec_ctx, NULL, &codec_opts);
419  if (ret < 0)
420  goto end;
421 
422  if (ass->force_style) {
423  char **list = NULL;
424  char *temp = NULL;
425  char *ptr = av_strtok(ass->force_style, ",", &temp);
426  int i = 0;
427  while (ptr) {
428  av_dynarray_add(&list, &i, ptr);
429  if (!list) {
430  ret = AVERROR(ENOMEM);
431  goto end;
432  }
433  ptr = av_strtok(NULL, ",", &temp);
434  }
435  av_dynarray_add(&list, &i, NULL);
436  if (!list) {
437  ret = AVERROR(ENOMEM);
438  goto end;
439  }
440  ass_set_style_overrides(ass->library, list);
441  av_free(list);
442  }
443  /* Decode subtitles and push them into the renderer (libass) */
444  if (dec_ctx->subtitle_header)
445  ass_process_codec_private(ass->track,
446  dec_ctx->subtitle_header,
447  dec_ctx->subtitle_header_size);
448  av_init_packet(&pkt);
449  pkt.data = NULL;
450  pkt.size = 0;
451  while (av_read_frame(fmt, &pkt) >= 0) {
452  int i, got_subtitle;
453  AVSubtitle sub = {0};
454 
455  if (pkt.stream_index == sid) {
456  ret = avcodec_decode_subtitle2(dec_ctx, &sub, &got_subtitle, &pkt);
457  if (ret < 0) {
458  av_log(ctx, AV_LOG_WARNING, "Error decoding: %s (ignored)\n",
459  av_err2str(ret));
460  } else if (got_subtitle) {
461  const int64_t start_time = av_rescale_q(sub.pts, AV_TIME_BASE_Q, av_make_q(1, 1000));
462  const int64_t duration = sub.end_display_time;
463  for (i = 0; i < sub.num_rects; i++) {
464  char *ass_line = sub.rects[i]->ass;
465  if (!ass_line)
466  break;
467  if (LIBAVCODEC_VERSION_INT < AV_VERSION_INT(57,25,100))
468  ass_process_data(ass->track, ass_line, strlen(ass_line));
469  else
470  ass_process_chunk(ass->track, ass_line, strlen(ass_line),
471  start_time, duration);
472  }
473  }
474  }
475  av_packet_unref(&pkt);
476  avsubtitle_free(&sub);
477  }
478 
479 end:
480  av_dict_free(&codec_opts);
481  avcodec_close(dec_ctx);
482  avcodec_free_context(&dec_ctx);
483  avformat_close_input(&fmt);
484  return ret;
485 }
486 
488  .name = "subtitles",
489  .description = NULL_IF_CONFIG_SMALL("Render text subtitles onto input video using the libass library."),
490  .priv_size = sizeof(AssContext),
491  .init = init_subtitles,
492  .uninit = uninit,
494  .inputs = ass_inputs,
495  .outputs = ass_outputs,
496  .priv_class = &subtitles_class,
497 };
498 #endif
static void overlay_ass_image(AssContext *ass, AVFrame *picref, const ASS_Image *image)
Definition: vf_subtitles.c:163
AVFilterFormats * ff_draw_supported_pixel_formats(unsigned flags)
Return the list of pixel formats supported by the draw functions.
Definition: drawutils.c:731
#define NULL
Definition: coverity.c:32
static int config_input(AVFilterLink *inlink)
Definition: vf_subtitles.c:141
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
FFDrawContext draw
Definition: vf_subtitles.c:62
AVOption.
Definition: opt.h:246
static int filter_frame(AVFilterLink *inlink, AVFrame *picref)
Definition: vf_subtitles.c:178
const char * fmt
Definition: avisynth_c.h:861
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
Main libavfilter public API header.
ASS_Track * track
Definition: vf_subtitles.c:51
else temp
Definition: vf_mcdeint.c:256
static const AVClass ass_class
Definition: assenc.c:223
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3968
int size
Definition: avcodec.h:1481
#define AV_CODEC_PROP_TEXT_SUB
Subtitle codec is text based.
Definition: avcodec.h:783
int pix_step[4]
steps per pixel for each plane of the main output
Definition: vf_subtitles.c:59
int avformat_open_input(AVFormatContext **ps, const char *url, ff_const59 AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
Definition: utils.c:539
unsigned num_rects
Definition: avcodec.h:3948
static AVPacket pkt
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, AVPacket *avpkt)
Decode a subtitle message.
Definition: decode.c:1069
AVCodec.
Definition: avcodec.h:3492
static void ass_log(int ass_level, const char *fmt, va_list args, void *ctx)
Definition: vf_subtitles.c:87
AVSubtitleRect ** rects
Definition: avcodec.h:3949
Format I/O context.
Definition: avformat.h:1358
const char * name
Pad name.
Definition: internal.h:60
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1093
static int query_formats(AVFilterContext *ctx)
Definition: vf_subtitles.c:136
static int64_t start_time
Definition: ffplay.c:331
uint8_t
#define av_cold
Definition: attributes.h:82
ASS_Library * library
Definition: vf_subtitles.c:49
AVOptions.
int subtitle_header_size
Definition: avcodec.h:3054
static const uint32_t color[16+AV_CLASS_CATEGORY_NB]
Definition: log.c:92
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:388
#define LIBAVCODEC_VERSION_INT
Definition: version.h:34
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1426
int64_t duration
Definition: movenc.c:63
int avcodec_parameters_to_context(AVCodecContext *codec, const AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
Definition: utils.c:2115
AVFilter ff_vf_subtitles
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:40
uint8_t * data
Definition: avcodec.h:1480
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
uint32_t tag
Definition: movenc.c:1531
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
#define av_log(a,...)
A filter pad used for either input or output.
Definition: internal.h:54
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type, int wanted_stream_nb, int related_stream, AVCodec **decoder_ret, int flags)
Find the "best" stream in the file.
Definition: utils.c:4226
int avcodec_close(AVCodecContext *avctx)
Close a given AVCodecContext and free all the data associated with it (but not the AVCodecContext its...
Definition: utils.c:1100
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
Definition: avcodec.h:3122
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AA(c)
Definition: vf_subtitles.c:161
int width
Definition: frame.h:353
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define AV_DICT_MATCH_CASE
Only get an entry with exact-case key match.
Definition: dict.h:69
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
A helper for query_formats() which sets all links to the same list of formats.
Definition: formats.c:569
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
void * priv
private data for use by the filter
Definition: avfilter.h:353
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:203
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3964
void ff_draw_color(FFDrawContext *draw, FFDrawColor *color, const uint8_t rgba[4])
Prepare a color.
Definition: drawutils.c:231
#define AV_VERSION_INT(a, b, c)
Definition: version.h:56
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3276
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:3986
uint32_t end_display_time
Definition: avcodec.h:3947
int64_t pts
Same as packet pts, in AV_TIME_BASE.
Definition: avcodec.h:3950
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
Definition: avcodec.h:735
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1414
AVFilter ff_vf_ass
#define FF_DRAW_PROCESS_ALPHA
Process alpha pixel component.
Definition: drawutils.h:74
int stream_index
Definition: vf_subtitles.c:56
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:213
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:156
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:119
AVFormatContext * ctx
Definition: movenc.c:48
int n
Definition: avisynth_c.h:760
AVDictionary * metadata
Definition: avformat.h:945
Opaque data information usually sparse.
Definition: avutil.h:205
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
#define FF_ARRAY_ELEMS(a)
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:1166
Stream structure.
Definition: avformat.h:881
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
char * fontsdir
Definition: vf_subtitles.c:53
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:622
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
Libavcodec external API header.
misc drawing utilities
#define AG(c)
Definition: vf_subtitles.c:159
void avcodec_free_context(AVCodecContext **avctx)
Free the codec context and everything associated with it and write NULL to the provided pointer...
Definition: options.c:171
ASS_Renderer * renderer
Definition: vf_subtitles.c:50
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
static const int ass_libavfilter_log_level_map[]
Definition: vf_subtitles.c:76
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
uint8_t rgba_map[4]
Definition: vf_subtitles.c:58
main external API structure.
Definition: avcodec.h:1568
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:896
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:599
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 list
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: utils.c:1081
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 inputs
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
Describe the class of an AVClass context structure.
Definition: log.h:67
Filter definition.
Definition: avfilter.h:144
char * filename
Definition: vf_subtitles.c:52
void av_vlog(void *avcl, int level, const char *fmt, va_list vl)
Send the specified message to the log if the level is less than or equal to the current av_log_level...
Definition: log.c:373
const char * name
Filter name.
Definition: avfilter.h:148
int ff_draw_init(FFDrawContext *draw, enum AVPixelFormat format, unsigned flags)
Init a draw context.
Definition: drawutils.c:178
int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: utils.c:548
misc parsing utilities
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: utils.c:1777
#define AB(c)
Definition: vf_subtitles.c:160
This struct describes the properties of a single codec described by an AVCodecID. ...
Definition: avcodec.h:719
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
uint8_t level
Definition: svq3.c:207
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
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:184
static av_cold int init(AVFilterContext *ctx)
Definition: vf_subtitles.c:97
Main libavformat public API header.
AVDictionary * codec_opts
Definition: cmdutils.c:73
#define OFFSET(x)
Definition: vf_subtitles.c:65
int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
Read packets of a media file to get stream information.
Definition: utils.c:3600
#define FLAGS
Definition: vf_subtitles.c:66
static AVCodecContext * dec_ctx
static const AVFilterPad ass_inputs[]
Definition: vf_subtitles.c:196
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:33
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: utils.c:4474
#define COMMON_OPTIONS
Definition: vf_subtitles.c:68
#define av_free(p)
void av_dynarray_add(void *tab_ptr, int *nb_ptr, void *elem)
Add the pointer to an element to a dynamic array.
Definition: mem.c:308
char * value
Definition: dict.h:87
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_subtitles.c:124
#define AVFILTER_DEFINE_CLASS(fname)
Definition: internal.h:334
char * force_style
Definition: vf_subtitles.c:55
char * ass
0 terminated ASS/SSA compatible event line.
Definition: avcodec.h:3939
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:3982
An instance of a filter.
Definition: avfilter.h:338
int height
Definition: frame.h:353
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
Definition: log.h:170
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1028
char * charenc
Definition: vf_subtitles.c:54
int stream_index
Definition: avcodec.h:1482
internal API functions
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:910
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
This structure stores compressed data.
Definition: avcodec.h:1457
static const AVFilterPad ass_outputs[]
Definition: vf_subtitles.c:207
int original_w
Definition: vf_subtitles.c:60
#define AR(c)
Definition: vf_subtitles.c:158
uint8_t * subtitle_header
Header containing style information for text subtitles.
Definition: avcodec.h:3053
int original_h
Definition: vf_subtitles.c:60