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_components.h"
33 #if CONFIG_SUBTITLES_FILTER
34 # include "libavcodec/avcodec.h"
35 # include "libavcodec/codec_desc.h"
36 # include "libavformat/avformat.h"
37 #endif
38 #include "libavutil/avstring.h"
39 #include "libavutil/mem.h"
40 #include "libavutil/opt.h"
41 #include "drawutils.h"
42 #include "avfilter.h"
43 #include "internal.h"
44 #include "formats.h"
45 #include "video.h"
46 
47 #define FF_ASS_FEATURE_WRAP_UNICODE (LIBASS_VERSION >= 0x01600010)
48 
49 typedef struct AssContext {
50  const AVClass *class;
51  ASS_Library *library;
52  ASS_Renderer *renderer;
53  ASS_Track *track;
54  char *filename;
55  char *fontsdir;
56  char *charenc;
57  char *force_style;
59  int alpha;
60  uint8_t rgba_map[4];
61  int pix_step[4]; ///< steps per pixel for each plane of the main output
63  int shaping;
66 } AssContext;
67 
68 #define OFFSET(x) offsetof(AssContext, x)
69 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
70 
71 #define COMMON_OPTIONS \
72  {"filename", "set the filename of file to read", OFFSET(filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS }, \
73  {"f", "set the filename of file to read", OFFSET(filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS }, \
74  {"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 }, \
75  {"fontsdir", "set the directory containing the fonts to read", OFFSET(fontsdir), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS }, \
76  {"alpha", "enable processing of alpha channel", OFFSET(alpha), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, FLAGS }, \
77 
78 /* libass supports a log level ranging from 0 to 7 */
79 static const int ass_libavfilter_log_level_map[] = {
80  [0] = AV_LOG_FATAL, /* MSGL_FATAL */
81  [1] = AV_LOG_ERROR, /* MSGL_ERR */
82  [2] = AV_LOG_WARNING, /* MSGL_WARN */
83  [3] = AV_LOG_WARNING, /* <undefined> */
84  [4] = AV_LOG_INFO, /* MSGL_INFO */
85  [5] = AV_LOG_INFO, /* <undefined> */
86  [6] = AV_LOG_VERBOSE, /* MSGL_V */
87  [7] = AV_LOG_DEBUG, /* MSGL_DBG2 */
88 };
89 
90 static void ass_log(int ass_level, const char *fmt, va_list args, void *ctx)
91 {
92  const int ass_level_clip = av_clip(ass_level, 0,
94  const int level = ass_libavfilter_log_level_map[ass_level_clip];
95 
96  av_vlog(ctx, level, fmt, args);
97  av_log(ctx, level, "\n");
98 }
99 
101 {
102  AssContext *ass = ctx->priv;
103 
104  if (!ass->filename) {
105  av_log(ctx, AV_LOG_ERROR, "No filename provided!\n");
106  return AVERROR(EINVAL);
107  }
108 
109  ass->library = ass_library_init();
110  if (!ass->library) {
111  av_log(ctx, AV_LOG_ERROR, "Could not initialize libass.\n");
112  return AVERROR(EINVAL);
113  }
114  ass_set_message_cb(ass->library, ass_log, ctx);
115 
116  ass_set_fonts_dir(ass->library, ass->fontsdir);
117  ass_set_extract_fonts(ass->library, 1);
118 
119  ass->renderer = ass_renderer_init(ass->library);
120  if (!ass->renderer) {
121  av_log(ctx, AV_LOG_ERROR, "Could not initialize libass renderer.\n");
122  return AVERROR(EINVAL);
123  }
124 
125  return 0;
126 }
127 
129 {
130  AssContext *ass = ctx->priv;
131 
132  if (ass->track)
133  ass_free_track(ass->track);
134  if (ass->renderer)
135  ass_renderer_done(ass->renderer);
136  if (ass->library)
137  ass_library_done(ass->library);
138 }
139 
141 {
143 }
144 
146 {
147  AssContext *ass = inlink->dst->priv;
148 
149  ff_draw_init2(&ass->draw, inlink->format, inlink->colorspace, inlink->color_range,
150  ass->alpha ? FF_DRAW_PROCESS_ALPHA : 0);
151 
152  ass_set_frame_size (ass->renderer, inlink->w, inlink->h);
153  if (ass->original_w && ass->original_h) {
154  ass_set_pixel_aspect(ass->renderer, (double)inlink->w / inlink->h /
155  ((double)ass->original_w / ass->original_h));
156  ass_set_storage_size(ass->renderer, ass->original_w, ass->original_h);
157  } else
158  ass_set_storage_size(ass->renderer, inlink->w, inlink->h);
159 
160  if (ass->shaping != -1)
161  ass_set_shaper(ass->renderer, ass->shaping);
162 
163  return 0;
164 }
165 
166 /* libass stores an RGBA color in the format RRGGBBTT, where TT is the transparency level */
167 #define AR(c) ( (c)>>24)
168 #define AG(c) (((c)>>16)&0xFF)
169 #define AB(c) (((c)>>8) &0xFF)
170 #define AA(c) ((0xFF-(c)) &0xFF)
171 
172 static void overlay_ass_image(AssContext *ass, AVFrame *picref,
173  const ASS_Image *image)
174 {
175  for (; image; image = image->next) {
176  uint8_t rgba_color[] = {AR(image->color), AG(image->color), AB(image->color), AA(image->color)};
178  ff_draw_color(&ass->draw, &color, rgba_color);
179  ff_blend_mask(&ass->draw, &color,
180  picref->data, picref->linesize,
181  picref->width, picref->height,
182  image->bitmap, image->stride, image->w, image->h,
183  3, 0, image->dst_x, image->dst_y);
184  }
185 }
186 
188 {
189  AVFilterContext *ctx = inlink->dst;
190  AVFilterLink *outlink = ctx->outputs[0];
191  AssContext *ass = ctx->priv;
192  int detect_change = 0;
193  double time_ms = picref->pts * av_q2d(inlink->time_base) * 1000;
194  ASS_Image *image = ass_render_frame(ass->renderer, ass->track,
195  time_ms, &detect_change);
196 
197  if (detect_change)
198  av_log(ctx, AV_LOG_DEBUG, "Change happened at time ms:%f\n", time_ms);
199 
200  overlay_ass_image(ass, picref, image);
201 
202  return ff_filter_frame(outlink, picref);
203 }
204 
205 static const AVFilterPad ass_inputs[] = {
206  {
207  .name = "default",
208  .type = AVMEDIA_TYPE_VIDEO,
210  .filter_frame = filter_frame,
211  .config_props = config_input,
212  },
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, .unit = "shaping_mode"},
220  {"auto", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = -1}, INT_MIN, INT_MAX, FLAGS, .unit = "shaping_mode"},
221  {"simple", "simple shaping", 0, AV_OPT_TYPE_CONST, {.i64 = ASS_SHAPING_SIMPLE}, INT_MIN, INT_MAX, FLAGS, .unit = "shaping_mode"},
222  {"complex", "complex shaping", 0, AV_OPT_TYPE_CONST, {.i64 = ASS_SHAPING_COMPLEX}, INT_MIN, INT_MAX, FLAGS, .unit = "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) {
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 
249 const AVFilter ff_vf_ass = {
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,
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}, 0, 0, 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}, 0, 0, FLAGS},
270 #if FF_ASS_FEATURE_WRAP_UNICODE
271  {"wrap_unicode", "break lines according to the Unicode Line Breaking Algorithm", OFFSET(wrap_unicode), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, FLAGS },
272 #endif
273  {NULL},
274 };
275 
276 static const char * const font_mimetypes[] = {
277  "font/ttf",
278  "font/otf",
279  "font/sfnt",
280  "font/woff",
281  "font/woff2",
282  "application/font-sfnt",
283  "application/font-woff",
284  "application/x-truetype-font",
285  "application/vnd.ms-opentype",
286  "application/x-font-ttf",
287  NULL
288 };
289 
290 static int attachment_is_font(AVStream * st)
291 {
292  const AVDictionaryEntry *tag = NULL;
293  int n;
294 
295  tag = av_dict_get(st->metadata, "mimetype", NULL, AV_DICT_MATCH_CASE);
296 
297  if (tag) {
298  for (n = 0; font_mimetypes[n]; n++) {
299  if (av_strcasecmp(font_mimetypes[n], tag->value) == 0)
300  return 1;
301  }
302  }
303  return 0;
304 }
305 
306 AVFILTER_DEFINE_CLASS(subtitles);
307 
308 static av_cold int init_subtitles(AVFilterContext *ctx)
309 {
310  int j, ret, sid;
311  int k = 0;
313  AVFormatContext *fmt = NULL;
315  const AVCodec *dec;
316  const AVCodecDescriptor *dec_desc;
317  AVStream *st;
318  AVPacket pkt;
319  AssContext *ass = ctx->priv;
320 
321  /* Init libass */
322  ret = init(ctx);
323  if (ret < 0)
324  return ret;
325  ass->track = ass_new_track(ass->library);
326  if (!ass->track) {
327  av_log(ctx, AV_LOG_ERROR, "Could not create a libass track\n");
328  return AVERROR(EINVAL);
329  }
330 
331  /* Open subtitles file */
332  ret = avformat_open_input(&fmt, ass->filename, NULL, NULL);
333  if (ret < 0) {
334  av_log(ctx, AV_LOG_ERROR, "Unable to open %s\n", ass->filename);
335  goto end;
336  }
338  if (ret < 0)
339  goto end;
340 
341  /* Locate subtitles stream */
342  if (ass->stream_index < 0)
344  else {
345  ret = -1;
346  if (ass->stream_index < fmt->nb_streams) {
347  for (j = 0; j < fmt->nb_streams; j++) {
349  if (ass->stream_index == k) {
350  ret = j;
351  break;
352  }
353  k++;
354  }
355  }
356  }
357  }
358 
359  if (ret < 0) {
360  av_log(ctx, AV_LOG_ERROR, "Unable to locate subtitle stream in %s\n",
361  ass->filename);
362  goto end;
363  }
364  sid = ret;
365  st = fmt->streams[sid];
366 
367  /* Load attached fonts */
368  for (j = 0; j < fmt->nb_streams; j++) {
369  AVStream *st = fmt->streams[j];
371  attachment_is_font(st)) {
372  const AVDictionaryEntry *tag = NULL;
373  tag = av_dict_get(st->metadata, "filename", NULL,
375 
376  if (tag) {
377  av_log(ctx, AV_LOG_DEBUG, "Loading attached font: %s\n",
378  tag->value);
379  ass_add_font(ass->library, tag->value,
380  st->codecpar->extradata,
381  st->codecpar->extradata_size);
382  } else {
384  "Font attachment has no filename, ignored.\n");
385  }
386  }
387  }
388 
389  /* Initialize fonts */
390  ass_set_fonts(ass->renderer, NULL, NULL, 1, NULL, 1);
391 
392  /* Open decoder */
394  if (!dec) {
395  av_log(ctx, AV_LOG_ERROR, "Failed to find subtitle codec %s\n",
398  goto end;
399  }
400  dec_desc = avcodec_descriptor_get(st->codecpar->codec_id);
401  if (dec_desc && !(dec_desc->props & AV_CODEC_PROP_TEXT_SUB)) {
403  "Only text based subtitles are currently supported\n");
405  goto end;
406  }
407  if (ass->charenc)
408  av_dict_set(&codec_opts, "sub_charenc", ass->charenc, 0);
409 
411  if (!dec_ctx) {
412  ret = AVERROR(ENOMEM);
413  goto end;
414  }
415 
417  if (ret < 0)
418  goto end;
419 
420  /*
421  * This is required by the decoding process in order to rescale the
422  * timestamps: in the current API the decoded subtitles have their pts
423  * expressed in AV_TIME_BASE, and thus the lavc internals need to know the
424  * stream time base in order to achieve the rescaling.
425  *
426  * That API is old and needs to be reworked to match behaviour with A/V.
427  */
429 
431  if (ret < 0)
432  goto end;
433 
434 #if FF_ASS_FEATURE_WRAP_UNICODE
435  /* Don't overwrite wrap automatically for native ASS */
436  if (ass->wrap_unicode == -1)
438  if (ass->wrap_unicode) {
439  ret = ass_track_set_feature(ass->track, ASS_FEATURE_WRAP_UNICODE, 1);
440  if (ret < 0)
442  "libass wasn't built with ASS_FEATURE_WRAP_UNICODE support\n");
443  }
444 #endif
445 
446  if (ass->force_style) {
447  char **list = NULL;
448  char *temp = NULL;
449  char *ptr = av_strtok(ass->force_style, ",", &temp);
450  int i = 0;
451  while (ptr) {
452  av_dynarray_add(&list, &i, ptr);
453  if (!list) {
454  ret = AVERROR(ENOMEM);
455  goto end;
456  }
457  ptr = av_strtok(NULL, ",", &temp);
458  }
459  av_dynarray_add(&list, &i, NULL);
460  if (!list) {
461  ret = AVERROR(ENOMEM);
462  goto end;
463  }
464  ass_set_style_overrides(ass->library, list);
465  av_free(list);
466  }
467  /* Decode subtitles and push them into the renderer (libass) */
469  ass_process_codec_private(ass->track,
472  while (av_read_frame(fmt, &pkt) >= 0) {
473  int i, got_subtitle;
474  AVSubtitle sub = {0};
475 
476  if (pkt.stream_index == sid) {
477  ret = avcodec_decode_subtitle2(dec_ctx, &sub, &got_subtitle, &pkt);
478  if (ret < 0) {
479  av_log(ctx, AV_LOG_WARNING, "Error decoding: %s (ignored)\n",
480  av_err2str(ret));
481  } else if (got_subtitle) {
482  const int64_t start_time = av_rescale_q(sub.pts, AV_TIME_BASE_Q, av_make_q(1, 1000));
483  const int64_t duration = sub.end_display_time;
484  for (i = 0; i < sub.num_rects; i++) {
485  char *ass_line = sub.rects[i]->ass;
486  if (!ass_line)
487  break;
488  ass_process_chunk(ass->track, ass_line, strlen(ass_line),
490  }
491  }
492  }
494  avsubtitle_free(&sub);
495  }
496 
497 end:
500  avformat_close_input(&fmt);
501  return ret;
502 }
503 
504 const AVFilter ff_vf_subtitles = {
505  .name = "subtitles",
506  .description = NULL_IF_CONFIG_SMALL("Render text subtitles onto input video using the libass library."),
507  .priv_size = sizeof(AssContext),
508  .init = init_subtitles,
509  .uninit = uninit,
513  .priv_class = &subtitles_class,
514 };
515 #endif
AVSubtitle
Definition: avcodec.h:2228
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:431
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:428
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:205
av_clip
#define av_clip
Definition: common.h:100
dec_ctx
static AVCodecContext * dec_ctx
Definition: decode_filter_audio.c:47
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:2233
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:443
AssContext::alpha
int alpha
Definition: vf_subtitles.c:59
color
Definition: vf_paletteuse.c:512
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1015
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:145
int64_t
long long int64_t
Definition: coverity.c:34
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:2232
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:374
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1328
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:486
AVFrame::width
int width
Definition: frame.h:446
AVOption
AVOption.
Definition: opt.h:357
FILTER_QUERY_FUNC
#define FILTER_QUERY_FUNC(func)
Definition: internal.h:159
AVCodecContext::subtitle_header
uint8_t * subtitle_header
Definition: avcodec.h:1892
ass_log
static void ass_log(int ass_level, const char *fmt, va_list args, void *ctx)
Definition: vf_subtitles.c:90
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:167
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:1538
video.h
AssContext::track
ASS_Track * track
Definition: vf_subtitles.c:53
AA
#define AA(c)
Definition: vf_subtitles.c:170
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:395
formats.h
avformat_close_input
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: demux.c:363
AV_CODEC_ID_ASS
@ AV_CODEC_ID_ASS
Definition: codec_id.h:572
AssContext::original_h
int original_h
Definition: vf_subtitles.c:62
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: vf_subtitles.c:140
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:535
AVSubtitleRect::ass
char * ass
0 terminated ASS/SSA compatible event line.
Definition: avcodec.h:2225
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:33
avsubtitle_free
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: avcodec.c:393
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:951
pkt
AVPacket * pkt
Definition: movenc.c:60
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:868
AssContext::fontsdir
char * fontsdir
Definition: vf_subtitles.c:55
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:37
duration
int64_t duration
Definition: movenc.c:65
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:215
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:149
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:60
AssContext::force_style
char * force_style
Definition: vf_subtitles.c:57
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:49
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:2234
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:182
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:1260
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:771
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:787
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:225
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:164
AVCodecContext::subtitle_header_size
int subtitle_header_size
Header containing style information for text subtitles.
Definition: avcodec.h:1891
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:828
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:142
avcodec_find_decoder
const AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:966
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:1316
codec_opts
AVDictionary * codec_opts
Definition: cmdutils.c:58
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:2516
AssContext::renderer
ASS_Renderer * renderer
Definition: vf_subtitles.c:52
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:94
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:329
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:122
ff_draw_init2
int ff_draw_init2(FFDrawContext *draw, enum AVPixelFormat format, enum AVColorSpace csp, enum AVColorRange range, unsigned flags)
Init a draw context.
Definition: drawutils.c:81
start_time
static int64_t start_time
Definition: ffplay.c:326
AssContext::filename
char * filename
Definition: vf_subtitles.c:54
AVCodecContext::pkt_timebase
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are expressed.
Definition: avcodec.h:551
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:61
AssContext
Definition: vf_subtitles.c:49
AVSubtitle::end_display_time
uint32_t end_display_time
Definition: avcodec.h:2231
AssContext::wrap_unicode
int wrap_unicode
Definition: vf_subtitles.c:65
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:223
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:323
avcodec_get_name
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:406
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
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:648
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:39
COMMON_OPTIONS
#define COMMON_OPTIONS
Definition: vf_subtitles.c:71
ff_draw_color
void ff_draw_color(FFDrawContext *draw, FFDrawColor *color, const uint8_t rgba[4])
Prepare a color.
Definition: drawutils.c:157
avcodec.h
AssContext::library
ASS_Library * library
Definition: vf_subtitles.c:51
AVFilter
Filter definition.
Definition: avfilter.h:166
AssContext::charenc
char * charenc
Definition: vf_subtitles.c:56
tag
uint32_t tag
Definition: movenc.c:1873
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:748
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:79
avformat.h
AssContext::original_w
int original_w
Definition: vf_subtitles.c:62
AssContext::stream_index
int stream_index
Definition: vf_subtitles.c:58
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:168
AVCodecContext
main external API structure.
Definition: avcodec.h:445
AVFrame::height
int height
Definition: frame.h:446
ff_vf_ass
const AVFilter ff_vf_ass
AssContext::draw
FFDrawContext draw
Definition: vf_subtitles.c:64
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:245
avfilter.h
init
static av_cold int init(AVFilterContext *ctx)
Definition: vf_subtitles.c:100
temp
else temp
Definition: vf_mcdeint.c:263
AVPacket::stream_index
int stream_index
Definition: packet.h:535
AVFilterContext
An instance of a filter.
Definition: avfilter.h:407
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:172
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mem.h
AB
#define AB(c)
Definition: vf_subtitles.c:169
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:510
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:261
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:183
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:128
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:419
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AssContext::shaping
int shaping
Definition: vf_subtitles.c:63
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *picref)
Definition: vf_subtitles.c:187
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3735
avstring.h
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:249
drawutils.h
codec_desc.h
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:254
FLAGS
#define FLAGS
Definition: vf_subtitles.c:69
OFFSET
#define OFFSET(x)
Definition: vf_subtitles.c:68
ass_inputs
static const AVFilterPad ass_inputs[]
Definition: vf_subtitles.c:205
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:52