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 #include "config_components.h"
34 #if CONFIG_SUBTITLES_FILTER
35 # include "libavcodec/avcodec.h"
36 # include "libavcodec/codec_desc.h"
37 # include "libavformat/avformat.h"
38 #endif
39 #include "libavutil/avstring.h"
40 #include "libavutil/imgutils.h"
41 #include "libavutil/opt.h"
42 #include "libavutil/parseutils.h"
43 #include "drawutils.h"
44 #include "avfilter.h"
45 #include "internal.h"
46 #include "formats.h"
47 #include "video.h"
48 
49 #define FF_ASS_FEATURE_WRAP_UNICODE (LIBASS_VERSION >= 0x01600010)
50 
51 typedef struct AssContext {
52  const AVClass *class;
53  ASS_Library *library;
54  ASS_Renderer *renderer;
55  ASS_Track *track;
56  char *filename;
57  char *fontsdir;
58  char *charenc;
59  char *force_style;
61  int alpha;
62  uint8_t rgba_map[4];
63  int pix_step[4]; ///< steps per pixel for each plane of the main output
65  int shaping;
68 } AssContext;
69 
70 #define OFFSET(x) offsetof(AssContext, x)
71 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
72 
73 #define COMMON_OPTIONS \
74  {"filename", "set the filename of file to read", OFFSET(filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS }, \
75  {"f", "set the filename of file to read", OFFSET(filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS }, \
76  {"original_size", "set the size of the original video (used to scale fonts)", OFFSET(original_w), AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL}, 0, 0, FLAGS }, \
77  {"fontsdir", "set the directory containing the fonts to read", OFFSET(fontsdir), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS }, \
78  {"alpha", "enable processing of alpha channel", OFFSET(alpha), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, FLAGS }, \
79 
80 /* libass supports a log level ranging from 0 to 7 */
81 static const int ass_libavfilter_log_level_map[] = {
82  [0] = AV_LOG_FATAL, /* MSGL_FATAL */
83  [1] = AV_LOG_ERROR, /* MSGL_ERR */
84  [2] = AV_LOG_WARNING, /* MSGL_WARN */
85  [3] = AV_LOG_WARNING, /* <undefined> */
86  [4] = AV_LOG_INFO, /* MSGL_INFO */
87  [5] = AV_LOG_INFO, /* <undefined> */
88  [6] = AV_LOG_VERBOSE, /* MSGL_V */
89  [7] = AV_LOG_DEBUG, /* MSGL_DBG2 */
90 };
91 
92 static void ass_log(int ass_level, const char *fmt, va_list args, void *ctx)
93 {
94  const int ass_level_clip = av_clip(ass_level, 0,
96  const int level = ass_libavfilter_log_level_map[ass_level_clip];
97 
98  av_vlog(ctx, level, fmt, args);
99  av_log(ctx, level, "\n");
100 }
101 
103 {
104  AssContext *ass = ctx->priv;
105 
106  if (!ass->filename) {
107  av_log(ctx, AV_LOG_ERROR, "No filename provided!\n");
108  return AVERROR(EINVAL);
109  }
110 
111  ass->library = ass_library_init();
112  if (!ass->library) {
113  av_log(ctx, AV_LOG_ERROR, "Could not initialize libass.\n");
114  return AVERROR(EINVAL);
115  }
116  ass_set_message_cb(ass->library, ass_log, ctx);
117 
118  ass_set_fonts_dir(ass->library, ass->fontsdir);
119  ass_set_extract_fonts(ass->library, 1);
120 
121  ass->renderer = ass_renderer_init(ass->library);
122  if (!ass->renderer) {
123  av_log(ctx, AV_LOG_ERROR, "Could not initialize libass renderer.\n");
124  return AVERROR(EINVAL);
125  }
126 
127  return 0;
128 }
129 
131 {
132  AssContext *ass = ctx->priv;
133 
134  if (ass->track)
135  ass_free_track(ass->track);
136  if (ass->renderer)
137  ass_renderer_done(ass->renderer);
138  if (ass->library)
139  ass_library_done(ass->library);
140 }
141 
143 {
145 }
146 
148 {
149  AssContext *ass = inlink->dst->priv;
150 
151  ff_draw_init(&ass->draw, inlink->format, ass->alpha ? FF_DRAW_PROCESS_ALPHA : 0);
152 
153  ass_set_frame_size (ass->renderer, inlink->w, inlink->h);
154  if (ass->original_w && ass->original_h) {
155  ass_set_pixel_aspect(ass->renderer, (double)inlink->w / inlink->h /
156  ((double)ass->original_w / ass->original_h));
157  ass_set_storage_size(ass->renderer, ass->original_w, ass->original_h);
158  } else
159  ass_set_storage_size(ass->renderer, inlink->w, inlink->h);
160 
161  if (ass->shaping != -1)
162  ass_set_shaper(ass->renderer, ass->shaping);
163 
164  return 0;
165 }
166 
167 /* libass stores an RGBA color in the format RRGGBBTT, where TT is the transparency level */
168 #define AR(c) ( (c)>>24)
169 #define AG(c) (((c)>>16)&0xFF)
170 #define AB(c) (((c)>>8) &0xFF)
171 #define AA(c) ((0xFF-(c)) &0xFF)
172 
173 static void overlay_ass_image(AssContext *ass, AVFrame *picref,
174  const ASS_Image *image)
175 {
176  for (; image; image = image->next) {
177  uint8_t rgba_color[] = {AR(image->color), AG(image->color), AB(image->color), AA(image->color)};
179  ff_draw_color(&ass->draw, &color, rgba_color);
180  ff_blend_mask(&ass->draw, &color,
181  picref->data, picref->linesize,
182  picref->width, picref->height,
183  image->bitmap, image->stride, image->w, image->h,
184  3, 0, image->dst_x, image->dst_y);
185  }
186 }
187 
189 {
190  AVFilterContext *ctx = inlink->dst;
191  AVFilterLink *outlink = ctx->outputs[0];
192  AssContext *ass = ctx->priv;
193  int detect_change = 0;
194  double time_ms = picref->pts * av_q2d(inlink->time_base) * 1000;
195  ASS_Image *image = ass_render_frame(ass->renderer, ass->track,
196  time_ms, &detect_change);
197 
198  if (detect_change)
199  av_log(ctx, AV_LOG_DEBUG, "Change happened at time ms:%f\n", time_ms);
200 
201  overlay_ass_image(ass, picref, image);
202 
203  return ff_filter_frame(outlink, picref);
204 }
205 
206 static const AVFilterPad ass_inputs[] = {
207  {
208  .name = "default",
209  .type = AVMEDIA_TYPE_VIDEO,
211  .filter_frame = filter_frame,
212  .config_props = config_input,
213  },
214 };
215 
216 #if CONFIG_ASS_FILTER
217 
218 static const AVOption ass_options[] = {
220  {"shaping", "set shaping engine", OFFSET(shaping), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, FLAGS, "shaping_mode"},
221  {"auto", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = -1}, INT_MIN, INT_MAX, FLAGS, "shaping_mode"},
222  {"simple", "simple shaping", 0, AV_OPT_TYPE_CONST, {.i64 = ASS_SHAPING_SIMPLE}, INT_MIN, INT_MAX, FLAGS, "shaping_mode"},
223  {"complex", "complex shaping", 0, AV_OPT_TYPE_CONST, {.i64 = ASS_SHAPING_COMPLEX}, INT_MIN, INT_MAX, FLAGS, "shaping_mode"},
224  {NULL},
225 };
226 
228 
229 static av_cold int init_ass(AVFilterContext *ctx)
230 {
231  AssContext *ass = ctx->priv;
232  int ret = init(ctx);
233 
234  if (ret < 0)
235  return ret;
236 
237  /* Initialize fonts */
238  ass_set_fonts(ass->renderer, NULL, NULL, 1, NULL, 1);
239 
240  ass->track = ass_read_file(ass->library, ass->filename, NULL);
241  if (!ass->track) {
243  "Could not create a libass track when reading file '%s'\n",
244  ass->filename);
245  return AVERROR(EINVAL);
246  }
247  return 0;
248 }
249 
250 const AVFilter ff_vf_ass = {
251  .name = "ass",
252  .description = NULL_IF_CONFIG_SMALL("Render ASS subtitles onto input video using the libass library."),
253  .priv_size = sizeof(AssContext),
254  .init = init_ass,
255  .uninit = uninit,
259  .priv_class = &ass_class,
260 };
261 #endif
262 
263 #if CONFIG_SUBTITLES_FILTER
264 
265 static const AVOption subtitles_options[] = {
267  {"charenc", "set input character encoding", OFFSET(charenc), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS},
268  {"stream_index", "set stream index", OFFSET(stream_index), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS},
269  {"si", "set stream index", OFFSET(stream_index), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS},
270  {"force_style", "force subtitle style", OFFSET(force_style), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS},
271 #if FF_ASS_FEATURE_WRAP_UNICODE
272  {"wrap_unicode", "break lines according to the Unicode Line Breaking Algorithm", OFFSET(wrap_unicode), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, FLAGS },
273 #endif
274  {NULL},
275 };
276 
277 static const char * const font_mimetypes[] = {
278  "font/ttf",
279  "font/otf",
280  "font/sfnt",
281  "font/woff",
282  "font/woff2",
283  "application/font-sfnt",
284  "application/font-woff",
285  "application/x-truetype-font",
286  "application/vnd.ms-opentype",
287  "application/x-font-ttf",
288  NULL
289 };
290 
291 static int attachment_is_font(AVStream * st)
292 {
293  const AVDictionaryEntry *tag = NULL;
294  int n;
295 
296  tag = av_dict_get(st->metadata, "mimetype", NULL, AV_DICT_MATCH_CASE);
297 
298  if (tag) {
299  for (n = 0; font_mimetypes[n]; n++) {
300  if (av_strcasecmp(font_mimetypes[n], tag->value) == 0)
301  return 1;
302  }
303  }
304  return 0;
305 }
306 
307 AVFILTER_DEFINE_CLASS(subtitles);
308 
309 static av_cold int init_subtitles(AVFilterContext *ctx)
310 {
311  int j, ret, sid;
312  int k = 0;
314  AVFormatContext *fmt = NULL;
316  const AVCodec *dec;
317  const AVCodecDescriptor *dec_desc;
318  AVStream *st;
319  AVPacket pkt;
320  AssContext *ass = ctx->priv;
321 
322  /* Init libass */
323  ret = init(ctx);
324  if (ret < 0)
325  return ret;
326  ass->track = ass_new_track(ass->library);
327  if (!ass->track) {
328  av_log(ctx, AV_LOG_ERROR, "Could not create a libass track\n");
329  return AVERROR(EINVAL);
330  }
331 
332  /* Open subtitles file */
333  ret = avformat_open_input(&fmt, ass->filename, NULL, NULL);
334  if (ret < 0) {
335  av_log(ctx, AV_LOG_ERROR, "Unable to open %s\n", ass->filename);
336  goto end;
337  }
339  if (ret < 0)
340  goto end;
341 
342  /* Locate subtitles stream */
343  if (ass->stream_index < 0)
345  else {
346  ret = -1;
347  if (ass->stream_index < fmt->nb_streams) {
348  for (j = 0; j < fmt->nb_streams; j++) {
350  if (ass->stream_index == k) {
351  ret = j;
352  break;
353  }
354  k++;
355  }
356  }
357  }
358  }
359 
360  if (ret < 0) {
361  av_log(ctx, AV_LOG_ERROR, "Unable to locate subtitle stream in %s\n",
362  ass->filename);
363  goto end;
364  }
365  sid = ret;
366  st = fmt->streams[sid];
367 
368  /* Load attached fonts */
369  for (j = 0; j < fmt->nb_streams; j++) {
370  AVStream *st = fmt->streams[j];
372  attachment_is_font(st)) {
373  const AVDictionaryEntry *tag = NULL;
374  tag = av_dict_get(st->metadata, "filename", NULL,
376 
377  if (tag) {
378  av_log(ctx, AV_LOG_DEBUG, "Loading attached font: %s\n",
379  tag->value);
380  ass_add_font(ass->library, tag->value,
381  st->codecpar->extradata,
382  st->codecpar->extradata_size);
383  } else {
385  "Font attachment has no filename, ignored.\n");
386  }
387  }
388  }
389 
390  /* Initialize fonts */
391  ass_set_fonts(ass->renderer, NULL, NULL, 1, NULL, 1);
392 
393  /* Open decoder */
395  if (!dec) {
396  av_log(ctx, AV_LOG_ERROR, "Failed to find subtitle codec %s\n",
399  goto end;
400  }
401  dec_desc = avcodec_descriptor_get(st->codecpar->codec_id);
402  if (dec_desc && !(dec_desc->props & AV_CODEC_PROP_TEXT_SUB)) {
404  "Only text based subtitles are currently supported\n");
406  goto end;
407  }
408  if (ass->charenc)
409  av_dict_set(&codec_opts, "sub_charenc", ass->charenc, 0);
410 
412  if (!dec_ctx) {
413  ret = AVERROR(ENOMEM);
414  goto end;
415  }
416 
418  if (ret < 0)
419  goto end;
420 
421  /*
422  * This is required by the decoding process in order to rescale the
423  * timestamps: in the current API the decoded subtitles have their pts
424  * expressed in AV_TIME_BASE, and thus the lavc internals need to know the
425  * stream time base in order to achieve the rescaling.
426  *
427  * That API is old and needs to be reworked to match behaviour with A/V.
428  */
430 
432  if (ret < 0)
433  goto end;
434 
435 #if FF_ASS_FEATURE_WRAP_UNICODE
436  /* Don't overwrite wrap automatically for native ASS */
437  if (ass->wrap_unicode == -1)
439  if (ass->wrap_unicode) {
440  ret = ass_track_set_feature(ass->track, ASS_FEATURE_WRAP_UNICODE, 1);
441  if (ret < 0)
443  "libass wasn't built with ASS_FEATURE_WRAP_UNICODE support\n");
444  }
445 #endif
446 
447  if (ass->force_style) {
448  char **list = NULL;
449  char *temp = NULL;
450  char *ptr = av_strtok(ass->force_style, ",", &temp);
451  int i = 0;
452  while (ptr) {
453  av_dynarray_add(&list, &i, ptr);
454  if (!list) {
455  ret = AVERROR(ENOMEM);
456  goto end;
457  }
458  ptr = av_strtok(NULL, ",", &temp);
459  }
460  av_dynarray_add(&list, &i, NULL);
461  if (!list) {
462  ret = AVERROR(ENOMEM);
463  goto end;
464  }
465  ass_set_style_overrides(ass->library, list);
466  av_free(list);
467  }
468  /* Decode subtitles and push them into the renderer (libass) */
470  ass_process_codec_private(ass->track,
473  while (av_read_frame(fmt, &pkt) >= 0) {
474  int i, got_subtitle;
475  AVSubtitle sub = {0};
476 
477  if (pkt.stream_index == sid) {
478  ret = avcodec_decode_subtitle2(dec_ctx, &sub, &got_subtitle, &pkt);
479  if (ret < 0) {
480  av_log(ctx, AV_LOG_WARNING, "Error decoding: %s (ignored)\n",
481  av_err2str(ret));
482  } else if (got_subtitle) {
483  const int64_t start_time = av_rescale_q(sub.pts, AV_TIME_BASE_Q, av_make_q(1, 1000));
484  const int64_t duration = sub.end_display_time;
485  for (i = 0; i < sub.num_rects; i++) {
486  char *ass_line = sub.rects[i]->ass;
487  if (!ass_line)
488  break;
489  ass_process_chunk(ass->track, ass_line, strlen(ass_line),
491  }
492  }
493  }
495  avsubtitle_free(&sub);
496  }
497 
498 end:
501  avformat_close_input(&fmt);
502  return ret;
503 }
504 
505 const AVFilter ff_vf_subtitles = {
506  .name = "subtitles",
507  .description = NULL_IF_CONFIG_SMALL("Render text subtitles onto input video using the libass library."),
508  .priv_size = sizeof(AssContext),
509  .init = init_subtitles,
510  .uninit = uninit,
514  .priv_class = &subtitles_class,
515 };
516 #endif
AVSubtitle
Definition: avcodec.h:2269
av_vlog
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:426
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:423
AVCodec
AVCodec.
Definition: codec.h:187
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:69
FFDrawColor
Definition: drawutils.h:50
level
uint8_t level
Definition: svq3.c:204
av_clip
#define av_clip
Definition: common.h:96
dec_ctx
static AVCodecContext * dec_ctx
Definition: decode_filter_audio.c:46
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
AVSubtitle::rects
AVSubtitleRect ** rects
Definition: avcodec.h:2274
opt.h
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
av_find_best_stream
int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type, int wanted_stream_nb, int related_stream, const AVCodec **decoder_ret, int flags)
Definition: avformat.c:390
AssContext::alpha
int alpha
Definition: vf_subtitles.c:61
color
Definition: vf_paletteuse.c:511
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:978
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:264
config_input
static int config_input(AVFilterLink *inlink)
Definition: vf_subtitles.c:147
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
AVSubtitle::num_rects
unsigned num_rects
Definition: avcodec.h:2273
av_strcasecmp
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:207
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1183
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:452
AVFrame::width
int width
Definition: frame.h:412
AVOption
AVOption.
Definition: opt.h:251
FILTER_QUERY_FUNC
#define FILTER_QUERY_FUNC(func)
Definition: internal.h:169
AVCodecContext::subtitle_header
uint8_t * subtitle_header
Header containing style information for text subtitles.
Definition: avcodec.h:1776
ass_log
static void ass_log(int ass_level, const char *fmt, va_list args, void *ctx)
Definition: vf_subtitles.c:92
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
AVDictionary
Definition: dict.c:34
AR
#define AR(c)
Definition: vf_subtitles.c:168
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:170
av_read_frame
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: demux.c:1462
video.h
AssContext::track
ASS_Track * track
Definition: vf_subtitles.c:55
AA
#define AA(c)
Definition: vf_subtitles.c:171
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
formats.h
avformat_close_input
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: demux.c:374
AV_CODEC_ID_ASS
@ AV_CODEC_ID_ASS
Definition: codec_id.h:572
AssContext::original_h
int original_h
Definition: vf_subtitles.c:64
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: vf_subtitles.c:142
ff_blend_mask
void ff_blend_mask(FFDrawContext *draw, FFDrawColor *color, uint8_t *dst[], int dst_linesize[], int dst_w, int dst_h, const uint8_t *mask, int mask_linesize, int mask_w, int mask_h, int l2depth, unsigned endianness, int x0, int y0)
Blend an alpha mask with an uniform color.
Definition: drawutils.c:534
AVSubtitleRect::ass
char * ass
0 terminated ASS/SSA compatible event line.
Definition: avcodec.h:2264
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:47
avsubtitle_free
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: avcodec.c:413
avcodec_decode_subtitle2
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, const AVPacket *avpkt)
Decode a subtitle message.
Definition: decode.c:969
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
ff_set_common_formats
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:770
AssContext::fontsdir
char * fontsdir
Definition: vf_subtitles.c:57
ff_video_default_filterpad
const AVFilterPad ff_video_default_filterpad[1]
An AVFilterPad array whose only entry has name "default" and is of type AVMEDIA_TYPE_VIDEO.
Definition: video.c:36
duration
int64_t duration
Definition: movenc.c:64
avformat_open_input
int avformat_open_input(AVFormatContext **ps, const char *url, const AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
Definition: demux.c:226
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:62
avcodec_alloc_context3
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:153
AVCodecDescriptor
This struct describes the properties of a single codec described by an AVCodecID.
Definition: codec_desc.h:38
AssContext::rgba_map
uint8_t rgba_map[4]
Definition: vf_subtitles.c:62
AssContext::force_style
char * force_style
Definition: vf_subtitles.c:59
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
av_strtok
char * av_strtok(char *s, const char *delim, char **saveptr)
Split the string into several tokens which can be accessed by successive calls to av_strtok().
Definition: avstring.c:178
FF_DRAW_PROCESS_ALPHA
#define FF_DRAW_PROCESS_ALPHA
Process alpha pixel component.
Definition: drawutils.h:62
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:48
av_rescale_q
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
AVSubtitle::pts
int64_t pts
Same as packet pts, in AV_TIME_BASE.
Definition: avcodec.h:2275
ff_draw_init
int ff_draw_init(FFDrawContext *draw, enum AVPixelFormat format, unsigned flags)
Definition: drawutils.c:151
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:192
AVCodecDescriptor::props
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
Definition: codec_desc.h:54
AVFormatContext
Format I/O context.
Definition: avformat.h:1115
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:864
avcodec_parameters_to_context
int avcodec_parameters_to_context(AVCodecContext *codec, const struct AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
AVStream::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avformat.h:880
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
ass_class
static const AVClass ass_class
Definition: assenc.c:224
avcodec_free_context
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:168
AVCodecContext::subtitle_header_size
int subtitle_header_size
Definition: avcodec.h:1777
parseutils.h
list
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
Definition: filter_design.txt:25
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:921
avcodec_open2
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: avcodec.c:128
avcodec_find_decoder
const AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:975
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:73
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1171
codec_opts
AVDictionary * codec_opts
Definition: cmdutils.c:60
avformat_find_stream_info
int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
Read packets of a media file to get stream information.
Definition: demux.c:2436
AssContext::renderer
ASS_Renderer * renderer
Definition: vf_subtitles.c:54
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:106
av_dynarray_add
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:327
av_err2str
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:121
start_time
static int64_t start_time
Definition: ffplay.c:328
AssContext::filename
char * filename
Definition: vf_subtitles.c:56
AVCodecContext::pkt_timebase
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are expressed.
Definition: avcodec.h:1817
color
static const uint32_t color[16+AV_CLASS_CATEGORY_NB]
Definition: log.c:94
av_make_q
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
AssContext::pix_step
int pix_step[4]
steps per pixel for each plane of the main output
Definition: vf_subtitles.c:63
AssContext
Definition: vf_subtitles.c:51
AVSubtitle::end_display_time
uint32_t end_display_time
Definition: avcodec.h:2272
AssContext::wrap_unicode
int wrap_unicode
Definition: vf_subtitles.c:67
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:225
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
internal.h
AVFILTER_DEFINE_CLASS
#define AVFILTER_DEFINE_CLASS(fname)
Definition: internal.h:319
avcodec_get_name
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:417
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
ff_draw_supported_pixel_formats
AVFilterFormats * ff_draw_supported_pixel_formats(unsigned flags)
Return the list of pixel formats supported by the draw functions.
Definition: drawutils.c:647
AVMEDIA_TYPE_ATTACHMENT
@ AVMEDIA_TYPE_ATTACHMENT
Opaque data information usually sparse.
Definition: avutil.h:205
FFDrawContext
Definition: drawutils.h:35
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:53
COMMON_OPTIONS
#define COMMON_OPTIONS
Definition: vf_subtitles.c:73
ff_draw_color
void ff_draw_color(FFDrawContext *draw, FFDrawColor *color, const uint8_t rgba[4])
Prepare a color.
Definition: drawutils.c:156
avcodec.h
AssContext::library
ASS_Library * library
Definition: vf_subtitles.c:53
AVFilter
Filter definition.
Definition: avfilter.h:166
AssContext::charenc
char * charenc
Definition: vf_subtitles.c:58
tag
uint32_t tag
Definition: movenc.c:1737
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:841
AV_LOG_FATAL
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
Definition: log.h:174
ff_vf_subtitles
const AVFilter ff_vf_subtitles
AV_CODEC_PROP_TEXT_SUB
#define AV_CODEC_PROP_TEXT_SUB
Subtitle codec is text based.
Definition: codec_desc.h:108
ass_libavfilter_log_level_map
static const int ass_libavfilter_log_level_map[]
Definition: vf_subtitles.c:81
avformat.h
AssContext::original_w
int original_w
Definition: vf_subtitles.c:64
AssContext::stream_index
int stream_index
Definition: vf_subtitles.c:60
AV_DICT_MATCH_CASE
#define AV_DICT_MATCH_CASE
Only get an entry with exact-case key match.
Definition: dict.h:74
AG
#define AG(c)
Definition: vf_subtitles.c:169
AVCodecContext
main external API structure.
Definition: avcodec.h:441
AVFrame::height
int height
Definition: frame.h:412
ff_vf_ass
const AVFilter ff_vf_ass
AssContext::draw
FFDrawContext draw
Definition: vf_subtitles.c:66
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
avfilter.h
init
static av_cold int init(AVFilterContext *ctx)
Definition: vf_subtitles.c:102
temp
else temp
Definition: vf_mcdeint.c:263
AVPacket::stream_index
int stream_index
Definition: packet.h:493
AVFilterContext
An instance of a filter.
Definition: avfilter.h:397
AVERROR_DECODER_NOT_FOUND
#define AVERROR_DECODER_NOT_FOUND
Decoder not found.
Definition: error.h:54
overlay_ass_image
static void overlay_ass_image(AssContext *ass, AVFrame *picref, const ASS_Image *image)
Definition: vf_subtitles.c:173
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AB
#define AB(c)
Definition: vf_subtitles.c:170
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVDictionaryEntry
Definition: dict.h:89
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:468
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:193
av_dict_set
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:88
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_subtitles.c:130
imgutils.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:385
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AssContext::shaping
int shaping
Definition: vf_subtitles.c:65
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *picref)
Definition: vf_subtitles.c:188
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3722
avstring.h
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
drawutils.h
codec_desc.h
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
FLAGS
#define FLAGS
Definition: vf_subtitles.c:71
OFFSET
#define OFFSET(x)
Definition: vf_subtitles.c:70
ass_inputs
static const AVFilterPad ass_inputs[]
Definition: vf_subtitles.c:206
AVFILTERPAD_FLAG_NEEDS_WRITABLE
#define AVFILTERPAD_FLAG_NEEDS_WRITABLE
The filter expects writable frames from its input link, duplicating data buffers if needed.
Definition: internal.h:66