FFmpeg
webmdashenc.c
Go to the documentation of this file.
1 /*
2  * WebM DASH Manifest XML muxer
3  * Copyright (c) 2014 Vignesh Venkatasubramanian
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /*
23  * WebM DASH Specification:
24  * https://sites.google.com/a/webmproject.org/wiki/adaptive-streaming/webm-dash-specification
25  * ISO DASH Specification:
26  * http://standards.iso.org/ittf/PubliclyAvailableStandards/c065274_ISO_IEC_23009-1_2014.zip
27  */
28 
29 #include <float.h>
30 #include <stdint.h>
31 #include <string.h>
32 #include <time.h>
33 
34 #include "avformat.h"
35 #include "matroska.h"
36 #include "mux.h"
37 
38 #include "libavutil/avstring.h"
39 #include "libavutil/dict.h"
40 #include "libavutil/opt.h"
42 
43 #include "libavcodec/codec_desc.h"
44 
45 typedef struct AdaptationSet {
46  char id[10];
47  int *streams;
48  int nb_streams;
50 
51 typedef struct WebMDashMuxContext {
52  const AVClass *class;
55  int nb_as;
57  int is_live;
64 
65 static const char *get_codec_name(int codec_id)
66 {
68 }
69 
71 {
72  int i = 0;
73  double max = 0.0;
74  for (i = 0; i < s->nb_streams; i++) {
75  AVDictionaryEntry *duration = av_dict_get(s->streams[i]->metadata,
76  DURATION, NULL, 0);
77  if (!duration || atof(duration->value) < 0) continue;
78  if (atof(duration->value) > max) max = atof(duration->value);
79  }
80  return max / 1000;
81 }
82 
84 {
85  WebMDashMuxContext *w = s->priv_data;
86  AVIOContext *pb = s->pb;
87  double min_buffer_time = 1.0;
88  avio_printf(pb, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
89  avio_printf(pb, "<MPD\n");
90  avio_printf(pb, " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n");
91  avio_printf(pb, " xmlns=\"urn:mpeg:DASH:schema:MPD:2011\"\n");
92  avio_printf(pb, " xsi:schemaLocation=\"urn:mpeg:DASH:schema:MPD:2011\"\n");
93  avio_printf(pb, " type=\"%s\"\n", w->is_live ? "dynamic" : "static");
94  if (!w->is_live) {
95  avio_printf(pb, " mediaPresentationDuration=\"PT%gS\"\n",
96  get_duration(s));
97  }
98  avio_printf(pb, " minBufferTime=\"PT%gS\"\n", min_buffer_time);
99  avio_printf(pb, " profiles=\"%s\"%s",
100  w->is_live ? "urn:mpeg:dash:profile:isoff-live:2011" : "urn:mpeg:dash:profile:webm-on-demand:2012",
101  w->is_live ? "\n" : ">\n");
102  if (w->is_live) {
103  time_t local_time = time(NULL);
104  struct tm gmt_buffer;
105  struct tm *gmt = gmtime_r(&local_time, &gmt_buffer);
106  char gmt_iso[21];
107  if (!strftime(gmt_iso, 21, "%Y-%m-%dT%H:%M:%SZ", gmt)) {
108  return AVERROR_UNKNOWN;
109  }
110  if (s->flags & AVFMT_FLAG_BITEXACT) {
111  av_strlcpy(gmt_iso, "", 1);
112  }
113  avio_printf(pb, " availabilityStartTime=\"%s\"\n", gmt_iso);
114  avio_printf(pb, " timeShiftBufferDepth=\"PT%gS\"\n", w->time_shift_buffer_depth);
115  avio_printf(pb, " minimumUpdatePeriod=\"PT%dS\"", w->minimum_update_period);
116  avio_printf(pb, ">\n");
117  if (w->utc_timing_url) {
118  avio_printf(pb, "<UTCTiming\n");
119  avio_printf(pb, " schemeIdUri=\"urn:mpeg:dash:utc:http-iso:2014\"\n");
120  avio_printf(pb, " value=\"%s\"/>\n", w->utc_timing_url);
121  }
122  }
123  return 0;
124 }
125 
127 {
128  avio_printf(s->pb, "</MPD>\n");
129 }
130 
132 {
133  int i;
134  AVDictionaryEntry *gold = av_dict_get(s->streams[as->streams[0]]->metadata,
135  CUE_TIMESTAMPS, NULL, 0);
136  if (!gold) return 0;
137  for (i = 1; i < as->nb_streams; i++) {
138  AVDictionaryEntry *ts = av_dict_get(s->streams[as->streams[i]]->metadata,
139  CUE_TIMESTAMPS, NULL, 0);
140  if (!ts || !av_strstart(ts->value, gold->value, NULL)) return 0;
141  }
142  return 1;
143 }
144 
146 {
147  int i;
148  const AVStream *gold_st = s->streams[as->streams[0]];
149  AVDictionaryEntry *gold_track_num = av_dict_get(gold_st->metadata,
150  TRACK_NUMBER, NULL, 0);
151  AVCodecParameters *gold_par = gold_st->codecpar;
152  if (!gold_track_num) return 0;
153  for (i = 1; i < as->nb_streams; i++) {
154  const AVStream *st = s->streams[as->streams[i]];
155  AVDictionaryEntry *track_num = av_dict_get(st->metadata,
156  TRACK_NUMBER, NULL, 0);
157  AVCodecParameters *par = st->codecpar;
158  if (!track_num ||
159  !av_strstart(track_num->value, gold_track_num->value, NULL) ||
160  gold_par->codec_id != par->codec_id ||
161  gold_par->extradata_size != par->extradata_size ||
162  (par->extradata_size > 0 &&
163  memcmp(gold_par->extradata, par->extradata, par->extradata_size))) {
164  return 0;
165  }
166  }
167  return 1;
168 }
169 
170 /*
171  * Writes a Representation within an Adaptation Set. Returns 0 on success and
172  * < 0 on failure.
173  */
174 static int write_representation(AVFormatContext *s, AVStream *st, char *id,
175  int output_width, int output_height,
176  int output_sample_rate)
177 {
178  WebMDashMuxContext *w = s->priv_data;
179  AVIOContext *pb = s->pb;
180  const AVCodecParameters *par = st->codecpar;
181  AVDictionaryEntry *bandwidth = av_dict_get(st->metadata, BANDWIDTH, NULL, 0);
182  const char *bandwidth_str;
183  avio_printf(pb, "<Representation id=\"%s\"", id);
184  if (bandwidth) {
185  bandwidth_str = bandwidth->value;
186  } else if (w->is_live) {
187  // if bandwidth for live was not provided, use a default
188  bandwidth_str = (par->codec_type == AVMEDIA_TYPE_AUDIO) ? "128000" : "1000000";
189  } else {
190  return AVERROR(EINVAL);
191  }
192  avio_printf(pb, " bandwidth=\"%s\"", bandwidth_str);
193  if (par->codec_type == AVMEDIA_TYPE_VIDEO && output_width)
194  avio_printf(pb, " width=\"%d\"", par->width);
195  if (par->codec_type == AVMEDIA_TYPE_VIDEO && output_height)
196  avio_printf(pb, " height=\"%d\"", par->height);
197  if (par->codec_type == AVMEDIA_TYPE_AUDIO && output_sample_rate)
198  avio_printf(pb, " audioSamplingRate=\"%d\"", par->sample_rate);
199  if (w->is_live) {
200  // For live streams, Codec and Mime Type always go in the Representation tag.
201  avio_printf(pb, " codecs=\"%s\"", get_codec_name(par->codec_id));
202  avio_printf(pb, " mimeType=\"%s/webm\"",
203  par->codec_type == AVMEDIA_TYPE_VIDEO ? "video" : "audio");
204  // For live streams, subsegments always start with key frames. So this
205  // is always 1.
206  avio_printf(pb, " startsWithSAP=\"1\"");
207  avio_printf(pb, ">");
208  } else {
210  AVDictionaryEntry *cues_start = av_dict_get(st->metadata, CUES_START, NULL, 0);
211  AVDictionaryEntry *cues_end = av_dict_get(st->metadata, CUES_END, NULL, 0);
212  AVDictionaryEntry *filename = av_dict_get(st->metadata, FILENAME, NULL, 0);
213  if (!irange || !cues_start || !cues_end || !filename)
214  return AVERROR(EINVAL);
215 
216  avio_printf(pb, ">\n");
217  avio_printf(pb, "<BaseURL>%s</BaseURL>\n", filename->value);
218  avio_printf(pb, "<SegmentBase\n");
219  avio_printf(pb, " indexRange=\"%s-%s\">\n", cues_start->value, cues_end->value);
220  avio_printf(pb, "<Initialization\n");
221  avio_printf(pb, " range=\"0-%s\" />\n", irange->value);
222  avio_printf(pb, "</SegmentBase>\n");
223  }
224  avio_printf(pb, "</Representation>\n");
225  return 0;
226 }
227 
228 /*
229  * Checks if width of all streams are the same. Returns 1 if true, 0 otherwise.
230  */
232 {
233  int first_width, i;
234  if (as->nb_streams < 2) return 1;
235  first_width = s->streams[as->streams[0]]->codecpar->width;
236  for (i = 1; i < as->nb_streams; i++)
237  if (first_width != s->streams[as->streams[i]]->codecpar->width)
238  return 0;
239  return 1;
240 }
241 
242 /*
243  * Checks if height of all streams are the same. Returns 1 if true, 0 otherwise.
244  */
246 {
247  int first_height, i;
248  if (as->nb_streams < 2) return 1;
249  first_height = s->streams[as->streams[0]]->codecpar->height;
250  for (i = 1; i < as->nb_streams; i++)
251  if (first_height != s->streams[as->streams[i]]->codecpar->height)
252  return 0;
253  return 1;
254 }
255 
256 /*
257  * Checks if sample rate of all streams are the same. Returns 1 if true, 0 otherwise.
258  */
260 {
261  int first_sample_rate, i;
262  if (as->nb_streams < 2) return 1;
263  first_sample_rate = s->streams[as->streams[0]]->codecpar->sample_rate;
264  for (i = 1; i < as->nb_streams; i++)
265  if (first_sample_rate != s->streams[as->streams[i]]->codecpar->sample_rate)
266  return 0;
267  return 1;
268 }
269 
271 {
272  WebMDashMuxContext *w = s->priv_data;
273  int i;
274  for (i = 0; i < w->nb_as; i++) {
275  av_freep(&w->as[i].streams);
276  }
277  av_freep(&w->as);
278  w->nb_as = 0;
279 }
280 
281 /*
282  * Parses a live header filename and returns the position of the '_' and '.'
283  * delimiting <file_description> and <representation_id>.
284  *
285  * Name of the header file should conform to the following pattern:
286  * <file_description>_<representation_id>.hdr where <file_description> can be
287  * anything. The chunks should be named according to the following pattern:
288  * <file_description>_<representation_id>_<chunk_number>.chk
289  */
290 static int split_filename(char *filename, char **underscore_pos,
291  char **period_pos)
292 {
293  *underscore_pos = strrchr(filename, '_');
294  if (!*underscore_pos)
295  return AVERROR(EINVAL);
296  *period_pos = strchr(*underscore_pos, '.');
297  if (!*period_pos)
298  return AVERROR(EINVAL);
299  return 0;
300 }
301 
302 /*
303  * Writes an Adaptation Set. Returns 0 on success and < 0 on failure.
304  */
305 static int write_adaptation_set(AVFormatContext *s, int as_index)
306 {
307  WebMDashMuxContext *w = s->priv_data;
308  AdaptationSet *as = &w->as[as_index];
309  const AVStream *st = s->streams[as->streams[0]];
310  AVCodecParameters *par = st->codecpar;
311  AVDictionaryEntry *lang;
312  AVIOContext *pb = s->pb;
313  int i;
314  static const char boolean[2][6] = { "false", "true" };
315  int subsegmentStartsWithSAP = 1;
316 
317  // Width, Height and Sample Rate will go in the AdaptationSet tag if they
318  // are the same for all contained Representations. otherwise, they will go
319  // on their respective Representation tag. For live streams, they always go
320  // in the Representation tag.
321  int width_in_as = 1, height_in_as = 1, sample_rate_in_as = 1;
322  if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
323  width_in_as = !w->is_live && check_matching_width (s, as);
324  height_in_as = !w->is_live && check_matching_height(s, as);
325  } else {
326  sample_rate_in_as = !w->is_live && check_matching_sample_rate(s, as);
327  }
328 
329  avio_printf(pb, "<AdaptationSet id=\"%s\"", as->id);
330  avio_printf(pb, " mimeType=\"%s/webm\"",
331  par->codec_type == AVMEDIA_TYPE_VIDEO ? "video" : "audio");
332  avio_printf(pb, " codecs=\"%s\"", get_codec_name(par->codec_id));
333 
334  lang = av_dict_get(st->metadata, "language", NULL, 0);
335  if (lang)
336  avio_printf(pb, " lang=\"%s\"", lang->value);
337 
338  if (par->codec_type == AVMEDIA_TYPE_VIDEO && width_in_as)
339  avio_printf(pb, " width=\"%d\"", par->width);
340  if (par->codec_type == AVMEDIA_TYPE_VIDEO && height_in_as)
341  avio_printf(pb, " height=\"%d\"", par->height);
342  if (par->codec_type == AVMEDIA_TYPE_AUDIO && sample_rate_in_as)
343  avio_printf(pb, " audioSamplingRate=\"%d\"", par->sample_rate);
344 
345  avio_printf(pb, " bitstreamSwitching=\"%s\"",
346  boolean[bitstream_switching(s, as)]);
347  avio_printf(pb, " subsegmentAlignment=\"%s\"",
348  boolean[w->is_live || subsegment_alignment(s, as)]);
349 
350  for (i = 0; i < as->nb_streams; i++) {
351  AVDictionaryEntry *kf = av_dict_get(s->streams[as->streams[i]]->metadata,
352  CLUSTER_KEYFRAME, NULL, 0);
353  if (!w->is_live && (!kf || !strncmp(kf->value, "0", 1))) subsegmentStartsWithSAP = 0;
354  }
355  avio_printf(pb, " subsegmentStartsWithSAP=\"%d\"", subsegmentStartsWithSAP);
356  avio_printf(pb, ">\n");
357 
358  if (w->is_live) {
359  AVDictionaryEntry *filename =
360  av_dict_get(st->metadata, FILENAME, NULL, 0);
361  char *underscore_pos, *period_pos;
362  int ret;
363  if (!filename)
364  return AVERROR(EINVAL);
365  ret = split_filename(filename->value, &underscore_pos, &period_pos);
366  if (ret) return ret;
367  *underscore_pos = '\0';
368  avio_printf(pb, "<ContentComponent id=\"1\" type=\"%s\"/>\n",
369  par->codec_type == AVMEDIA_TYPE_VIDEO ? "video" : "audio");
370  avio_printf(pb, "<SegmentTemplate");
371  avio_printf(pb, " timescale=\"1000\"");
372  avio_printf(pb, " duration=\"%d\"", w->chunk_duration);
373  avio_printf(pb, " media=\"%s_$RepresentationID$_$Number$.chk\"",
374  filename->value);
375  avio_printf(pb, " startNumber=\"%d\"", w->chunk_start_index);
376  avio_printf(pb, " initialization=\"%s_$RepresentationID$.hdr\"",
377  filename->value);
378  avio_printf(pb, "/>\n");
379  *underscore_pos = '_';
380  }
381 
382  for (i = 0; i < as->nb_streams; i++) {
383  char buf[25], *representation_id = buf, *underscore_pos, *period_pos;
384  AVStream *st = s->streams[as->streams[i]];
385  int ret;
386  if (w->is_live) {
387  AVDictionaryEntry *filename =
388  av_dict_get(st->metadata, FILENAME, NULL, 0);
389  if (!filename)
390  return AVERROR(EINVAL);
391  ret = split_filename(filename->value, &underscore_pos, &period_pos);
392  if (ret < 0)
393  return ret;
394  representation_id = underscore_pos + 1;
395  *period_pos = '\0';
396  } else {
397  snprintf(buf, sizeof(buf), "%d", w->representation_id++);
398  }
399  ret = write_representation(s, st, representation_id, !width_in_as,
400  !height_in_as, !sample_rate_in_as);
401  if (ret) return ret;
402  if (w->is_live)
403  *period_pos = '.';
404  }
405  avio_printf(s->pb, "</AdaptationSet>\n");
406  return 0;
407 }
408 
410 {
411  WebMDashMuxContext *w = s->priv_data;
412  char *p = w->adaptation_sets;
413  char *q;
414  enum { new_set, parsed_id, parsing_streams } state;
415  if (!w->adaptation_sets) {
416  av_log(s, AV_LOG_ERROR, "The 'adaptation_sets' option must be set.\n");
417  return AVERROR(EINVAL);
418  }
419  // syntax id=0,streams=0,1,2 id=1,streams=3,4 and so on
420  state = new_set;
421  while (1) {
422  if (*p == '\0') {
423  if (state == new_set)
424  break;
425  else
426  return AVERROR(EINVAL);
427  } else if (state == new_set && *p == ' ') {
428  p++;
429  continue;
430  } else if (state == new_set && !strncmp(p, "id=", 3)) {
431  void *mem = av_realloc(w->as, sizeof(*w->as) * (w->nb_as + 1));
432  const char *comma;
433  if (mem == NULL)
434  return AVERROR(ENOMEM);
435  w->as = mem;
436  ++w->nb_as;
437  w->as[w->nb_as - 1].nb_streams = 0;
438  w->as[w->nb_as - 1].streams = NULL;
439  p += 3; // consume "id="
440  q = w->as[w->nb_as - 1].id;
441  comma = strchr(p, ',');
442  if (!comma || comma - p >= sizeof(w->as[w->nb_as - 1].id)) {
443  av_log(s, AV_LOG_ERROR, "'id' in 'adaptation_sets' is malformed.\n");
444  return AVERROR(EINVAL);
445  }
446  while (*p != ',') *q++ = *p++;
447  *q = 0;
448  p++;
449  state = parsed_id;
450  } else if (state == parsed_id && !strncmp(p, "streams=", 8)) {
451  p += 8; // consume "streams="
452  state = parsing_streams;
453  } else if (state == parsing_streams) {
454  struct AdaptationSet *as = &w->as[w->nb_as - 1];
455  int64_t num;
456  int ret = av_reallocp_array(&as->streams, ++as->nb_streams,
457  sizeof(*as->streams));
458  if (ret < 0)
459  return ret;
460  num = strtoll(p, &q, 10);
461  if (!av_isdigit(*p) || (*q != ' ' && *q != '\0' && *q != ',') ||
462  num < 0 || num >= s->nb_streams) {
463  av_log(s, AV_LOG_ERROR, "Invalid value for 'streams' in adapation_sets.\n");
464  return AVERROR(EINVAL);
465  }
466  as->streams[as->nb_streams - 1] = num;
467  if (*q == '\0') break;
468  if (*q == ' ') state = new_set;
469  p = ++q;
470  } else {
471  return -1;
472  }
473  }
474  return 0;
475 }
476 
478 {
479  int i;
480  double start = 0.0;
481  int ret;
482  WebMDashMuxContext *w = s->priv_data;
483 
484  for (unsigned i = 0; i < s->nb_streams; i++) {
485  enum AVCodecID codec_id = s->streams[i]->codecpar->codec_id;
489  return AVERROR(EINVAL);
490  }
491 
493  if (ret < 0) {
494  goto fail;
495  }
496  ret = write_header(s);
497  if (ret < 0) {
498  goto fail;
499  }
500  avio_printf(s->pb, "<Period id=\"0\"");
501  avio_printf(s->pb, " start=\"PT%gS\"", start);
502  if (!w->is_live) {
503  avio_printf(s->pb, " duration=\"PT%gS\"", get_duration(s));
504  }
505  avio_printf(s->pb, " >\n");
506 
507  for (i = 0; i < w->nb_as; i++) {
509  if (ret < 0) {
510  goto fail;
511  }
512  }
513 
514  avio_printf(s->pb, "</Period>\n");
515  write_footer(s);
516 fail:
518  return ret < 0 ? ret : 0;
519 }
520 
522 {
523  return AVERROR_EOF;
524 }
525 
526 #define OFFSET(x) offsetof(WebMDashMuxContext, x)
527 static const AVOption options[] = {
528  { "adaptation_sets", "Adaptation sets. Syntax: id=0,streams=0,1,2 id=1,streams=3,4 and so on", OFFSET(adaptation_sets), AV_OPT_TYPE_STRING, { 0 }, 0, 0, AV_OPT_FLAG_ENCODING_PARAM },
529  { "live", "create a live stream manifest", OFFSET(is_live), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM },
530  { "chunk_start_index", "start index of the chunk", OFFSET(chunk_start_index), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
531  { "chunk_duration_ms", "duration of each chunk (in milliseconds)", OFFSET(chunk_duration), AV_OPT_TYPE_INT, {.i64 = 1000}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
532  { "utc_timing_url", "URL of the page that will return the UTC timestamp in ISO format", OFFSET(utc_timing_url), AV_OPT_TYPE_STRING, { 0 }, 0, 0, AV_OPT_FLAG_ENCODING_PARAM },
533  { "time_shift_buffer_depth", "Smallest time (in seconds) shifting buffer for which any Representation is guaranteed to be available.", OFFSET(time_shift_buffer_depth), AV_OPT_TYPE_DOUBLE, { .dbl = 60.0 }, 1.0, DBL_MAX, AV_OPT_FLAG_ENCODING_PARAM },
534  { "minimum_update_period", "Minimum Update Period (in seconds) of the manifest.", OFFSET(minimum_update_period), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
535  { NULL },
536 };
537 
538 static const AVClass webm_dash_class = {
539  .class_name = "WebM DASH Manifest muxer",
540  .item_name = av_default_item_name,
541  .option = options,
542  .version = LIBAVUTIL_VERSION_INT,
543 };
544 
546  .p.name = "webm_dash_manifest",
547  .p.long_name = NULL_IF_CONFIG_SMALL("WebM DASH Manifest"),
548  .p.mime_type = "application/xml",
549  .p.extensions = "xml",
550  .priv_data_size = sizeof(WebMDashMuxContext),
553  .p.priv_class = &webm_dash_class,
554 };
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:69
AVOutputFormat::name
const char * name
Definition: avformat.h:511
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
check_matching_width
static int check_matching_width(AVFormatContext *s, const AdaptationSet *as)
Definition: webmdashenc.c:231
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
bitstream_switching
static int bitstream_switching(AVFormatContext *s, const AdaptationSet *as)
Definition: webmdashenc.c:145
check_matching_sample_rate
static int check_matching_sample_rate(AVFormatContext *s, const AdaptationSet *as)
Definition: webmdashenc.c:259
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
free_adaptation_sets
static void free_adaptation_sets(AVFormatContext *s)
Definition: webmdashenc.c:270
AVCodecDescriptor::name
const char * name
Name of the codec described by this descriptor.
Definition: codec_desc.h:46
CUES_START
#define CUES_START
Definition: matroska.h:429
AdaptationSet::id
int id
Definition: dashenc.c:89
w
uint8_t w
Definition: llviddspenc.c:38
AVOption
AVOption.
Definition: opt.h:294
write_footer
static void write_footer(AVFormatContext *s)
Definition: webmdashenc.c:126
matroska.h
split_filename
static int split_filename(char *filename, char **underscore_pos, char **period_pos)
Definition: webmdashenc.c:290
float.h
max
#define max(a, b)
Definition: cuda_runtime.h:33
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
FFOutputFormat::p
AVOutputFormat p
The public AVOutputFormat.
Definition: mux.h:36
AdaptationSet::nb_streams
int nb_streams
Definition: dashenc.c:100
fail
#define fail()
Definition: checkasm.h:179
state
static struct @377 state
gmtime_r
#define gmtime_r
Definition: time_internal.h:34
write_representation
static int write_representation(AVFormatContext *s, AVStream *st, char *id, int output_width, int output_height, int output_sample_rate)
Definition: webmdashenc.c:174
AdaptationSet::streams
int * streams
Definition: webmdashenc.c:47
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
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:62
webm_dash_manifest_write_packet
static int webm_dash_manifest_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: webmdashenc.c:521
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_OPT_TYPE_DOUBLE
@ AV_OPT_TYPE_DOUBLE
Definition: opt.h:227
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CODEC_ID_VP9
@ AV_CODEC_ID_VP9
Definition: codec_id.h:220
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:121
TRACK_NUMBER
#define TRACK_NUMBER
Definition: matroska.h:436
WebMDashMuxContext::representation_id
int representation_id
Definition: webmdashenc.c:56
get_duration
static double get_duration(AVFormatContext *s)
Definition: webmdashenc.c:70
CLUSTER_KEYFRAME
#define CLUSTER_KEYFRAME
Definition: matroska.h:434
ff_webm_dash_manifest_muxer
const FFOutputFormat ff_webm_dash_manifest_muxer
Definition: webmdashenc.c:545
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:389
write_header
static int write_header(AVFormatContext *s)
Definition: webmdashenc.c:83
get_codec_name
static const char * get_codec_name(int codec_id)
Definition: webmdashenc.c:65
time_internal.h
WebMDashMuxContext::is_live
int is_live
Definition: webmdashenc.c:57
AVFormatContext
Format I/O context.
Definition: avformat.h:1363
parse_adaptation_sets
static int parse_adaptation_sets(AVFormatContext *s)
Definition: webmdashenc.c:409
subsegment_alignment
static int subsegment_alignment(AVFormatContext *s, const AdaptationSet *as)
Definition: webmdashenc.c:131
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:864
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
WebMDashMuxContext::chunk_duration
int chunk_duration
Definition: webmdashenc.c:59
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
AV_CODEC_ID_AV1
@ AV_CODEC_ID_AV1
Definition: codec_id.h:283
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
WebMDashMuxContext::adaptation_sets
char * adaptation_sets
Definition: webmdashenc.c:53
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:921
FFOutputFormat
Definition: mux.h:32
time.h
WebMDashMuxContext
Definition: webmdashenc.c:51
CUES_END
#define CUES_END
Definition: matroska.h:430
AV_OPT_FLAG_ENCODING_PARAM
#define AV_OPT_FLAG_ENCODING_PARAM
A generic parameter which can be set by the user for muxing or encoding.
Definition: opt.h:251
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:171
webm_dash_manifest_write_header
static int webm_dash_manifest_write_header(AVFormatContext *s)
Definition: webmdashenc.c:477
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:73
AVIOContext
Bytestream IO Context.
Definition: avio.h:166
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:106
WebMDashMuxContext::nb_as
int nb_as
Definition: webmdashenc.c:55
AV_CODEC_ID_OPUS
@ AV_CODEC_ID_OPUS
Definition: codec_id.h:503
INITIALIZATION_RANGE
#define INITIALIZATION_RANGE
Definition: matroska.h:428
av_isdigit
static av_const int av_isdigit(int c)
Locale-independent conversion of ASCII isdigit.
Definition: avstring.h:202
av_reallocp_array
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate an array through a pointer to a pointer.
Definition: mem.c:223
OFFSET
#define OFFSET(x)
Definition: webmdashenc.c:526
av_strstart
int av_strstart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str.
Definition: avstring.c:36
check_matching_height
static int check_matching_height(AVFormatContext *s, const AdaptationSet *as)
Definition: webmdashenc.c:245
FILENAME
#define FILENAME
Definition: matroska.h:431
WebMDashMuxContext::chunk_start_index
int chunk_start_index
Definition: webmdashenc.c:58
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
BANDWIDTH
#define BANDWIDTH
Definition: matroska.h:432
AVCodecParameters::height
int height
Definition: codec_par.h:122
DURATION
#define DURATION
Definition: matroska.h:433
AdaptationSet
Definition: dashenc.c:88
CUE_TIMESTAMPS
#define CUE_TIMESTAMPS
Definition: matroska.h:435
write_packet
static int write_packet(Muxer *mux, OutputStream *ost, AVPacket *pkt)
Definition: ffmpeg_mux.c:209
write_adaptation_set
static int write_adaptation_set(AVFormatContext *s, int as_index)
Definition: webmdashenc.c:305
ret
ret
Definition: filter_design.txt:187
AVFMT_FLAG_BITEXACT
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition: avformat.h:1498
AVStream
Stream structure.
Definition: avformat.h:841
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
options
static const AVOption options[]
Definition: webmdashenc.c:527
WebMDashMuxContext::minimum_update_period
int minimum_update_period
Definition: webmdashenc.c:62
avformat.h
dict.h
avio_printf
int avio_printf(AVIOContext *s, const char *fmt,...) av_printf_format(2
Writes a formatted string to the context.
webm_dash_class
static const AVClass webm_dash_class
Definition: webmdashenc.c:538
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
WebMDashMuxContext::time_shift_buffer_depth
double time_shift_buffer_depth
Definition: webmdashenc.c:61
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
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:499
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
AV_CODEC_ID_VP8
@ AV_CODEC_ID_VP8
Definition: codec_id.h:192
av_strlcpy
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:85
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3736
AV_CODEC_ID_VORBIS
@ AV_CODEC_ID_VORBIS
Definition: codec_id.h:448
AVDictionaryEntry::value
char * value
Definition: dict.h:91
avstring.h
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
WebMDashMuxContext::as
AdaptationSet * as
Definition: webmdashenc.c:54
codec_desc.h
WebMDashMuxContext::utc_timing_url
char * utc_timing_url
Definition: webmdashenc.c:60
snprintf
#define snprintf
Definition: snprintf.h:34
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:153
mux.h