FFmpeg
vf_subtitles.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2011 Baptiste Coudurier
3  * Copyright (c) 2011 Stefano Sabatini
4  * Copyright (c) 2012 Clément Bœsch
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * Libass subtitles burning filter.
26  *
27  * @see{http://www.matroska.org/technical/specs/subtitles/ssa.html}
28  */
29 
30 #include <ass/ass.h>
31 
32 #include "config.h"
33 #if CONFIG_SUBTITLES_FILTER
34 # include "libavcodec/avcodec.h"
35 # include "libavformat/avformat.h"
36 #endif
37 #include "libavutil/avstring.h"
38 #include "libavutil/imgutils.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/parseutils.h"
41 #include "drawutils.h"
42 #include "avfilter.h"
43 #include "internal.h"
44 #include "formats.h"
45 #include "video.h"
46 
47 typedef struct AssContext {
48  const AVClass *class;
49  ASS_Library *library;
50  ASS_Renderer *renderer;
51  ASS_Track *track;
52  char *filename;
53  char *fontsdir;
54  char *charenc;
55  char *force_style;
57  int alpha;
59  int pix_step[4]; ///< steps per pixel for each plane of the main output
61  int shaping;
63 } AssContext;
64 
65 #define OFFSET(x) offsetof(AssContext, x)
66 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
67 
68 #define COMMON_OPTIONS \
69  {"filename", "set the filename of file to read", OFFSET(filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS }, \
70  {"f", "set the filename of file to read", OFFSET(filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS }, \
71  {"original_size", "set the size of the original video (used to scale fonts)", OFFSET(original_w), AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL}, 0, 0, FLAGS }, \
72  {"fontsdir", "set the directory containing the fonts to read", OFFSET(fontsdir), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS }, \
73  {"alpha", "enable processing of alpha channel", OFFSET(alpha), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, FLAGS }, \
74 
75 /* libass supports a log level ranging from 0 to 7 */
76 static const int ass_libavfilter_log_level_map[] = {
77  [0] = AV_LOG_FATAL, /* MSGL_FATAL */
78  [1] = AV_LOG_ERROR, /* MSGL_ERR */
79  [2] = AV_LOG_WARNING, /* MSGL_WARN */
80  [3] = AV_LOG_WARNING, /* <undefined> */
81  [4] = AV_LOG_INFO, /* MSGL_INFO */
82  [5] = AV_LOG_INFO, /* <undefined> */
83  [6] = AV_LOG_VERBOSE, /* MSGL_V */
84  [7] = AV_LOG_DEBUG, /* MSGL_DBG2 */
85 };
86 
87 static void ass_log(int ass_level, const char *fmt, va_list args, void *ctx)
88 {
89  const int ass_level_clip = av_clip(ass_level, 0,
91  const int level = ass_libavfilter_log_level_map[ass_level_clip];
92 
93  av_vlog(ctx, level, fmt, args);
94  av_log(ctx, level, "\n");
95 }
96 
98 {
99  AssContext *ass = ctx->priv;
100 
101  if (!ass->filename) {
102  av_log(ctx, AV_LOG_ERROR, "No filename provided!\n");
103  return AVERROR(EINVAL);
104  }
105 
106  ass->library = ass_library_init();
107  if (!ass->library) {
108  av_log(ctx, AV_LOG_ERROR, "Could not initialize libass.\n");
109  return AVERROR(EINVAL);
110  }
111  ass_set_message_cb(ass->library, ass_log, ctx);
112 
113  ass_set_fonts_dir(ass->library, ass->fontsdir);
114 
115  ass->renderer = ass_renderer_init(ass->library);
116  if (!ass->renderer) {
117  av_log(ctx, AV_LOG_ERROR, "Could not initialize libass renderer.\n");
118  return AVERROR(EINVAL);
119  }
120 
121  return 0;
122 }
123 
125 {
126  AssContext *ass = ctx->priv;
127 
128  if (ass->track)
129  ass_free_track(ass->track);
130  if (ass->renderer)
131  ass_renderer_done(ass->renderer);
132  if (ass->library)
133  ass_library_done(ass->library);
134 }
135 
137 {
139 }
140 
142 {
143  AssContext *ass = inlink->dst->priv;
144 
145  ff_draw_init(&ass->draw, inlink->format, ass->alpha ? FF_DRAW_PROCESS_ALPHA : 0);
146 
147  ass_set_frame_size (ass->renderer, inlink->w, inlink->h);
148  if (ass->original_w && ass->original_h)
149  ass_set_aspect_ratio(ass->renderer, (double)inlink->w / inlink->h,
150  (double)ass->original_w / ass->original_h);
151  if (ass->shaping != -1)
152  ass_set_shaper(ass->renderer, ass->shaping);
153 
154  return 0;
155 }
156 
157 /* libass stores an RGBA color in the format RRGGBBTT, where TT is the transparency level */
158 #define AR(c) ( (c)>>24)
159 #define AG(c) (((c)>>16)&0xFF)
160 #define AB(c) (((c)>>8) &0xFF)
161 #define AA(c) ((0xFF-(c)) &0xFF)
162 
163 static void overlay_ass_image(AssContext *ass, AVFrame *picref,
164  const ASS_Image *image)
165 {
166  for (; image; image = image->next) {
167  uint8_t rgba_color[] = {AR(image->color), AG(image->color), AB(image->color), AA(image->color)};
169  ff_draw_color(&ass->draw, &color, rgba_color);
170  ff_blend_mask(&ass->draw, &color,
171  picref->data, picref->linesize,
172  picref->width, picref->height,
173  image->bitmap, image->stride, image->w, image->h,
174  3, 0, image->dst_x, image->dst_y);
175  }
176 }
177 
179 {
180  AVFilterContext *ctx = inlink->dst;
181  AVFilterLink *outlink = ctx->outputs[0];
182  AssContext *ass = ctx->priv;
183  int detect_change = 0;
184  double time_ms = picref->pts * av_q2d(inlink->time_base) * 1000;
185  ASS_Image *image = ass_render_frame(ass->renderer, ass->track,
186  time_ms, &detect_change);
187 
188  if (detect_change)
189  av_log(ctx, AV_LOG_DEBUG, "Change happened at time ms:%f\n", time_ms);
190 
191  overlay_ass_image(ass, picref, image);
192 
193  return ff_filter_frame(outlink, picref);
194 }
195 
196 static const AVFilterPad ass_inputs[] = {
197  {
198  .name = "default",
199  .type = AVMEDIA_TYPE_VIDEO,
200  .filter_frame = filter_frame,
201  .config_props = config_input,
202  .needs_writable = 1,
203  },
204  { NULL }
205 };
206 
207 static const AVFilterPad ass_outputs[] = {
208  {
209  .name = "default",
210  .type = AVMEDIA_TYPE_VIDEO,
211  },
212  { NULL }
213 };
214 
215 #if CONFIG_ASS_FILTER
216 
217 static const AVOption ass_options[] = {
219  {"shaping", "set shaping engine", OFFSET(shaping), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, FLAGS, "shaping_mode"},
220  {"auto", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = -1}, INT_MIN, INT_MAX, FLAGS, "shaping_mode"},
221  {"simple", "simple shaping", 0, AV_OPT_TYPE_CONST, {.i64 = ASS_SHAPING_SIMPLE}, INT_MIN, INT_MAX, FLAGS, "shaping_mode"},
222  {"complex", "complex shaping", 0, AV_OPT_TYPE_CONST, {.i64 = ASS_SHAPING_COMPLEX}, INT_MIN, INT_MAX, FLAGS, "shaping_mode"},
223  {NULL},
224 };
225 
227 
228 static av_cold int init_ass(AVFilterContext *ctx)
229 {
230  AssContext *ass = ctx->priv;
231  int ret = init(ctx);
232 
233  if (ret < 0)
234  return ret;
235 
236  /* Initialize fonts */
237  ass_set_fonts(ass->renderer, NULL, NULL, 1, NULL, 1);
238 
239  ass->track = ass_read_file(ass->library, ass->filename, NULL);
240  if (!ass->track) {
242  "Could not create a libass track when reading file '%s'\n",
243  ass->filename);
244  return AVERROR(EINVAL);
245  }
246  return 0;
247 }
248 
250  .name = "ass",
251  .description = NULL_IF_CONFIG_SMALL("Render ASS subtitles onto input video using the libass library."),
252  .priv_size = sizeof(AssContext),
253  .init = init_ass,
254  .uninit = uninit,
256  .inputs = ass_inputs,
257  .outputs = ass_outputs,
258  .priv_class = &ass_class,
259 };
260 #endif
261 
262 #if CONFIG_SUBTITLES_FILTER
263 
264 static const AVOption subtitles_options[] = {
266  {"charenc", "set input character encoding", OFFSET(charenc), AV_OPT_TYPE_STRING, {.str = NULL}, 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  {NULL},
271 };
272 
273 static const char * const font_mimetypes[] = {
274  "application/x-truetype-font",
275  "application/vnd.ms-opentype",
276  "application/x-font-ttf",
277  NULL
278 };
279 
280 static int attachment_is_font(AVStream * st)
281 {
282  const AVDictionaryEntry *tag = NULL;
283  int n;
284 
285  tag = av_dict_get(st->metadata, "mimetype", NULL, AV_DICT_MATCH_CASE);
286 
287  if (tag) {
288  for (n = 0; font_mimetypes[n]; n++) {
289  if (av_strcasecmp(font_mimetypes[n], tag->value) == 0)
290  return 1;
291  }
292  }
293  return 0;
294 }
295 
296 AVFILTER_DEFINE_CLASS(subtitles);
297 
298 static av_cold int init_subtitles(AVFilterContext *ctx)
299 {
300  int j, ret, sid;
301  int k = 0;
303  AVFormatContext *fmt = NULL;
305  const AVCodec *dec;
306  const AVCodecDescriptor *dec_desc;
307  AVStream *st;
308  AVPacket pkt;
309  AssContext *ass = ctx->priv;
310 
311  /* Init libass */
312  ret = init(ctx);
313  if (ret < 0)
314  return ret;
315  ass->track = ass_new_track(ass->library);
316  if (!ass->track) {
317  av_log(ctx, AV_LOG_ERROR, "Could not create a libass track\n");
318  return AVERROR(EINVAL);
319  }
320 
321  /* Open subtitles file */
322  ret = avformat_open_input(&fmt, ass->filename, NULL, NULL);
323  if (ret < 0) {
324  av_log(ctx, AV_LOG_ERROR, "Unable to open %s\n", ass->filename);
325  goto end;
326  }
328  if (ret < 0)
329  goto end;
330 
331  /* Locate subtitles stream */
332  if (ass->stream_index < 0)
334  else {
335  ret = -1;
336  if (ass->stream_index < fmt->nb_streams) {
337  for (j = 0; j < fmt->nb_streams; j++) {
339  if (ass->stream_index == k) {
340  ret = j;
341  break;
342  }
343  k++;
344  }
345  }
346  }
347  }
348 
349  if (ret < 0) {
350  av_log(ctx, AV_LOG_ERROR, "Unable to locate subtitle stream in %s\n",
351  ass->filename);
352  goto end;
353  }
354  sid = ret;
355  st = fmt->streams[sid];
356 
357  /* Load attached fonts */
358  for (j = 0; j < fmt->nb_streams; j++) {
359  AVStream *st = fmt->streams[j];
361  attachment_is_font(st)) {
362  const AVDictionaryEntry *tag = NULL;
363  tag = av_dict_get(st->metadata, "filename", NULL,
365 
366  if (tag) {
367  av_log(ctx, AV_LOG_DEBUG, "Loading attached font: %s\n",
368  tag->value);
369  ass_add_font(ass->library, tag->value,
370  st->codecpar->extradata,
371  st->codecpar->extradata_size);
372  } else {
374  "Font attachment has no filename, ignored.\n");
375  }
376  }
377  }
378 
379  /* Initialize fonts */
380  ass_set_fonts(ass->renderer, NULL, NULL, 1, NULL, 1);
381 
382  /* Open decoder */
384  if (!dec) {
385  av_log(ctx, AV_LOG_ERROR, "Failed to find subtitle codec %s\n",
388  goto end;
389  }
390  dec_desc = avcodec_descriptor_get(st->codecpar->codec_id);
391  if (dec_desc && !(dec_desc->props & AV_CODEC_PROP_TEXT_SUB)) {
393  "Only text based subtitles are currently supported\n");
395  goto end;
396  }
397  if (ass->charenc)
398  av_dict_set(&codec_opts, "sub_charenc", ass->charenc, 0);
399  av_dict_set(&codec_opts, "sub_text_format", "ass", 0);
400 
402  if (!dec_ctx) {
403  ret = AVERROR(ENOMEM);
404  goto end;
405  }
406 
408  if (ret < 0)
409  goto end;
410 
411  /*
412  * This is required by the decoding process in order to rescale the
413  * timestamps: in the current API the decoded subtitles have their pts
414  * expressed in AV_TIME_BASE, and thus the lavc internals need to know the
415  * stream time base in order to achieve the rescaling.
416  *
417  * That API is old and needs to be reworked to match behaviour with A/V.
418  */
420 
422  if (ret < 0)
423  goto end;
424 
425  if (ass->force_style) {
426  char **list = NULL;
427  char *temp = NULL;
428  char *ptr = av_strtok(ass->force_style, ",", &temp);
429  int i = 0;
430  while (ptr) {
431  av_dynarray_add(&list, &i, ptr);
432  if (!list) {
433  ret = AVERROR(ENOMEM);
434  goto end;
435  }
436  ptr = av_strtok(NULL, ",", &temp);
437  }
438  av_dynarray_add(&list, &i, NULL);
439  if (!list) {
440  ret = AVERROR(ENOMEM);
441  goto end;
442  }
443  ass_set_style_overrides(ass->library, list);
444  av_free(list);
445  }
446  /* Decode subtitles and push them into the renderer (libass) */
448  ass_process_codec_private(ass->track,
451  while (av_read_frame(fmt, &pkt) >= 0) {
452  int i, got_subtitle;
453  AVSubtitle sub = {0};
454 
455  if (pkt.stream_index == sid) {
456  ret = avcodec_decode_subtitle2(dec_ctx, &sub, &got_subtitle, &pkt);
457  if (ret < 0) {
458  av_log(ctx, AV_LOG_WARNING, "Error decoding: %s (ignored)\n",
459  av_err2str(ret));
460  } else if (got_subtitle) {
461  const int64_t start_time = av_rescale_q(sub.pts, AV_TIME_BASE_Q, av_make_q(1, 1000));
462  const int64_t duration = sub.end_display_time;
463  for (i = 0; i < sub.num_rects; i++) {
464  char *ass_line = sub.rects[i]->ass;
465  if (!ass_line)
466  break;
467  ass_process_chunk(ass->track, ass_line, strlen(ass_line),
469  }
470  }
471  }
474  }
475 
476 end:
479  avformat_close_input(&fmt);
480  return ret;
481 }
482 
484  .name = "subtitles",
485  .description = NULL_IF_CONFIG_SMALL("Render text subtitles onto input video using the libass library."),
486  .priv_size = sizeof(AssContext),
487  .init = init_subtitles,
488  .uninit = uninit,
490  .inputs = ass_inputs,
491  .outputs = ass_outputs,
492  .priv_class = &subtitles_class,
493 };
494 #endif
AVSubtitle
Definition: avcodec.h:2722
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:424
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:634
AVCodec
AVCodec.
Definition: codec.h:197
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:200
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
FFDrawColor
Definition: drawutils.h:49
level
uint8_t level
Definition: svq3.c:204
ass_outputs
static const AVFilterPad ass_outputs[]
Definition: vf_subtitles.c:207
av_clip
#define av_clip
Definition: common.h:122
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:56
AssContext::alpha
int alpha
Definition: vf_subtitles.c:57
color
Definition: vf_paletteuse.c:583
sub
static float sub(float src0, float src1)
Definition: dnn_backend_native_layer_mathbinary.c:32
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1094
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:141
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:215
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:324
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1299
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:417
AVFrame::width
int width
Definition: frame.h:382
avcodec_decode_subtitle2
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, AVPacket *avpkt)
Decode a subtitle message.
Definition: decode.c:1025
AVOption
AVOption.
Definition: opt.h:248
AVCodecContext::subtitle_header
uint8_t * subtitle_header
Header containing style information for text subtitles.
Definition: avcodec.h:2016
ass_log
static void ass_log(int ass_level, const char *fmt, va_list args, void *ctx)
Definition: vf_subtitles.c:87
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:210
AVDictionary
Definition: dict.c:30
AR
#define AR(c)
Definition: vf_subtitles.c:158
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:149
av_read_frame
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: utils.c:1772
video.h
AssContext::track
ASS_Track * track
Definition: vf_subtitles.c:51
AA
#define AA(c)
Definition: vf_subtitles.c:161
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:338
formats.h
avformat_close_input
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: utils.c:4525
AssContext::original_h
int original_h
Definition: vf_subtitles.c:60
ff_vf_subtitles
AVFilter ff_vf_subtitles
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: vf_subtitles.c:136
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:528
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:54
avsubtitle_free
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: avcodec.c:504
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:194
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
inputs
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several inputs
Definition: filter_design.txt:243
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:587
AssContext::fontsdir
char * fontsdir
Definition: vf_subtitles.c:53
duration
int64_t duration
Definition: movenc.c:64
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:170
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:58
AssContext::force_style
char * force_style
Definition: vf_subtitles.c:55
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:186
FF_DRAW_PROCESS_ALPHA
#define FF_DRAW_PROCESS_ALPHA
Process alpha pixel component.
Definition: drawutils.h:61
outputs
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
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)
Init a draw context.
Definition: drawutils.c:84
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:1231
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1038
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
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:902
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
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:185
AVCodecContext::subtitle_header_size
int subtitle_header_size
Definition: avcodec.h:2017
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:937
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
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:78
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1287
codec_opts
AVDictionary * codec_opts
Definition: cmdutils.c:70
avformat_find_stream_info
int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
Read packets of a media file to get stream information.
Definition: utils.c:3650
AssContext::renderer
ASS_Renderer * renderer
Definition: vf_subtitles.c:50
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:310
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:119
start_time
static int64_t start_time
Definition: ffplay.c:332
AssContext::filename
char * filename
Definition: vf_subtitles.c:52
AVCodecContext::pkt_timebase
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
Definition: avcodec.h:2085
color
static const uint32_t color[16+AV_CLASS_CATEGORY_NB]
Definition: log.c:92
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:59
AssContext
Definition: vf_subtitles.c:47
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:205
internal.h
AVFILTER_DEFINE_CLASS
#define AVFILTER_DEFINE_CLASS(fname)
Definition: internal.h:288
avcodec_get_name
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:454
i
int i
Definition: input.c:407
avformat_open_input
int avformat_open_input(AVFormatContext **ps, const char *url, ff_const59 AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
Definition: utils.c:547
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:147
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:637
AVMEDIA_TYPE_ATTACHMENT
@ AVMEDIA_TYPE_ATTACHMENT
Opaque data information usually sparse.
Definition: avutil.h:205
uint8_t
uint8_t
Definition: audio_convert.c:194
FFDrawContext
Definition: drawutils.h:35
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:60
COMMON_OPTIONS
#define COMMON_OPTIONS
Definition: vf_subtitles.c:68
ff_draw_color
void ff_draw_color(FFDrawContext *draw, FFDrawColor *color, const uint8_t rgba[4])
Prepare a color.
Definition: drawutils.c:137
avcodec.h
AssContext::library
ASS_Library * library
Definition: vf_subtitles.c:49
AVFilter
Filter definition.
Definition: avfilter.h:145
AssContext::charenc
char * charenc
Definition: vf_subtitles.c:54
tag
uint32_t tag
Definition: movenc.c:1611
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:873
AV_LOG_FATAL
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
Definition: log.h:188
avcodec_find_decoder
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:946
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:76
avformat.h
AssContext::original_w
int original_w
Definition: vf_subtitles.c:60
AssContext::stream_index
int stream_index
Definition: vf_subtitles.c:56
AV_DICT_MATCH_CASE
#define AV_DICT_MATCH_CASE
Only get an entry with exact-case key match.
Definition: dict.h:69
AG
#define AG(c)
Definition: vf_subtitles.c:159
AVCodecContext
main external API structure.
Definition: avcodec.h:536
AVFrame::height
int height
Definition: frame.h:382
AssContext::draw
FFDrawContext draw
Definition: vf_subtitles.c:62
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:97
temp
else temp
Definition: vf_mcdeint.c:259
AVPacket::stream_index
int stream_index
Definition: packet.h:371
AVFilterContext
An instance of a filter.
Definition: avfilter.h:341
AVERROR_DECODER_NOT_FOUND
#define AVERROR_DECODER_NOT_FOUND
Decoder not found.
Definition: error.h:52
ff_vf_ass
AVFilter ff_vf_ass
overlay_ass_image
static void overlay_ass_image(AssContext *ass, AVFrame *picref, const ASS_Image *image)
Definition: vf_subtitles.c:163
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AB
#define AB(c)
Definition: vf_subtitles.c:160
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVDictionaryEntry
Definition: dict.h:81
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
AVPacket
This structure stores compressed data.
Definition: packet.h:346
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:124
imgutils.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:355
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AssContext::shaping
int shaping
Definition: vf_subtitles.c:61
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *picref)
Definition: vf_subtitles.c:178
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3501
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:66
dec_ctx
static AVCodecContext * dec_ctx
Definition: filtering_audio.c:43
OFFSET
#define OFFSET(x)
Definition: vf_subtitles.c:65
av_find_best_stream
int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type, int wanted_stream_nb, int related_stream, AVCodec **decoder_ret, int flags)
Find the "best" stream in the file.
Definition: utils.c:4275
ass_inputs
static const AVFilterPad ass_inputs[]
Definition: vf_subtitles.c:196