FFmpeg
dashenc.c
Go to the documentation of this file.
1 /*
2  * MPEG-DASH ISO BMFF segmenter
3  * Copyright (c) 2014 Martin Storsjo
4  * Copyright (c) 2018 Akamai Technologies, Inc.
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 #include "config.h"
24 #if HAVE_UNISTD_H
25 #include <unistd.h>
26 #endif
27 
28 #include "libavutil/avassert.h"
29 #include "libavutil/avutil.h"
30 #include "libavutil/avstring.h"
31 #include "libavutil/intreadwrite.h"
32 #include "libavutil/mathematics.h"
33 #include "libavutil/opt.h"
34 #include "libavutil/parseutils.h"
35 #include "libavutil/rational.h"
36 #include "libavutil/time.h"
38 
39 #include "av1.h"
40 #include "avc.h"
41 #include "avformat.h"
42 #include "avio_internal.h"
43 #include "hlsplaylist.h"
44 #if CONFIG_HTTP_PROTOCOL
45 #include "http.h"
46 #endif
47 #include "internal.h"
48 #include "isom.h"
49 #include "os_support.h"
50 #include "url.h"
51 #include "vpcc.h"
52 #include "dash.h"
53 
54 typedef enum {
59 } SegmentType;
60 
61 enum {
67 };
68 
69 #define MPD_PROFILE_DASH 1
70 #define MPD_PROFILE_DVB 2
71 
72 typedef struct Segment {
73  char file[1024];
74  int64_t start_pos;
76  int64_t time;
78  int64_t duration;
79  int n;
80 } Segment;
81 
82 typedef struct AdaptationSet {
83  int id;
84  char *descriptor;
85  int64_t seg_duration;
86  int64_t frag_duration;
87  int frag_type;
96  int trick_idx;
98 
99 typedef struct OutputStream {
106  char initfile[1024];
107  int64_t init_start_pos, pos;
110  int64_t seg_duration;
111  int64_t frag_duration;
112  int64_t last_duration;
115  int64_t last_dts, last_pts;
117  int bit_rate;
119  SegmentType segment_type; /* segment type selected for this particular stream */
120  const char *format_name;
121  const char *extension_name;
122  const char *single_file_name; /* file names selected for this particular stream */
123  const char *init_seg_name;
124  const char *media_seg_name;
125 
126  char codec_str[100];
128  char filename[1024];
129  char full_path[1024];
130  char temp_path[1024];
138  int64_t gop_size;
141 } OutputStream;
142 
143 typedef struct DASHContext {
144  const AVClass *class; /* Class for private options. */
147  int nb_as;
150  int64_t seg_duration;
151  int64_t frag_duration;
158  int64_t last_duration;
159  int64_t total_duration;
161  time_t start_time_s;
163  char dirname[1024];
164  const char *single_file_name; /* file names as specified in options */
165  const char *init_seg_name;
166  const char *media_seg_name;
167  const char *utc_timing_url;
168  const char *method;
169  const char *user_agent;
172  const char *hls_master_name;
178  int64_t timeout;
182  SegmentType segment_type_option; /* segment type as specified in options */
184  int lhls;
185  int ldash;
191  int64_t max_gop_size;
193  int profile;
194  int64_t target_latency;
198  int64_t update_period;
199 } DASHContext;
200 
201 static struct codec_string {
202  int id;
203  const char *str;
204 } codecs[] = {
205  { AV_CODEC_ID_VP8, "vp8" },
206  { AV_CODEC_ID_VP9, "vp9" },
207  { AV_CODEC_ID_VORBIS, "vorbis" },
208  { AV_CODEC_ID_OPUS, "opus" },
209  { AV_CODEC_ID_FLAC, "flac" },
210  { 0, NULL }
211 };
212 
213 static struct format_string {
215  const char *str;
216 } formats[] = {
217  { SEGMENT_TYPE_AUTO, "auto" },
218  { SEGMENT_TYPE_MP4, "mp4" },
219  { SEGMENT_TYPE_WEBM, "webm" },
220  { 0, NULL }
221 };
222 
223 static int dashenc_io_open(AVFormatContext *s, AVIOContext **pb, char *filename,
224  AVDictionary **options) {
225  DASHContext *c = s->priv_data;
226  int http_base_proto = filename ? ff_is_http_proto(filename) : 0;
227  int err = AVERROR_MUXER_NOT_FOUND;
228  if (!*pb || !http_base_proto || !c->http_persistent) {
229  err = s->io_open(s, pb, filename, AVIO_FLAG_WRITE, options);
230 #if CONFIG_HTTP_PROTOCOL
231  } else {
232  URLContext *http_url_context = ffio_geturlcontext(*pb);
233  av_assert0(http_url_context);
234  err = ff_http_do_new_request(http_url_context, filename);
235  if (err < 0)
236  ff_format_io_close(s, pb);
237 #endif
238  }
239  return err;
240 }
241 
242 static void dashenc_io_close(AVFormatContext *s, AVIOContext **pb, char *filename) {
243  DASHContext *c = s->priv_data;
244  int http_base_proto = filename ? ff_is_http_proto(filename) : 0;
245 
246  if (!*pb)
247  return;
248 
249  if (!http_base_proto || !c->http_persistent) {
250  ff_format_io_close(s, pb);
251 #if CONFIG_HTTP_PROTOCOL
252  } else {
253  URLContext *http_url_context = ffio_geturlcontext(*pb);
254  av_assert0(http_url_context);
255  avio_flush(*pb);
256  ffurl_shutdown(http_url_context, AVIO_FLAG_WRITE);
257 #endif
258  }
259 }
260 
261 static const char *get_format_str(SegmentType segment_type) {
262  int i;
263  for (i = 0; i < SEGMENT_TYPE_NB; i++)
264  if (formats[i].segment_type == segment_type)
265  return formats[i].str;
266  return NULL;
267 }
268 
269 static const char *get_extension_str(SegmentType type, int single_file)
270 {
271  switch (type) {
272 
273  case SEGMENT_TYPE_MP4: return single_file ? "mp4" : "m4s";
274  case SEGMENT_TYPE_WEBM: return "webm";
275  default: return NULL;
276  }
277 }
278 
279 static int handle_io_open_error(AVFormatContext *s, int err, char *url) {
280  DASHContext *c = s->priv_data;
281  char errbuf[AV_ERROR_MAX_STRING_SIZE];
282  av_strerror(err, errbuf, sizeof(errbuf));
283  av_log(s, c->ignore_io_errors ? AV_LOG_WARNING : AV_LOG_ERROR,
284  "Unable to open %s for writing: %s\n", url, errbuf);
285  return c->ignore_io_errors ? 0 : err;
286 }
287 
289 {
290  if (segment_type == SEGMENT_TYPE_AUTO) {
293  segment_type = SEGMENT_TYPE_WEBM;
294  } else {
295  segment_type = SEGMENT_TYPE_MP4;
296  }
297  }
298 
299  return segment_type;
300 }
301 
303 {
304  DASHContext *c = s->priv_data;
305  int has_mp4_streams = 0;
306  for (int i = 0; i < s->nb_streams; ++i) {
307  OutputStream *os = &c->streams[i];
308  SegmentType segment_type = select_segment_type(
309  c->segment_type_option, s->streams[i]->codecpar->codec_id);
310  os->segment_type = segment_type;
311  os->format_name = get_format_str(segment_type);
312  if (!os->format_name) {
313  av_log(s, AV_LOG_ERROR, "Could not select DASH segment type for stream %d\n", i);
315  }
316  os->extension_name = get_extension_str(segment_type, c->single_file);
317  if (!os->extension_name) {
318  av_log(s, AV_LOG_ERROR, "Could not get extension type for stream %d\n", i);
320  }
321 
322  has_mp4_streams |= segment_type == SEGMENT_TYPE_MP4;
323  }
324 
325  if (c->hls_playlist && !has_mp4_streams) {
326  av_log(s, AV_LOG_WARNING, "No mp4 streams, disabling HLS manifest generation\n");
327  c->hls_playlist = 0;
328  }
329 
330  return 0;
331 }
332 
334  AVRational *frame_rate, char *str, int size) {
335  VPCC vpcc;
336  int ret = ff_isom_get_vpcc_features(s, par, frame_rate, &vpcc);
337  if (ret == 0) {
338  av_strlcatf(str, size, "vp09.%02d.%02d.%02d",
339  vpcc.profile, vpcc.level, vpcc.bitdepth);
340  } else {
341  // Default to just vp9 in case of error while finding out profile or level
342  av_log(s, AV_LOG_WARNING, "Could not find VP9 profile and/or level\n");
343  av_strlcpy(str, "vp9", size);
344  }
345  return;
346 }
347 
349  AVRational *frame_rate, char *str, int size)
350 {
351  const AVCodecTag *tags[2] = { NULL, NULL };
352  uint32_t tag;
353  int i;
354 
355  // common Webm codecs are not part of RFC 6381
356  for (i = 0; codecs[i].id; i++)
357  if (codecs[i].id == par->codec_id) {
358  if (codecs[i].id == AV_CODEC_ID_VP9) {
359  set_vp9_codec_str(s, par, frame_rate, str, size);
360  } else {
362  }
363  return;
364  }
365 
366  // for codecs part of RFC 6381
367  if (par->codec_type == AVMEDIA_TYPE_VIDEO)
368  tags[0] = ff_codec_movvideo_tags;
369  else if (par->codec_type == AVMEDIA_TYPE_AUDIO)
370  tags[0] = ff_codec_movaudio_tags;
371  else
372  return;
373 
374  tag = par->codec_tag;
375  if (!tag)
376  tag = av_codec_get_tag(tags, par->codec_id);
377  if (!tag)
378  return;
379  if (size < 5)
380  return;
381 
382  AV_WL32(str, tag);
383  str[4] = '\0';
384  if (!strcmp(str, "mp4a") || !strcmp(str, "mp4v")) {
385  uint32_t oti;
386  tags[0] = ff_mp4_obj_type;
387  oti = av_codec_get_tag(tags, par->codec_id);
388  if (oti)
389  av_strlcatf(str, size, ".%02"PRIx32, oti);
390  else
391  return;
392 
393  if (tag == MKTAG('m', 'p', '4', 'a')) {
394  if (par->extradata_size >= 2) {
395  int aot = par->extradata[0] >> 3;
396  if (aot == 31)
397  aot = ((AV_RB16(par->extradata) >> 5) & 0x3f) + 32;
398  av_strlcatf(str, size, ".%d", aot);
399  }
400  } else if (tag == MKTAG('m', 'p', '4', 'v')) {
401  // Unimplemented, should output ProfileLevelIndication as a decimal number
402  av_log(s, AV_LOG_WARNING, "Incomplete RFC 6381 codec string for mp4v\n");
403  }
404  } else if (!strcmp(str, "avc1")) {
405  uint8_t *tmpbuf = NULL;
406  uint8_t *extradata = par->extradata;
407  int extradata_size = par->extradata_size;
408  if (!extradata_size)
409  return;
410  if (extradata[0] != 1) {
411  AVIOContext *pb;
412  if (avio_open_dyn_buf(&pb) < 0)
413  return;
414  if (ff_isom_write_avcc(pb, extradata, extradata_size) < 0) {
415  ffio_free_dyn_buf(&pb);
416  return;
417  }
418  extradata_size = avio_close_dyn_buf(pb, &extradata);
419  tmpbuf = extradata;
420  }
421 
422  if (extradata_size >= 4)
423  av_strlcatf(str, size, ".%02x%02x%02x",
424  extradata[1], extradata[2], extradata[3]);
425  av_free(tmpbuf);
426  } else if (!strcmp(str, "av01")) {
428  if (!par->extradata_size)
429  return;
430  if (ff_av1_parse_seq_header(&seq, par->extradata, par->extradata_size) < 0)
431  return;
432 
433  av_strlcatf(str, size, ".%01u.%02u%s.%02u",
434  seq.profile, seq.level, seq.tier ? "H" : "M", seq.bitdepth);
436  av_strlcatf(str, size, ".%01u.%01u%01u%01u.%02u.%02u.%02u.%01u",
437  seq.monochrome,
440  seq.color_range);
441  }
442 }
443 
444 static int flush_dynbuf(DASHContext *c, OutputStream *os, int *range_length)
445 {
446  uint8_t *buffer;
447 
448  if (!os->ctx->pb) {
449  return AVERROR(EINVAL);
450  }
451 
452  // flush
453  av_write_frame(os->ctx, NULL);
454  avio_flush(os->ctx->pb);
455 
456  if (!c->single_file) {
457  // write out to file
458  *range_length = avio_close_dyn_buf(os->ctx->pb, &buffer);
459  os->ctx->pb = NULL;
460  if (os->out)
461  avio_write(os->out, buffer + os->written_len, *range_length - os->written_len);
462  os->written_len = 0;
463  av_free(buffer);
464 
465  // re-open buffer
466  return avio_open_dyn_buf(&os->ctx->pb);
467  } else {
468  *range_length = avio_tell(os->ctx->pb) - os->pos;
469  return 0;
470  }
471 }
472 
474 {
475  if (c->method)
476  av_dict_set(options, "method", c->method, 0);
477  av_dict_copy(options, c->http_opts, 0);
478  if (c->user_agent)
479  av_dict_set(options, "user_agent", c->user_agent, 0);
480  if (c->http_persistent)
481  av_dict_set_int(options, "multiple_requests", 1, 0);
482  if (c->timeout >= 0)
483  av_dict_set_int(options, "timeout", c->timeout, 0);
484 }
485 
486 static void get_hls_playlist_name(char *playlist_name, int string_size,
487  const char *base_url, int id) {
488  if (base_url)
489  snprintf(playlist_name, string_size, "%smedia_%d.m3u8", base_url, id);
490  else
491  snprintf(playlist_name, string_size, "media_%d.m3u8", id);
492 }
493 
495  int *start_index, int *start_number) {
496  *start_index = 0;
497  *start_number = 1;
498  if (c->window_size) {
499  *start_index = FFMAX(os->nb_segments - c->window_size, 0);
500  *start_number = FFMAX(os->segment_index - c->window_size, 1);
501  }
502 }
503 
505  int representation_id, int final,
506  char *prefetch_url) {
507  DASHContext *c = s->priv_data;
508  int timescale = os->ctx->streams[0]->time_base.den;
509  char temp_filename_hls[1024];
510  char filename_hls[1024];
511  AVDictionary *http_opts = NULL;
512  int target_duration = 0;
513  int ret = 0;
514  const char *proto = avio_find_protocol_name(c->dirname);
515  int use_rename = proto && !strcmp(proto, "file");
516  int i, start_index, start_number;
517  double prog_date_time = 0;
518 
519  get_start_index_number(os, c, &start_index, &start_number);
520 
521  if (!c->hls_playlist || start_index >= os->nb_segments ||
523  return;
524 
525  get_hls_playlist_name(filename_hls, sizeof(filename_hls),
526  c->dirname, representation_id);
527 
528  snprintf(temp_filename_hls, sizeof(temp_filename_hls), use_rename ? "%s.tmp" : "%s", filename_hls);
529 
530  set_http_options(&http_opts, c);
531  ret = dashenc_io_open(s, &c->m3u8_out, temp_filename_hls, &http_opts);
532  av_dict_free(&http_opts);
533  if (ret < 0) {
534  handle_io_open_error(s, ret, temp_filename_hls);
535  return;
536  }
537  for (i = start_index; i < os->nb_segments; i++) {
538  Segment *seg = os->segments[i];
539  double duration = (double) seg->duration / timescale;
540  if (target_duration <= duration)
541  target_duration = lrint(duration);
542  }
543 
544  ff_hls_write_playlist_header(c->m3u8_out, 6, -1, target_duration,
545  start_number, PLAYLIST_TYPE_NONE, 0);
546 
547  ff_hls_write_init_file(c->m3u8_out, os->initfile, c->single_file,
549 
550  for (i = start_index; i < os->nb_segments; i++) {
551  Segment *seg = os->segments[i];
552 
553  if (prog_date_time == 0) {
554  if (os->nb_segments == 1)
555  prog_date_time = c->start_time_s;
556  else
557  prog_date_time = seg->prog_date_time;
558  }
559  seg->prog_date_time = prog_date_time;
560 
561  ret = ff_hls_write_file_entry(c->m3u8_out, 0, c->single_file,
562  (double) seg->duration / timescale, 0,
563  seg->range_length, seg->start_pos, NULL,
564  c->single_file ? os->initfile : seg->file,
565  &prog_date_time, 0, 0, 0);
566  if (ret < 0) {
567  av_log(os->ctx, AV_LOG_WARNING, "ff_hls_write_file_entry get error\n");
568  }
569  }
570 
571  if (prefetch_url)
572  avio_printf(c->m3u8_out, "#EXT-X-PREFETCH:%s\n", prefetch_url);
573 
574  if (final)
575  ff_hls_write_end_list(c->m3u8_out);
576 
577  dashenc_io_close(s, &c->m3u8_out, temp_filename_hls);
578 
579  if (use_rename)
580  ff_rename(temp_filename_hls, filename_hls, os->ctx);
581 }
582 
584 {
585  DASHContext *c = s->priv_data;
586  int ret, range_length;
587 
588  ret = flush_dynbuf(c, os, &range_length);
589  if (ret < 0)
590  return ret;
591 
592  os->pos = os->init_range_length = range_length;
593  if (!c->single_file) {
594  char filename[1024];
595  snprintf(filename, sizeof(filename), "%s%s", c->dirname, os->initfile);
596  dashenc_io_close(s, &os->out, filename);
597  }
598  return 0;
599 }
600 
602 {
603  DASHContext *c = s->priv_data;
604  int i, j;
605 
606  if (c->as) {
607  for (i = 0; i < c->nb_as; i++) {
608  av_dict_free(&c->as[i].metadata);
609  av_freep(&c->as[i].descriptor);
610  }
611  av_freep(&c->as);
612  c->nb_as = 0;
613  }
614 
615  if (!c->streams)
616  return;
617  for (i = 0; i < s->nb_streams; i++) {
618  OutputStream *os = &c->streams[i];
619  if (os->ctx && os->ctx->pb) {
620  if (!c->single_file)
621  ffio_free_dyn_buf(&os->ctx->pb);
622  else
623  avio_close(os->ctx->pb);
624  }
625  ff_format_io_close(s, &os->out);
628  av_parser_close(os->parser);
629  for (j = 0; j < os->nb_segments; j++)
630  av_free(os->segments[j]);
631  av_free(os->segments);
633  av_freep(&os->init_seg_name);
634  av_freep(&os->media_seg_name);
635  }
636  av_freep(&c->streams);
637 
638  ff_format_io_close(s, &c->mpd_out);
639  ff_format_io_close(s, &c->m3u8_out);
640 }
641 
643  int representation_id, int final)
644 {
645  DASHContext *c = s->priv_data;
646  int i, start_index, start_number;
647  get_start_index_number(os, c, &start_index, &start_number);
648 
649  if (c->use_template) {
650  int timescale = c->use_timeline ? os->ctx->streams[0]->time_base.den : AV_TIME_BASE;
651  avio_printf(out, "\t\t\t\t<SegmentTemplate timescale=\"%d\" ", timescale);
652  if (!c->use_timeline) {
653  avio_printf(out, "duration=\"%"PRId64"\" ", os->seg_duration);
654  if (c->streaming && os->availability_time_offset)
655  avio_printf(out, "availabilityTimeOffset=\"%.3f\" ",
657  }
658  if (c->streaming && os->availability_time_offset && !final)
659  avio_printf(out, "availabilityTimeComplete=\"false\" ");
660 
661  avio_printf(out, "initialization=\"%s\" media=\"%s\" startNumber=\"%d\"", os->init_seg_name, os->media_seg_name, c->use_timeline ? start_number : 1);
662  if (c->presentation_time_offset)
663  avio_printf(out, " presentationTimeOffset=\"%"PRId64"\"", c->presentation_time_offset);
664  avio_printf(out, ">\n");
665  if (c->use_timeline) {
666  int64_t cur_time = 0;
667  avio_printf(out, "\t\t\t\t\t<SegmentTimeline>\n");
668  for (i = start_index; i < os->nb_segments; ) {
669  Segment *seg = os->segments[i];
670  int repeat = 0;
671  avio_printf(out, "\t\t\t\t\t\t<S ");
672  if (i == start_index || seg->time != cur_time) {
673  cur_time = seg->time;
674  avio_printf(out, "t=\"%"PRId64"\" ", seg->time);
675  }
676  avio_printf(out, "d=\"%"PRId64"\" ", seg->duration);
677  while (i + repeat + 1 < os->nb_segments &&
678  os->segments[i + repeat + 1]->duration == seg->duration &&
679  os->segments[i + repeat + 1]->time == os->segments[i + repeat]->time + os->segments[i + repeat]->duration)
680  repeat++;
681  if (repeat > 0)
682  avio_printf(out, "r=\"%d\" ", repeat);
683  avio_printf(out, "/>\n");
684  i += 1 + repeat;
685  cur_time += (1 + repeat) * seg->duration;
686  }
687  avio_printf(out, "\t\t\t\t\t</SegmentTimeline>\n");
688  }
689  avio_printf(out, "\t\t\t\t</SegmentTemplate>\n");
690  } else if (c->single_file) {
691  avio_printf(out, "\t\t\t\t<BaseURL>%s</BaseURL>\n", os->initfile);
692  avio_printf(out, "\t\t\t\t<SegmentList timescale=\"%d\" duration=\"%"PRId64"\" startNumber=\"%d\">\n", AV_TIME_BASE, FFMIN(os->seg_duration, os->last_duration), start_number);
693  avio_printf(out, "\t\t\t\t\t<Initialization range=\"%"PRId64"-%"PRId64"\" />\n", os->init_start_pos, os->init_start_pos + os->init_range_length - 1);
694  for (i = start_index; i < os->nb_segments; i++) {
695  Segment *seg = os->segments[i];
696  avio_printf(out, "\t\t\t\t\t<SegmentURL mediaRange=\"%"PRId64"-%"PRId64"\" ", seg->start_pos, seg->start_pos + seg->range_length - 1);
697  if (seg->index_length)
698  avio_printf(out, "indexRange=\"%"PRId64"-%"PRId64"\" ", seg->start_pos, seg->start_pos + seg->index_length - 1);
699  avio_printf(out, "/>\n");
700  }
701  avio_printf(out, "\t\t\t\t</SegmentList>\n");
702  } else {
703  avio_printf(out, "\t\t\t\t<SegmentList timescale=\"%d\" duration=\"%"PRId64"\" startNumber=\"%d\">\n", AV_TIME_BASE, FFMIN(os->seg_duration, os->last_duration), start_number);
704  avio_printf(out, "\t\t\t\t\t<Initialization sourceURL=\"%s\" />\n", os->initfile);
705  for (i = start_index; i < os->nb_segments; i++) {
706  Segment *seg = os->segments[i];
707  avio_printf(out, "\t\t\t\t\t<SegmentURL media=\"%s\" />\n", seg->file);
708  }
709  avio_printf(out, "\t\t\t\t</SegmentList>\n");
710  }
711  if (!c->lhls || final) {
712  write_hls_media_playlist(os, s, representation_id, final, NULL);
713  }
714 
715 }
716 
717 static char *xmlescape(const char *str) {
718  int outlen = strlen(str)*3/2 + 6;
719  char *out = av_realloc(NULL, outlen + 1);
720  int pos = 0;
721  if (!out)
722  return NULL;
723  for (; *str; str++) {
724  if (pos + 6 > outlen) {
725  char *tmp;
726  outlen = 2 * outlen + 6;
727  tmp = av_realloc(out, outlen + 1);
728  if (!tmp) {
729  av_free(out);
730  return NULL;
731  }
732  out = tmp;
733  }
734  if (*str == '&') {
735  memcpy(&out[pos], "&amp;", 5);
736  pos += 5;
737  } else if (*str == '<') {
738  memcpy(&out[pos], "&lt;", 4);
739  pos += 4;
740  } else if (*str == '>') {
741  memcpy(&out[pos], "&gt;", 4);
742  pos += 4;
743  } else if (*str == '\'') {
744  memcpy(&out[pos], "&apos;", 6);
745  pos += 6;
746  } else if (*str == '\"') {
747  memcpy(&out[pos], "&quot;", 6);
748  pos += 6;
749  } else {
750  out[pos++] = *str;
751  }
752  }
753  out[pos] = '\0';
754  return out;
755 }
756 
757 static void write_time(AVIOContext *out, int64_t time)
758 {
759  int seconds = time / AV_TIME_BASE;
760  int fractions = time % AV_TIME_BASE;
761  int minutes = seconds / 60;
762  int hours = minutes / 60;
763  seconds %= 60;
764  minutes %= 60;
765  avio_printf(out, "PT");
766  if (hours)
767  avio_printf(out, "%dH", hours);
768  if (hours || minutes)
769  avio_printf(out, "%dM", minutes);
770  avio_printf(out, "%d.%dS", seconds, fractions / (AV_TIME_BASE / 10));
771 }
772 
773 static void format_date(char *buf, int size, int64_t time_us)
774 {
775  struct tm *ptm, tmbuf;
776  int64_t time_ms = time_us / 1000;
777  const time_t time_s = time_ms / 1000;
778  int millisec = time_ms - (time_s * 1000);
779  ptm = gmtime_r(&time_s, &tmbuf);
780  if (ptm) {
781  int len;
782  if (!strftime(buf, size, "%Y-%m-%dT%H:%M:%S", ptm)) {
783  buf[0] = '\0';
784  return;
785  }
786  len = strlen(buf);
787  snprintf(buf + len, size - len, ".%03dZ", millisec);
788  }
789 }
790 
792  int final)
793 {
794  DASHContext *c = s->priv_data;
795  AdaptationSet *as = &c->as[as_index];
796  AVDictionaryEntry *lang, *role;
797  int i;
798 
799  avio_printf(out, "\t\t<AdaptationSet id=\"%d\" contentType=\"%s\" startWithSAP=\"1\" segmentAlignment=\"true\" bitstreamSwitching=\"true\"",
800  as->id, as->media_type == AVMEDIA_TYPE_VIDEO ? "video" : "audio");
802  avio_printf(out, " maxFrameRate=\"%d/%d\"", as->max_frame_rate.num, as->max_frame_rate.den);
804  avio_printf(out, " frameRate=\"%d/%d\"", as->max_frame_rate.num, as->max_frame_rate.den);
805  if (as->media_type == AVMEDIA_TYPE_VIDEO) {
806  avio_printf(out, " maxWidth=\"%d\" maxHeight=\"%d\"", as->max_width, as->max_height);
807  avio_printf(out, " par=\"%d:%d\"", as->par.num, as->par.den);
808  }
809  lang = av_dict_get(as->metadata, "language", NULL, 0);
810  if (lang)
811  avio_printf(out, " lang=\"%s\"", lang->value);
812  avio_printf(out, ">\n");
813 
814  if (!final && c->ldash && as->max_frag_duration && !(c->profile & MPD_PROFILE_DVB))
815  avio_printf(out, "\t\t\t<Resync dT=\"%"PRId64"\" type=\"0\"/>\n", as->max_frag_duration);
816  if (as->trick_idx >= 0)
817  avio_printf(out, "\t\t\t<EssentialProperty id=\"%d\" schemeIdUri=\"http://dashif.org/guidelines/trickmode\" value=\"%d\"/>\n", as->id, as->trick_idx);
818  role = av_dict_get(as->metadata, "role", NULL, 0);
819  if (role)
820  avio_printf(out, "\t\t\t<Role schemeIdUri=\"urn:mpeg:dash:role:2011\" value=\"%s\"/>\n", role->value);
821  if (as->descriptor)
822  avio_printf(out, "\t\t\t%s\n", as->descriptor);
823  for (i = 0; i < s->nb_streams; i++) {
824  AVStream *st = s->streams[i];
825  OutputStream *os = &c->streams[i];
826  char bandwidth_str[64] = {'\0'};
827 
828  if (os->as_idx - 1 != as_index)
829  continue;
830 
831  if (os->bit_rate > 0)
832  snprintf(bandwidth_str, sizeof(bandwidth_str), " bandwidth=\"%d\"", os->bit_rate);
833  else if (final) {
834  int average_bit_rate = os->pos * 8 * AV_TIME_BASE / c->total_duration;
835  snprintf(bandwidth_str, sizeof(bandwidth_str), " bandwidth=\"%d\"", average_bit_rate);
836  } else if (os->first_segment_bit_rate > 0)
837  snprintf(bandwidth_str, sizeof(bandwidth_str), " bandwidth=\"%d\"", os->first_segment_bit_rate);
838 
839  if (as->media_type == AVMEDIA_TYPE_VIDEO) {
840  avio_printf(out, "\t\t\t<Representation id=\"%d\" mimeType=\"video/%s\" codecs=\"%s\"%s width=\"%d\" height=\"%d\"",
841  i, os->format_name, os->codec_str, bandwidth_str, s->streams[i]->codecpar->width, s->streams[i]->codecpar->height);
843  avio_printf(out, " scanType=\"unknown\"");
844  else if (st->codecpar->field_order != AV_FIELD_PROGRESSIVE)
845  avio_printf(out, " scanType=\"interlaced\"");
846  avio_printf(out, " sar=\"%d:%d\"", os->sar.num, os->sar.den);
847  if (st->avg_frame_rate.num && av_cmp_q(as->min_frame_rate, as->max_frame_rate) < 0)
848  avio_printf(out, " frameRate=\"%d/%d\"", st->avg_frame_rate.num, st->avg_frame_rate.den);
849  if (as->trick_idx >= 0) {
850  AdaptationSet *tas = &c->as[as->trick_idx];
851  if (!as->ambiguous_frame_rate && !tas->ambiguous_frame_rate)
852  avio_printf(out, " maxPlayoutRate=\"%d\"", FFMAX((int)av_q2d(av_div_q(tas->min_frame_rate, as->min_frame_rate)), 1));
853  }
854  if (!os->coding_dependency)
855  avio_printf(out, " codingDependency=\"false\"");
856  avio_printf(out, ">\n");
857  } else {
858  avio_printf(out, "\t\t\t<Representation id=\"%d\" mimeType=\"audio/%s\" codecs=\"%s\"%s audioSamplingRate=\"%d\">\n",
859  i, os->format_name, os->codec_str, bandwidth_str, s->streams[i]->codecpar->sample_rate);
860  avio_printf(out, "\t\t\t\t<AudioChannelConfiguration schemeIdUri=\"urn:mpeg:dash:23003:3:audio_channel_configuration:2011\" value=\"%d\" />\n",
861  s->streams[i]->codecpar->channels);
862  }
863  if (!final && c->write_prft && os->producer_reference_time_str[0]) {
864  avio_printf(out, "\t\t\t\t<ProducerReferenceTime id=\"%d\" inband=\"true\" type=\"%s\" wallClockTime=\"%s\" presentationTime=\"%"PRId64"\">\n",
865  i, os->producer_reference_time.flags ? "captured" : "encoder", os->producer_reference_time_str, c->presentation_time_offset);
866  avio_printf(out, "\t\t\t\t\t<UTCTiming schemeIdUri=\"urn:mpeg:dash:utc:http-xsdate:2014\" value=\"%s\"/>\n", c->utc_timing_url);
867  avio_printf(out, "\t\t\t\t</ProducerReferenceTime>\n");
868  }
869  if (!final && c->ldash && os->gop_size && os->frag_type != FRAG_TYPE_NONE && !(c->profile & MPD_PROFILE_DVB) &&
871  avio_printf(out, "\t\t\t\t<Resync dT=\"%"PRId64"\" type=\"1\"/>\n", os->gop_size);
872  output_segment_list(os, out, s, i, final);
873  avio_printf(out, "\t\t\t</Representation>\n");
874  }
875  avio_printf(out, "\t\t</AdaptationSet>\n");
876 
877  return 0;
878 }
879 
881 {
882  DASHContext *c = s->priv_data;
883  void *mem;
884 
885  if (c->profile & MPD_PROFILE_DVB && (c->nb_as + 1) > 16) {
886  av_log(s, AV_LOG_ERROR, "DVB-DASH profile allows a max of 16 Adaptation Sets\n");
887  return AVERROR(EINVAL);
888  }
889  mem = av_realloc(c->as, sizeof(*c->as) * (c->nb_as + 1));
890  if (!mem)
891  return AVERROR(ENOMEM);
892  c->as = mem;
893  ++c->nb_as;
894 
895  *as = &c->as[c->nb_as - 1];
896  memset(*as, 0, sizeof(**as));
897  (*as)->media_type = type;
898  (*as)->frag_type = -1;
899  (*as)->trick_idx = -1;
900 
901  return 0;
902 }
903 
904 static int adaptation_set_add_stream(AVFormatContext *s, int as_idx, int i)
905 {
906  DASHContext *c = s->priv_data;
907  AdaptationSet *as = &c->as[as_idx - 1];
908  OutputStream *os = &c->streams[i];
909 
910  if (as->media_type != s->streams[i]->codecpar->codec_type) {
911  av_log(s, AV_LOG_ERROR, "Codec type of stream %d doesn't match AdaptationSet's media type\n", i);
912  return AVERROR(EINVAL);
913  } else if (os->as_idx) {
914  av_log(s, AV_LOG_ERROR, "Stream %d is already assigned to an AdaptationSet\n", i);
915  return AVERROR(EINVAL);
916  }
917  if (c->profile & MPD_PROFILE_DVB && (as->nb_streams + 1) > 16) {
918  av_log(s, AV_LOG_ERROR, "DVB-DASH profile allows a max of 16 Representations per Adaptation Set\n");
919  return AVERROR(EINVAL);
920  }
921  os->as_idx = as_idx;
922  ++as->nb_streams;
923 
924  return 0;
925 }
926 
928 {
929  DASHContext *c = s->priv_data;
930  const char *p = c->adaptation_sets;
931  enum { new_set, parse_default, parsing_streams, parse_seg_duration, parse_frag_duration } state;
932  AdaptationSet *as;
933  int i, n, ret;
934 
935  // default: one AdaptationSet for each stream
936  if (!p) {
937  for (i = 0; i < s->nb_streams; i++) {
938  if ((ret = add_adaptation_set(s, &as, s->streams[i]->codecpar->codec_type)) < 0)
939  return ret;
940  as->id = i;
941 
942  c->streams[i].as_idx = c->nb_as;
943  ++as->nb_streams;
944  }
945  goto end;
946  }
947 
948  // syntax id=0,streams=0,1,2 id=1,streams=3,4 and so on
949  // option id=0,descriptor=descriptor_str,streams=0,1,2 and so on
950  // option id=0,seg_duration=2.5,frag_duration=0.5,streams=0,1,2
951  // id=1,trick_id=0,seg_duration=10,frag_type=none,streams=3 and so on
952  // descriptor is useful to the scheme defined by ISO/IEC 23009-1:2014/Amd.2:2015
953  // descriptor_str should be a self-closing xml tag.
954  // seg_duration and frag_duration have the same syntax as the global options of
955  // the same name, and the former have precedence over them if set.
956  state = new_set;
957  while (*p) {
958  if (*p == ' ') {
959  p++;
960  continue;
961  } else if (state == new_set && av_strstart(p, "id=", &p)) {
962  char id_str[10], *end_str;
963 
964  n = strcspn(p, ",");
965  snprintf(id_str, sizeof(id_str), "%.*s", n, p);
966 
967  i = strtol(id_str, &end_str, 10);
968  if (id_str == end_str || i < 0 || i > c->nb_as) {
969  av_log(s, AV_LOG_ERROR, "\"%s\" is not a valid value for an AdaptationSet id\n", id_str);
970  return AVERROR(EINVAL);
971  }
972 
973  if ((ret = add_adaptation_set(s, &as, AVMEDIA_TYPE_UNKNOWN)) < 0)
974  return ret;
975  as->id = i;
976 
977  p += n;
978  if (*p)
979  p++;
980  state = parse_default;
981  } else if (state != new_set && av_strstart(p, "seg_duration=", &p)) {
982  state = parse_seg_duration;
983  } else if (state != new_set && av_strstart(p, "frag_duration=", &p)) {
984  state = parse_frag_duration;
985  } else if (state == parse_seg_duration || state == parse_frag_duration) {
986  char str[32];
987  int64_t usecs = 0;
988 
989  n = strcspn(p, ",");
990  snprintf(str, sizeof(str), "%.*s", n, p);
991  p += n;
992  if (*p)
993  p++;
994 
995  ret = av_parse_time(&usecs, str, 1);
996  if (ret < 0) {
997  av_log(s, AV_LOG_ERROR, "Unable to parse option value \"%s\" as duration\n", str);
998  return ret;
999  }
1000 
1001  if (state == parse_seg_duration)
1002  as->seg_duration = usecs;
1003  else
1004  as->frag_duration = usecs;
1005  state = parse_default;
1006  } else if (state != new_set && av_strstart(p, "frag_type=", &p)) {
1007  char type_str[16];
1008 
1009  n = strcspn(p, ",");
1010  snprintf(type_str, sizeof(type_str), "%.*s", n, p);
1011  p += n;
1012  if (*p)
1013  p++;
1014 
1015  if (!strcmp(type_str, "duration"))
1017  else if (!strcmp(type_str, "pframes"))
1019  else if (!strcmp(type_str, "every_frame"))
1021  else if (!strcmp(type_str, "none"))
1022  as->frag_type = FRAG_TYPE_NONE;
1023  else {
1024  av_log(s, AV_LOG_ERROR, "Unable to parse option value \"%s\" as fragment type\n", type_str);
1025  return ret;
1026  }
1027  state = parse_default;
1028  } else if (state != new_set && av_strstart(p, "descriptor=", &p)) {
1029  n = strcspn(p, ">") + 1; //followed by one comma, so plus 1
1030  if (n < strlen(p)) {
1031  as->descriptor = av_strndup(p, n);
1032  } else {
1033  av_log(s, AV_LOG_ERROR, "Parse error, descriptor string should be a self-closing xml tag\n");
1034  return AVERROR(EINVAL);
1035  }
1036  p += n;
1037  if (*p)
1038  p++;
1039  state = parse_default;
1040  } else if ((state != new_set) && av_strstart(p, "trick_id=", &p)) {
1041  char trick_id_str[10], *end_str;
1042 
1043  n = strcspn(p, ",");
1044  snprintf(trick_id_str, sizeof(trick_id_str), "%.*s", n, p);
1045  p += n;
1046 
1047  as->trick_idx = strtol(trick_id_str, &end_str, 10);
1048  if (trick_id_str == end_str || as->trick_idx < 0)
1049  return AVERROR(EINVAL);
1050 
1051  if (*p)
1052  p++;
1053  state = parse_default;
1054  } else if ((state != new_set) && av_strstart(p, "streams=", &p)) { //descriptor and durations are optional
1055  state = parsing_streams;
1056  } else if (state == parsing_streams) {
1057  AdaptationSet *as = &c->as[c->nb_as - 1];
1058  char idx_str[8], *end_str;
1059 
1060  n = strcspn(p, " ,");
1061  snprintf(idx_str, sizeof(idx_str), "%.*s", n, p);
1062  p += n;
1063 
1064  // if value is "a" or "v", map all streams of that type
1065  if (as->media_type == AVMEDIA_TYPE_UNKNOWN && (idx_str[0] == 'v' || idx_str[0] == 'a')) {
1066  enum AVMediaType type = (idx_str[0] == 'v') ? AVMEDIA_TYPE_VIDEO : AVMEDIA_TYPE_AUDIO;
1067  av_log(s, AV_LOG_DEBUG, "Map all streams of type %s\n", idx_str);
1068 
1069  for (i = 0; i < s->nb_streams; i++) {
1070  if (s->streams[i]->codecpar->codec_type != type)
1071  continue;
1072 
1073  as->media_type = s->streams[i]->codecpar->codec_type;
1074 
1075  if ((ret = adaptation_set_add_stream(s, c->nb_as, i)) < 0)
1076  return ret;
1077  }
1078  } else { // select single stream
1079  i = strtol(idx_str, &end_str, 10);
1080  if (idx_str == end_str || i < 0 || i >= s->nb_streams) {
1081  av_log(s, AV_LOG_ERROR, "Selected stream \"%s\" not found!\n", idx_str);
1082  return AVERROR(EINVAL);
1083  }
1084  av_log(s, AV_LOG_DEBUG, "Map stream %d\n", i);
1085 
1086  if (as->media_type == AVMEDIA_TYPE_UNKNOWN) {
1087  as->media_type = s->streams[i]->codecpar->codec_type;
1088  }
1089 
1090  if ((ret = adaptation_set_add_stream(s, c->nb_as, i)) < 0)
1091  return ret;
1092  }
1093 
1094  if (*p == ' ')
1095  state = new_set;
1096  if (*p)
1097  p++;
1098  } else {
1099  return AVERROR(EINVAL);
1100  }
1101  }
1102 
1103 end:
1104  // check for unassigned streams
1105  for (i = 0; i < s->nb_streams; i++) {
1106  OutputStream *os = &c->streams[i];
1107  if (!os->as_idx) {
1108  av_log(s, AV_LOG_ERROR, "Stream %d is not mapped to an AdaptationSet\n", i);
1109  return AVERROR(EINVAL);
1110  }
1111  }
1112 
1113  // check references for trick mode AdaptationSet
1114  for (i = 0; i < c->nb_as; i++) {
1115  as = &c->as[i];
1116  if (as->trick_idx < 0)
1117  continue;
1118  for (n = 0; n < c->nb_as; n++) {
1119  if (c->as[n].id == as->trick_idx)
1120  break;
1121  }
1122  if (n >= c->nb_as) {
1123  av_log(s, AV_LOG_ERROR, "reference AdaptationSet id \"%d\" not found for trick mode AdaptationSet id \"%d\"\n", as->trick_idx, as->id);
1124  return AVERROR(EINVAL);
1125  }
1126  }
1127 
1128  return 0;
1129 }
1130 
1131 static int write_manifest(AVFormatContext *s, int final)
1132 {
1133  DASHContext *c = s->priv_data;
1134  AVIOContext *out;
1135  char temp_filename[1024];
1136  int ret, i;
1137  const char *proto = avio_find_protocol_name(s->url);
1138  int use_rename = proto && !strcmp(proto, "file");
1139  static unsigned int warned_non_file = 0;
1140  AVDictionaryEntry *title = av_dict_get(s->metadata, "title", NULL, 0);
1141  AVDictionary *opts = NULL;
1142 
1143  if (!use_rename && !warned_non_file++)
1144  av_log(s, AV_LOG_ERROR, "Cannot use rename on non file protocol, this may lead to races and temporary partial files\n");
1145 
1146  snprintf(temp_filename, sizeof(temp_filename), use_rename ? "%s.tmp" : "%s", s->url);
1147  set_http_options(&opts, c);
1148  ret = dashenc_io_open(s, &c->mpd_out, temp_filename, &opts);
1149  av_dict_free(&opts);
1150  if (ret < 0) {
1151  return handle_io_open_error(s, ret, temp_filename);
1152  }
1153  out = c->mpd_out;
1154  avio_printf(out, "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
1155  avio_printf(out, "<MPD xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n"
1156  "\txmlns=\"urn:mpeg:dash:schema:mpd:2011\"\n"
1157  "\txmlns:xlink=\"http://www.w3.org/1999/xlink\"\n"
1158  "\txsi:schemaLocation=\"urn:mpeg:DASH:schema:MPD:2011 http://standards.iso.org/ittf/PubliclyAvailableStandards/MPEG-DASH_schema_files/DASH-MPD.xsd\"\n"
1159  "\tprofiles=\"");
1160  if (c->profile & MPD_PROFILE_DASH)
1161  avio_printf(out, "%s%s", "urn:mpeg:dash:profile:isoff-live:2011", c->profile & MPD_PROFILE_DVB ? "," : "\"\n");
1162  if (c->profile & MPD_PROFILE_DVB)
1163  avio_printf(out, "%s", "urn:dvb:dash:profile:dvb-dash:2014\"\n");
1164  avio_printf(out, "\ttype=\"%s\"\n",
1165  final ? "static" : "dynamic");
1166  if (final) {
1167  avio_printf(out, "\tmediaPresentationDuration=\"");
1168  write_time(out, c->total_duration);
1169  avio_printf(out, "\"\n");
1170  } else {
1171  int64_t update_period = c->last_duration / AV_TIME_BASE;
1172  char now_str[100];
1173  if (c->use_template && !c->use_timeline)
1174  update_period = 500;
1175  if (c->update_period)
1176  update_period = c->update_period;
1177  avio_printf(out, "\tminimumUpdatePeriod=\"PT%"PRId64"S\"\n", update_period);
1178  if (!c->ldash)
1179  avio_printf(out, "\tsuggestedPresentationDelay=\"PT%"PRId64"S\"\n", c->last_duration / AV_TIME_BASE);
1180  if (c->availability_start_time[0])
1181  avio_printf(out, "\tavailabilityStartTime=\"%s\"\n", c->availability_start_time);
1182  format_date(now_str, sizeof(now_str), av_gettime());
1183  if (now_str[0])
1184  avio_printf(out, "\tpublishTime=\"%s\"\n", now_str);
1185  if (c->window_size && c->use_template) {
1186  avio_printf(out, "\ttimeShiftBufferDepth=\"");
1187  write_time(out, c->last_duration * c->window_size);
1188  avio_printf(out, "\"\n");
1189  }
1190  }
1191  avio_printf(out, "\tmaxSegmentDuration=\"");
1192  write_time(out, c->max_segment_duration);
1193  avio_printf(out, "\"\n");
1194  avio_printf(out, "\tminBufferTime=\"");
1195  write_time(out, c->ldash && c->max_gop_size ? c->max_gop_size : c->last_duration * 2);
1196  avio_printf(out, "\">\n");
1197  avio_printf(out, "\t<ProgramInformation>\n");
1198  if (title) {
1199  char *escaped = xmlescape(title->value);
1200  avio_printf(out, "\t\t<Title>%s</Title>\n", escaped);
1201  av_free(escaped);
1202  }
1203  avio_printf(out, "\t</ProgramInformation>\n");
1204 
1205  avio_printf(out, "\t<ServiceDescription id=\"0\">\n");
1206  if (!final && c->target_latency && c->target_latency_refid >= 0) {
1207  avio_printf(out, "\t\t<Latency target=\"%"PRId64"\"", c->target_latency / 1000);
1208  if (s->nb_streams > 1)
1209  avio_printf(out, " referenceId=\"%d\"", c->target_latency_refid);
1210  avio_printf(out, "/>\n");
1211  }
1212  if (av_cmp_q(c->min_playback_rate, (AVRational) {1, 1}) ||
1213  av_cmp_q(c->max_playback_rate, (AVRational) {1, 1}))
1214  avio_printf(out, "\t\t<PlaybackRate min=\"%.2f\" max=\"%.2f\"/>\n",
1215  av_q2d(c->min_playback_rate), av_q2d(c->max_playback_rate));
1216  avio_printf(out, "\t</ServiceDescription>\n");
1217 
1218  if (c->window_size && s->nb_streams > 0 && c->streams[0].nb_segments > 0 && !c->use_template) {
1219  OutputStream *os = &c->streams[0];
1220  int start_index = FFMAX(os->nb_segments - c->window_size, 0);
1221  int64_t start_time = av_rescale_q(os->segments[start_index]->time, s->streams[0]->time_base, AV_TIME_BASE_Q);
1222  avio_printf(out, "\t<Period id=\"0\" start=\"");
1224  avio_printf(out, "\">\n");
1225  } else {
1226  avio_printf(out, "\t<Period id=\"0\" start=\"PT0.0S\">\n");
1227  }
1228 
1229  for (i = 0; i < c->nb_as; i++) {
1230  if ((ret = write_adaptation_set(s, out, i, final)) < 0)
1231  return ret;
1232  }
1233  avio_printf(out, "\t</Period>\n");
1234 
1235  if (c->utc_timing_url)
1236  avio_printf(out, "\t<UTCTiming schemeIdUri=\"urn:mpeg:dash:utc:http-xsdate:2014\" value=\"%s\"/>\n", c->utc_timing_url);
1237 
1238  avio_printf(out, "</MPD>\n");
1239  avio_flush(out);
1240  dashenc_io_close(s, &c->mpd_out, temp_filename);
1241 
1242  if (use_rename) {
1243  if ((ret = ff_rename(temp_filename, s->url, s)) < 0)
1244  return ret;
1245  }
1246 
1247  if (c->hls_playlist) {
1248  char filename_hls[1024];
1249 
1250  // Publish master playlist only the configured rate
1251  if (c->master_playlist_created && (!c->master_publish_rate ||
1252  c->streams[0].segment_index % c->master_publish_rate))
1253  return 0;
1254 
1255  if (*c->dirname)
1256  snprintf(filename_hls, sizeof(filename_hls), "%s%s", c->dirname, c->hls_master_name);
1257  else
1258  snprintf(filename_hls, sizeof(filename_hls), "%s", c->hls_master_name);
1259 
1260  snprintf(temp_filename, sizeof(temp_filename), use_rename ? "%s.tmp" : "%s", filename_hls);
1261 
1262  set_http_options(&opts, c);
1263  ret = dashenc_io_open(s, &c->m3u8_out, temp_filename, &opts);
1264  av_dict_free(&opts);
1265  if (ret < 0) {
1266  return handle_io_open_error(s, ret, temp_filename);
1267  }
1268 
1269  ff_hls_write_playlist_version(c->m3u8_out, 7);
1270 
1271  if (c->has_video) {
1272  // treat audio streams as alternative renditions for video streams
1273  const char *audio_group = "A1";
1274  char audio_codec_str[128] = "\0";
1275  int is_default = 1;
1276  int max_audio_bitrate = 0;
1277 
1278  for (i = 0; i < s->nb_streams; i++) {
1279  char playlist_file[64];
1280  AVStream *st = s->streams[i];
1281  OutputStream *os = &c->streams[i];
1283  continue;
1284  if (os->segment_type != SEGMENT_TYPE_MP4)
1285  continue;
1286  get_hls_playlist_name(playlist_file, sizeof(playlist_file), NULL, i);
1287  ff_hls_write_audio_rendition(c->m3u8_out, (char *)audio_group,
1288  playlist_file, NULL, i, is_default);
1289  max_audio_bitrate = FFMAX(st->codecpar->bit_rate +
1290  os->muxer_overhead, max_audio_bitrate);
1291  if (!av_strnstr(audio_codec_str, os->codec_str, sizeof(audio_codec_str))) {
1292  if (strlen(audio_codec_str))
1293  av_strlcat(audio_codec_str, ",", sizeof(audio_codec_str));
1294  av_strlcat(audio_codec_str, os->codec_str, sizeof(audio_codec_str));
1295  }
1296  is_default = 0;
1297  }
1298 
1299  for (i = 0; i < s->nb_streams; i++) {
1300  char playlist_file[64];
1301  char codec_str[128];
1302  AVStream *st = s->streams[i];
1303  OutputStream *os = &c->streams[i];
1304  char *agroup = NULL;
1305  int stream_bitrate = os->muxer_overhead;
1306  if (os->bit_rate > 0)
1307  stream_bitrate += os->bit_rate;
1308  else if (final)
1309  stream_bitrate += os->pos * 8 * AV_TIME_BASE / c->total_duration;
1310  else if (os->first_segment_bit_rate > 0)
1311  stream_bitrate += os->first_segment_bit_rate;
1313  continue;
1314  if (os->segment_type != SEGMENT_TYPE_MP4)
1315  continue;
1316  av_strlcpy(codec_str, os->codec_str, sizeof(codec_str));
1317  if (max_audio_bitrate) {
1318  agroup = (char *)audio_group;
1319  stream_bitrate += max_audio_bitrate;
1320  av_strlcat(codec_str, ",", sizeof(codec_str));
1321  av_strlcat(codec_str, audio_codec_str, sizeof(codec_str));
1322  }
1323  get_hls_playlist_name(playlist_file, sizeof(playlist_file), NULL, i);
1324  ff_hls_write_stream_info(st, c->m3u8_out, stream_bitrate,
1325  playlist_file, agroup,
1326  codec_str, NULL, NULL);
1327  }
1328 
1329  } else {
1330  // treat audio streams as separate renditions
1331 
1332  for (i = 0; i < s->nb_streams; i++) {
1333  char playlist_file[64];
1334  char codec_str[128];
1335  AVStream *st = s->streams[i];
1336  OutputStream *os = &c->streams[i];
1337  int stream_bitrate = os->muxer_overhead;
1338  if (os->bit_rate > 0)
1339  stream_bitrate += os->bit_rate;
1340  else if (final)
1341  stream_bitrate += os->pos * 8 * AV_TIME_BASE / c->total_duration;
1342  else if (os->first_segment_bit_rate > 0)
1343  stream_bitrate += os->first_segment_bit_rate;
1345  continue;
1346  if (os->segment_type != SEGMENT_TYPE_MP4)
1347  continue;
1348  av_strlcpy(codec_str, os->codec_str, sizeof(codec_str));
1349  get_hls_playlist_name(playlist_file, sizeof(playlist_file), NULL, i);
1350  ff_hls_write_stream_info(st, c->m3u8_out, stream_bitrate,
1351  playlist_file, NULL,
1352  codec_str, NULL, NULL);
1353  }
1354  }
1355 
1356  dashenc_io_close(s, &c->m3u8_out, temp_filename);
1357  if (use_rename)
1358  if ((ret = ff_rename(temp_filename, filename_hls, s)) < 0)
1359  return ret;
1360  c->master_playlist_created = 1;
1361  }
1362 
1363  return 0;
1364 }
1365 
1366 static int dict_copy_entry(AVDictionary **dst, const AVDictionary *src, const char *key)
1367 {
1368  AVDictionaryEntry *entry = av_dict_get(src, key, NULL, 0);
1369  if (entry)
1371  return 0;
1372 }
1373 
1375 {
1376  DASHContext *c = s->priv_data;
1377  int ret = 0, i;
1378  char *ptr;
1379  char basename[1024];
1380 
1381  c->nr_of_streams_to_flush = 0;
1382  if (c->single_file_name)
1383  c->single_file = 1;
1384  if (c->single_file)
1385  c->use_template = 0;
1386 
1387  if (!c->profile) {
1388  av_log(s, AV_LOG_ERROR, "At least one profile must be enabled.\n");
1389  return AVERROR(EINVAL);
1390  }
1391  if (c->lhls && s->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
1393  "LHLS is experimental, Please set -strict experimental in order to enable it.\n");
1394  return AVERROR_EXPERIMENTAL;
1395  }
1396 
1397  if (c->lhls && !c->streaming) {
1398  av_log(s, AV_LOG_WARNING, "LHLS option will be ignored as streaming is not enabled\n");
1399  c->lhls = 0;
1400  }
1401 
1402  if (c->lhls && !c->hls_playlist) {
1403  av_log(s, AV_LOG_WARNING, "LHLS option will be ignored as hls_playlist is not enabled\n");
1404  c->lhls = 0;
1405  }
1406 
1407  if (c->ldash && !c->streaming) {
1408  av_log(s, AV_LOG_WARNING, "LDash option will be ignored as streaming is not enabled\n");
1409  c->ldash = 0;
1410  }
1411 
1412  if (c->target_latency && !c->streaming) {
1413  av_log(s, AV_LOG_WARNING, "Target latency option will be ignored as streaming is not enabled\n");
1414  c->target_latency = 0;
1415  }
1416 
1417  if (c->global_sidx && !c->single_file) {
1418  av_log(s, AV_LOG_WARNING, "Global SIDX option will be ignored as single_file is not enabled\n");
1419  c->global_sidx = 0;
1420  }
1421 
1422  if (c->global_sidx && c->streaming) {
1423  av_log(s, AV_LOG_WARNING, "Global SIDX option will be ignored as streaming is enabled\n");
1424  c->global_sidx = 0;
1425  }
1426  if (c->frag_type == FRAG_TYPE_NONE && c->streaming) {
1427  av_log(s, AV_LOG_VERBOSE, "Changing frag_type from none to every_frame as streaming is enabled\n");
1428  c->frag_type = FRAG_TYPE_EVERY_FRAME;
1429  }
1430 
1431  if (c->write_prft < 0) {
1432  c->write_prft = c->ldash;
1433  if (c->ldash)
1434  av_log(s, AV_LOG_VERBOSE, "Enabling Producer Reference Time element for Low Latency mode\n");
1435  }
1436 
1437  if (c->write_prft && !c->utc_timing_url) {
1438  av_log(s, AV_LOG_WARNING, "Producer Reference Time element option will be ignored as utc_timing_url is not set\n");
1439  c->write_prft = 0;
1440  }
1441 
1442  if (c->write_prft && !c->streaming) {
1443  av_log(s, AV_LOG_WARNING, "Producer Reference Time element option will be ignored as streaming is not enabled\n");
1444  c->write_prft = 0;
1445  }
1446 
1447  if (c->ldash && !c->write_prft) {
1448  av_log(s, AV_LOG_WARNING, "Low Latency mode enabled without Producer Reference Time element option! Resulting manifest may not be complaint\n");
1449  }
1450 
1451  if (c->target_latency && !c->write_prft) {
1452  av_log(s, AV_LOG_WARNING, "Target latency option will be ignored as Producer Reference Time element will not be written\n");
1453  c->target_latency = 0;
1454  }
1455 
1456  if (av_cmp_q(c->max_playback_rate, c->min_playback_rate) < 0) {
1457  av_log(s, AV_LOG_WARNING, "Minimum playback rate value is higer than the Maximum. Both will be ignored\n");
1458  c->min_playback_rate = c->max_playback_rate = (AVRational) {1, 1};
1459  }
1460 
1461  av_strlcpy(c->dirname, s->url, sizeof(c->dirname));
1462  ptr = strrchr(c->dirname, '/');
1463  if (ptr) {
1464  av_strlcpy(basename, &ptr[1], sizeof(basename));
1465  ptr[1] = '\0';
1466  } else {
1467  c->dirname[0] = '\0';
1468  av_strlcpy(basename, s->url, sizeof(basename));
1469  }
1470 
1471  ptr = strrchr(basename, '.');
1472  if (ptr)
1473  *ptr = '\0';
1474 
1475  c->streams = av_mallocz(sizeof(*c->streams) * s->nb_streams);
1476  if (!c->streams)
1477  return AVERROR(ENOMEM);
1478 
1479  if ((ret = parse_adaptation_sets(s)) < 0)
1480  return ret;
1481 
1482  if ((ret = init_segment_types(s)) < 0)
1483  return ret;
1484 
1485  for (i = 0; i < s->nb_streams; i++) {
1486  OutputStream *os = &c->streams[i];
1487  AdaptationSet *as = &c->as[os->as_idx - 1];
1489  AVStream *st;
1490  AVDictionary *opts = NULL;
1491  char filename[1024];
1492 
1493  os->bit_rate = s->streams[i]->codecpar->bit_rate;
1494  if (!os->bit_rate) {
1495  int level = s->strict_std_compliance >= FF_COMPLIANCE_STRICT ?
1497  av_log(s, level, "No bit rate set for stream %d\n", i);
1498  if (s->strict_std_compliance >= FF_COMPLIANCE_STRICT)
1499  return AVERROR(EINVAL);
1500  }
1501 
1502  // copy AdaptationSet language and role from stream metadata
1503  dict_copy_entry(&as->metadata, s->streams[i]->metadata, "language");
1504  dict_copy_entry(&as->metadata, s->streams[i]->metadata, "role");
1505 
1506  if (c->init_seg_name) {
1507  os->init_seg_name = av_strireplace(c->init_seg_name, "$ext$", os->extension_name);
1508  if (!os->init_seg_name)
1509  return AVERROR(ENOMEM);
1510  }
1511  if (c->media_seg_name) {
1512  os->media_seg_name = av_strireplace(c->media_seg_name, "$ext$", os->extension_name);
1513  if (!os->media_seg_name)
1514  return AVERROR(ENOMEM);
1515  }
1516  if (c->single_file_name) {
1517  os->single_file_name = av_strireplace(c->single_file_name, "$ext$", os->extension_name);
1518  if (!os->single_file_name)
1519  return AVERROR(ENOMEM);
1520  }
1521 
1522  if (os->segment_type == SEGMENT_TYPE_WEBM) {
1523  if ((!c->single_file && !av_match_ext(os->init_seg_name, os->format_name)) ||
1524  (!c->single_file && !av_match_ext(os->media_seg_name, os->format_name)) ||
1525  ( c->single_file && !av_match_ext(os->single_file_name, os->format_name))) {
1527  "One or many segment file names doesn't end with .webm. "
1528  "Override -init_seg_name and/or -media_seg_name and/or "
1529  "-single_file_name to end with the extension .webm\n");
1530  }
1531  if (c->streaming) {
1532  // Streaming not supported as matroskaenc buffers internally before writing the output
1533  av_log(s, AV_LOG_WARNING, "One or more streams in WebM output format. Streaming option will be ignored\n");
1534  c->streaming = 0;
1535  }
1536  }
1537 
1538  os->ctx = ctx = avformat_alloc_context();
1539  if (!ctx)
1540  return AVERROR(ENOMEM);
1541 
1543  if (!ctx->oformat)
1544  return AVERROR_MUXER_NOT_FOUND;
1545  ctx->interrupt_callback = s->interrupt_callback;
1546  ctx->opaque = s->opaque;
1547  ctx->io_close = s->io_close;
1548  ctx->io_open = s->io_open;
1549  ctx->strict_std_compliance = s->strict_std_compliance;
1550 
1551  if (!(st = avformat_new_stream(ctx, NULL)))
1552  return AVERROR(ENOMEM);
1553  avcodec_parameters_copy(st->codecpar, s->streams[i]->codecpar);
1554  st->sample_aspect_ratio = s->streams[i]->sample_aspect_ratio;
1555  st->time_base = s->streams[i]->time_base;
1556  st->avg_frame_rate = s->streams[i]->avg_frame_rate;
1557  ctx->avoid_negative_ts = s->avoid_negative_ts;
1558  ctx->flags = s->flags;
1559 
1560  os->parser = av_parser_init(st->codecpar->codec_id);
1561  if (os->parser) {
1563  if (!os->parser_avctx)
1564  return AVERROR(ENOMEM);
1566  if (ret < 0)
1567  return ret;
1568  // We only want to parse frame headers
1570  }
1571 
1572  if (c->single_file) {
1573  if (os->single_file_name)
1574  ff_dash_fill_tmpl_params(os->initfile, sizeof(os->initfile), os->single_file_name, i, 0, os->bit_rate, 0);
1575  else
1576  snprintf(os->initfile, sizeof(os->initfile), "%s-stream%d.%s", basename, i, os->format_name);
1577  } else {
1578  ff_dash_fill_tmpl_params(os->initfile, sizeof(os->initfile), os->init_seg_name, i, 0, os->bit_rate, 0);
1579  }
1580  snprintf(filename, sizeof(filename), "%s%s", c->dirname, os->initfile);
1581  set_http_options(&opts, c);
1582  if (!c->single_file) {
1583  if ((ret = avio_open_dyn_buf(&ctx->pb)) < 0)
1584  return ret;
1585  ret = s->io_open(s, &os->out, filename, AVIO_FLAG_WRITE, &opts);
1586  } else {
1587  ctx->url = av_strdup(filename);
1588  ret = avio_open2(&ctx->pb, filename, AVIO_FLAG_WRITE, NULL, &opts);
1589  }
1590  av_dict_free(&opts);
1591  if (ret < 0)
1592  return ret;
1593  os->init_start_pos = 0;
1594 
1595  av_dict_copy(&opts, c->format_options, 0);
1596  if (!as->seg_duration)
1597  as->seg_duration = c->seg_duration;
1598  if (!as->frag_duration)
1599  as->frag_duration = c->frag_duration;
1600  if (as->frag_type < 0)
1601  as->frag_type = c->frag_type;
1602  os->seg_duration = as->seg_duration;
1603  os->frag_duration = as->frag_duration;
1604  os->frag_type = as->frag_type;
1605 
1606  c->max_segment_duration = FFMAX(c->max_segment_duration, as->seg_duration);
1607 
1608  if (c->profile & MPD_PROFILE_DVB && (os->seg_duration > 15000000 || os->seg_duration < 960000)) {
1609  av_log(s, AV_LOG_ERROR, "Segment duration %"PRId64" is outside the allowed range for DVB-DASH profile\n", os->seg_duration);
1610  return AVERROR(EINVAL);
1611  }
1612 
1613  if (os->frag_type == FRAG_TYPE_DURATION && !os->frag_duration) {
1614  av_log(s, AV_LOG_WARNING, "frag_type set to duration for stream %d but no frag_duration set\n", i);
1615  os->frag_type = c->streaming ? FRAG_TYPE_EVERY_FRAME : FRAG_TYPE_NONE;
1616  }
1617  if (os->frag_type == FRAG_TYPE_DURATION && os->frag_duration > os->seg_duration) {
1618  av_log(s, AV_LOG_ERROR, "Fragment duration %"PRId64" is longer than Segment duration %"PRId64"\n", os->frag_duration, os->seg_duration);
1619  return AVERROR(EINVAL);
1620  }
1621  if (os->frag_type == FRAG_TYPE_PFRAMES && (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO || !os->parser)) {
1622  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && !os->parser)
1623  av_log(s, AV_LOG_WARNING, "frag_type set to P-Frame reordering, but no parser found for stream %d\n", i);
1624  os->frag_type = c->streaming ? FRAG_TYPE_EVERY_FRAME : FRAG_TYPE_NONE;
1625  }
1626  if (os->frag_type != FRAG_TYPE_PFRAMES && as->trick_idx < 0)
1627  // Set this now if a parser isn't used
1628  os->coding_dependency = 1;
1629 
1630  if (os->segment_type == SEGMENT_TYPE_MP4) {
1631  if (c->streaming)
1632  // skip_sidx : Reduce bitrate overhead
1633  // skip_trailer : Avoids growing memory usage with time
1634  av_dict_set(&opts, "movflags", "+dash+delay_moov+skip_sidx+skip_trailer", AV_DICT_APPEND);
1635  else {
1636  if (c->global_sidx)
1637  av_dict_set(&opts, "movflags", "+dash+delay_moov+global_sidx+skip_trailer", AV_DICT_APPEND);
1638  else
1639  av_dict_set(&opts, "movflags", "+dash+delay_moov+skip_trailer", AV_DICT_APPEND);
1640  }
1641  if (os->frag_type == FRAG_TYPE_EVERY_FRAME)
1642  av_dict_set(&opts, "movflags", "+frag_every_frame", AV_DICT_APPEND);
1643  else
1644  av_dict_set(&opts, "movflags", "+frag_custom", AV_DICT_APPEND);
1645  if (os->frag_type == FRAG_TYPE_DURATION)
1646  av_dict_set_int(&opts, "frag_duration", os->frag_duration, 0);
1647  if (c->write_prft)
1648  av_dict_set(&opts, "write_prft", "wallclock", 0);
1649  } else {
1650  av_dict_set_int(&opts, "cluster_time_limit", c->seg_duration / 1000, 0);
1651  av_dict_set_int(&opts, "cluster_size_limit", 5 * 1024 * 1024, 0); // set a large cluster size limit
1652  av_dict_set_int(&opts, "dash", 1, 0);
1653  av_dict_set_int(&opts, "dash_track_number", i + 1, 0);
1654  av_dict_set_int(&opts, "live", 1, 0);
1655  }
1657  av_dict_free(&opts);
1658  if (ret < 0)
1659  return ret;
1660  os->ctx_inited = 1;
1661  avio_flush(ctx->pb);
1662 
1663  av_log(s, AV_LOG_VERBOSE, "Representation %d init segment will be written to: %s\n", i, filename);
1664 
1665  s->streams[i]->time_base = st->time_base;
1666  // If the muxer wants to shift timestamps, request to have them shifted
1667  // already before being handed to this muxer, so we don't have mismatches
1668  // between the MPD and the actual segments.
1669  s->avoid_negative_ts = ctx->avoid_negative_ts;
1670  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1671  AVRational avg_frame_rate = s->streams[i]->avg_frame_rate;
1672  AVRational par;
1673  if (avg_frame_rate.num > 0) {
1674  if (av_cmp_q(avg_frame_rate, as->min_frame_rate) < 0)
1675  as->min_frame_rate = avg_frame_rate;
1676  if (av_cmp_q(as->max_frame_rate, avg_frame_rate) < 0)
1677  as->max_frame_rate = avg_frame_rate;
1678  } else {
1679  as->ambiguous_frame_rate = 1;
1680  }
1681 
1682  if (st->codecpar->width > as->max_width)
1683  as->max_width = st->codecpar->width;
1684  if (st->codecpar->height > as->max_height)
1685  as->max_height = st->codecpar->height;
1686 
1687  if (st->sample_aspect_ratio.num)
1688  os->sar = st->sample_aspect_ratio;
1689  else
1690  os->sar = (AVRational){1,1};
1691  av_reduce(&par.num, &par.den,
1692  st->codecpar->width * (int64_t)os->sar.num,
1693  st->codecpar->height * (int64_t)os->sar.den,
1694  1024 * 1024);
1695 
1696  if (as->par.num && av_cmp_q(par, as->par)) {
1697  av_log(s, AV_LOG_ERROR, "Conflicting stream aspect ratios values in Adaptation Set %d. Please ensure all adaptation sets have the same aspect ratio\n", os->as_idx);
1698  return AVERROR(EINVAL);
1699  }
1700  as->par = par;
1701 
1702  c->has_video = 1;
1703  }
1704 
1706  sizeof(os->codec_str));
1707  os->first_pts = AV_NOPTS_VALUE;
1708  os->max_pts = AV_NOPTS_VALUE;
1709  os->last_dts = AV_NOPTS_VALUE;
1710  os->segment_index = 1;
1711 
1712  if (s->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
1713  c->nr_of_streams_to_flush++;
1714  }
1715 
1716  if (!c->has_video && c->seg_duration <= 0) {
1717  av_log(s, AV_LOG_WARNING, "no video stream and no seg duration set\n");
1718  return AVERROR(EINVAL);
1719  }
1720  if (!c->has_video && c->frag_type == FRAG_TYPE_PFRAMES)
1721  av_log(s, AV_LOG_WARNING, "no video stream and P-frame fragmentation set\n");
1722 
1723  c->nr_of_streams_flushed = 0;
1724  c->target_latency_refid = -1;
1725 
1726  return 0;
1727 }
1728 
1730 {
1731  DASHContext *c = s->priv_data;
1732  int i, ret;
1733  for (i = 0; i < s->nb_streams; i++) {
1734  OutputStream *os = &c->streams[i];
1735  if ((ret = avformat_write_header(os->ctx, NULL)) < 0)
1736  return ret;
1737 
1738  // Flush init segment
1739  // Only for WebM segment, since for mp4 delay_moov is set and
1740  // the init segment is thus flushed after the first packets.
1741  if (os->segment_type == SEGMENT_TYPE_WEBM &&
1742  (ret = flush_init_segment(s, os)) < 0)
1743  return ret;
1744  }
1745  return ret;
1746 }
1747 
1748 static int add_segment(OutputStream *os, const char *file,
1749  int64_t time, int64_t duration,
1750  int64_t start_pos, int64_t range_length,
1751  int64_t index_length, int next_exp_index)
1752 {
1753  int err;
1754  Segment *seg;
1755  if (os->nb_segments >= os->segments_size) {
1756  os->segments_size = (os->segments_size + 1) * 2;
1757  if ((err = av_reallocp_array(&os->segments, sizeof(*os->segments),
1758  os->segments_size)) < 0) {
1759  os->segments_size = 0;
1760  os->nb_segments = 0;
1761  return err;
1762  }
1763  }
1764  seg = av_mallocz(sizeof(*seg));
1765  if (!seg)
1766  return AVERROR(ENOMEM);
1767  av_strlcpy(seg->file, file, sizeof(seg->file));
1768  seg->time = time;
1769  seg->duration = duration;
1770  if (seg->time < 0) { // If pts<0, it is expected to be cut away with an edit list
1771  seg->duration += seg->time;
1772  seg->time = 0;
1773  }
1774  seg->start_pos = start_pos;
1775  seg->range_length = range_length;
1776  seg->index_length = index_length;
1777  os->segments[os->nb_segments++] = seg;
1778  os->segment_index++;
1779  //correcting the segment index if it has fallen behind the expected value
1780  if (os->segment_index < next_exp_index) {
1781  av_log(NULL, AV_LOG_WARNING, "Correcting the segment index after file %s: current=%d corrected=%d\n",
1782  file, os->segment_index, next_exp_index);
1783  os->segment_index = next_exp_index;
1784  }
1785  return 0;
1786 }
1787 
1788 static void write_styp(AVIOContext *pb)
1789 {
1790  avio_wb32(pb, 24);
1791  ffio_wfourcc(pb, "styp");
1792  ffio_wfourcc(pb, "msdh");
1793  avio_wb32(pb, 0); /* minor */
1794  ffio_wfourcc(pb, "msdh");
1795  ffio_wfourcc(pb, "msix");
1796 }
1797 
1798 static void find_index_range(AVFormatContext *s, const char *full_path,
1799  int64_t pos, int *index_length)
1800 {
1801  uint8_t buf[8];
1802  AVIOContext *pb;
1803  int ret;
1804 
1805  ret = s->io_open(s, &pb, full_path, AVIO_FLAG_READ, NULL);
1806  if (ret < 0)
1807  return;
1808  if (avio_seek(pb, pos, SEEK_SET) != pos) {
1809  ff_format_io_close(s, &pb);
1810  return;
1811  }
1812  ret = avio_read(pb, buf, 8);
1813  ff_format_io_close(s, &pb);
1814  if (ret < 8)
1815  return;
1816  if (AV_RL32(&buf[4]) != MKTAG('s', 'i', 'd', 'x'))
1817  return;
1818  *index_length = AV_RB32(&buf[0]);
1819 }
1820 
1822  AVPacket *pkt, AVRational *frame_rate)
1823 {
1824  AVCodecParameters *par = os->ctx->streams[0]->codecpar;
1825  uint8_t *extradata;
1826  size_t extradata_size;
1827  int ret;
1828 
1829  if (par->extradata_size)
1830  return 0;
1831 
1832  extradata = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA, &extradata_size);
1833  if (!extradata_size)
1834  return 0;
1835 
1836  ret = ff_alloc_extradata(par, extradata_size);
1837  if (ret < 0)
1838  return ret;
1839 
1840  memcpy(par->extradata, extradata, extradata_size);
1841 
1842  set_codec_str(s, par, frame_rate, os->codec_str, sizeof(os->codec_str));
1843 
1844  return 0;
1845 }
1846 
1847 static void dashenc_delete_file(AVFormatContext *s, char *filename) {
1848  DASHContext *c = s->priv_data;
1849  int http_base_proto = ff_is_http_proto(filename);
1850 
1851  if (http_base_proto) {
1852  AVIOContext *out = NULL;
1853  AVDictionary *http_opts = NULL;
1854 
1855  set_http_options(&http_opts, c);
1856  av_dict_set(&http_opts, "method", "DELETE", 0);
1857 
1858  if (dashenc_io_open(s, &out, filename, &http_opts) < 0) {
1859  av_log(s, AV_LOG_ERROR, "failed to delete %s\n", filename);
1860  }
1861 
1862  av_dict_free(&http_opts);
1864  } else {
1865  int res = ffurl_delete(filename);
1866  if (res < 0) {
1867  char errbuf[AV_ERROR_MAX_STRING_SIZE];
1868  av_strerror(res, errbuf, sizeof(errbuf));
1869  av_log(s, (res == AVERROR(ENOENT) ? AV_LOG_WARNING : AV_LOG_ERROR), "failed to delete %s: %s\n", filename, errbuf);
1870  }
1871  }
1872 }
1873 
1874 static int dashenc_delete_segment_file(AVFormatContext *s, const char* file)
1875 {
1876  DASHContext *c = s->priv_data;
1877  AVBPrint buf;
1878 
1880 
1881  av_bprintf(&buf, "%s%s", c->dirname, file);
1882  if (!av_bprint_is_complete(&buf)) {
1883  av_bprint_finalize(&buf, NULL);
1884  av_log(s, AV_LOG_WARNING, "Out of memory for filename\n");
1885  return AVERROR(ENOMEM);
1886  }
1887 
1888  dashenc_delete_file(s, buf.str);
1889 
1890  av_bprint_finalize(&buf, NULL);
1891  return 0;
1892 }
1893 
1894 static inline void dashenc_delete_media_segments(AVFormatContext *s, OutputStream *os, int remove_count)
1895 {
1896  for (int i = 0; i < remove_count; ++i) {
1898 
1899  // Delete the segment regardless of whether the file was successfully deleted
1900  av_free(os->segments[i]);
1901  }
1902 
1903  os->nb_segments -= remove_count;
1904  memmove(os->segments, os->segments + remove_count, os->nb_segments * sizeof(*os->segments));
1905 }
1906 
1907 static int dash_flush(AVFormatContext *s, int final, int stream)
1908 {
1909  DASHContext *c = s->priv_data;
1910  int i, ret = 0;
1911 
1912  const char *proto = avio_find_protocol_name(s->url);
1913  int use_rename = proto && !strcmp(proto, "file");
1914 
1915  int cur_flush_segment_index = 0, next_exp_index = -1;
1916  if (stream >= 0) {
1917  cur_flush_segment_index = c->streams[stream].segment_index;
1918 
1919  //finding the next segment's expected index, based on the current pts value
1920  if (c->use_template && !c->use_timeline && c->index_correction &&
1921  c->streams[stream].last_pts != AV_NOPTS_VALUE &&
1922  c->streams[stream].first_pts != AV_NOPTS_VALUE) {
1923  int64_t pts_diff = av_rescale_q(c->streams[stream].last_pts -
1924  c->streams[stream].first_pts,
1925  s->streams[stream]->time_base,
1926  AV_TIME_BASE_Q);
1927  next_exp_index = (pts_diff / c->streams[stream].seg_duration) + 1;
1928  }
1929  }
1930 
1931  for (i = 0; i < s->nb_streams; i++) {
1932  OutputStream *os = &c->streams[i];
1933  AVStream *st = s->streams[i];
1934  int range_length, index_length = 0;
1935  int64_t duration;
1936 
1937  if (!os->packets_written)
1938  continue;
1939 
1940  // Flush the single stream that got a keyframe right now.
1941  // Flush all audio streams as well, in sync with video keyframes,
1942  // but not the other video streams.
1943  if (stream >= 0 && i != stream) {
1944  if (s->streams[stream]->codecpar->codec_type != AVMEDIA_TYPE_VIDEO &&
1945  s->streams[i]->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
1946  continue;
1947  if (s->streams[i]->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
1948  continue;
1949  // Make sure we don't flush audio streams multiple times, when
1950  // all video streams are flushed one at a time.
1951  if (c->has_video && os->segment_index > cur_flush_segment_index)
1952  continue;
1953  }
1954 
1955  if (c->single_file)
1956  snprintf(os->full_path, sizeof(os->full_path), "%s%s", c->dirname, os->initfile);
1957 
1958  ret = flush_dynbuf(c, os, &range_length);
1959  if (ret < 0)
1960  break;
1961  os->packets_written = 0;
1962 
1963  if (c->single_file) {
1964  find_index_range(s, os->full_path, os->pos, &index_length);
1965  } else {
1966  dashenc_io_close(s, &os->out, os->temp_path);
1967 
1968  if (use_rename) {
1969  ret = ff_rename(os->temp_path, os->full_path, os->ctx);
1970  if (ret < 0)
1971  break;
1972  }
1973  }
1974 
1977 
1978  if (!os->muxer_overhead && os->max_pts > os->start_pts)
1979  os->muxer_overhead = ((int64_t) (range_length - os->total_pkt_size) *
1980  8 * AV_TIME_BASE) / duration;
1981  os->total_pkt_size = 0;
1982  os->total_pkt_duration = 0;
1983 
1984  if (!os->bit_rate && !os->first_segment_bit_rate) {
1985  os->first_segment_bit_rate = (int64_t) range_length * 8 * AV_TIME_BASE / duration;
1986  }
1987  add_segment(os, os->filename, os->start_pts, os->max_pts - os->start_pts, os->pos, range_length, index_length, next_exp_index);
1988  av_log(s, AV_LOG_VERBOSE, "Representation %d media segment %d written to: %s\n", i, os->segment_index, os->full_path);
1989 
1990  os->pos += range_length;
1991  }
1992 
1993  if (c->window_size) {
1994  for (i = 0; i < s->nb_streams; i++) {
1995  OutputStream *os = &c->streams[i];
1996  int remove_count = os->nb_segments - c->window_size - c->extra_window_size;
1997  if (remove_count > 0)
1998  dashenc_delete_media_segments(s, os, remove_count);
1999  }
2000  }
2001 
2002  if (final) {
2003  for (i = 0; i < s->nb_streams; i++) {
2004  OutputStream *os = &c->streams[i];
2005  if (os->ctx && os->ctx_inited) {
2006  int64_t file_size = avio_tell(os->ctx->pb);
2007  av_write_trailer(os->ctx);
2008  if (c->global_sidx) {
2009  int j, start_index, start_number;
2010  int64_t sidx_size = avio_tell(os->ctx->pb) - file_size;
2011  get_start_index_number(os, c, &start_index, &start_number);
2012  if (start_index >= os->nb_segments ||
2014  continue;
2015  os->init_range_length += sidx_size;
2016  for (j = start_index; j < os->nb_segments; j++) {
2017  Segment *seg = os->segments[j];
2018  seg->start_pos += sidx_size;
2019  }
2020  }
2021 
2022  }
2023  }
2024  }
2025  if (ret >= 0) {
2026  if (c->has_video && !final) {
2027  c->nr_of_streams_flushed++;
2028  if (c->nr_of_streams_flushed != c->nr_of_streams_to_flush)
2029  return ret;
2030 
2031  c->nr_of_streams_flushed = 0;
2032  }
2033  // In streaming mode the manifest is written at the beginning
2034  // of the segment instead
2035  if (!c->streaming || final)
2036  ret = write_manifest(s, final);
2037  }
2038  return ret;
2039 }
2040 
2042 {
2043  OutputStream *os = &c->streams[pkt->stream_index];
2045  size_t side_data_size;
2046 
2048  if (!prft || side_data_size != sizeof(AVProducerReferenceTime) || (prft->flags && prft->flags != 24)) {
2049  // No encoder generated or user provided capture time AVProducerReferenceTime side data. Instead
2050  // of letting the mov muxer generate one, do it here so we can also use it for the manifest.
2052  sizeof(AVProducerReferenceTime));
2053  if (!prft)
2054  return AVERROR(ENOMEM);
2055  prft->wallclock = av_gettime();
2056  prft->flags = 24;
2057  }
2058  if (os->first_pts == AV_NOPTS_VALUE) {
2059  os->producer_reference_time = *prft;
2060  if (c->target_latency_refid < 0)
2061  c->target_latency_refid = pkt->stream_index;
2062  }
2063 
2064  return 0;
2065 }
2066 
2068 {
2069  DASHContext *c = s->priv_data;
2070  AVStream *st = s->streams[pkt->stream_index];
2071  OutputStream *os = &c->streams[pkt->stream_index];
2072  AdaptationSet *as = &c->as[os->as_idx - 1];
2073  int64_t seg_end_duration, elapsed_duration;
2074  int ret;
2075 
2077  if (ret < 0)
2078  return ret;
2079 
2080  // Fill in a heuristic guess of the packet duration, if none is available.
2081  // The mp4 muxer will do something similar (for the last packet in a fragment)
2082  // if nothing is set (setting it for the other packets doesn't hurt).
2083  // By setting a nonzero duration here, we can be sure that the mp4 muxer won't
2084  // invoke its heuristic (this doesn't have to be identical to that algorithm),
2085  // so that we know the exact timestamps of fragments.
2086  if (!pkt->duration && os->last_dts != AV_NOPTS_VALUE)
2087  pkt->duration = pkt->dts - os->last_dts;
2088  os->last_dts = pkt->dts;
2089 
2090  // If forcing the stream to start at 0, the mp4 muxer will set the start
2091  // timestamps to 0. Do the same here, to avoid mismatches in duration/timestamps.
2092  if (os->first_pts == AV_NOPTS_VALUE &&
2093  s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_MAKE_ZERO) {
2094  pkt->pts -= pkt->dts;
2095  pkt->dts = 0;
2096  }
2097 
2098  if (c->write_prft) {
2099  ret = dash_parse_prft(c, pkt);
2100  if (ret < 0)
2101  return ret;
2102  }
2103 
2104  if (os->first_pts == AV_NOPTS_VALUE) {
2105  os->first_pts = pkt->pts;
2106  }
2107  os->last_pts = pkt->pts;
2108 
2109  if (!c->availability_start_time[0]) {
2110  int64_t start_time_us = av_gettime();
2111  c->start_time_s = start_time_us / 1000000;
2112  format_date(c->availability_start_time,
2113  sizeof(c->availability_start_time), start_time_us);
2114  }
2115 
2116  if (!os->packets_written)
2117  os->availability_time_offset = 0;
2118 
2119  if (!os->availability_time_offset &&
2120  ((os->frag_type == FRAG_TYPE_DURATION && os->seg_duration != os->frag_duration) ||
2121  (os->frag_type == FRAG_TYPE_EVERY_FRAME && pkt->duration))) {
2122  AdaptationSet *as = &c->as[os->as_idx - 1];
2123  int64_t frame_duration = 0;
2124 
2125  switch (os->frag_type) {
2126  case FRAG_TYPE_DURATION:
2127  frame_duration = os->frag_duration;
2128  break;
2129  case FRAG_TYPE_EVERY_FRAME:
2130  frame_duration = av_rescale_q(pkt->duration, st->time_base, AV_TIME_BASE_Q);
2131  break;
2132  }
2133 
2134  os->availability_time_offset = ((double) os->seg_duration -
2135  frame_duration) / AV_TIME_BASE;
2136  as->max_frag_duration = FFMAX(frame_duration, as->max_frag_duration);
2137  }
2138 
2139  if (c->use_template && !c->use_timeline) {
2140  elapsed_duration = pkt->pts - os->first_pts;
2141  seg_end_duration = (int64_t) os->segment_index * os->seg_duration;
2142  } else {
2143  elapsed_duration = pkt->pts - os->start_pts;
2144  seg_end_duration = os->seg_duration;
2145  }
2146 
2147  if (os->parser &&
2148  (os->frag_type == FRAG_TYPE_PFRAMES ||
2149  as->trick_idx >= 0)) {
2150  // Parse the packets only in scenarios where it's needed
2151  uint8_t *data;
2152  int size;
2154  &data, &size, pkt->data, pkt->size,
2155  pkt->pts, pkt->dts, pkt->pos);
2156 
2158  }
2159 
2160  if (pkt->flags & AV_PKT_FLAG_KEY && os->packets_written &&
2161  av_compare_ts(elapsed_duration, st->time_base,
2162  seg_end_duration, AV_TIME_BASE_Q) >= 0) {
2163  if (!c->has_video || st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2164  c->last_duration = av_rescale_q(pkt->pts - os->start_pts,
2165  st->time_base,
2166  AV_TIME_BASE_Q);
2167  c->total_duration = av_rescale_q(pkt->pts - os->first_pts,
2168  st->time_base,
2169  AV_TIME_BASE_Q);
2170 
2171  if ((!c->use_timeline || !c->use_template) && os->last_duration) {
2172  if (c->last_duration < os->last_duration*9/10 ||
2173  c->last_duration > os->last_duration*11/10) {
2175  "Segment durations differ too much, enable use_timeline "
2176  "and use_template, or keep a stricter keyframe interval\n");
2177  }
2178  }
2179  }
2180 
2181  if (c->write_prft && os->producer_reference_time.wallclock && !os->producer_reference_time_str[0])
2183  sizeof(os->producer_reference_time_str),
2185 
2186  if ((ret = dash_flush(s, 0, pkt->stream_index)) < 0)
2187  return ret;
2188  }
2189 
2190  if (!os->packets_written) {
2191  // If we wrote a previous segment, adjust the start time of the segment
2192  // to the end of the previous one (which is the same as the mp4 muxer
2193  // does). This avoids gaps in the timeline.
2194  if (os->max_pts != AV_NOPTS_VALUE)
2195  os->start_pts = os->max_pts;
2196  else
2197  os->start_pts = pkt->pts;
2198  }
2199  if (os->max_pts == AV_NOPTS_VALUE)
2200  os->max_pts = pkt->pts + pkt->duration;
2201  else
2202  os->max_pts = FFMAX(os->max_pts, pkt->pts + pkt->duration);
2203 
2204  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2205  os->frag_type == FRAG_TYPE_PFRAMES &&
2206  os->packets_written) {
2207  av_assert0(os->parser);
2208  if ((os->parser->pict_type == AV_PICTURE_TYPE_P &&
2209  st->codecpar->video_delay &&
2210  !(os->last_flags & AV_PKT_FLAG_KEY)) ||
2211  pkt->flags & AV_PKT_FLAG_KEY) {
2212  ret = av_write_frame(os->ctx, NULL);
2213  if (ret < 0)
2214  return ret;
2215 
2216  if (!os->availability_time_offset) {
2217  int64_t frag_duration = av_rescale_q(os->total_pkt_duration, st->time_base,
2218  AV_TIME_BASE_Q);
2219  os->availability_time_offset = ((double) os->seg_duration -
2220  frag_duration) / AV_TIME_BASE;
2221  as->max_frag_duration = FFMAX(frag_duration, as->max_frag_duration);
2222  }
2223  }
2224  }
2225 
2226  if (pkt->flags & AV_PKT_FLAG_KEY && (os->packets_written || os->nb_segments) && !os->gop_size && as->trick_idx < 0) {
2228  c->max_gop_size = FFMAX(c->max_gop_size, os->gop_size);
2229  }
2230 
2231  if ((ret = ff_write_chained(os->ctx, 0, pkt, s, 0)) < 0)
2232  return ret;
2233 
2234  os->packets_written++;
2235  os->total_pkt_size += pkt->size;
2237  os->last_flags = pkt->flags;
2238 
2239  if (!os->init_range_length)
2240  flush_init_segment(s, os);
2241 
2242  //open the output context when the first frame of a segment is ready
2243  if (!c->single_file && os->packets_written == 1) {
2244  AVDictionary *opts = NULL;
2245  const char *proto = avio_find_protocol_name(s->url);
2246  int use_rename = proto && !strcmp(proto, "file");
2247  if (os->segment_type == SEGMENT_TYPE_MP4)
2248  write_styp(os->ctx->pb);
2249  os->filename[0] = os->full_path[0] = os->temp_path[0] = '\0';
2250  ff_dash_fill_tmpl_params(os->filename, sizeof(os->filename),
2252  os->segment_index, os->bit_rate, os->start_pts);
2253  snprintf(os->full_path, sizeof(os->full_path), "%s%s", c->dirname,
2254  os->filename);
2255  snprintf(os->temp_path, sizeof(os->temp_path),
2256  use_rename ? "%s.tmp" : "%s", os->full_path);
2257  set_http_options(&opts, c);
2258  ret = dashenc_io_open(s, &os->out, os->temp_path, &opts);
2259  av_dict_free(&opts);
2260  if (ret < 0) {
2261  return handle_io_open_error(s, ret, os->temp_path);
2262  }
2263 
2264  // in streaming mode, the segments are available for playing
2265  // before fully written but the manifest is needed so that
2266  // clients and discover the segment filenames.
2267  if (c->streaming) {
2268  write_manifest(s, 0);
2269  }
2270 
2271  if (c->lhls) {
2272  char *prefetch_url = use_rename ? NULL : os->filename;
2273  write_hls_media_playlist(os, s, pkt->stream_index, 0, prefetch_url);
2274  }
2275  }
2276 
2277  //write out the data immediately in streaming mode
2278  if (c->streaming && os->segment_type == SEGMENT_TYPE_MP4) {
2279  int len = 0;
2280  uint8_t *buf = NULL;
2281  avio_flush(os->ctx->pb);
2282  len = avio_get_dyn_buf (os->ctx->pb, &buf);
2283  if (os->out) {
2284  avio_write(os->out, buf + os->written_len, len - os->written_len);
2285  avio_flush(os->out);
2286  }
2287  os->written_len = len;
2288  }
2289 
2290  return ret;
2291 }
2292 
2294 {
2295  DASHContext *c = s->priv_data;
2296  int i;
2297 
2298  if (s->nb_streams > 0) {
2299  OutputStream *os = &c->streams[0];
2300  // If no segments have been written so far, try to do a crude
2301  // guess of the segment duration
2302  if (!c->last_duration)
2303  c->last_duration = av_rescale_q(os->max_pts - os->start_pts,
2304  s->streams[0]->time_base,
2305  AV_TIME_BASE_Q);
2306  c->total_duration = av_rescale_q(os->max_pts - os->first_pts,
2307  s->streams[0]->time_base,
2308  AV_TIME_BASE_Q);
2309  }
2310  dash_flush(s, 1, -1);
2311 
2312  if (c->remove_at_exit) {
2313  for (i = 0; i < s->nb_streams; ++i) {
2314  OutputStream *os = &c->streams[i];
2317  if (c->hls_playlist && os->segment_type == SEGMENT_TYPE_MP4) {
2318  char filename[1024];
2319  get_hls_playlist_name(filename, sizeof(filename), c->dirname, i);
2320  dashenc_delete_file(s, filename);
2321  }
2322  }
2323  dashenc_delete_file(s, s->url);
2324 
2325  if (c->hls_playlist && c->master_playlist_created) {
2326  char filename[1024];
2327  snprintf(filename, sizeof(filename), "%s%s", c->dirname, c->hls_master_name);
2328  dashenc_delete_file(s, filename);
2329  }
2330  }
2331 
2332  return 0;
2333 }
2334 
2335 static int dash_check_bitstream(struct AVFormatContext *s, const AVPacket *avpkt)
2336 {
2337  DASHContext *c = s->priv_data;
2338  OutputStream *os = &c->streams[avpkt->stream_index];
2339  AVFormatContext *oc = os->ctx;
2340  if (oc->oformat->check_bitstream) {
2341  int ret;
2342  AVPacket pkt = *avpkt;
2343  pkt.stream_index = 0;
2344  ret = oc->oformat->check_bitstream(oc, &pkt);
2345  if (ret == 1) {
2346  AVStream *st = s->streams[avpkt->stream_index];
2347  AVStream *ost = oc->streams[0];
2348  st->internal->bsfc = ost->internal->bsfc;
2349  ost->internal->bsfc = NULL;
2350  }
2351  return ret;
2352  }
2353  return 1;
2354 }
2355 
2356 #define OFFSET(x) offsetof(DASHContext, x)
2357 #define E AV_OPT_FLAG_ENCODING_PARAM
2358 static const AVOption options[] = {
2359  { "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 },
2360  { "window_size", "number of segments kept in the manifest", OFFSET(window_size), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, E },
2361  { "extra_window_size", "number of segments kept outside of the manifest before removing from disk", OFFSET(extra_window_size), AV_OPT_TYPE_INT, { .i64 = 5 }, 0, INT_MAX, E },
2362  { "seg_duration", "segment duration (in seconds, fractional value can be set)", OFFSET(seg_duration), AV_OPT_TYPE_DURATION, { .i64 = 5000000 }, 0, INT_MAX, E },
2363  { "frag_duration", "fragment duration (in seconds, fractional value can be set)", OFFSET(frag_duration), AV_OPT_TYPE_DURATION, { .i64 = 0 }, 0, INT_MAX, E },
2364  { "frag_type", "set type of interval for fragments", OFFSET(frag_type), AV_OPT_TYPE_INT, {.i64 = FRAG_TYPE_NONE }, 0, FRAG_TYPE_NB - 1, E, "frag_type"},
2365  { "none", "one fragment per segment", 0, AV_OPT_TYPE_CONST, {.i64 = FRAG_TYPE_NONE }, 0, UINT_MAX, E, "frag_type"},
2366  { "every_frame", "fragment at every frame", 0, AV_OPT_TYPE_CONST, {.i64 = FRAG_TYPE_EVERY_FRAME }, 0, UINT_MAX, E, "frag_type"},
2367  { "duration", "fragment at specific time intervals", 0, AV_OPT_TYPE_CONST, {.i64 = FRAG_TYPE_DURATION }, 0, UINT_MAX, E, "frag_type"},
2368  { "pframes", "fragment at keyframes and following P-Frame reordering (Video only, experimental)", 0, AV_OPT_TYPE_CONST, {.i64 = FRAG_TYPE_PFRAMES }, 0, UINT_MAX, E, "frag_type"},
2369  { "remove_at_exit", "remove all segments when finished", OFFSET(remove_at_exit), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
2370  { "use_template", "Use SegmentTemplate instead of SegmentList", OFFSET(use_template), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, E },
2371  { "use_timeline", "Use SegmentTimeline in SegmentTemplate", OFFSET(use_timeline), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, E },
2372  { "single_file", "Store all segments in one file, accessed using byte ranges", OFFSET(single_file), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
2373  { "single_file_name", "DASH-templated name to be used for baseURL. Implies storing all segments in one file, accessed using byte ranges", OFFSET(single_file_name), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, E },
2374  { "init_seg_name", "DASH-templated name to used for the initialization segment", OFFSET(init_seg_name), AV_OPT_TYPE_STRING, {.str = "init-stream$RepresentationID$.$ext$"}, 0, 0, E },
2375  { "media_seg_name", "DASH-templated name to used for the media segments", OFFSET(media_seg_name), AV_OPT_TYPE_STRING, {.str = "chunk-stream$RepresentationID$-$Number%05d$.$ext$"}, 0, 0, E },
2376  { "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, E },
2377  { "method", "set the HTTP method", OFFSET(method), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E },
2378  { "http_user_agent", "override User-Agent field in HTTP header", OFFSET(user_agent), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
2379  { "http_persistent", "Use persistent HTTP connections", OFFSET(http_persistent), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
2380  { "hls_playlist", "Generate HLS playlist files(master.m3u8, media_%d.m3u8)", OFFSET(hls_playlist), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
2381  { "hls_master_name", "HLS master playlist name", OFFSET(hls_master_name), AV_OPT_TYPE_STRING, {.str = "master.m3u8"}, 0, 0, E },
2382  { "streaming", "Enable/Disable streaming mode of output. Each frame will be moof fragment", OFFSET(streaming), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
2383  { "timeout", "set timeout for socket I/O operations", OFFSET(timeout), AV_OPT_TYPE_DURATION, { .i64 = -1 }, -1, INT_MAX, .flags = E },
2384  { "index_correction", "Enable/Disable segment index correction logic", OFFSET(index_correction), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
2385  { "format_options","set list of options for the container format (mp4/webm) used for dash", OFFSET(format_options), AV_OPT_TYPE_DICT, {.str = NULL}, 0, 0, E},
2386  { "global_sidx", "Write global SIDX atom. Applicable only for single file, mp4 output, non-streaming mode", OFFSET(global_sidx), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
2387  { "dash_segment_type", "set dash segment files type", OFFSET(segment_type_option), AV_OPT_TYPE_INT, {.i64 = SEGMENT_TYPE_AUTO }, 0, SEGMENT_TYPE_NB - 1, E, "segment_type"},
2388  { "auto", "select segment file format based on codec", 0, AV_OPT_TYPE_CONST, {.i64 = SEGMENT_TYPE_AUTO }, 0, UINT_MAX, E, "segment_type"},
2389  { "mp4", "make segment file in ISOBMFF format", 0, AV_OPT_TYPE_CONST, {.i64 = SEGMENT_TYPE_MP4 }, 0, UINT_MAX, E, "segment_type"},
2390  { "webm", "make segment file in WebM format", 0, AV_OPT_TYPE_CONST, {.i64 = SEGMENT_TYPE_WEBM }, 0, UINT_MAX, E, "segment_type"},
2391  { "ignore_io_errors", "Ignore IO errors during open and write. Useful for long-duration runs with network output", OFFSET(ignore_io_errors), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
2392  { "lhls", "Enable Low-latency HLS(Experimental). Adds #EXT-X-PREFETCH tag with current segment's URI", OFFSET(lhls), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
2393  { "ldash", "Enable Low-latency dash. Constrains the value of a few elements", OFFSET(ldash), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
2394  { "master_m3u8_publish_rate", "Publish master playlist every after this many segment intervals", OFFSET(master_publish_rate), AV_OPT_TYPE_INT, {.i64 = 0}, 0, UINT_MAX, E},
2395  { "write_prft", "Write producer reference time element", OFFSET(write_prft), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, E},
2396  { "mpd_profile", "Set profiles. Elements and values used in the manifest may be constrained by them", OFFSET(profile), AV_OPT_TYPE_FLAGS, {.i64 = MPD_PROFILE_DASH }, 0, UINT_MAX, E, "mpd_profile"},
2397  { "dash", "MPEG-DASH ISO Base media file format live profile", 0, AV_OPT_TYPE_CONST, {.i64 = MPD_PROFILE_DASH }, 0, UINT_MAX, E, "mpd_profile"},
2398  { "dvb_dash", "DVB-DASH profile", 0, AV_OPT_TYPE_CONST, {.i64 = MPD_PROFILE_DVB }, 0, UINT_MAX, E, "mpd_profile"},
2399  { "http_opts", "HTTP protocol options", OFFSET(http_opts), AV_OPT_TYPE_DICT, { .str = NULL }, 0, 0, E },
2400  { "target_latency", "Set desired target latency for Low-latency dash", OFFSET(target_latency), AV_OPT_TYPE_DURATION, { .i64 = 0 }, 0, INT_MAX, E },
2401  { "min_playback_rate", "Set desired minimum playback rate", OFFSET(min_playback_rate), AV_OPT_TYPE_RATIONAL, { .dbl = 1.0 }, 0.5, 1.5, E },
2402  { "max_playback_rate", "Set desired maximum playback rate", OFFSET(max_playback_rate), AV_OPT_TYPE_RATIONAL, { .dbl = 1.0 }, 0.5, 1.5, E },
2403  { "update_period", "Set the mpd update interval", OFFSET(update_period), AV_OPT_TYPE_INT64, {.i64 = 0}, 0, INT64_MAX, E},
2404  { NULL },
2405 };
2406 
2407 static const AVClass dash_class = {
2408  .class_name = "dash muxer",
2409  .item_name = av_default_item_name,
2410  .option = options,
2411  .version = LIBAVUTIL_VERSION_INT,
2412 };
2413 
2415  .name = "dash",
2416  .long_name = NULL_IF_CONFIG_SMALL("DASH Muxer"),
2417  .extensions = "mpd",
2418  .priv_data_size = sizeof(DASHContext),
2419  .audio_codec = AV_CODEC_ID_AAC,
2420  .video_codec = AV_CODEC_ID_H264,
2422  .init = dash_init,
2426  .deinit = dash_free,
2428  .priv_class = &dash_class,
2429 };
OutputStream::as_idx
int as_idx
Definition: dashenc.c:101
Segment::n
int n
Definition: dashenc.c:79
AdaptationSet::max_height
int max_height
Definition: dashenc.c:93
OutputStream::gop_size
int64_t gop_size
Definition: dashenc.c:138
formats
formats
Definition: signature.h:48
DASHContext::target_latency_refid
int target_latency_refid
Definition: dashenc.c:195
options
static const AVOption options[]
Definition: dashenc.c:2358
DASHContext::remove_at_exit
int remove_at_exit
Definition: dashenc.c:152
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AV_BPRINT_SIZE_UNLIMITED
#define AV_BPRINT_SIZE_UNLIMITED
DASHContext::master_playlist_created
int master_playlist_created
Definition: dashenc.c:174
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
DASHContext::profile
int profile
Definition: dashenc.c:193
AdaptationSet::max_frame_rate
AVRational max_frame_rate
Definition: dashenc.c:90
AVERROR_EXPERIMENTAL
#define AVERROR_EXPERIMENTAL
Requested feature is flagged experimental. Set strict_std_compliance if you really want to use it.
Definition: error.h:72
DASHContext::as
AdaptationSet * as
Definition: dashenc.c:146
DASHContext::last_duration
int64_t last_duration
Definition: dashenc.c:158
level
uint8_t level
Definition: svq3.c:204
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
AVOutputFormat::name
const char * name
Definition: avformat.h:496
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
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4374
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
av_compare_ts
int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b)
Compare two timestamps each in its own time base.
Definition: mathematics.c:146
ffio_wfourcc
static av_always_inline void ffio_wfourcc(AVIOContext *pb, const uint8_t *s)
Definition: avio_internal.h:58
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:234
avio_close
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
Definition: aviobuf.c:1152
OutputStream::format_name
const char * format_name
Definition: dashenc.c:120
out
FILE * out
Definition: movenc.c:54
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:1281
AVCodecParserContext::pict_type
int pict_type
Definition: avcodec.h:2777
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:68
FRAG_TYPE_NB
@ FRAG_TYPE_NB
Definition: dashenc.c:66
ff_mp4_obj_type
const AVCodecTag ff_mp4_obj_type[]
Definition: isom.c:35
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
ff_isom_get_vpcc_features
int ff_isom_get_vpcc_features(AVFormatContext *s, AVCodecParameters *par, AVRational *frame_rate, VPCC *vpcc)
Definition: vpcc.c:117
ff_hls_write_end_list
void ff_hls_write_end_list(AVIOContext *out)
Definition: hlsplaylist.c:189
DASHContext::index_correction
int index_correction
Definition: dashenc.c:179
FRAG_TYPE_DURATION
@ FRAG_TYPE_DURATION
Definition: dashenc.c:64
AdaptationSet::metadata
AVDictionary * metadata
Definition: dashenc.c:89
MKTAG
#define MKTAG(a, b, c, d)
Definition: common.h:478
av_div_q
AVRational av_div_q(AVRational b, AVRational c)
Divide one rational by another.
Definition: rational.c:88
dict_copy_entry
static int dict_copy_entry(AVDictionary **dst, const AVDictionary *src, const char *key)
Definition: dashenc.c:1366
DASHContext::presentation_time_offset
int64_t presentation_time_offset
Definition: dashenc.c:162
rational.h
OutputStream::start_pts
int64_t start_pts
Definition: dashenc.c:114
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
codecs
static struct codec_string codecs[]
OutputStream::packets_written
int packets_written
Definition: dashenc.c:105
DASHContext::timeout
int64_t timeout
Definition: dashenc.c:178
DASHContext::http_persistent
int http_persistent
Definition: dashenc.c:173
DASHContext::hls_master_name
const char * hls_master_name
Definition: dashenc.c:172
set_http_options
static void set_http_options(AVDictionary **options, DASHContext *c)
Definition: dashenc.c:473
parse_adaptation_sets
static int parse_adaptation_sets(AVFormatContext *s)
Definition: dashenc.c:927
update_stream_extradata
static int update_stream_extradata(AVFormatContext *s, OutputStream *os, AVPacket *pkt, AVRational *frame_rate)
Definition: dashenc.c:1821
profile
mfxU16 profile
Definition: qsvenc.c:45
AdaptationSet::id
int id
Definition: dashenc.c:83
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1175
AVFormatContext::strict_std_compliance
int strict_std_compliance
Allow non-standard and experimental extension.
Definition: avformat.h:1404
set_codec_str
static void set_codec_str(AVFormatContext *s, AVCodecParameters *par, AVRational *frame_rate, char *str, int size)
Definition: dashenc.c:348
AVProducerReferenceTime::wallclock
int64_t wallclock
A UTC timestamp, in microseconds, since Unix epoch (e.g, av_gettime()).
Definition: defs.h:157
AVPacket::data
uint8_t * data
Definition: packet.h:373
OutputStream::last_dts
int64_t last_dts
Definition: dashenc.c:115
dash_init
static int dash_init(AVFormatContext *s)
Definition: dashenc.c:1374
AVStream::internal
AVStreamInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1009
AVOption
AVOption.
Definition: opt.h:247
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:914
data
const char data[16]
Definition: mxf.c:143
AV_OPT_TYPE_DURATION
@ AV_OPT_TYPE_DURATION
Definition: opt.h:238
AVOutputFormat::check_bitstream
int(* check_bitstream)(struct AVFormatContext *, const AVPacket *pkt)
Set up any necessary bitstream filtering and extract any extra data needed for the global header.
Definition: avformat.h:616
AV_DICT_APPEND
#define AV_DICT_APPEND
If the entry already exists, append to it.
Definition: dict.h:75
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
FRAG_TYPE_NONE
@ FRAG_TYPE_NONE
Definition: dashenc.c:62
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:391
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:64
PLAYLIST_TYPE_NONE
@ PLAYLIST_TYPE_NONE
Definition: hlsplaylist.h:33
mathematics.h
dashenc_io_close
static void dashenc_io_close(AVFormatContext *s, AVIOContext **pb, char *filename)
Definition: dashenc.c:242
AVDictionary
Definition: dict.c:30
AV_CODEC_ID_FLAC
@ AV_CODEC_ID_FLAC
Definition: codec_id.h:434
AdaptationSet::min_frame_rate
AVRational min_frame_rate
Definition: dashenc.c:90
avformat_init_output
av_warn_unused_result int avformat_init_output(AVFormatContext *s, AVDictionary **options)
Allocate the stream private data and initialize the codec, but do not write the header.
Definition: mux.c:449
codec_string::str
const char * str
Definition: dashenc.c:203
DASHContext::global_sidx
int global_sidx
Definition: dashenc.c:181
OutputStream::last_flags
int last_flags
Definition: dashenc.c:116
SEGMENT_TYPE_MP4
@ SEGMENT_TYPE_MP4
Definition: dashenc.c:56
AVStreamInternal::bsfc
AVBSFContext * bsfc
bitstream filter to run on stream
Definition: internal.h:192
AV_OPT_TYPE_RATIONAL
@ AV_OPT_TYPE_RATIONAL
Definition: opt.h:229
av_strlcatf
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
Definition: avstring.c:101
avio_get_dyn_buf
int avio_get_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1374
os_support.h
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:404
AV1SequenceParameters::chroma_subsampling_y
uint8_t chroma_subsampling_y
Definition: av1.h:35
hlsplaylist.h
add_adaptation_set
static int add_adaptation_set(AVFormatContext *s, AdaptationSet **as, enum AVMediaType type)
Definition: dashenc.c:880
OutputStream::parser
AVCodecParserContext * parser
Definition: dashenc.c:103
DASHContext
Definition: dashdec.c:121
AdaptationSet::descriptor
char * descriptor
Definition: dashenc.c:84
OutputStream::coding_dependency
int coding_dependency
Definition: dashenc.c:140
AVFormatContext::interrupt_callback
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
Definition: avformat.h:1374
AdaptationSet::nb_streams
int nb_streams
Definition: dashenc.c:94
SEGMENT_TYPE_AUTO
@ SEGMENT_TYPE_AUTO
Definition: dashenc.c:55
avio_open2
int avio_open2(AVIOContext **s, const char *url, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options)
Create and initialize a AVIOContext for accessing the resource indicated by url.
Definition: aviobuf.c:1146
DASHContext::single_file_name
const char * single_file_name
Definition: dashenc.c:164
ff_hls_write_playlist_header
void ff_hls_write_playlist_header(AVIOContext *out, int version, int allowcache, int target_duration, int64_t sequence, uint32_t playlist_type, int iframe_mode)
Definition: hlsplaylist.c:98
AdaptationSet::seg_duration
int64_t seg_duration
Definition: dashenc.c:85
av_strerror
int av_strerror(int errnum, char *errbuf, size_t errbuf_size)
Put a description of the AVERROR code errnum in errbuf.
Definition: error.c:105
OutputStream::full_path
char full_path[1024]
Definition: dashenc.c:129
dashenc_delete_media_segments
static void dashenc_delete_media_segments(AVFormatContext *s, OutputStream *os, int remove_count)
Definition: dashenc.c:1894
DASHContext::method
const char * method
Definition: dashenc.c:168
gmtime_r
#define gmtime_r
Definition: time_internal.h:34
dashenc_delete_segment_file
static int dashenc_delete_segment_file(AVFormatContext *s, const char *file)
Definition: dashenc.c:1874
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:538
ff_hls_write_audio_rendition
void ff_hls_write_audio_rendition(AVIOContext *out, const char *agroup, const char *filename, const char *language, int name_id, int is_default)
Definition: hlsplaylist.c:39
format_string::str
const char * str
Definition: dashenc.c:215
AVFMT_AVOID_NEG_TS_MAKE_ZERO
#define AVFMT_AVOID_NEG_TS_MAKE_ZERO
Shift timestamps so that they start at 0.
Definition: avformat.h:1442
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
av_parser_init
AVCodecParserContext * av_parser_init(int codec_id)
Definition: parser.c:34
add_segment
static int add_segment(OutputStream *os, const char *file, int64_t time, int64_t duration, int64_t start_pos, int64_t range_length, int64_t index_length, int next_exp_index)
Definition: dashenc.c:1748
av_reduce
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
ff_rename
int ff_rename(const char *url_src, const char *url_dst, void *logctx)
Wrap ffurl_move() and log if error happens.
Definition: avio.c:665
AVRational::num
int num
Numerator.
Definition: rational.h:59
DASHContext::user_agent
const char * user_agent
Definition: dashenc.c:169
vpcc.h
AV1SequenceParameters::color_description_present_flag
uint8_t color_description_present_flag
Definition: av1.h:37
get_hls_playlist_name
static void get_hls_playlist_name(char *playlist_name, int string_size, const char *base_url, int id)
Definition: dashenc.c:486
write_time
static void write_time(AVIOContext *out, int64_t time)
Definition: dashenc.c:757
avio_close_dyn_buf
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1407
avassert.h
lrint
#define lrint
Definition: tablegen.h:53
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
AdaptationSet::par
AVRational par
Definition: dashenc.c:95
E
#define E
Definition: dashenc.c:2357
AVCodecTag
Definition: internal.h:52
DASHContext::init_seg_name
const char * init_seg_name
Definition: dashenc.c:165
get_start_index_number
static void get_start_index_number(OutputStream *os, DASHContext *c, int *start_index, int *start_number)
Definition: dashenc.c:494
ff_write_chained
int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt, AVFormatContext *src, int interleave)
Write a packet to another muxer than the one the user originally intended.
Definition: mux.c:1291
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
avio_open_dyn_buf
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1362
avcodec_alloc_context3
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:141
format_string::segment_type
SegmentType segment_type
Definition: dashenc.c:214
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
DASHContext::ignore_io_errors
int ignore_io_errors
Definition: dashenc.c:183
SegmentType
SegmentType
Definition: dashenc.c:54
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:277
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1225
DASHContext::media_seg_name
const char * media_seg_name
Definition: dashenc.c:166
DASHContext::window_size
int window_size
Definition: dashenc.c:148
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CODEC_ID_VP9
@ AV_CODEC_ID_VP9
Definition: codec_id.h:218
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:126
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
av_match_ext
int av_match_ext(const char *filename, const char *extensions)
Return a positive value if the given filename has one of the given extensions, 0 otherwise.
Definition: format.c:38
AV_OPT_TYPE_INT64
@ AV_OPT_TYPE_INT64
Definition: opt.h:225
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
dash_check_bitstream
static int dash_check_bitstream(struct AVFormatContext *s, const AVPacket *avpkt)
Definition: dashenc.c:2335
AVIO_FLAG_WRITE
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:656
AV_FIELD_UNKNOWN
@ AV_FIELD_UNKNOWN
Definition: codec_par.h:37
AV1SequenceParameters::color_range
uint8_t color_range
Definition: av1.h:41
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
ff_is_http_proto
int ff_is_http_proto(char *filename)
Utility function to check if the file uses http or https protocol.
Definition: utils.c:5459
OutputStream::max_pts
int64_t max_pts
Definition: dashenc.c:114
DASHContext::use_timeline
int use_timeline
Definition: dashenc.c:154
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:141
DASHContext::hls_playlist
int hls_playlist
Definition: dashenc.c:171
DASHContext::mpd_out
AVIOContext * mpd_out
Definition: dashenc.c:175
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:369
AVFormatContext::opaque
void * opaque
User data.
Definition: avformat.h:1618
key
const char * key
Definition: hwcontext_opencl.c:168
dashenc_delete_file
static void dashenc_delete_file(AVFormatContext *s, char *filename)
Definition: dashenc.c:1847
DASHContext::dirname
char dirname[1024]
Definition: dashenc.c:163
OutputStream::media_seg_name
const char * media_seg_name
Definition: dashenc.c:124
write_manifest
static int write_manifest(AVFormatContext *s, int final)
Definition: dashenc.c:1131
AV_PKT_DATA_PRFT
@ AV_PKT_DATA_PRFT
Producer Reference Time data corresponding to the AVProducerReferenceTime struct, usually exported by...
Definition: packet.h:268
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:77
avformat_write_header
av_warn_unused_result int avformat_write_header(AVFormatContext *s, AVDictionary **options)
Allocate the stream private data and write the stream header to an output media file.
Definition: mux.c:469
time_internal.h
ff_http_do_new_request
int ff_http_do_new_request(URLContext *h, const char *uri)
Send a new HTTP request, reusing the old connection.
Definition: http.c:389
if
if(ret)
Definition: filter_design.txt:179
avio_flush
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:235
DASHContext::max_gop_size
int64_t max_gop_size
Definition: dashenc.c:191
AVFormatContext
Format I/O context.
Definition: avformat.h:1107
DASHContext::streaming
int streaming
Definition: dashenc.c:177
internal.h
opts
AVDictionary * opts
Definition: movenc.c:50
AV1SequenceParameters::chroma_sample_position
uint8_t chroma_sample_position
Definition: av1.h:36
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:994
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
OutputStream::first_segment_bit_rate
int first_segment_bit_rate
Definition: dashenc.c:118
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:870
NULL
#define NULL
Definition: coverity.c:32
SEGMENT_TYPE_WEBM
@ SEGMENT_TYPE_WEBM
Definition: dashenc.c:57
OutputStream::frag_type
int frag_type
Definition: dashenc.c:137
OutputStream::ctx_inited
int ctx_inited
Definition: dashenc.c:101
DASHContext::write_prft
int write_prft
Definition: dashenc.c:190
dash_write_packet
static int dash_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: dashenc.c:2067
isom.h
VPCC::bitdepth
int bitdepth
Definition: vpcc.h:38
DASHContext::use_template
int use_template
Definition: dashenc.c:153
write_trailer
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:98
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:156
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
av_strireplace
char * av_strireplace(const char *str, const char *from, const char *to)
Locale-independent strings replace.
Definition: avstring.c:237
OutputStream::init_start_pos
int64_t init_start_pos
Definition: dashenc.c:107
state
static struct @317 state
OutputStream::pos
int64_t pos
Definition: dashenc.c:107
AV_OPT_TYPE_DICT
@ AV_OPT_TYPE_DICT
Definition: opt.h:231
Segment::range_length
int range_length
Definition: dashenc.c:75
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
ffurl_shutdown
int ffurl_shutdown(URLContext *h, int flags)
Signal the URLContext that we are done reading or writing the stream.
Definition: avio.c:651
AVFormatContext::pb
AVIOContext * pb
I/O context.
Definition: avformat.h:1149
AV1SequenceParameters::transfer_characteristics
uint8_t transfer_characteristics
Definition: av1.h:39
src
#define src
Definition: vp8dsp.c:255
avc.h
parseutils.h
DASHContext::single_file
int single_file
Definition: dashenc.c:155
flush_init_segment
static int flush_init_segment(AVFormatContext *s, OutputStream *os)
Definition: dashenc.c:583
AV1SequenceParameters::tier
uint8_t tier
Definition: av1.h:31
select_segment_type
static SegmentType select_segment_type(SegmentType segment_type, enum AVCodecID codec_id)
Definition: dashenc.c:288
av_parse_time
int av_parse_time(int64_t *timeval, const char *timestr, int duration)
Parse timestr and return in *time a corresponding number of microseconds.
Definition: parseutils.c:587
AV_DICT_DONT_OVERWRITE
#define AV_DICT_DONT_OVERWRITE
Don't overwrite existing entries.
Definition: dict.h:74
AVCodecParserContext::flags
int flags
Definition: avcodec.h:2802
time.h
DASHContext::start_time_s
time_t start_time_s
Definition: dashenc.c:161
ff_codec_movvideo_tags
const AVCodecTag ff_codec_movvideo_tags[]
Definition: isom_tags.c:29
av_write_frame
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
Write a packet to an output media file.
Definition: mux.c:1175
AVProducerReferenceTime
This structure supplies correlation between a packet timestamp and a wall clock production time.
Definition: defs.h:153
AdaptationSet::frag_duration
int64_t frag_duration
Definition: dashenc.c:86
format_string
Definition: dashenc.c:213
AVProducerReferenceTime::flags
int flags
Definition: defs.h:158
codec_string::id
int id
Definition: dashenc.c:202
ff_codec_movaudio_tags
const AVCodecTag ff_codec_movaudio_tags[]
Definition: isom_tags.c:278
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
av_bprint_is_complete
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
Definition: bprint.h:185
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:47
DASHContext::lhls
int lhls
Definition: dashenc.c:184
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:78
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:424
MPD_PROFILE_DASH
#define MPD_PROFILE_DASH
Definition: dashenc.c:69
DASHContext::master_publish_rate
int master_publish_rate
Definition: dashenc.c:186
AV1SequenceParameters::monochrome
uint8_t monochrome
Definition: av1.h:33
ff_hls_write_playlist_version
void ff_hls_write_playlist_version(AVIOContext *out, int version)
Definition: hlsplaylist.c:31
OutputStream::extension_name
const char * extension_name
Definition: dashenc.c:121
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
AV1SequenceParameters::matrix_coefficients
uint8_t matrix_coefficients
Definition: av1.h:40
AVMediaType
AVMediaType
Definition: avutil.h:199
AVPacket::size
int size
Definition: packet.h:374
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:116
OutputStream::total_pkt_size
int total_pkt_size
Definition: dashenc.c:134
avformat_alloc_context
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:166
OutputStream::availability_time_offset
double availability_time_offset
Definition: dashenc.c:131
av_codec_get_tag
unsigned int av_codec_get_tag(const struct AVCodecTag *const *tags, enum AVCodecID id)
Get the codec tag for the given codec id id.
ff_isom_write_avcc
int ff_isom_write_avcc(AVIOContext *pb, const uint8_t *data, int len)
Definition: avc.c:108
OutputStream::producer_reference_time
AVProducerReferenceTime producer_reference_time
Definition: dashenc.c:132
ff_dash_muxer
const AVOutputFormat ff_dash_muxer
Definition: dashenc.c:2414
FF_COMPLIANCE_STRICT
#define FF_COMPLIANCE_STRICT
Strictly conform to all the things in the spec no matter what consequences.
Definition: avcodec.h:1278
start_time
static int64_t start_time
Definition: ffplay.c:330
FFMAX
#define FFMAX(a, b)
Definition: common.h:103
DASHContext::streams
OutputStream * streams
Definition: dashenc.c:156
AVFormatContext::url
char * url
input or output URL.
Definition: avformat.h:1190
DASHContext::nr_of_streams_to_flush
int nr_of_streams_to_flush
Definition: dashenc.c:187
size
int size
Definition: twinvq_data.h:10344
DASHContext::utc_timing_url
const char * utc_timing_url
Definition: dashenc.c:167
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:96
DASHContext::frag_duration
int64_t frag_duration
Definition: dashenc.c:151
DASHContext::min_playback_rate
AVRational min_playback_rate
Definition: dashenc.c:196
AV_CODEC_ID_OPUS
@ AV_CODEC_ID_OPUS
Definition: codec_id.h:482
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:463
DASHContext::has_video
int has_video
Definition: dashenc.c:157
ff_hls_write_init_file
void ff_hls_write_init_file(AVIOContext *out, const char *filename, int byterange_mode, int64_t size, int64_t pos)
Definition: hlsplaylist.c:122
AVMEDIA_TYPE_UNKNOWN
@ AVMEDIA_TYPE_UNKNOWN
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:903
SegmentType
SegmentType
Definition: pgssubdec.c:41
Segment::prog_date_time
double prog_date_time
Definition: dashenc.c:77
set_vp9_codec_str
static void set_vp9_codec_str(AVFormatContext *s, AVCodecParameters *par, AVRational *frame_rate, char *str, int size)
Definition: dashenc.c:333
DASHContext::availability_start_time
uint64_t availability_start_time
Definition: dashdec.c:135
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:372
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:215
avio_wb32
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:373
FFMIN
#define FFMIN(a, b)
Definition: common.h:105
av_reallocp_array
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array through a pointer to a pointer.
Definition: mem.c:212
OutputStream::segments
Segment ** segments
Definition: dashenc.c:113
DASHContext::nb_as
int nb_as
Definition: dashenc.c:147
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:379
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_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:34
OFFSET
#define OFFSET(x)
Definition: dashenc.c:2356
OutputStream::parser_avctx
AVCodecContext * parser_avctx
Definition: dashenc.c:104
OutputStream::temp_path
char temp_path[1024]
Definition: dashenc.c:130
AV1SequenceParameters::profile
uint8_t profile
Definition: av1.h:29
Segment::duration
int64_t duration
Definition: dashenc.c:78
OutputStream::written_len
int written_len
Definition: dashenc.c:127
flush_dynbuf
static int flush_dynbuf(DASHContext *c, OutputStream *os, int *range_length)
Definition: dashenc.c:444
OutputStream::codec_str
char codec_str[100]
Definition: dashenc.c:126
AdaptationSet::frag_type
int frag_type
Definition: dashenc.c:87
OutputStream::first_pts
int64_t first_pts
Definition: ffmpeg.h:469
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:134
write_packet
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:729
DASHContext::max_playback_rate
AVRational max_playback_rate
Definition: dashenc.c:197
AdaptationSet::max_frag_duration
int64_t max_frag_duration
Definition: dashenc.c:92
OutputStream::segment_index
int segment_index
Definition: dashenc.c:109
avcodec_parameters_copy
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: codec_par.c:72
AV1SequenceParameters::color_primaries
uint8_t color_primaries
Definition: av1.h:38
get_format_str
static const char * get_format_str(SegmentType segment_type)
Definition: dashenc.c:261
av_write_trailer
int av_write_trailer(AVFormatContext *s)
Write the stream trailer to an output media file and free the file private data.
Definition: mux.c:1237
i
int i
Definition: input.c:406
URLContext
Definition: url.h:38
AVFMT_GLOBALHEADER
#define AVFMT_GLOBALHEADER
Format wants global header.
Definition: avformat.h:466
PARSER_FLAG_COMPLETE_FRAMES
#define PARSER_FLAG_COMPLETE_FRAMES
Definition: avcodec.h:2803
AVOutputFormat
Definition: avformat.h:495
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:366
avio_internal.h
av_packet_get_side_data
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, size_t *size)
Get side information from packet.
Definition: avpacket.c:241
AVERROR_MUXER_NOT_FOUND
#define AVERROR_MUXER_NOT_FOUND
Muxer not found.
Definition: error.h:60
AVCodecParameters::height
int height
Definition: codec_par.h:127
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
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
OutputStream::last_pts
int64_t last_pts
Definition: dashenc.c:115
find_index_range
static void find_index_range(AVFormatContext *s, const char *full_path, int64_t pos, int *index_length)
Definition: dashenc.c:1798
AdaptationSet
Definition: dashenc.c:82
DASHContext::adaptation_sets
char * adaptation_sets
Definition: dashenc.c:145
AVFormatContext::avoid_negative_ts
int avoid_negative_ts
Avoid negative timestamps during muxing.
Definition: avformat.h:1439
AV1SequenceParameters::level
uint8_t level
Definition: av1.h:30
url.h
OutputStream::ctx
AVFormatContext * ctx
Definition: dashenc.c:100
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:243
MPD_PROFILE_DVB
#define MPD_PROFILE_DVB
Definition: dashenc.c:70
AdaptationSet::ambiguous_frame_rate
int ambiguous_frame_rate
Definition: dashenc.c:91
len
int len
Definition: vorbis_enc_data.h:426
DASHContext::seg_duration
int64_t seg_duration
Definition: dashenc.c:150
FRAG_TYPE_EVERY_FRAME
@ FRAG_TYPE_EVERY_FRAME
Definition: dashenc.c:63
AVCodecParameters::field_order
enum AVFieldOrder field_order
Video only.
Definition: codec_par.h:141
AVFMT_TS_NEGATIVE
#define AVFMT_TS_NEGATIVE
Format allows muxing negative timestamps.
Definition: avformat.h:480
AVCodecParserContext
Definition: avcodec.h:2769
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
Segment
Definition: dashenc.c:72
AdaptationSet::max_width
int max_width
Definition: dashenc.c:93
OutputStream::producer_reference_time_str
char producer_reference_time_str[100]
Definition: dashenc.c:133
AdaptationSet::trick_idx
int trick_idx
Definition: dashenc.c:96
ff_av1_parse_seq_header
int ff_av1_parse_seq_header(AV1SequenceParameters *seq, const uint8_t *buf, int size)
Parses a Sequence Header from the the provided buffer.
Definition: av1.c:334
tag
uint32_t tag
Definition: movenc.c:1594
ffio_free_dyn_buf
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
Definition: aviobuf.c:1437
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:847
OutputStream::init_seg_name
const char * init_seg_name
Definition: dashenc.c:123
ff_hls_write_file_entry
int ff_hls_write_file_entry(AVIOContext *out, int insert_discont, int byterange_mode, double duration, int round_duration, int64_t size, int64_t pos, const char *baseurl, const char *filename, double *prog_date_time, int64_t video_keyframe_size, int64_t video_keyframe_pos, int iframe_mode)
Definition: hlsplaylist.c:132
write_adaptation_set
static int write_adaptation_set(AVFormatContext *s, AVIOContext *out, int as_index, int final)
Definition: dashenc.c:791
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:243
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
AVFormatContext::oformat
const struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1126
av_strlcat
size_t av_strlcat(char *dst, const char *src, size_t size)
Append the string src to the string dst, but to a total length of no more than size - 1 bytes,...
Definition: avstring.c:93
av_strnstr
char * av_strnstr(const char *haystack, const char *needle, size_t hay_length)
Locate the first occurrence of the string needle in the string haystack where not more than hay_lengt...
Definition: avstring.c:69
pos
unsigned int pos
Definition: spdifenc.c:412
avformat.h
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:93
AV_ERROR_MAX_STRING_SIZE
#define AV_ERROR_MAX_STRING_SIZE
Definition: error.h:83
OutputStream::seg_duration
int64_t seg_duration
Definition: dashenc.c:110
VPCC::level
int level
Definition: vpcc.h:37
ost
OutputStream * ost
Definition: ffmpeg_filter.c:163
adaptation_set_add_stream
static int adaptation_set_add_stream(AVFormatContext *s, int as_idx, int i)
Definition: dashenc.c:904
SEGMENT_TYPE_NB
@ SEGMENT_TYPE_NB
Definition: dashenc.c:58
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
avio_printf
int avio_printf(AVIOContext *s, const char *fmt,...) av_printf_format(2
Writes a formatted string to the context.
OutputStream::single_file_name
const char * single_file_name
Definition: dashenc.c:122
dash_write_header
static int dash_write_header(AVFormatContext *s)
Definition: dashenc.c:1729
write_styp
static void write_styp(AVIOContext *pb)
Definition: dashenc.c:1788
AVCodecContext
main external API structure.
Definition: avcodec.h:379
DASHContext::max_segment_duration
int64_t max_segment_duration
Definition: dashenc.c:192
DASHContext::frag_type
int frag_type
Definition: dashenc.c:189
OutputStream::init_range_length
int init_range_length
Definition: dashenc.c:108
DASHContext::nr_of_streams_flushed
int nr_of_streams_flushed
Definition: dashenc.c:188
dashenc_io_open
static int dashenc_io_open(AVFormatContext *s, AVIOContext **pb, char *filename, AVDictionary **options)
Definition: dashenc.c:223
VPCC
Definition: vpcc.h:35
get_extension_str
static const char * get_extension_str(SegmentType type, int single_file)
Definition: dashenc.c:269
OutputStream::last_duration
int64_t last_duration
Definition: dashenc.c:112
Segment::file
char file[1024]
Definition: dashenc.c:73
OutputStream::initfile
char initfile[1024]
Definition: dashenc.c:106
Segment::index_length
int index_length
Definition: dashenc.c:75
av_packet_new_side_data
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, size_t size)
Allocate new information of a packet.
Definition: avpacket.c:220
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
OutputStream::muxer_overhead
int muxer_overhead
Definition: dashenc.c:136
AV_PKT_DATA_NEW_EXTRADATA
@ AV_PKT_DATA_NEW_EXTRADATA
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: packet.h:55
AVRational::den
int den
Denominator.
Definition: rational.h:60
ff_hls_write_stream_info
void ff_hls_write_stream_info(AVStream *st, AVIOContext *out, int bandwidth, const char *filename, const char *agroup, const char *codecs, const char *ccgroup, const char *sgroup)
Definition: hlsplaylist.c:69
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
avformat_free_context
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: utils.c:4301
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:616
OutputStream::total_pkt_duration
int64_t total_pkt_duration
Definition: dashenc.c:135
AVFormatContext::io_close
void(* io_close)(struct AVFormatContext *s, AVIOContext *pb)
A callback for closing the streams opened with AVFormatContext.io_open().
Definition: avformat.h:1678
format_date
static void format_date(char *buf, int size, int64_t time_us)
Definition: dashenc.c:773
OutputStream::nb_segments
int nb_segments
Definition: dashenc.c:109
AVFormatContext::io_open
int(* io_open)(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags, AVDictionary **options)
A callback for opening new IO streams.
Definition: avformat.h:1672
DASHContext::total_duration
int64_t total_duration
Definition: dashenc.c:159
AV1SequenceParameters::chroma_subsampling_x
uint8_t chroma_subsampling_x
Definition: av1.h:34
dash_write_trailer
static int dash_write_trailer(AVFormatContext *s)
Definition: dashenc.c:2293
AVPacket::stream_index
int stream_index
Definition: packet.h:375
OutputStream::sar
AVRational sar
Definition: dashenc.c:139
OutputStream::filename
char filename[1024]
Definition: dashenc.c:128
write_hls_media_playlist
static void write_hls_media_playlist(OutputStream *os, AVFormatContext *s, int representation_id, int final, char *prefetch_url)
Definition: dashenc.c:504
OutputStream::out
AVIOContext * out
Definition: dashenc.c:102
OutputStream::bit_rate
int bit_rate
Definition: dashenc.c:117
av_gettime
int64_t av_gettime(void)
Get the current time in microseconds.
Definition: time.c:39
av_dict_set_int
int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags)
Convenience wrapper for av_dict_set that converts the value to a string and stores it.
Definition: dict.c:147
ff_format_io_close
void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
Definition: utils.c:5452
AVIO_FLAG_READ
#define AVIO_FLAG_READ
read-only
Definition: avio.h:655
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:259
output_segment_list
static void output_segment_list(OutputStream *os, AVIOContext *out, AVFormatContext *s, int representation_id, int final)
Definition: dashenc.c:642
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
av_parser_parse2
int av_parser_parse2(AVCodecParserContext *s, AVCodecContext *avctx, uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size, int64_t pts, int64_t dts, int64_t pos)
Parse a packet.
Definition: parser.c:115
avutil.h
av_guess_format
const AVOutputFormat * av_guess_format(const char *short_name, const char *filename, const char *mime_type)
Return the output format in the list of registered output formats which best matches the provided par...
Definition: format.c:51
DASHContext::m3u8_out
AVIOContext * m3u8_out
Definition: dashenc.c:176
AVCodecParameters::video_delay
int video_delay
Video only.
Definition: codec_par.h:155
AV_FIELD_PROGRESSIVE
@ AV_FIELD_PROGRESSIVE
Definition: codec_par.h:38
FRAG_TYPE_PFRAMES
@ FRAG_TYPE_PFRAMES
Definition: dashenc.c:65
handle_io_open_error
static int handle_io_open_error(AVFormatContext *s, int err, char *url)
Definition: dashenc.c:279
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
dash_flush
static int dash_flush(AVFormatContext *s, int final, int stream)
Definition: dashenc.c:1907
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:60
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:241
ff_dash_fill_tmpl_params
void ff_dash_fill_tmpl_params(char *dst, size_t buffer_size, const char *template, int rep_id, int number, int bit_rate, int64_t time)
Definition: dash.c:95
DASHContext::http_opts
AVDictionary * http_opts
Definition: dashenc.c:170
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
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
av_dict_copy
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:217
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:393
DASHContext::target_latency
int64_t target_latency
Definition: dashenc.c:194
avio_find_protocol_name
const char * avio_find_protocol_name(const char *url)
Return the name of the protocol that will handle the passed URL.
Definition: avio.c:467
codec_string
Definition: dashenc.c:201
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Definition: opt.h:223
convert_header.str
string str
Definition: convert_header.py:20
OutputStream
Definition: muxing.c:54
AV_CODEC_ID_VP8
@ AV_CODEC_ID_VP8
Definition: codec_id.h:190
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
dash_parse_prft
static int dash_parse_prft(DASHContext *c, AVPacket *pkt)
Definition: dashenc.c:2041
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:83
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:89
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AV1SequenceParameters::bitdepth
uint8_t bitdepth
Definition: av1.h:32
DASHContext::format_options
AVDictionary * format_options
Definition: dashenc.c:180
dash_class
static const AVClass dash_class
Definition: dashenc.c:2407
av1.h
AV_CODEC_ID_VORBIS
@ AV_CODEC_ID_VORBIS
Definition: codec_id.h:427
dash.h
AV1SequenceParameters
Definition: av1.h:28
AVDictionaryEntry::value
char * value
Definition: dict.h:81
VPCC::profile
int profile
Definition: vpcc.h:36
avstring.h
DASHContext::segment_type_option
SegmentType segment_type_option
Definition: dashenc.c:182
Segment::time
int64_t time
Definition: dashenc.c:76
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:228
ffurl_delete
int ffurl_delete(const char *url)
Delete a resource.
Definition: avio.c:515
write_header
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:347
av_strndup
char * av_strndup(const char *s, size_t len)
Duplicate a substring of a string.
Definition: mem.c:271
Segment::start_pos
int64_t start_pos
Definition: dashenc.c:74
http.h
check_bitstream
static int check_bitstream(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mux.c:1058
dash_free
static void dash_free(AVFormatContext *s)
Definition: dashenc.c:601
DASHContext::update_period
int64_t update_period
Definition: dashenc.c:198
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:233
snprintf
#define snprintf
Definition: snprintf.h:34
OutputStream::segments_size
int segments_size
Definition: dashenc.c:109
ffio_geturlcontext
URLContext * ffio_geturlcontext(AVIOContext *s)
Return the URLContext associated with the AVIOContext.
Definition: aviobuf.c:962
AdaptationSet::media_type
enum AVMediaType media_type
Definition: dashenc.c:88
init_segment_types
static int init_segment_types(AVFormatContext *s)
Definition: dashenc.c:302
OutputStream::frag_duration
int64_t frag_duration
Definition: dashenc.c:111
DASHContext::extra_window_size
int extra_window_size
Definition: dashenc.c:149
av_parser_close
void av_parser_close(AVCodecParserContext *s)
Definition: parser.c:187
AV_RB16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:98
xmlescape
static char * xmlescape(const char *str)
Definition: dashenc.c:717
ff_alloc_extradata
int ff_alloc_extradata(AVCodecParameters *par, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0.
Definition: utils.c:3264
DASHContext::ldash
int ldash
Definition: dashenc.c:185
OutputStream::segment_type
SegmentType segment_type
Definition: dashenc.c:119