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