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 "libavformat/avformat.h"
37 #endif
38 #include "libavutil/avstring.h"
39 #include "libavutil/imgutils.h"
40 #include "libavutil/opt.h"
41 #include "libavutil/parseutils.h"
42 #include "drawutils.h"
43 #include "avfilter.h"
44 #include "internal.h"
45 #include "formats.h"
46 #include "video.h"
47 
48 typedef struct AssContext {
49  const AVClass *class;
50  ASS_Library *library;
51  ASS_Renderer *renderer;
52  ASS_Track *track;
53  char *filename;
54  char *fontsdir;
55  char *charenc;
56  char *force_style;
58  int alpha;
59  uint8_t rgba_map[4];
60  int pix_step[4]; ///< steps per pixel for each plane of the main output
62  int shaping;
64 } AssContext;
65 
66 #define OFFSET(x) offsetof(AssContext, x)
67 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
68 
69 #define COMMON_OPTIONS \
70  {"filename", "set the filename of file to read", OFFSET(filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS }, \
71  {"f", "set the filename of file to read", OFFSET(filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS }, \
72  {"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 }, \
73  {"fontsdir", "set the directory containing the fonts to read", OFFSET(fontsdir), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS }, \
74  {"alpha", "enable processing of alpha channel", OFFSET(alpha), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, FLAGS }, \
75 
76 /* libass supports a log level ranging from 0 to 7 */
77 static const int ass_libavfilter_log_level_map[] = {
78  [0] = AV_LOG_FATAL, /* MSGL_FATAL */
79  [1] = AV_LOG_ERROR, /* MSGL_ERR */
80  [2] = AV_LOG_WARNING, /* MSGL_WARN */
81  [3] = AV_LOG_WARNING, /* <undefined> */
82  [4] = AV_LOG_INFO, /* MSGL_INFO */
83  [5] = AV_LOG_INFO, /* <undefined> */
84  [6] = AV_LOG_VERBOSE, /* MSGL_V */
85  [7] = AV_LOG_DEBUG, /* MSGL_DBG2 */
86 };
87 
88 static void ass_log(int ass_level, const char *fmt, va_list args, void *ctx)
89 {
90  const int ass_level_clip = av_clip(ass_level, 0,
92  const int level = ass_libavfilter_log_level_map[ass_level_clip];
93 
94  av_vlog(ctx, level, fmt, args);
95  av_log(ctx, level, "\n");
96 }
97 
99 {
100  AssContext *ass = ctx->priv;
101 
102  if (!ass->filename) {
103  av_log(ctx, AV_LOG_ERROR, "No filename provided!\n");
104  return AVERROR(EINVAL);
105  }
106 
107  ass->library = ass_library_init();
108  if (!ass->library) {
109  av_log(ctx, AV_LOG_ERROR, "Could not initialize libass.\n");
110  return AVERROR(EINVAL);
111  }
112  ass_set_message_cb(ass->library, ass_log, ctx);
113 
114  ass_set_fonts_dir(ass->library, ass->fontsdir);
115  ass_set_extract_fonts(ass->library, 1);
116 
117  ass->renderer = ass_renderer_init(ass->library);
118  if (!ass->renderer) {
119  av_log(ctx, AV_LOG_ERROR, "Could not initialize libass renderer.\n");
120  return AVERROR(EINVAL);
121  }
122 
123  return 0;
124 }
125 
127 {
128  AssContext *ass = ctx->priv;
129 
130  if (ass->track)
131  ass_free_track(ass->track);
132  if (ass->renderer)
133  ass_renderer_done(ass->renderer);
134  if (ass->library)
135  ass_library_done(ass->library);
136 }
137 
139 {
141 }
142 
144 {
145  AssContext *ass = inlink->dst->priv;
146 
147  ff_draw_init(&ass->draw, inlink->format, ass->alpha ? FF_DRAW_PROCESS_ALPHA : 0);
148 
149  ass_set_frame_size (ass->renderer, inlink->w, inlink->h);
150  if (ass->original_w && ass->original_h) {
151  ass_set_pixel_aspect(ass->renderer, (double)inlink->w / inlink->h /
152  ((double)ass->original_w / ass->original_h));
153  ass_set_storage_size(ass->renderer, ass->original_w, ass->original_h);
154  } else
155  ass_set_storage_size(ass->renderer, inlink->w, inlink->h);
156 
157  if (ass->shaping != -1)
158  ass_set_shaper(ass->renderer, ass->shaping);
159 
160  return 0;
161 }
162 
163 /* libass stores an RGBA color in the format RRGGBBTT, where TT is the transparency level */
164 #define AR(c) ( (c)>>24)
165 #define AG(c) (((c)>>16)&0xFF)
166 #define AB(c) (((c)>>8) &0xFF)
167 #define AA(c) ((0xFF-(c)) &0xFF)
168 
169 static void overlay_ass_image(AssContext *ass, AVFrame *picref,
170  const ASS_Image *image)
171 {
172  for (; image; image = image->next) {
173  uint8_t rgba_color[] = {AR(image->color), AG(image->color), AB(image->color), AA(image->color)};
175  ff_draw_color(&ass->draw, &color, rgba_color);
176  ff_blend_mask(&ass->draw, &color,
177  picref->data, picref->linesize,
178  picref->width, picref->height,
179  image->bitmap, image->stride, image->w, image->h,
180  3, 0, image->dst_x, image->dst_y);
181  }
182 }
183 
185 {
186  AVFilterContext *ctx = inlink->dst;
187  AVFilterLink *outlink = ctx->outputs[0];
188  AssContext *ass = ctx->priv;
189  int detect_change = 0;
190  double time_ms = picref->pts * av_q2d(inlink->time_base) * 1000;
191  ASS_Image *image = ass_render_frame(ass->renderer, ass->track,
192  time_ms, &detect_change);
193 
194  if (detect_change)
195  av_log(ctx, AV_LOG_DEBUG, "Change happened at time ms:%f\n", time_ms);
196 
197  overlay_ass_image(ass, picref, image);
198 
199  return ff_filter_frame(outlink, picref);
200 }
201 
202 static const AVFilterPad ass_inputs[] = {
203  {
204  .name = "default",
205  .type = AVMEDIA_TYPE_VIDEO,
207  .filter_frame = filter_frame,
208  .config_props = config_input,
209  },
210 };
211 
212 static const AVFilterPad ass_outputs[] = {
213  {
214  .name = "default",
215  .type = AVMEDIA_TYPE_VIDEO,
216  },
217 };
218 
219 #if CONFIG_ASS_FILTER
220 
221 static const AVOption ass_options[] = {
223  {"shaping", "set shaping engine", OFFSET(shaping), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, FLAGS, "shaping_mode"},
224  {"auto", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = -1}, INT_MIN, INT_MAX, FLAGS, "shaping_mode"},
225  {"simple", "simple shaping", 0, AV_OPT_TYPE_CONST, {.i64 = ASS_SHAPING_SIMPLE}, INT_MIN, INT_MAX, FLAGS, "shaping_mode"},
226  {"complex", "complex shaping", 0, AV_OPT_TYPE_CONST, {.i64 = ASS_SHAPING_COMPLEX}, INT_MIN, INT_MAX, FLAGS, "shaping_mode"},
227  {NULL},
228 };
229 
231 
232 static av_cold int init_ass(AVFilterContext *ctx)
233 {
234  AssContext *ass = ctx->priv;
235  int ret = init(ctx);
236 
237  if (ret < 0)
238  return ret;
239 
240  /* Initialize fonts */
241  ass_set_fonts(ass->renderer, NULL, NULL, 1, NULL, 1);
242 
243  ass->track = ass_read_file(ass->library, ass->filename, NULL);
244  if (!ass->track) {
246  "Could not create a libass track when reading file '%s'\n",
247  ass->filename);
248  return AVERROR(EINVAL);
249  }
250  return 0;
251 }
252 
253 const AVFilter ff_vf_ass = {
254  .name = "ass",
255  .description = NULL_IF_CONFIG_SMALL("Render ASS subtitles onto input video using the libass library."),
256  .priv_size = sizeof(AssContext),
257  .init = init_ass,
258  .uninit = uninit,
262  .priv_class = &ass_class,
263 };
264 #endif
265 
266 #if CONFIG_SUBTITLES_FILTER
267 
268 static const AVOption subtitles_options[] = {
270  {"charenc", "set input character encoding", OFFSET(charenc), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS},
271  {"stream_index", "set stream index", OFFSET(stream_index), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS},
272  {"si", "set stream index", OFFSET(stream_index), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS},
273  {"force_style", "force subtitle style", OFFSET(force_style), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS},
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 (ass->force_style) {
436  char **list = NULL;
437  char *temp = NULL;
438  char *ptr = av_strtok(ass->force_style, ",", &temp);
439  int i = 0;
440  while (ptr) {
441  av_dynarray_add(&list, &i, ptr);
442  if (!list) {
443  ret = AVERROR(ENOMEM);
444  goto end;
445  }
446  ptr = av_strtok(NULL, ",", &temp);
447  }
448  av_dynarray_add(&list, &i, NULL);
449  if (!list) {
450  ret = AVERROR(ENOMEM);
451  goto end;
452  }
453  ass_set_style_overrides(ass->library, list);
454  av_free(list);
455  }
456  /* Decode subtitles and push them into the renderer (libass) */
458  ass_process_codec_private(ass->track,
461  while (av_read_frame(fmt, &pkt) >= 0) {
462  int i, got_subtitle;
463  AVSubtitle sub = {0};
464 
465  if (pkt.stream_index == sid) {
466  ret = avcodec_decode_subtitle2(dec_ctx, &sub, &got_subtitle, &pkt);
467  if (ret < 0) {
468  av_log(ctx, AV_LOG_WARNING, "Error decoding: %s (ignored)\n",
469  av_err2str(ret));
470  } else if (got_subtitle) {
471  const int64_t start_time = av_rescale_q(sub.pts, AV_TIME_BASE_Q, av_make_q(1, 1000));
472  const int64_t duration = sub.end_display_time;
473  for (i = 0; i < sub.num_rects; i++) {
474  char *ass_line = sub.rects[i]->ass;
475  if (!ass_line)
476  break;
477  ass_process_chunk(ass->track, ass_line, strlen(ass_line),
479  }
480  }
481  }
484  }
485 
486 end:
489  avformat_close_input(&fmt);
490  return ret;
491 }
492 
493 const AVFilter ff_vf_subtitles = {
494  .name = "subtitles",
495  .description = NULL_IF_CONFIG_SMALL("Render text subtitles onto input video using the libass library."),
496  .priv_size = sizeof(AssContext),
497  .init = init_subtitles,
498  .uninit = uninit,
502  .priv_class = &subtitles_class,
503 };
504 #endif
AVSubtitle
Definition: avcodec.h:2314
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:422
AVCodec
AVCodec.
Definition: codec.h:204
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:75
FFDrawColor
Definition: drawutils.h:50
level
uint8_t level
Definition: svq3.c:206
ass_outputs
static const AVFilterPad ass_outputs[]
Definition: vf_subtitles.c:212
av_clip
#define av_clip
Definition: common.h:95
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
opt.h
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:57
AssContext::alpha
int alpha
Definition: vf_subtitles.c:58
color
Definition: vf_paletteuse.c:600
sub
static float sub(float src0, float src1)
Definition: dnn_backend_native_layer_mathbinary.c:31
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:999
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
config_input
static int config_input(AVFilterLink *inlink)
Definition: vf_subtitles.c:143
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
av_strcasecmp
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:218
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1281
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:432
AVFrame::width
int width
Definition: frame.h:397
avcodec_decode_subtitle2
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, AVPacket *avpkt)
Decode a subtitle message.
Definition: decode.c:875
AVOption
AVOption.
Definition: opt.h:251
FILTER_QUERY_FUNC
#define FILTER_QUERY_FUNC(func)
Definition: internal.h:167
AVCodecContext::subtitle_header
uint8_t * subtitle_header
Header containing style information for text subtitles.
Definition: avcodec.h:1714
ass_log
static void ass_log(int ass_level, const char *fmt, va_list args, void *ctx)
Definition: vf_subtitles.c:88
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
AVDictionary
Definition: dict.c:30
AR
#define AR(c)
Definition: vf_subtitles.c:164
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:175
av_read_frame
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: demux.c:1438
video.h
AssContext::track
ASS_Track * track
Definition: vf_subtitles.c:52
AA
#define AA(c)
Definition: vf_subtitles.c:167
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:346
formats.h
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)
Find the "best" stream in the file.
Definition: avformat.c:347
avformat_close_input
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: demux.c:368
AssContext::original_h
int original_h
Definition: vf_subtitles.c:61
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: vf_subtitles.c:138
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:537
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:49
avsubtitle_free
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: avcodec.c:418
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:749
AssContext::fontsdir
char * fontsdir
Definition: vf_subtitles.c:54
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:220
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:40
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:59
AssContext::force_style
char * force_style
Definition: vf_subtitles.c:56
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:189
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
ff_draw_init
int ff_draw_init(FFDrawContext *draw, enum AVPixelFormat format, unsigned flags)
Definition: drawutils.c:154
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:190
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:1213
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1108
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:978
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:222
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
Definition: avcodec.h:1715
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:1019
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:115
avcodec_find_decoder
const AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:939
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:79
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1269
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:2415
AssContext::renderer
ASS_Renderer * renderer
Definition: vf_subtitles.c:51
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:117
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:337
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:331
AssContext::filename
char * filename
Definition: vf_subtitles.c:53
AVCodecContext::pkt_timebase
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
Definition: avcodec.h:1755
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:60
AssContext
Definition: vf_subtitles.c:48
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:203
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:325
avcodec_get_name
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:447
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
avcodec_parameters_to_context
int avcodec_parameters_to_context(AVCodecContext *codec, const AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
Definition: codec_par.c:182
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:650
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:55
COMMON_OPTIONS
#define COMMON_OPTIONS
Definition: vf_subtitles.c:69
ff_draw_color
void ff_draw_color(FFDrawContext *draw, FFDrawColor *color, const uint8_t rgba[4])
Prepare a color.
Definition: drawutils.c:159
avcodec.h
AssContext::library
ASS_Library * library
Definition: vf_subtitles.c:50
AVFilter
Filter definition.
Definition: avfilter.h:171
AssContext::charenc
char * charenc
Definition: vf_subtitles.c:55
tag
uint32_t tag
Definition: movenc.c:1646
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:948
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:102
ass_libavfilter_log_level_map
static const int ass_libavfilter_log_level_map[]
Definition: vf_subtitles.c:77
avformat.h
AssContext::original_w
int original_w
Definition: vf_subtitles.c:61
AssContext::stream_index
int stream_index
Definition: vf_subtitles.c:57
AV_DICT_MATCH_CASE
#define AV_DICT_MATCH_CASE
Only get an entry with exact-case key match.
Definition: dict.h:67
AG
#define AG(c)
Definition: vf_subtitles.c:165
AVCodecContext
main external API structure.
Definition: avcodec.h:398
AVFrame::height
int height
Definition: frame.h:397
ff_vf_ass
const AVFilter ff_vf_ass
AssContext::draw
FFDrawContext draw
Definition: vf_subtitles.c:63
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:98
temp
else temp
Definition: vf_mcdeint.c:248
AVPacket::stream_index
int stream_index
Definition: packet.h:376
AVFilterContext
An instance of a filter.
Definition: avfilter.h:408
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:169
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AB
#define AB(c)
Definition: vf_subtitles.c:166
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVDictionaryEntry
Definition: dict.h:79
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:61
AVPacket
This structure stores compressed data.
Definition: packet.h:351
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:191
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:70
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_subtitles.c:126
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:370
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AssContext::shaping
int shaping
Definition: vf_subtitles.c:62
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *picref)
Definition: vf_subtitles.c:184
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3573
avstring.h
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
drawutils.h
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
FLAGS
#define FLAGS
Definition: vf_subtitles.c:67
dec_ctx
static AVCodecContext * dec_ctx
Definition: filtering_audio.c:44
OFFSET
#define OFFSET(x)
Definition: vf_subtitles.c:66
ass_inputs
static const AVFilterPad ass_inputs[]
Definition: vf_subtitles.c:202
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:68