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