FFmpeg
hlsenc.c
Go to the documentation of this file.
1 /*
2  * Apple HTTP Live Streaming segmenter
3  * Copyright (c) 2012, Luca Barbato
4  * Copyright (c) 2017 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 <stdint.h>
26 #include <time.h>
27 #if HAVE_UNISTD_H
28 #include <unistd.h>
29 #endif
30 
31 #include "libavutil/avassert.h"
32 #include "libavutil/mathematics.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/bprint.h"
35 #include "libavutil/intreadwrite.h"
36 #include "libavutil/opt.h"
37 #include "libavutil/log.h"
38 #include "libavutil/random_seed.h"
39 #include "libavutil/time.h"
41 
42 #include "libavcodec/defs.h"
43 
44 #include "avformat.h"
45 #include "avio_internal.h"
46 #include "avc.h"
47 #if CONFIG_HTTP_PROTOCOL
48 #include "http.h"
49 #endif
50 #include "hlsplaylist.h"
51 #include "internal.h"
52 #include "mux.h"
53 #include "os_support.h"
54 #include "url.h"
55 
56 typedef enum {
63 
64 typedef enum {
68 
69 #define KEYSIZE 16
70 #define LINE_BUFFER_SIZE MAX_URL_SIZE
71 #define HLS_MICROSECOND_UNIT 1000000
72 #define BUFSIZE (16 * 1024)
73 #define POSTFIX_PATTERN "_%d"
74 
75 typedef struct HLSSegment {
78  double duration; /* in seconds */
79  int discont;
80  int64_t pos;
81  int64_t size;
82  int64_t keyframe_pos;
83  int64_t keyframe_size;
84  unsigned var_stream_idx;
85 
87  char iv_string[KEYSIZE*2 + 1];
88 
89  struct HLSSegment *next;
91 } HLSSegment;
92 
93 typedef enum HLSFlags {
94  // Generate a single media file and use byte ranges in the playlist.
95  HLS_SINGLE_FILE = (1 << 0),
96  HLS_DELETE_SEGMENTS = (1 << 1),
97  HLS_ROUND_DURATIONS = (1 << 2),
98  HLS_DISCONT_START = (1 << 3),
99  HLS_OMIT_ENDLIST = (1 << 4),
100  HLS_SPLIT_BY_TIME = (1 << 5),
101  HLS_APPEND_LIST = (1 << 6),
103  HLS_SECOND_LEVEL_SEGMENT_INDEX = (1 << 8), // include segment index in segment filenames when use_localtime e.g.: %%03d
104  HLS_SECOND_LEVEL_SEGMENT_DURATION = (1 << 9), // include segment duration (microsec) in segment filenames when use_localtime e.g.: %%09t
105  HLS_SECOND_LEVEL_SEGMENT_SIZE = (1 << 10), // include segment size (bytes) in segment filenames when use_localtime e.g.: %%014s
106  HLS_TEMP_FILE = (1 << 11),
107  HLS_PERIODIC_REKEY = (1 << 12),
109  HLS_I_FRAMES_ONLY = (1 << 14),
110 } HLSFlags;
111 
112 typedef enum {
115 } SegmentType;
116 
117 typedef struct VariantStream {
118  unsigned var_stream_idx;
119  unsigned number;
120  int64_t sequence;
127  uint8_t *temp_buffer;
128  uint8_t *init_buffer;
129 
132 
137  double dpp; // duration per packet
138  int64_t start_pts;
139  int64_t end_pts;
140  int64_t video_lastpos;
143  double duration; // last segment duration computed so far, in seconds
144  int64_t start_pos; // last segment starting position
145  int64_t size; // last segment size
150 
154 
156  char *basename;
159  char *m3u8_name;
160 
162  char current_segment_final_filename_fmt[MAX_URL_SIZE]; // when renaming segments
163 
166 
168 
171  char key_string[KEYSIZE*2 + 1];
172  char iv_string[KEYSIZE*2 + 1];
173 
175  char codec_attr[128];
177  unsigned int nb_streams;
178  int m3u8_created; /* status of media play-list creation */
179  int is_default; /* default status of audio group */
180  const char *language; /* audio language name */
181  const char *agroup; /* audio group name */
182  const char *sgroup; /* subtitle group name */
183  const char *ccgroup; /* closed caption group name */
184  const char *varname; /* variant name */
185 } VariantStream;
186 
187 typedef struct ClosedCaptionsStream {
188  const char *ccgroup; /* closed caption group name */
189  const char *instreamid; /* closed captions INSTREAM-ID */
190  const char *language; /* closed captions language */
192 
193 typedef struct HLSContext {
194  const AVClass *class; // Class for private options.
195  int64_t start_sequence;
196  uint32_t start_sequence_source_type; // enum StartSequenceSourceType
197 
198  int64_t time; // Set by a private option.
199  int64_t init_time; // Set by a private option.
200  int max_nb_segments; // Set by a private option.
201  int hls_delete_threshold; // Set by a private option.
202  uint32_t flags; // enum HLSFlags
203  uint32_t pl_type; // enum PlaylistType
207  int resend_init_file; ///< resend init file into disk after refresh m3u8
208 
209  int use_localtime; ///< flag to expand filename with localtime
210  int use_localtime_mkdir;///< flag to mkdir dirname in timebased filename
212  int64_t recording_time;
213  int64_t max_seg_size; // every segment file max size
214 
215  char *baseurl;
219 
220  int encrypt;
221  char *key;
222  char *key_url;
223  char *iv;
226 
230  char key_string[KEYSIZE*2 + 1];
231  char iv_string[KEYSIZE*2 + 1];
233 
234  char *method;
235  char *user_agent;
236 
238  unsigned int nb_varstreams;
240  unsigned int nb_ccstreams;
241 
242  int master_m3u8_created; /* status of master play-list creation */
243  char *master_m3u8_url; /* URL of the master m3u8 file */
244  int version; /* HLS version */
245  char *var_stream_map; /* user specified variant stream map string */
246  char *cc_stream_map; /* user specified closed caption streams map string */
248  unsigned int master_publish_rate;
249  int http_persistent;
253  int64_t timeout;
255  char *headers;
256  int has_default_key; /* has DEFAULT field of var_stream_map */
257  int has_video_m3u8; /* has video stream m3u8 list */
258 } HLSContext;
259 
260 static int strftime_expand(const char *fmt, char **dest)
261 {
262  int r = 1;
263  time_t now0;
264  struct tm *tm, tmpbuf;
265  char *buf;
266 
267  buf = av_mallocz(MAX_URL_SIZE);
268  if (!buf)
269  return AVERROR(ENOMEM);
270 
271  time(&now0);
272  tm = localtime_r(&now0, &tmpbuf);
273  r = strftime(buf, MAX_URL_SIZE, fmt, tm);
274  if (!r) {
275  av_free(buf);
276  return AVERROR(EINVAL);
277  }
278  *dest = buf;
279 
280  return r;
281 }
282 
283 static int hlsenc_io_open(AVFormatContext *s, AVIOContext **pb, const char *filename,
285 {
286  HLSContext *hls = s->priv_data;
287  int http_base_proto = filename ? ff_is_http_proto(filename) : 0;
288  int err = AVERROR_MUXER_NOT_FOUND;
289  if (!*pb || !http_base_proto || !hls->http_persistent) {
290  err = s->io_open(s, pb, filename, AVIO_FLAG_WRITE, options);
291 #if CONFIG_HTTP_PROTOCOL
292  } else {
293  URLContext *http_url_context = ffio_geturlcontext(*pb);
294  av_assert0(http_url_context);
295  err = ff_http_do_new_request(http_url_context, filename);
296  if (err < 0)
297  ff_format_io_close(s, pb);
298 
299 #endif
300  }
301  return err;
302 }
303 
304 static int hlsenc_io_close(AVFormatContext *s, AVIOContext **pb, char *filename)
305 {
306  HLSContext *hls = s->priv_data;
307  int http_base_proto = filename ? ff_is_http_proto(filename) : 0;
308  int ret = 0;
309  if (!*pb)
310  return ret;
311  if (!http_base_proto || !hls->http_persistent || hls->key_info_file || hls->encrypt) {
312  ff_format_io_close(s, pb);
313 #if CONFIG_HTTP_PROTOCOL
314  } else {
315  URLContext *http_url_context = ffio_geturlcontext(*pb);
316  av_assert0(http_url_context);
317  avio_flush(*pb);
318  ret = ffurl_shutdown(http_url_context, AVIO_FLAG_WRITE);
319 #endif
320  }
321  return ret;
322 }
323 
325 {
326  int http_base_proto = ff_is_http_proto(s->url);
327 
328  if (c->method) {
329  av_dict_set(options, "method", c->method, 0);
330  } else if (http_base_proto) {
331  av_dict_set(options, "method", "PUT", 0);
332  }
333  if (c->user_agent)
334  av_dict_set(options, "user_agent", c->user_agent, 0);
335  if (c->http_persistent)
336  av_dict_set_int(options, "multiple_requests", 1, 0);
337  if (c->timeout >= 0)
338  av_dict_set_int(options, "timeout", c->timeout, 0);
339  if (c->headers)
340  av_dict_set(options, "headers", c->headers, 0);
341 }
342 
344 {
345  int codec_strlen = strlen(vs->codec_attr);
346  char attr[32];
347 
349  return;
351  return;
352 
353  if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
354  uint8_t *data = st->codecpar->extradata;
355  if (data) {
356  const uint8_t *p;
357 
358  if (AV_RB32(data) == 0x01 && (data[4] & 0x1F) == 7)
359  p = &data[5];
360  else if (AV_RB24(data) == 0x01 && (data[3] & 0x1F) == 7)
361  p = &data[4];
362  else if (data[0] == 0x01) /* avcC */
363  p = &data[1];
364  else
365  goto fail;
366  snprintf(attr, sizeof(attr),
367  "avc1.%02x%02x%02x", p[0], p[1], p[2]);
368  } else {
369  goto fail;
370  }
371  } else if (st->codecpar->codec_id == AV_CODEC_ID_HEVC) {
372  uint8_t *data = st->codecpar->extradata;
374  int level = AV_LEVEL_UNKNOWN;
375 
376  if (st->codecpar->profile != AV_PROFILE_UNKNOWN)
377  profile = st->codecpar->profile;
378  if (st->codecpar->level != AV_LEVEL_UNKNOWN)
379  level = st->codecpar->level;
380 
381  /* check the boundary of data which from current position is small than extradata_size */
382  while (data && (data - st->codecpar->extradata + 19) < st->codecpar->extradata_size) {
383  /* get HEVC SPS NAL and seek to profile_tier_level */
384  if (!(data[0] | data[1] | data[2]) && data[3] == 1 && ((data[4] & 0x7E) == 0x42)) {
385  uint8_t *rbsp_buf;
386  int remain_size = 0;
387  int rbsp_size = 0;
388  /* skip start code + nalu header */
389  data += 6;
390  /* process by reference General NAL unit syntax */
391  remain_size = st->codecpar->extradata_size - (data - st->codecpar->extradata);
392  rbsp_buf = ff_nal_unit_extract_rbsp(data, remain_size, &rbsp_size, 0);
393  if (!rbsp_buf)
394  return;
395  if (rbsp_size < 13) {
396  av_freep(&rbsp_buf);
397  break;
398  }
399  /* skip sps_video_parameter_set_id u(4),
400  * sps_max_sub_layers_minus1 u(3),
401  * and sps_temporal_id_nesting_flag u(1) */
402  profile = rbsp_buf[1] & 0x1f;
403  /* skip 8 + 8 + 32 + 4 + 43 + 1 bit */
404  level = rbsp_buf[12];
405  av_freep(&rbsp_buf);
406  break;
407  }
408  data++;
409  }
410  if (st->codecpar->codec_tag == MKTAG('h','v','c','1') &&
412  level != AV_LEVEL_UNKNOWN) {
413  snprintf(attr, sizeof(attr), "%s.%d.4.L%d.B01", av_fourcc2str(st->codecpar->codec_tag), profile, level);
414  } else
415  goto fail;
416  } else if (st->codecpar->codec_id == AV_CODEC_ID_MP2) {
417  snprintf(attr, sizeof(attr), "mp4a.40.33");
418  } else if (st->codecpar->codec_id == AV_CODEC_ID_MP3) {
419  snprintf(attr, sizeof(attr), "mp4a.40.34");
420  } else if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
421  /* TODO : For HE-AAC, HE-AACv2, the last digit needs to be set to 5 and 29 respectively */
422  snprintf(attr, sizeof(attr), "mp4a.40.2");
423  } else if (st->codecpar->codec_id == AV_CODEC_ID_AC3) {
424  snprintf(attr, sizeof(attr), "ac-3");
425  } else if (st->codecpar->codec_id == AV_CODEC_ID_EAC3) {
426  snprintf(attr, sizeof(attr), "ec-3");
427  } else {
428  goto fail;
429  }
430  // Don't write the same attribute multiple times
431  if (!av_stristr(vs->codec_attr, attr)) {
432  snprintf(vs->codec_attr + codec_strlen,
433  sizeof(vs->codec_attr) - codec_strlen,
434  "%s%s", codec_strlen ? "," : "", attr);
435  }
436  return;
437 
438 fail:
439  vs->codec_attr[0] = '\0';
441  return;
442 }
443 
444 static int replace_str_data_in_filename(char **s, const char *filename, char placeholder, const char *datastring)
445 {
446  const char *p;
447  char c;
448  int addchar_count;
449  int found_count = 0;
450  AVBPrint buf;
451  int ret;
452 
454 
455  p = filename;
456  for (;;) {
457  c = *p;
458  if (c == '\0')
459  break;
460  if (c == '%' && *(p+1) == '%') // %%
461  addchar_count = 2;
462  else if (c == '%' && *(p+1) == placeholder) {
463  av_bprintf(&buf, "%s", datastring);
464  p += 2;
465  addchar_count = 0;
466  found_count ++;
467  } else
468  addchar_count = 1;
469 
470  if (addchar_count > 0) {
471  av_bprint_append_data(&buf, p, addchar_count);
472  p += addchar_count;
473  }
474  }
475  if (!av_bprint_is_complete(&buf)) {
476  av_bprint_finalize(&buf, NULL);
477  return AVERROR(ENOMEM);
478  }
479  if ((ret = av_bprint_finalize(&buf, s)) < 0)
480  return ret;
481  return found_count;
482 }
483 
484 static int replace_int_data_in_filename(char **s, const char *filename, char placeholder, int64_t number)
485 {
486  const char *p;
487  char c;
488  int nd, addchar_count;
489  int found_count = 0;
490  AVBPrint buf;
491  int ret;
492 
494 
495  p = filename;
496  for (;;) {
497  c = *p;
498  if (c == '\0')
499  break;
500  if (c == '%' && *(p+1) == '%') // %%
501  addchar_count = 2;
502  else if (c == '%' && (av_isdigit(*(p+1)) || *(p+1) == placeholder)) {
503  nd = 0;
504  addchar_count = 1;
505  while (av_isdigit(*(p + addchar_count))) {
506  nd = nd * 10 + *(p + addchar_count) - '0';
507  addchar_count++;
508  }
509 
510  if (*(p + addchar_count) == placeholder) {
511  av_bprintf(&buf, "%0*"PRId64, (number < 0) ? nd : nd++, number);
512  p += (addchar_count + 1);
513  addchar_count = 0;
514  found_count++;
515  }
516 
517  } else
518  addchar_count = 1;
519 
520  av_bprint_append_data(&buf, p, addchar_count);
521  p += addchar_count;
522  }
523  if (!av_bprint_is_complete(&buf)) {
524  av_bprint_finalize(&buf, NULL);
525  return AVERROR(ENOMEM);
526  }
527  if ((ret = av_bprint_finalize(&buf, s)) < 0)
528  return ret;
529  return found_count;
530 }
531 
532 static void write_styp(AVIOContext *pb)
533 {
534  avio_wb32(pb, 24);
535  ffio_wfourcc(pb, "styp");
536  ffio_wfourcc(pb, "msdh");
537  avio_wb32(pb, 0); /* minor */
538  ffio_wfourcc(pb, "msdh");
539  ffio_wfourcc(pb, "msix");
540 }
541 
542 static int flush_dynbuf(VariantStream *vs, int *range_length)
543 {
544  AVFormatContext *ctx = vs->avf;
545 
546  if (!ctx->pb) {
547  return AVERROR(EINVAL);
548  }
549 
550  // flush
552 
553  // write out to file
554  *range_length = avio_close_dyn_buf(ctx->pb, &vs->temp_buffer);
555  ctx->pb = NULL;
556  avio_write(vs->out, vs->temp_buffer, *range_length);
557  avio_flush(vs->out);
558 
559  // re-open buffer
560  return avio_open_dyn_buf(&ctx->pb);
561 }
562 
563 static void reflush_dynbuf(VariantStream *vs, int *range_length)
564 {
565  // re-open buffer
566  avio_write(vs->out, vs->temp_buffer, *range_length);
567 }
568 
569 #if HAVE_DOS_PATHS
570 #define SEPARATOR '\\'
571 #else
572 #define SEPARATOR '/'
573 #endif
574 
576  char *path, const char *proto)
577 {
578  if (hls->method || (proto && !av_strcasecmp(proto, "http"))) {
579  AVDictionary *opt = NULL;
580  int ret;
581 
582  set_http_options(avf, &opt, hls);
583  av_dict_set(&opt, "method", "DELETE", 0);
584 
585  ret = hlsenc_io_open(avf, &hls->http_delete, path, &opt);
586  av_dict_free(&opt);
587  if (ret < 0)
588  return hls->ignore_io_errors ? 1 : ret;
589 
590  //Nothing to write
591  hlsenc_io_close(avf, &hls->http_delete, path);
592  } else if (unlink(path) < 0) {
593  av_log(hls, AV_LOG_ERROR, "failed to delete old segment %s: %s\n",
594  path, strerror(errno));
595  }
596  return 0;
597 }
598 
600  VariantStream *vs)
601 {
602 
603  HLSSegment *segment, *previous_segment = NULL;
604  float playlist_duration = 0.0f;
605  int ret = 0;
606  int segment_cnt = 0;
607  AVBPrint path;
608  const char *dirname = NULL;
609  char *dirname_r = NULL;
610  char *dirname_repl = NULL;
611  const char *vtt_dirname = NULL;
612  char *vtt_dirname_r = NULL;
613  const char *proto = NULL;
614 
616 
617  segment = vs->segments;
618  while (segment) {
619  playlist_duration += segment->duration;
620  segment = segment->next;
621  }
622 
623  segment = vs->old_segments;
624  segment_cnt = 0;
625  while (segment) {
626  playlist_duration -= segment->duration;
627  previous_segment = segment;
628  segment = previous_segment->next;
629  segment_cnt++;
630  if (playlist_duration <= -previous_segment->duration) {
631  previous_segment->next = NULL;
632  break;
633  }
634  if (segment_cnt >= hls->hls_delete_threshold) {
635  previous_segment->next = NULL;
636  break;
637  }
638  }
639 
640  if (segment && !hls->use_localtime_mkdir) {
641  dirname_r = hls->segment_filename ? av_strdup(hls->segment_filename): av_strdup(vs->avf->url);
642  dirname = av_dirname(dirname_r);
643  }
644 
645  /* if %v is present in the file's directory
646  * all segment belongs to the same variant, so do it only once before the loop*/
647  if (dirname && av_stristr(dirname, "%v")) {
648  if (!vs->varname) {
649  if (replace_int_data_in_filename(&dirname_repl, dirname, 'v', segment->var_stream_idx) < 1) {
650  ret = AVERROR(EINVAL);
651  goto fail;
652  }
653  } else {
654  if (replace_str_data_in_filename(&dirname_repl, dirname, 'v', vs->varname) < 1) {
655  ret = AVERROR(EINVAL);
656  goto fail;
657  }
658  }
659 
660  dirname = dirname_repl;
661  }
662 
663  while (segment) {
664  av_log(hls, AV_LOG_DEBUG, "deleting old segment %s\n",
665  segment->filename);
666  if (!hls->use_localtime_mkdir) // segment->filename contains basename only
667  av_bprintf(&path, "%s%c", dirname, SEPARATOR);
668  av_bprintf(&path, "%s", segment->filename);
669 
670  if (!av_bprint_is_complete(&path)) {
671  ret = AVERROR(ENOMEM);
672  goto fail;
673  }
674 
675  proto = avio_find_protocol_name(s->url);
676  if (ret = hls_delete_file(hls, s, path.str, proto))
677  goto fail;
678 
679  if ((segment->sub_filename[0] != '\0')) {
680  vtt_dirname_r = av_strdup(vs->vtt_avf->url);
681  vtt_dirname = av_dirname(vtt_dirname_r);
682 
683  av_bprint_clear(&path);
684  av_bprintf(&path, "%s%c%s", vtt_dirname, SEPARATOR,
685  segment->sub_filename);
686  av_freep(&vtt_dirname_r);
687 
688  if (!av_bprint_is_complete(&path)) {
689  ret = AVERROR(ENOMEM);
690  goto fail;
691  }
692 
693  if (ret = hls_delete_file(hls, s, path.str, proto))
694  goto fail;
695  }
696  av_bprint_clear(&path);
697  previous_segment = segment;
698  segment = previous_segment->next;
699  av_freep(&previous_segment);
700  }
701 
702 fail:
703  av_bprint_finalize(&path, NULL);
704  av_freep(&dirname_r);
705  av_freep(&dirname_repl);
706 
707  return ret;
708 }
709 
711 {
712  HLSContext *hls = s->priv_data;
713  int ret;
714  int len;
715  AVIOContext *pb;
716  uint8_t key[KEYSIZE];
717  char * key_basename_source = (hls->master_m3u8_url) ? hls->master_m3u8_url : s->url;
718 
719  len = strlen(key_basename_source) + 4 + 1;
720  hls->key_basename = av_mallocz(len);
721  if (!hls->key_basename)
722  return AVERROR(ENOMEM);
723 
724  av_strlcpy(hls->key_basename, key_basename_source, len);
725  av_strlcat(hls->key_basename, ".key", len);
726 
727  if (hls->key_url) {
728  av_strlcpy(hls->key_file, hls->key_url, sizeof(hls->key_file));
729  av_strlcpy(hls->key_uri, hls->key_url, sizeof(hls->key_uri));
730  } else {
731  av_strlcpy(hls->key_file, hls->key_basename, sizeof(hls->key_file));
732  av_strlcpy(hls->key_uri, hls->key_basename, sizeof(hls->key_uri));
733  }
734 
735  if (!*hls->iv_string) {
736  uint8_t iv[16] = { 0 };
737  char buf[33];
738 
739  if (!hls->iv) {
740  AV_WB64(iv + 8, vs->sequence);
741  } else {
742  memcpy(iv, hls->iv, sizeof(iv));
743  }
744  ff_data_to_hex(buf, iv, sizeof(iv), 0);
745  memcpy(hls->iv_string, buf, sizeof(hls->iv_string));
746  }
747 
748  if (!*hls->key_uri) {
749  av_log(hls, AV_LOG_ERROR, "no key URI specified in key info file\n");
750  return AVERROR(EINVAL);
751  }
752 
753  if (!*hls->key_file) {
754  av_log(hls, AV_LOG_ERROR, "no key file specified in key info file\n");
755  return AVERROR(EINVAL);
756  }
757 
758  if (!*hls->key_string) {
760  if (!hls->key) {
761  if ((ret = av_random_bytes(key, sizeof(key))) < 0) {
762  av_log(s, AV_LOG_ERROR, "Cannot generate a strong random key\n");
763  return ret;
764  }
765  } else {
766  memcpy(key, hls->key, sizeof(key));
767  }
768 
769  ff_data_to_hex(hls->key_string, key, sizeof(key), 0);
770  set_http_options(s, &options, hls);
771  ret = s->io_open(s, &pb, hls->key_file, AVIO_FLAG_WRITE, &options);
773  if (ret < 0)
774  return ret;
775  avio_seek(pb, 0, SEEK_CUR);
776  avio_write(pb, key, KEYSIZE);
777  avio_close(pb);
778  }
779  return 0;
780 }
781 
782 
784 {
785  HLSContext *hls = s->priv_data;
786  int ret;
787  AVIOContext *pb;
788  uint8_t key[KEYSIZE];
790 
791  set_http_options(s, &options, hls);
792  ret = s->io_open(s, &pb, hls->key_info_file, AVIO_FLAG_READ, &options);
794  if (ret < 0) {
795  av_log(hls, AV_LOG_ERROR,
796  "error opening key info file %s\n", hls->key_info_file);
797  return ret;
798  }
799 
800  ff_get_line(pb, vs->key_uri, sizeof(vs->key_uri));
801  vs->key_uri[strcspn(vs->key_uri, "\r\n")] = '\0';
802 
803  ff_get_line(pb, vs->key_file, sizeof(vs->key_file));
804  vs->key_file[strcspn(vs->key_file, "\r\n")] = '\0';
805 
806  ff_get_line(pb, vs->iv_string, sizeof(vs->iv_string));
807  vs->iv_string[strcspn(vs->iv_string, "\r\n")] = '\0';
808 
809  ff_format_io_close(s, &pb);
810 
811  if (!*vs->key_uri) {
812  av_log(hls, AV_LOG_ERROR, "no key URI specified in key info file\n");
813  return AVERROR(EINVAL);
814  }
815 
816  if (!*vs->key_file) {
817  av_log(hls, AV_LOG_ERROR, "no key file specified in key info file\n");
818  return AVERROR(EINVAL);
819  }
820 
821  set_http_options(s, &options, hls);
822  ret = s->io_open(s, &pb, vs->key_file, AVIO_FLAG_READ, &options);
824  if (ret < 0) {
825  av_log(hls, AV_LOG_ERROR, "error opening key file %s\n", vs->key_file);
826  return ret;
827  }
828 
829  ret = avio_read(pb, key, sizeof(key));
830  ff_format_io_close(s, &pb);
831  if (ret != sizeof(key)) {
832  av_log(hls, AV_LOG_ERROR, "error reading key file %s\n", vs->key_file);
833  if (ret >= 0 || ret == AVERROR_EOF)
834  ret = AVERROR(EINVAL);
835  return ret;
836  }
837  ff_data_to_hex(vs->key_string, key, sizeof(key), 0);
838 
839  return 0;
840 }
841 
843 {
845  HLSContext *hls = s->priv_data;
846  AVFormatContext *oc;
847  AVFormatContext *vtt_oc = NULL;
848  int byterange_mode = (hls->flags & HLS_SINGLE_FILE) || (hls->max_seg_size > 0);
849  int remaining_options;
850  int i, ret;
851 
853  if (ret < 0)
854  return ret;
855  oc = vs->avf;
856 
857  oc->url = av_strdup("");
858  if (!oc->url)
859  return AVERROR(ENOMEM);
860 
861  oc->interrupt_callback = s->interrupt_callback;
862  oc->max_delay = s->max_delay;
863  oc->opaque = s->opaque;
864  oc->io_open = s->io_open;
865 #if FF_API_AVFORMAT_IO_CLOSE
867  oc->io_close = s->io_close;
869 #endif
870  oc->io_close2 = s->io_close2;
871  oc->strict_std_compliance = s->strict_std_compliance;
872  av_dict_copy(&oc->metadata, s->metadata, 0);
873 
874  if (vs->vtt_oformat) {
876  if (ret < 0)
877  return ret;
878  vtt_oc = vs->vtt_avf;
879  av_dict_copy(&vtt_oc->metadata, s->metadata, 0);
880  }
881 
882  for (i = 0; i < vs->nb_streams; i++) {
883  AVStream *st;
884  AVFormatContext *loc;
886  loc = vtt_oc;
887  else
888  loc = oc;
889 
890  if (!(st = avformat_new_stream(loc, NULL)))
891  return AVERROR(ENOMEM);
893  if (!oc->oformat->codec_tag ||
897  } else {
898  st->codecpar->codec_tag = 0;
899  }
900 
902  st->time_base = vs->streams[i]->time_base;
903  av_dict_copy(&st->metadata, vs->streams[i]->metadata, 0);
904  st->id = vs->streams[i]->id;
905  }
906 
907  vs->start_pos = 0;
908  vs->new_start = 1;
909 
910  if (hls->segment_type == SEGMENT_TYPE_FMP4 && hls->max_seg_size > 0) {
911  if (hls->http_persistent > 0) {
912  //TODO: Support fragment fmp4 for http persistent in HLS muxer.
913  av_log(s, AV_LOG_WARNING, "http persistent mode is currently unsupported for fragment mp4 in the HLS muxer.\n");
914  }
915  if (hls->max_seg_size > 0) {
916  av_log(s, AV_LOG_WARNING, "Multi-file byterange mode is currently unsupported in the HLS muxer.\n");
917  return AVERROR_PATCHWELCOME;
918  }
919  }
920 
921  if ((ret = avio_open_dyn_buf(&oc->pb)) < 0)
922  return ret;
923 
924  if (hls->segment_type == SEGMENT_TYPE_FMP4) {
925  set_http_options(s, &options, hls);
926  if (byterange_mode) {
927  ret = hlsenc_io_open(s, &vs->out, vs->basename, &options);
928  } else {
930  }
932  }
933  if (ret < 0) {
934  av_log(s, AV_LOG_ERROR, "Failed to open segment '%s'\n", vs->fmp4_init_filename);
935  return ret;
936  }
937 
939  if (hls->segment_type == SEGMENT_TYPE_FMP4) {
940  av_dict_set(&options, "fflags", "-autobsf", 0);
941  av_dict_set(&options, "movflags", "+frag_custom+dash+delay_moov", AV_DICT_APPEND);
942  } else {
943  /* We only require one PAT/PMT per segment. */
944  char period[21];
945  snprintf(period, sizeof(period), "%d", (INT_MAX / 2) - 1);
948  }
950  remaining_options = av_dict_count(options);
952  if (ret < 0)
953  return ret;
954  if (remaining_options) {
955  av_log(s, AV_LOG_ERROR, "Some of the provided format options are not recognized\n");
956  return AVERROR(EINVAL);
957  }
958  avio_flush(oc->pb);
959  return 0;
960 }
961 
962 static HLSSegment *find_segment_by_filename(HLSSegment *segment, const char *filename)
963 {
964  while (segment) {
965  if (!av_strcasecmp(segment->filename,filename))
966  return segment;
967  segment = segment->next;
968  }
969  return (HLSSegment *) NULL;
970 }
971 
973  VariantStream *vs, HLSSegment *en,
974  double duration, int64_t pos, int64_t size)
975 {
978  char * new_url = av_strdup(vs->current_segment_final_filename_fmt);
979  if (!new_url) {
980  return AVERROR(ENOMEM);
981  }
982  ff_format_set_url(vs->avf, new_url);
984  char *filename = NULL;
985  if (replace_int_data_in_filename(&filename, vs->avf->url, 's', pos + size) < 1) {
986  av_log(hls, AV_LOG_ERROR,
987  "Invalid second level segment filename template '%s', "
988  "you can try to remove second_level_segment_size flag\n",
989  vs->avf->url);
990  av_freep(&filename);
991  return AVERROR(EINVAL);
992  }
993  ff_format_set_url(vs->avf, filename);
994  }
996  char *filename = NULL;
997  if (replace_int_data_in_filename(&filename, vs->avf->url,
998  't', (int64_t)round(duration * HLS_MICROSECOND_UNIT)) < 1) {
999  av_log(hls, AV_LOG_ERROR,
1000  "Invalid second level segment filename template '%s', "
1001  "you can try to remove second_level_segment_time flag\n",
1002  vs->avf->url);
1003  av_freep(&filename);
1004  return AVERROR(EINVAL);
1005  }
1006  ff_format_set_url(vs->avf, filename);
1007  }
1008  }
1009  return 0;
1010 }
1011 
1013 {
1014  int ret = 0;
1015 
1017  av_log(hls, AV_LOG_ERROR,
1018  "second_level_segment_duration hls_flag requires strftime to be true\n");
1019  ret = AVERROR(EINVAL);
1020  }
1021  if (hls->flags & HLS_SECOND_LEVEL_SEGMENT_SIZE) {
1022  av_log(hls, AV_LOG_ERROR,
1023  "second_level_segment_size hls_flag requires strfime to be true\n");
1024  ret = AVERROR(EINVAL);
1025  }
1027  av_log(hls, AV_LOG_ERROR,
1028  "second_level_segment_index hls_flag requires strftime to be true\n");
1029  ret = AVERROR(EINVAL);
1030  }
1031 
1032  return ret;
1033 }
1034 
1036 {
1037  const char *proto = avio_find_protocol_name(vs->basename);
1038  int segment_renaming_ok = proto && !strcmp(proto, "file");
1039  int ret = 0;
1040 
1041  if ((hls->flags & HLS_SECOND_LEVEL_SEGMENT_DURATION) && !segment_renaming_ok) {
1042  av_log(hls, AV_LOG_ERROR,
1043  "second_level_segment_duration hls_flag works only with file protocol segment names\n");
1044  ret = AVERROR(EINVAL);
1045  }
1046  if ((hls->flags & HLS_SECOND_LEVEL_SEGMENT_SIZE) && !segment_renaming_ok) {
1047  av_log(hls, AV_LOG_ERROR,
1048  "second_level_segment_size hls_flag works only with file protocol segment names\n");
1049  ret = AVERROR(EINVAL);
1050  }
1051 
1052  return ret;
1053 }
1054 
1055 static void sls_flag_file_rename(HLSContext *hls, VariantStream *vs, char *old_filename) {
1057  strlen(vs->current_segment_final_filename_fmt)) {
1058  ff_rename(old_filename, vs->avf->url, hls);
1059  }
1060 }
1061 
1063 {
1064  if (c->flags & HLS_SECOND_LEVEL_SEGMENT_INDEX) {
1065  char *filename = NULL;
1066  if (replace_int_data_in_filename(&filename,
1067  oc->url, 'd', vs->sequence) < 1) {
1068  av_log(c, AV_LOG_ERROR, "Invalid second level segment filename template '%s', "
1069  "you can try to remove second_level_segment_index flag\n",
1070  oc->url);
1071  av_freep(&filename);
1072  return AVERROR(EINVAL);
1073  }
1074  ff_format_set_url(oc, filename);
1075  }
1079  if (c->flags & HLS_SECOND_LEVEL_SEGMENT_SIZE) {
1080  char *filename = NULL;
1081  if (replace_int_data_in_filename(&filename, oc->url, 's', 0) < 1) {
1082  av_log(c, AV_LOG_ERROR, "Invalid second level segment filename template '%s', "
1083  "you can try to remove second_level_segment_size flag\n",
1084  oc->url);
1085  av_freep(&filename);
1086  return AVERROR(EINVAL);
1087  }
1088  ff_format_set_url(oc, filename);
1089  }
1090  if (c->flags & HLS_SECOND_LEVEL_SEGMENT_DURATION) {
1091  char *filename = NULL;
1092  if (replace_int_data_in_filename(&filename, oc->url, 't', 0) < 1) {
1093  av_log(c, AV_LOG_ERROR, "Invalid second level segment filename template '%s', "
1094  "you can try to remove second_level_segment_time flag\n",
1095  oc->url);
1096  av_freep(&filename);
1097  return AVERROR(EINVAL);
1098  }
1099  ff_format_set_url(oc, filename);
1100  }
1101  }
1102  return 0;
1103 }
1104 
1105 /* Create a new segment and append it to the segment list */
1107  VariantStream *vs, double duration, int64_t pos,
1108  int64_t size)
1109 {
1110  HLSSegment *en = av_malloc(sizeof(*en));
1111  const char *filename;
1112  int byterange_mode = (hls->flags & HLS_SINGLE_FILE) || (hls->max_seg_size > 0);
1113  int ret;
1114 
1115  if (!en)
1116  return AVERROR(ENOMEM);
1117 
1118  en->var_stream_idx = vs->var_stream_idx;
1119  ret = sls_flags_filename_process(s, hls, vs, en, duration, pos, size);
1120  if (ret < 0) {
1121  av_freep(&en);
1122  return ret;
1123  }
1124 
1125  filename = av_basename(vs->avf->url);
1126 
1127  if (hls->use_localtime_mkdir) {
1128  filename = vs->avf->url;
1129  }
1130  if ((find_segment_by_filename(vs->segments, filename) || find_segment_by_filename(vs->old_segments, filename))
1131  && !byterange_mode) {
1132  av_log(hls, AV_LOG_WARNING, "Duplicated segment filename detected: %s\n", filename);
1133  }
1134  av_strlcpy(en->filename, filename, sizeof(en->filename));
1135 
1136  if (vs->has_subtitle)
1137  av_strlcpy(en->sub_filename, av_basename(vs->vtt_avf->url), sizeof(en->sub_filename));
1138  else
1139  en->sub_filename[0] = '\0';
1140 
1141  en->duration = duration;
1142  en->pos = pos;
1143  en->size = size;
1144  en->keyframe_pos = vs->video_keyframe_pos;
1146  en->next = NULL;
1147  en->discont = 0;
1148  en->discont_program_date_time = 0;
1149 
1150  if (vs->discontinuity) {
1151  en->discont = 1;
1152  vs->discontinuity = 0;
1153  }
1154 
1155  if (hls->key_info_file || hls->encrypt) {
1156  av_strlcpy(en->key_uri, vs->key_uri, sizeof(en->key_uri));
1157  av_strlcpy(en->iv_string, vs->iv_string, sizeof(en->iv_string));
1158  }
1159 
1160  if (!vs->segments)
1161  vs->segments = en;
1162  else
1163  vs->last_segment->next = en;
1164 
1165  vs->last_segment = en;
1166 
1167  // EVENT or VOD playlists imply sliding window cannot be used
1168  if (hls->pl_type != PLAYLIST_TYPE_NONE)
1169  hls->max_nb_segments = 0;
1170 
1171  if (hls->max_nb_segments && vs->nb_entries >= hls->max_nb_segments) {
1172  en = vs->segments;
1174  vs->initial_prog_date_time += en->duration;
1175  vs->segments = en->next;
1176  if (en && hls->flags & HLS_DELETE_SEGMENTS &&
1177  !(hls->flags & HLS_SINGLE_FILE)) {
1178  en->next = vs->old_segments;
1179  vs->old_segments = en;
1180  if ((ret = hls_delete_old_segments(s, hls, vs)) < 0)
1181  return ret;
1182  } else
1183  av_freep(&en);
1184  } else
1185  vs->nb_entries++;
1186 
1187  if (hls->max_seg_size > 0) {
1188  return 0;
1189  }
1190  vs->sequence++;
1191 
1192  return 0;
1193 }
1194 
1195 static int parse_playlist(AVFormatContext *s, const char *url, VariantStream *vs)
1196 {
1197  HLSContext *hls = s->priv_data;
1198  AVIOContext *in;
1199  int ret = 0, is_segment = 0;
1200  int64_t new_start_pos;
1201  char line[MAX_URL_SIZE];
1202  const char *ptr;
1203  const char *end;
1204  double discont_program_date_time = 0;
1205 
1206  if ((ret = ffio_open_whitelist(&in, url, AVIO_FLAG_READ,
1207  &s->interrupt_callback, NULL,
1208  s->protocol_whitelist, s->protocol_blacklist)) < 0)
1209  return ret;
1210 
1211  ff_get_chomp_line(in, line, sizeof(line));
1212  if (strcmp(line, "#EXTM3U")) {
1214  goto fail;
1215  }
1216 
1217  vs->discontinuity = 0;
1218  while (!avio_feof(in)) {
1219  ff_get_chomp_line(in, line, sizeof(line));
1220  if (av_strstart(line, "#EXT-X-MEDIA-SEQUENCE:", &ptr)) {
1221  int64_t tmp_sequence = strtoll(ptr, NULL, 10);
1222  if (tmp_sequence < vs->sequence)
1223  av_log(hls, AV_LOG_VERBOSE,
1224  "Found playlist sequence number was smaller """
1225  "than specified start sequence number: %"PRId64" < %"PRId64", "
1226  "omitting\n", tmp_sequence, hls->start_sequence);
1227  else {
1228  av_log(hls, AV_LOG_DEBUG, "Found playlist sequence number: %"PRId64"\n", tmp_sequence);
1229  vs->sequence = tmp_sequence;
1230  }
1231  } else if (av_strstart(line, "#EXT-X-DISCONTINUITY", &ptr)) {
1232  is_segment = 1;
1233  vs->discontinuity = 1;
1234  } else if (av_strstart(line, "#EXTINF:", &ptr)) {
1235  is_segment = 1;
1236  vs->duration = atof(ptr);
1237  } else if (av_stristart(line, "#EXT-X-KEY:", &ptr)) {
1238  ptr = av_stristr(line, "URI=\"");
1239  if (ptr) {
1240  ptr += strlen("URI=\"");
1241  end = av_stristr(ptr, ",");
1242  if (end) {
1243  av_strlcpy(vs->key_uri, ptr, end - ptr);
1244  } else {
1245  av_strlcpy(vs->key_uri, ptr, sizeof(vs->key_uri));
1246  }
1247  }
1248 
1249  ptr = av_stristr(line, "IV=0x");
1250  if (ptr) {
1251  ptr += strlen("IV=0x");
1252  end = av_stristr(ptr, ",");
1253  if (end) {
1254  av_strlcpy(vs->iv_string, ptr, end - ptr);
1255  } else {
1256  av_strlcpy(vs->iv_string, ptr, sizeof(vs->iv_string));
1257  }
1258  }
1259  } else if (av_strstart(line, "#EXT-X-PROGRAM-DATE-TIME:", &ptr)) {
1260  struct tm program_date_time;
1261  int y,M,d,h,m,s;
1262  double ms;
1263  if (sscanf(ptr, "%d-%d-%dT%d:%d:%d.%lf", &y, &M, &d, &h, &m, &s, &ms) != 7) {
1265  goto fail;
1266  }
1267 
1268  program_date_time.tm_year = y - 1900;
1269  program_date_time.tm_mon = M - 1;
1270  program_date_time.tm_mday = d;
1271  program_date_time.tm_hour = h;
1272  program_date_time.tm_min = m;
1273  program_date_time.tm_sec = s;
1274  program_date_time.tm_isdst = -1;
1275 
1276  discont_program_date_time = mktime(&program_date_time);
1277  discont_program_date_time += (double)(ms / 1000);
1278  } else if (av_strstart(line, "#", NULL)) {
1279  continue;
1280  } else if (line[0]) {
1281  if (is_segment) {
1282  char *new_file = av_strdup(line);
1283  if (!new_file) {
1284  ret = AVERROR(ENOMEM);
1285  goto fail;
1286  }
1287  ff_format_set_url(vs->avf, new_file);
1288  is_segment = 0;
1289  new_start_pos = avio_tell(vs->avf->pb);
1290  vs->size = new_start_pos - vs->start_pos;
1291  ret = hls_append_segment(s, hls, vs, vs->duration, vs->start_pos, vs->size);
1292  if (discont_program_date_time) {
1293  vs->last_segment->discont_program_date_time = discont_program_date_time;
1294  discont_program_date_time += vs->duration;
1295  }
1296  if (ret < 0)
1297  goto fail;
1298  vs->start_pos = new_start_pos;
1299  }
1300  }
1301  }
1302 
1303 fail:
1304  avio_close(in);
1305  return ret;
1306 }
1307 
1309 {
1310  HLSSegment *en;
1311 
1312  while (p) {
1313  en = p;
1314  p = p->next;
1315  av_freep(&en);
1316  }
1317 }
1318 
1320 {
1321  size_t len = strlen(oc->url);
1322  char *final_filename = av_strdup(oc->url);
1323  int ret;
1324 
1325  if (!final_filename)
1326  return AVERROR(ENOMEM);
1327  final_filename[len-4] = '\0';
1328  ret = ff_rename(oc->url, final_filename, s);
1329  oc->url[len-4] = '\0';
1330  av_freep(&final_filename);
1331  return ret;
1332 }
1333 
1334 static const char* get_relative_url(const char *master_url, const char *media_url)
1335 {
1336  const char *p = strrchr(master_url, '/');
1337  size_t base_len = 0;
1338 
1339  if (!p) p = strrchr(master_url, '\\');
1340 
1341  if (p) {
1342  base_len = p - master_url;
1343  if (av_strncasecmp(master_url, media_url, base_len)) {
1344  av_log(NULL, AV_LOG_WARNING, "Unable to find relative url\n");
1345  return NULL;
1346  }
1347  } else {
1348  return media_url;
1349  }
1350 
1351  return media_url + base_len + 1;
1352 }
1353 
1354 static int64_t get_stream_bit_rate(AVStream *stream)
1355 {
1357  stream,
1359  NULL
1360  );
1361 
1362  if (stream->codecpar->bit_rate)
1363  return stream->codecpar->bit_rate;
1364  else if (props)
1365  return props->max_bitrate;
1366 
1367  return 0;
1368 }
1369 
1371  VariantStream * const input_vs)
1372 {
1373  HLSContext *hls = s->priv_data;
1374  VariantStream *vs, *temp_vs;
1375  AVStream *vid_st, *aud_st;
1377  unsigned int i, j;
1378  int ret, bandwidth;
1379  const char *m3u8_rel_name = NULL;
1380  const char *vtt_m3u8_rel_name = NULL;
1381  const char *ccgroup;
1382  const char *sgroup = NULL;
1383  ClosedCaptionsStream *ccs;
1384  const char *proto = avio_find_protocol_name(hls->master_m3u8_url);
1385  int is_file_proto = proto && !strcmp(proto, "file");
1386  int use_temp_file = is_file_proto && ((hls->flags & HLS_TEMP_FILE) || hls->master_publish_rate);
1387  char temp_filename[MAX_URL_SIZE];
1388 
1389  input_vs->m3u8_created = 1;
1390  if (!hls->master_m3u8_created) {
1391  /* For the first time, wait until all the media playlists are created */
1392  for (i = 0; i < hls->nb_varstreams; i++)
1393  if (!hls->var_streams[i].m3u8_created)
1394  return 0;
1395  } else {
1396  /* Keep publishing the master playlist at the configured rate */
1397  if (&hls->var_streams[0] != input_vs || !hls->master_publish_rate ||
1398  input_vs->number % hls->master_publish_rate)
1399  return 0;
1400  }
1401 
1402  set_http_options(s, &options, hls);
1403  snprintf(temp_filename, sizeof(temp_filename), use_temp_file ? "%s.tmp" : "%s", hls->master_m3u8_url);
1404  ret = hlsenc_io_open(s, &hls->m3u8_out, temp_filename, &options);
1406  if (ret < 0) {
1407  av_log(s, AV_LOG_ERROR, "Failed to open master play list file '%s'\n",
1408  temp_filename);
1409  goto fail;
1410  }
1411 
1413 
1414  for (i = 0; i < hls->nb_ccstreams; i++) {
1415  ccs = &(hls->cc_streams[i]);
1416  avio_printf(hls->m3u8_out, "#EXT-X-MEDIA:TYPE=CLOSED-CAPTIONS");
1417  avio_printf(hls->m3u8_out, ",GROUP-ID=\"%s\"", ccs->ccgroup);
1418  avio_printf(hls->m3u8_out, ",NAME=\"%s\"", ccs->instreamid);
1419  if (ccs->language)
1420  avio_printf(hls->m3u8_out, ",LANGUAGE=\"%s\"", ccs->language);
1421  avio_printf(hls->m3u8_out, ",INSTREAM-ID=\"%s\"\n", ccs->instreamid);
1422  }
1423 
1424  /* For audio only variant streams add #EXT-X-MEDIA tag with attributes*/
1425  for (i = 0; i < hls->nb_varstreams; i++) {
1426  vs = &(hls->var_streams[i]);
1427 
1428  if (vs->has_video || vs->has_subtitle || !vs->agroup)
1429  continue;
1430 
1431  m3u8_rel_name = get_relative_url(hls->master_m3u8_url, vs->m3u8_name);
1432  if (!m3u8_rel_name) {
1433  av_log(s, AV_LOG_ERROR, "Unable to find relative URL\n");
1434  goto fail;
1435  }
1436 
1437  ff_hls_write_audio_rendition(hls->m3u8_out, vs->agroup, m3u8_rel_name, vs->language, i, hls->has_default_key ? vs->is_default : 1);
1438  }
1439 
1440  /* For variant streams with video add #EXT-X-STREAM-INF tag with attributes*/
1441  for (i = 0; i < hls->nb_varstreams; i++) {
1442  vs = &(hls->var_streams[i]);
1443 
1444  m3u8_rel_name = get_relative_url(hls->master_m3u8_url, vs->m3u8_name);
1445  if (!m3u8_rel_name) {
1446  av_log(s, AV_LOG_ERROR, "Unable to find relative URL\n");
1447  goto fail;
1448  }
1449 
1450  vid_st = NULL;
1451  aud_st = NULL;
1452  for (j = 0; j < vs->nb_streams; j++) {
1454  vid_st = vs->streams[j];
1455  else if (vs->streams[j]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
1456  aud_st = vs->streams[j];
1457  }
1458 
1459  if (!vid_st && !aud_st) {
1460  av_log(s, AV_LOG_WARNING, "Media stream not found\n");
1461  continue;
1462  }
1463 
1464  /**
1465  * Traverse through the list of audio only rendition streams and find
1466  * the rendition which has highest bitrate in the same audio group
1467  */
1468  if (vs->agroup) {
1469  for (j = 0; j < hls->nb_varstreams; j++) {
1470  temp_vs = &(hls->var_streams[j]);
1471  if (!temp_vs->has_video && !temp_vs->has_subtitle &&
1472  temp_vs->agroup &&
1473  !av_strcasecmp(temp_vs->agroup, vs->agroup)) {
1474  if (!aud_st)
1475  aud_st = temp_vs->streams[0];
1476  if (temp_vs->streams[0]->codecpar->bit_rate >
1477  aud_st->codecpar->bit_rate)
1478  aud_st = temp_vs->streams[0];
1479  }
1480  }
1481  }
1482 
1483  bandwidth = 0;
1484  if (vid_st)
1485  bandwidth += get_stream_bit_rate(vid_st);
1486  if (aud_st)
1487  bandwidth += get_stream_bit_rate(aud_st);
1488  bandwidth += bandwidth / 10;
1489 
1490  ccgroup = NULL;
1491  if (vid_st && vs->ccgroup) {
1492  /* check if this group name is available in the cc map string */
1493  for (j = 0; j < hls->nb_ccstreams; j++) {
1494  ccs = &(hls->cc_streams[j]);
1495  if (!av_strcasecmp(ccs->ccgroup, vs->ccgroup)) {
1496  ccgroup = vs->ccgroup;
1497  break;
1498  }
1499  }
1500  if (j == hls->nb_ccstreams)
1501  av_log(s, AV_LOG_WARNING, "mapping ccgroup %s not found\n",
1502  vs->ccgroup);
1503  }
1504 
1505  if (vid_st && vs->sgroup) {
1506  sgroup = vs->sgroup;
1507  vtt_m3u8_rel_name = get_relative_url(hls->master_m3u8_url, vs->vtt_m3u8_name);
1508  if (!vtt_m3u8_rel_name) {
1509  av_log(s, AV_LOG_WARNING, "Unable to find relative subtitle URL\n");
1510  break;
1511  }
1512 
1513  ff_hls_write_subtitle_rendition(hls->m3u8_out, sgroup, vtt_m3u8_rel_name, vs->language, i, hls->has_default_key ? vs->is_default : 1);
1514  }
1515 
1516  if (!hls->has_default_key || !hls->has_video_m3u8) {
1517  ff_hls_write_stream_info(vid_st, hls->m3u8_out, bandwidth, m3u8_rel_name,
1518  aud_st ? vs->agroup : NULL, vs->codec_attr, ccgroup, sgroup);
1519  } else {
1520  if (vid_st) {
1521  ff_hls_write_stream_info(vid_st, hls->m3u8_out, bandwidth, m3u8_rel_name,
1522  aud_st ? vs->agroup : NULL, vs->codec_attr, ccgroup, sgroup);
1523  }
1524  }
1525  }
1526 fail:
1527  if (ret >=0)
1528  hls->master_m3u8_created = 1;
1529  hlsenc_io_close(s, &hls->m3u8_out, temp_filename);
1530  if (use_temp_file)
1531  ff_rename(temp_filename, hls->master_m3u8_url, s);
1532 
1533  return ret;
1534 }
1535 
1536 static int hls_window(AVFormatContext *s, int last, VariantStream *vs)
1537 {
1538  HLSContext *hls = s->priv_data;
1539  HLSSegment *en;
1540  int target_duration = 0;
1541  int ret = 0;
1542  char temp_filename[MAX_URL_SIZE];
1543  char temp_vtt_filename[MAX_URL_SIZE];
1544  int64_t sequence = FFMAX(hls->start_sequence, vs->sequence - vs->nb_entries);
1545  const char *proto = avio_find_protocol_name(vs->m3u8_name);
1546  int is_file_proto = proto && !strcmp(proto, "file");
1547  int use_temp_file = is_file_proto && ((hls->flags & HLS_TEMP_FILE) || !(hls->pl_type == PLAYLIST_TYPE_VOD));
1548  static unsigned warned_non_file;
1549  char *key_uri = NULL;
1550  char *iv_string = NULL;
1552  double prog_date_time = vs->initial_prog_date_time;
1553  double *prog_date_time_p = (hls->flags & HLS_PROGRAM_DATE_TIME) ? &prog_date_time : NULL;
1554  int byterange_mode = (hls->flags & HLS_SINGLE_FILE) || (hls->max_seg_size > 0);
1555 
1556  hls->version = 2;
1557  if (!(hls->flags & HLS_ROUND_DURATIONS)) {
1558  hls->version = 3;
1559  }
1560 
1561  if (byterange_mode) {
1562  hls->version = 4;
1563  sequence = 0;
1564  }
1565 
1566  if (hls->flags & HLS_I_FRAMES_ONLY) {
1567  hls->version = 4;
1568  }
1569 
1570  if (hls->flags & HLS_INDEPENDENT_SEGMENTS) {
1571  hls->version = 6;
1572  }
1573 
1574  if (hls->segment_type == SEGMENT_TYPE_FMP4) {
1575  hls->version = 7;
1576  }
1577 
1578  if (!is_file_proto && (hls->flags & HLS_TEMP_FILE) && !warned_non_file++)
1579  av_log(s, AV_LOG_ERROR, "Cannot use rename on non file protocol, this may lead to races and temporary partial files\n");
1580 
1581  set_http_options(s, &options, hls);
1582  snprintf(temp_filename, sizeof(temp_filename), use_temp_file ? "%s.tmp" : "%s", vs->m3u8_name);
1583  if ((ret = hlsenc_io_open(s, byterange_mode ? &hls->m3u8_out : &vs->out, temp_filename, &options)) < 0) {
1584  if (hls->ignore_io_errors)
1585  ret = 0;
1586  goto fail;
1587  }
1588 
1589  for (en = vs->segments; en; en = en->next) {
1590  if (target_duration <= en->duration)
1591  target_duration = lrint(en->duration);
1592  }
1593 
1594  vs->discontinuity_set = 0;
1595  ff_hls_write_playlist_header(byterange_mode ? hls->m3u8_out : vs->out, hls->version, hls->allowcache,
1596  target_duration, sequence, hls->pl_type, hls->flags & HLS_I_FRAMES_ONLY);
1597 
1598  if ((hls->flags & HLS_DISCONT_START) && sequence==hls->start_sequence && vs->discontinuity_set==0) {
1599  avio_printf(byterange_mode ? hls->m3u8_out : vs->out, "#EXT-X-DISCONTINUITY\n");
1600  vs->discontinuity_set = 1;
1601  }
1602  if (vs->has_video && (hls->flags & HLS_INDEPENDENT_SEGMENTS)) {
1603  avio_printf(byterange_mode ? hls->m3u8_out : vs->out, "#EXT-X-INDEPENDENT-SEGMENTS\n");
1604  }
1605  for (en = vs->segments; en; en = en->next) {
1606  if ((hls->encrypt || hls->key_info_file) && (!key_uri || strcmp(en->key_uri, key_uri) ||
1607  av_strcasecmp(en->iv_string, iv_string))) {
1608  avio_printf(byterange_mode ? hls->m3u8_out : vs->out, "#EXT-X-KEY:METHOD=AES-128,URI=\"%s\"", en->key_uri);
1609  if (*en->iv_string)
1610  avio_printf(byterange_mode ? hls->m3u8_out : vs->out, ",IV=0x%s", en->iv_string);
1611  avio_printf(byterange_mode ? hls->m3u8_out : vs->out, "\n");
1612  key_uri = en->key_uri;
1613  iv_string = en->iv_string;
1614  }
1615 
1616  if ((hls->segment_type == SEGMENT_TYPE_FMP4) && (en == vs->segments)) {
1617  ff_hls_write_init_file(byterange_mode ? hls->m3u8_out : vs->out, (hls->flags & HLS_SINGLE_FILE) ? en->filename : vs->fmp4_init_filename,
1618  hls->flags & HLS_SINGLE_FILE, vs->init_range_length, 0);
1619  }
1620 
1621  ret = ff_hls_write_file_entry(byterange_mode ? hls->m3u8_out : vs->out, en->discont, byterange_mode,
1622  en->duration, hls->flags & HLS_ROUND_DURATIONS,
1623  en->size, en->pos, hls->baseurl,
1624  en->filename,
1625  en->discont_program_date_time ? &en->discont_program_date_time : prog_date_time_p,
1627  if (en->discont_program_date_time)
1629  if (ret < 0) {
1630  av_log(s, AV_LOG_WARNING, "ff_hls_write_file_entry get error\n");
1631  }
1632  }
1633 
1634  if (last && (hls->flags & HLS_OMIT_ENDLIST)==0)
1635  ff_hls_write_end_list(byterange_mode ? hls->m3u8_out : vs->out);
1636 
1637  if (vs->vtt_m3u8_name) {
1638  snprintf(temp_vtt_filename, sizeof(temp_vtt_filename), use_temp_file ? "%s.tmp" : "%s", vs->vtt_m3u8_name);
1639  if ((ret = hlsenc_io_open(s, &hls->sub_m3u8_out, temp_vtt_filename, &options)) < 0) {
1640  if (hls->ignore_io_errors)
1641  ret = 0;
1642  goto fail;
1643  }
1645  target_duration, sequence, PLAYLIST_TYPE_NONE, 0);
1646  for (en = vs->segments; en; en = en->next) {
1647  ret = ff_hls_write_file_entry(hls->sub_m3u8_out, 0, byterange_mode,
1648  en->duration, 0, en->size, en->pos,
1649  hls->baseurl, en->sub_filename, NULL, 0, 0, 0);
1650  if (ret < 0) {
1651  av_log(s, AV_LOG_WARNING, "ff_hls_write_file_entry get error\n");
1652  }
1653  }
1654 
1655  if (last)
1657 
1658  }
1659 
1660 fail:
1662  ret = hlsenc_io_close(s, byterange_mode ? &hls->m3u8_out : &vs->out, temp_filename);
1663  if (ret < 0) {
1664  return ret;
1665  }
1667  if (use_temp_file) {
1668  ff_rename(temp_filename, vs->m3u8_name, s);
1669  if (vs->vtt_m3u8_name)
1670  ff_rename(temp_vtt_filename, vs->vtt_m3u8_name, s);
1671  }
1672  if (ret >= 0 && hls->master_pl_name)
1673  if (create_master_playlist(s, vs) < 0)
1674  av_log(s, AV_LOG_WARNING, "Master playlist creation failed\n");
1675 
1676  return ret;
1677 }
1678 
1680 {
1681  HLSContext *c = s->priv_data;
1682  AVFormatContext *oc = vs->avf;
1683  AVFormatContext *vtt_oc = vs->vtt_avf;
1685  const char *proto = NULL;
1686  int use_temp_file = 0;
1687  char iv_string[KEYSIZE*2 + 1];
1688  int err = 0;
1689 
1690  if (c->flags & HLS_SINGLE_FILE) {
1691  char *new_name = av_strdup(vs->basename);
1692  if (!new_name)
1693  return AVERROR(ENOMEM);
1694  ff_format_set_url(oc, new_name);
1695  if (vs->vtt_basename) {
1696  new_name = av_strdup(vs->vtt_basename);
1697  if (!new_name)
1698  return AVERROR(ENOMEM);
1699  ff_format_set_url(vtt_oc, new_name);
1700  }
1701  } else if (c->max_seg_size > 0) {
1702  char *filename = NULL;
1703  if (replace_int_data_in_filename(&filename,
1704  vs->basename, 'd', vs->sequence) < 1) {
1705  av_freep(&filename);
1706  av_log(oc, AV_LOG_ERROR, "Invalid segment filename template '%s', you can try to use -strftime 1 with it\n", vs->basename);
1707  return AVERROR(EINVAL);
1708  }
1709  ff_format_set_url(oc, filename);
1710  } else {
1711  if (c->use_localtime) {
1712  int r;
1713  char *expanded = NULL;
1714 
1715  r = strftime_expand(vs->basename, &expanded);
1716  if (r < 0) {
1717  av_log(oc, AV_LOG_ERROR, "Could not get segment filename with strftime\n");
1718  return r;
1719  }
1720  ff_format_set_url(oc, expanded);
1721 
1722  err = sls_flag_use_localtime_filename(oc, c, vs);
1723  if (err < 0) {
1724  return AVERROR(ENOMEM);
1725  }
1726 
1727  if (c->use_localtime_mkdir) {
1728  const char *dir;
1729  char *fn_copy = av_strdup(oc->url);
1730  if (!fn_copy)
1731  return AVERROR(ENOMEM);
1732  dir = av_dirname(fn_copy);
1733  if (ff_mkdir_p(dir) == -1 && errno != EEXIST) {
1734  av_log(oc, AV_LOG_ERROR, "Could not create directory %s with use_localtime_mkdir\n", dir);
1735  av_freep(&fn_copy);
1736  return AVERROR(errno);
1737  }
1738  av_freep(&fn_copy);
1739  }
1740  } else {
1741  char *filename = NULL;
1742  if (replace_int_data_in_filename(&filename,
1743  vs->basename, 'd', vs->sequence) < 1) {
1744  av_freep(&filename);
1745  av_log(oc, AV_LOG_ERROR, "Invalid segment filename template '%s' you can try to use -strftime 1 with it\n", vs->basename);
1746  return AVERROR(EINVAL);
1747  }
1748  ff_format_set_url(oc, filename);
1749  }
1750  if (vs->vtt_basename) {
1751  char *filename = NULL;
1752  if (replace_int_data_in_filename(&filename,
1753  vs->vtt_basename, 'd', vs->sequence) < 1) {
1754  av_freep(&filename);
1755  av_log(vtt_oc, AV_LOG_ERROR, "Invalid segment filename template '%s'\n", vs->vtt_basename);
1756  return AVERROR(EINVAL);
1757  }
1758  ff_format_set_url(vtt_oc, filename);
1759  }
1760  }
1761 
1762  proto = avio_find_protocol_name(oc->url);
1763  use_temp_file = proto && !strcmp(proto, "file") && (c->flags & HLS_TEMP_FILE);
1764 
1765  if (use_temp_file) {
1766  char *new_name = av_asprintf("%s.tmp", oc->url);
1767  if (!new_name)
1768  return AVERROR(ENOMEM);
1769  ff_format_set_url(oc, new_name);
1770  }
1771 
1772  if (c->key_info_file || c->encrypt) {
1773  if (c->segment_type == SEGMENT_TYPE_FMP4) {
1774  av_log(s, AV_LOG_ERROR, "Encrypted fmp4 not yet supported\n");
1775  return AVERROR_PATCHWELCOME;
1776  }
1777 
1778  if (c->key_info_file && c->encrypt) {
1779  av_log(s, AV_LOG_WARNING, "Cannot use both -hls_key_info_file and -hls_enc,"
1780  " ignoring -hls_enc\n");
1781  }
1782 
1783  if (!vs->encrypt_started || (c->flags & HLS_PERIODIC_REKEY)) {
1784  if (c->key_info_file) {
1785  if ((err = hls_encryption_start(s, vs)) < 0)
1786  goto fail;
1787  } else {
1788  if (!c->encrypt_started) {
1789  if ((err = do_encrypt(s, vs)) < 0)
1790  goto fail;
1791  c->encrypt_started = 1;
1792  }
1793  av_strlcpy(vs->key_uri, c->key_uri, sizeof(vs->key_uri));
1794  av_strlcpy(vs->key_string, c->key_string, sizeof(vs->key_string));
1795  av_strlcpy(vs->iv_string, c->iv_string, sizeof(vs->iv_string));
1796  }
1797  vs->encrypt_started = 1;
1798  }
1799  err = av_strlcpy(iv_string, vs->iv_string, sizeof(iv_string));
1800  if (!err) {
1801  snprintf(iv_string, sizeof(iv_string), "%032"PRIx64, vs->sequence);
1802  memset(vs->iv_string, 0, sizeof(vs->iv_string));
1803  memcpy(vs->iv_string, iv_string, sizeof(iv_string));
1804  }
1805  }
1806  if (c->segment_type != SEGMENT_TYPE_FMP4) {
1807  if (oc->oformat->priv_class && oc->priv_data) {
1808  av_opt_set(oc->priv_data, "mpegts_flags", "resend_headers", 0);
1809  }
1810  if (c->flags & HLS_SINGLE_FILE) {
1811  if (c->key_info_file || c->encrypt) {
1812  av_dict_set(&options, "encryption_key", vs->key_string, 0);
1813  av_dict_set(&options, "encryption_iv", vs->iv_string, 0);
1814 
1815  /* Write temp file with cryption content */
1816  av_freep(&vs->basename_tmp);
1817  vs->basename_tmp = av_asprintf("crypto:%s.tmp", oc->url);
1818 
1819  /* append temp file content into single file */
1820  av_freep(&vs->basename);
1821  vs->basename = av_asprintf("%s", oc->url);
1822  } else {
1823  vs->basename_tmp = vs->basename;
1824  }
1826  if (!vs->out_single_file)
1827  if ((err = hlsenc_io_open(s, &vs->out_single_file, vs->basename, &options)) < 0) {
1828  if (c->ignore_io_errors)
1829  err = 0;
1830  goto fail;
1831  }
1832 
1833  if ((err = hlsenc_io_open(s, &vs->out, vs->basename_tmp, &options)) < 0) {
1834  if (c->ignore_io_errors)
1835  err = 0;
1836  goto fail;
1837  }
1838 
1839  }
1840  }
1841  if (vs->vtt_basename) {
1843  if ((err = hlsenc_io_open(s, &vtt_oc->pb, vtt_oc->url, &options)) < 0) {
1844  if (c->ignore_io_errors)
1845  err = 0;
1846  goto fail;
1847  }
1848  }
1850 
1851  if (vs->vtt_basename) {
1852  err = avformat_write_header(vtt_oc,NULL);
1853  if (err < 0)
1854  return err;
1855  }
1856 
1857  return 0;
1858 fail:
1860 
1861  return err;
1862 }
1863 
1865 {
1866  char b[21];
1867  time_t t = time(NULL);
1868  struct tm *p, tmbuf;
1869  HLSContext *hls = s->priv_data;
1870 
1871  p = localtime_r(&t, &tmbuf);
1872  // no %s support when strftime returned error or left format string unchanged
1873  // also no %s support on MSVC, which invokes the invalid parameter handler on unsupported format strings, instead of returning an error
1874  if (hls->segment_type == SEGMENT_TYPE_FMP4) {
1875  return (HAVE_LIBC_MSVCRT || !strftime(b, sizeof(b), "%s", p) || !strcmp(b, "%s")) ? "-%Y%m%d%H%M%S.m4s" : "-%s.m4s";
1876  }
1877  return (HAVE_LIBC_MSVCRT || !strftime(b, sizeof(b), "%s", p) || !strcmp(b, "%s")) ? "-%Y%m%d%H%M%S.ts" : "-%s.ts";
1878 }
1879 
1880 static int append_postfix(char *name, int name_buf_len, int i)
1881 {
1882  char *p;
1883  char extension[10] = {'\0'};
1884 
1885  p = strrchr(name, '.');
1886  if (p) {
1887  av_strlcpy(extension, p, sizeof(extension));
1888  *p = '\0';
1889  }
1890 
1891  snprintf(name + strlen(name), name_buf_len - strlen(name), POSTFIX_PATTERN, i);
1892 
1893  if (strlen(extension))
1894  av_strlcat(name, extension, name_buf_len);
1895 
1896  return 0;
1897 }
1898 
1899 static int validate_name(int nb_vs, const char *fn)
1900 {
1901  const char *filename, *subdir_name;
1902  char *fn_dup = NULL;
1903  int ret = 0;
1904 
1905  if (!fn)
1906  return AVERROR(EINVAL);
1907 
1908  fn_dup = av_strdup(fn);
1909  if (!fn_dup)
1910  return AVERROR(ENOMEM);
1911  filename = av_basename(fn);
1912  subdir_name = av_dirname(fn_dup);
1913 
1914  if (nb_vs > 1 && !av_stristr(filename, "%v") && !av_stristr(subdir_name, "%v")) {
1915  av_log(NULL, AV_LOG_ERROR, "More than 1 variant streams are present, %%v is expected "
1916  "either in the filename or in the sub-directory name of file %s\n", fn);
1917  ret = AVERROR(EINVAL);
1918  goto fail;
1919  }
1920 
1921  if (av_stristr(filename, "%v") && av_stristr(subdir_name, "%v")) {
1922  av_log(NULL, AV_LOG_ERROR, "%%v is expected either in the filename or "
1923  "in the sub-directory name of file %s, but only in one of them\n", fn);
1924  ret = AVERROR(EINVAL);
1925  goto fail;
1926  }
1927 
1928 fail:
1929  av_freep(&fn_dup);
1930  return ret;
1931 }
1932 
1933 static int format_name(const char *buf, char **s, int index, const char *varname)
1934 {
1935  const char *proto, *dir;
1936  char *orig_buf_dup = NULL, *mod_buf_dup = NULL;
1937  int ret = 0;
1938 
1939  orig_buf_dup = av_strdup(buf);
1940  if (!orig_buf_dup)
1941  return AVERROR(ENOMEM);
1942 
1943  if (!av_stristr(buf, "%v")) {
1944  *s = orig_buf_dup;
1945  return 0;
1946  }
1947 
1948  if (!varname) {
1949  if (replace_int_data_in_filename(s, orig_buf_dup, 'v', index) < 1) {
1950  ret = AVERROR(EINVAL);
1951  goto fail;
1952  }
1953  } else {
1954  if (replace_str_data_in_filename(s, orig_buf_dup, 'v', varname) < 1) {
1955  ret = AVERROR(EINVAL);
1956  goto fail;
1957  }
1958  }
1959 
1960  proto = avio_find_protocol_name(orig_buf_dup);
1961  dir = av_dirname(orig_buf_dup);
1962 
1963  /* if %v is present in the file's directory, create sub-directory */
1964  if (av_stristr(dir, "%v") && proto && !strcmp(proto, "file")) {
1965  mod_buf_dup = av_strdup(*s);
1966  dir = av_dirname(mod_buf_dup);
1967  if (ff_mkdir_p(dir) == -1 && errno != EEXIST) {
1968  ret = AVERROR(errno);
1969  goto fail;
1970  }
1971  }
1972 
1973 fail:
1974  av_freep(&orig_buf_dup);
1975  av_freep(&mod_buf_dup);
1976  return ret;
1977 }
1978 
1980  enum AVMediaType codec_type,
1981  int64_t stream_id)
1982 {
1983  unsigned int stream_index, cnt;
1984  if (stream_id < 0 || stream_id > s->nb_streams - 1)
1985  return -1;
1986  cnt = 0;
1987  for (stream_index = 0; stream_index < s->nb_streams; stream_index++) {
1988  if (s->streams[stream_index]->codecpar->codec_type != codec_type)
1989  continue;
1990  if (cnt == stream_id)
1991  return stream_index;
1992  cnt++;
1993  }
1994  return -1;
1995 }
1996 
1998 {
1999  HLSContext *hls = s->priv_data;
2000  VariantStream *vs;
2001  int stream_index, i, j;
2002  enum AVMediaType codec_type;
2003  int nb_varstreams = 0, nb_streams;
2004  char *p, *q, *saveptr1, *saveptr2, *varstr, *keyval;
2005  const char *val;
2006 
2007  /**
2008  * Expected format for var_stream_map string is as below:
2009  * "a:0,v:0 a:1,v:1"
2010  * "a:0,agroup:a0,default:1,language:ENG a:1,agroup:a1,default:0 v:0,agroup:a0 v:1,agroup:a1"
2011  * This string specifies how to group the audio, video and subtitle streams
2012  * into different variant streams. The variant stream groups are separated
2013  * by space.
2014  *
2015  * a:, v:, s: are keys to specify audio, video and subtitle streams
2016  * respectively. Allowed values are 0 to 9 digits (limited just based on
2017  * practical usage)
2018  *
2019  * agroup: is key to specify audio group. A string can be given as value.
2020  * sgroup: is key to specify subtitle group. A string can be given as value.
2021  */
2022  p = av_strdup(hls->var_stream_map);
2023  if (!p)
2024  return AVERROR(ENOMEM);
2025 
2026  q = p;
2027  while (av_strtok(q, " \t", &saveptr1)) {
2028  q = NULL;
2029  nb_varstreams++;
2030  }
2031  av_freep(&p);
2032 
2033  hls->var_streams = av_mallocz(sizeof(*hls->var_streams) * nb_varstreams);
2034  if (!hls->var_streams)
2035  return AVERROR(ENOMEM);
2036  hls->nb_varstreams = nb_varstreams;
2037 
2038  p = hls->var_stream_map;
2039  nb_varstreams = 0;
2040  while (varstr = av_strtok(p, " \t", &saveptr1)) {
2041  p = NULL;
2042 
2043  if (nb_varstreams < hls->nb_varstreams) {
2044  vs = &(hls->var_streams[nb_varstreams]);
2045  vs->var_stream_idx = nb_varstreams;
2046  vs->is_default = 0;
2047  nb_varstreams++;
2048  } else
2049  return AVERROR(EINVAL);
2050 
2051  q = varstr;
2052  while (1) {
2053  if (!av_strncasecmp(q, "a:", 2) || !av_strncasecmp(q, "v:", 2) ||
2054  !av_strncasecmp(q, "s:", 2))
2055  vs->nb_streams++;
2056  q = strchr(q, ',');
2057  if (!q)
2058  break;
2059  q++;
2060  }
2061  vs->streams = av_mallocz(sizeof(AVStream *) * vs->nb_streams);
2062  if (!vs->streams)
2063  return AVERROR(ENOMEM);
2064 
2065  nb_streams = 0;
2066  while (keyval = av_strtok(varstr, ",", &saveptr2)) {
2067  int64_t num;
2068  char *end;
2069  varstr = NULL;
2070  if (av_strstart(keyval, "language:", &val)) {
2071  vs->language = val;
2072  continue;
2073  } else if (av_strstart(keyval, "default:", &val)) {
2074  vs->is_default = (!av_strncasecmp(val, "YES", strlen("YES")) ||
2075  (!av_strncasecmp(val, "1", strlen("1"))));
2076  hls->has_default_key = 1;
2077  continue;
2078  } else if (av_strstart(keyval, "name:", &val)) {
2079  vs->varname = val;
2080  continue;
2081  } else if (av_strstart(keyval, "agroup:", &val)) {
2082  vs->agroup = val;
2083  continue;
2084  } else if (av_strstart(keyval, "sgroup:", &val)) {
2085  vs->sgroup = val;
2086  continue;
2087  } else if (av_strstart(keyval, "ccgroup:", &val)) {
2088  vs->ccgroup = val;
2089  continue;
2090  } else if (av_strstart(keyval, "v:", &val)) {
2092  hls->has_video_m3u8 = 1;
2093  } else if (av_strstart(keyval, "a:", &val)) {
2095  } else if (av_strstart(keyval, "s:", &val)) {
2097  } else {
2098  av_log(s, AV_LOG_ERROR, "Invalid keyval %s\n", keyval);
2099  return AVERROR(EINVAL);
2100  }
2101 
2102  num = strtoll(val, &end, 10);
2103  if (!av_isdigit(*val) || *end != '\0') {
2104  av_log(s, AV_LOG_ERROR, "Invalid stream number: '%s'\n", val);
2105  return AVERROR(EINVAL);
2106  }
2107  stream_index = get_nth_codec_stream_index(s, codec_type, num);
2108 
2109  if (stream_index >= 0 && nb_streams < vs->nb_streams) {
2110  for (i = 0; nb_streams > 0 && i < nb_streams; i++) {
2111  if (vs->streams[i] == s->streams[stream_index]) {
2112  av_log(s, AV_LOG_ERROR, "Same elementary stream found more than once inside "
2113  "variant definition #%d\n", nb_varstreams - 1);
2114  return AVERROR(EINVAL);
2115  }
2116  }
2117  for (j = 0; nb_varstreams > 1 && j < nb_varstreams - 1; j++) {
2118  for (i = 0; i < hls->var_streams[j].nb_streams; i++) {
2119  if (hls->var_streams[j].streams[i] == s->streams[stream_index]) {
2120  av_log(s, AV_LOG_ERROR, "Same elementary stream found more than once "
2121  "in two different variant definitions #%d and #%d\n",
2122  j, nb_varstreams - 1);
2123  return AVERROR(EINVAL);
2124  }
2125  }
2126  }
2127  vs->streams[nb_streams++] = s->streams[stream_index];
2128  } else {
2129  av_log(s, AV_LOG_ERROR, "Unable to map stream at %s\n", keyval);
2130  return AVERROR(EINVAL);
2131  }
2132  }
2133  }
2134  av_log(s, AV_LOG_DEBUG, "Number of variant streams %d\n",
2135  hls->nb_varstreams);
2136 
2137  return 0;
2138 }
2139 
2141 {
2142  HLSContext *hls = s->priv_data;
2143  int nb_ccstreams = 0;
2144  char *p, *q, *ccstr, *keyval;
2145  char *saveptr1 = NULL, *saveptr2 = NULL;
2146  const char *val;
2147  ClosedCaptionsStream *ccs;
2148 
2149  p = av_strdup(hls->cc_stream_map);
2150  if(!p)
2151  return AVERROR(ENOMEM);
2152 
2153  q = p;
2154  while (av_strtok(q, " \t", &saveptr1)) {
2155  q = NULL;
2156  nb_ccstreams++;
2157  }
2158  av_freep(&p);
2159 
2160  hls->cc_streams = av_mallocz(sizeof(*hls->cc_streams) * nb_ccstreams);
2161  if (!hls->cc_streams)
2162  return AVERROR(ENOMEM);
2163  hls->nb_ccstreams = nb_ccstreams;
2164 
2165  p = hls->cc_stream_map;
2166  nb_ccstreams = 0;
2167  while (ccstr = av_strtok(p, " \t", &saveptr1)) {
2168  p = NULL;
2169 
2170  if (nb_ccstreams < hls->nb_ccstreams)
2171  ccs = &(hls->cc_streams[nb_ccstreams++]);
2172  else
2173  return AVERROR(EINVAL);
2174 
2175  while (keyval = av_strtok(ccstr, ",", &saveptr2)) {
2176  ccstr = NULL;
2177 
2178  if (av_strstart(keyval, "ccgroup:", &val)) {
2179  ccs->ccgroup = val;
2180  } else if (av_strstart(keyval, "instreamid:", &val)) {
2181  ccs->instreamid = val;
2182  } else if (av_strstart(keyval, "language:", &val)) {
2183  ccs->language = val;
2184  } else {
2185  av_log(s, AV_LOG_ERROR, "Invalid keyval %s\n", keyval);
2186  return AVERROR(EINVAL);
2187  }
2188  }
2189 
2190  if (!ccs->ccgroup || !ccs->instreamid) {
2191  av_log(s, AV_LOG_ERROR, "Insufficient parameters in cc stream map string\n");
2192  return AVERROR(EINVAL);
2193  }
2194 
2195  if (av_strstart(ccs->instreamid, "CC", &val)) {
2196  if (atoi(val) < 1 || atoi(val) > 4) {
2197  av_log(s, AV_LOG_ERROR, "Invalid instream ID CC index %d in %s, range 1-4\n",
2198  atoi(val), ccs->instreamid);
2199  return AVERROR(EINVAL);
2200  }
2201  } else if (av_strstart(ccs->instreamid, "SERVICE", &val)) {
2202  if (atoi(val) < 1 || atoi(val) > 63) {
2203  av_log(s, AV_LOG_ERROR, "Invalid instream ID SERVICE index %d in %s, range 1-63 \n",
2204  atoi(val), ccs->instreamid);
2205  return AVERROR(EINVAL);
2206  }
2207  } else {
2208  av_log(s, AV_LOG_ERROR, "Invalid instream ID %s, supported are CCn or SERVICEn\n",
2209  ccs->instreamid);
2210  return AVERROR(EINVAL);
2211  }
2212  }
2213 
2214  return 0;
2215 }
2216 
2218 {
2219  HLSContext *hls = s->priv_data;
2220  unsigned int i;
2221  int ret = 0;
2222 
2223  if (hls->cc_stream_map) {
2225  if (ret < 0)
2226  return ret;
2227  }
2228 
2229  if (hls->var_stream_map) {
2231  } else {
2232  //By default, a single variant stream with all the codec streams is created
2233  hls->var_streams = av_mallocz(sizeof(*hls->var_streams));
2234  if (!hls->var_streams)
2235  return AVERROR(ENOMEM);
2236  hls->nb_varstreams = 1;
2237 
2238  hls->var_streams[0].var_stream_idx = 0;
2239  hls->var_streams[0].nb_streams = s->nb_streams;
2240  hls->var_streams[0].streams = av_mallocz(sizeof(AVStream *) *
2241  hls->var_streams[0].nb_streams);
2242  if (!hls->var_streams[0].streams)
2243  return AVERROR(ENOMEM);
2244 
2245  //by default, the first available ccgroup is mapped to the variant stream
2246  if (hls->nb_ccstreams)
2247  hls->var_streams[0].ccgroup = hls->cc_streams[0].ccgroup;
2248 
2249  for (i = 0; i < s->nb_streams; i++)
2250  hls->var_streams[0].streams[i] = s->streams[i];
2251  }
2252  return 0;
2253 }
2254 
2256 {
2257  HLSContext *hls = s->priv_data;
2258  const char *dir;
2259  char *fn1= NULL, *fn2 = NULL;
2260  int ret = 0;
2261 
2262  fn1 = av_strdup(s->url);
2263  if (!fn1)
2264  return AVERROR(ENOMEM);
2265  dir = av_dirname(fn1);
2266 
2267  /**
2268  * if output file's directory has %v, variants are created in sub-directories
2269  * then master is created at the sub-directories level
2270  */
2271  if (dir && av_stristr(av_basename(dir), "%v")) {
2272  fn2 = av_strdup(dir);
2273  if (!fn2) {
2274  ret = AVERROR(ENOMEM);
2275  goto fail;
2276  }
2277  dir = av_dirname(fn2);
2278  }
2279 
2280  if (dir && strcmp(dir, "."))
2282  else
2284 
2285  if (!hls->master_m3u8_url) {
2286  ret = AVERROR(ENOMEM);
2287  goto fail;
2288  }
2289 
2290 fail:
2291  av_freep(&fn1);
2292  av_freep(&fn2);
2293 
2294  return ret;
2295 }
2296 
2298 {
2299  HLSContext *hls = s->priv_data;
2300  int ret, i, j;
2301  VariantStream *vs = NULL;
2302 
2303  for (i = 0; i < hls->nb_varstreams; i++) {
2304  int subtitle_streams = 0;
2305  vs = &hls->var_streams[i];
2306 
2308  if (ret < 0)
2309  return ret;
2310  //av_assert0(s->nb_streams == hls->avf->nb_streams);
2311  for (j = 0; j < vs->nb_streams; j++) {
2312  AVStream *inner_st;
2313  AVStream *outer_st = vs->streams[j];
2314 
2315  if (hls->max_seg_size > 0) {
2316  if ((outer_st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) &&
2317  (outer_st->codecpar->bit_rate > hls->max_seg_size)) {
2318  av_log(s, AV_LOG_WARNING, "Your video bitrate is bigger than hls_segment_size, "
2319  "(%"PRId64 " > %"PRId64 "), the result maybe not be what you want.",
2320  outer_st->codecpar->bit_rate, hls->max_seg_size);
2321  }
2322  }
2323 
2324  if (outer_st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE)
2325  inner_st = vs->avf->streams[j - subtitle_streams];
2326  else if (vs->vtt_avf) {
2327  inner_st = vs->vtt_avf->streams[0];
2328  subtitle_streams++;
2329  } else {
2330  /* We have a subtitle stream, when the user does not want one */
2331  inner_st = NULL;
2332  continue;
2333  }
2334  avpriv_set_pts_info(outer_st, inner_st->pts_wrap_bits, inner_st->time_base.num, inner_st->time_base.den);
2335  if (outer_st->codecpar->codec_id == AV_CODEC_ID_HEVC &&
2336  outer_st->codecpar->codec_tag != MKTAG('h','v','c','1')) {
2337  av_log(s, AV_LOG_WARNING, "Stream HEVC is not hvc1, you should use tag:v hvc1 to set it.\n");
2338  }
2339  write_codec_attr(outer_st, vs);
2340 
2341  }
2342  /* Update the Codec Attr string for the mapped audio groups */
2343  if (vs->has_video && vs->agroup) {
2344  for (j = 0; j < hls->nb_varstreams; j++) {
2345  VariantStream *vs_agroup = &(hls->var_streams[j]);
2346  if (!vs_agroup->has_video && !vs_agroup->has_subtitle &&
2347  vs_agroup->agroup &&
2348  !av_strcasecmp(vs_agroup->agroup, vs->agroup)) {
2349  write_codec_attr(vs_agroup->streams[0], vs);
2350  }
2351  }
2352  }
2353  }
2354 
2355  return ret;
2356 }
2357 
2359 {
2360  HLSContext *hls = s->priv_data;
2362  int ret = 0;
2363 
2364  set_http_options(s, &options, hls);
2367  if (ret < 0)
2368  return ret;
2370  hlsenc_io_close(s, &vs->out, hls->fmp4_init_filename);
2371 
2372  return ret;
2373 }
2374 
2376 {
2377  int ret = 0;
2378  int64_t read_byte = 0;
2379  int64_t total_size = 0;
2380  char *filename = NULL;
2381  char buf[BUFSIZE];
2382  AVFormatContext *oc = vs->avf;
2383 
2384  hlsenc_io_close(s, &vs->out, vs->basename_tmp);
2385  filename = av_asprintf("%s.tmp", oc->url);
2386  ret = s->io_open(s, &vs->out, filename, AVIO_FLAG_READ, NULL);
2387  if (ret < 0) {
2388  av_free(filename);
2389  return ret;
2390  }
2391 
2392  do {
2393  read_byte = avio_read(vs->out, buf, BUFSIZE);
2394  if (read_byte > 0) {
2395  avio_write(vs->out_single_file, buf, read_byte);
2396  total_size += read_byte;
2397  ret = total_size;
2398  }
2399  } while (read_byte > 0);
2400 
2401  hlsenc_io_close(s, &vs->out, filename);
2402  av_free(filename);
2403 
2404  return ret;
2405 }
2407 {
2408  HLSContext *hls = s->priv_data;
2409  AVFormatContext *oc = NULL;
2410  AVStream *st = s->streams[pkt->stream_index];
2411  int64_t end_pts = 0;
2412  int is_ref_pkt = 1;
2413  int ret = 0, can_split = 1, i, j;
2414  int stream_index = 0;
2415  int subtitle_streams = 0;
2416  int range_length = 0;
2417  const char *proto = NULL;
2418  int use_temp_file = 0;
2419  VariantStream *vs = NULL;
2420  char *old_filename = NULL;
2421 
2422  for (i = 0; i < hls->nb_varstreams; i++) {
2423  vs = &hls->var_streams[i];
2424  for (j = 0; j < vs->nb_streams; j++) {
2426  subtitle_streams++;
2427  }
2428  if (vs->streams[j] == st) {
2430  oc = vs->vtt_avf;
2431  stream_index = 0;
2432  } else {
2433  oc = vs->avf;
2434  stream_index = j - subtitle_streams;
2435  }
2436  break;
2437  }
2438  }
2439 
2440  if (oc)
2441  break;
2442  }
2443 
2444  if (!oc) {
2445  av_log(s, AV_LOG_ERROR, "Unable to find mapping variant stream\n");
2446  return AVERROR(ENOMEM);
2447  }
2448 
2449  end_pts = hls->recording_time * vs->number;
2450 
2451  if (vs->sequence - vs->nb_entries > hls->start_sequence && hls->init_time > 0) {
2452  /* reset end_pts, hls->recording_time at end of the init hls list */
2453  int64_t init_list_dur = hls->init_time * vs->nb_entries;
2454  int64_t after_init_list_dur = (vs->sequence - hls->start_sequence - vs->nb_entries) * hls->time;
2455  hls->recording_time = hls->time;
2456  end_pts = init_list_dur + after_init_list_dur ;
2457  }
2458 
2459  if (vs->start_pts == AV_NOPTS_VALUE) {
2460  vs->start_pts = pkt->pts;
2462  vs->start_pts_from_audio = 1;
2463  }
2465  vs->start_pts = pkt->pts;
2466  vs->start_pts_from_audio = 0;
2467  }
2468 
2469  if (vs->has_video) {
2470  can_split = st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2471  ((pkt->flags & AV_PKT_FLAG_KEY) || (hls->flags & HLS_SPLIT_BY_TIME));
2472  is_ref_pkt = (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) && (pkt->stream_index == vs->reference_stream_index);
2473  }
2474  if (pkt->pts == AV_NOPTS_VALUE)
2475  is_ref_pkt = can_split = 0;
2476 
2477  if (is_ref_pkt) {
2478  if (vs->end_pts == AV_NOPTS_VALUE)
2479  vs->end_pts = pkt->pts;
2480  if (vs->new_start) {
2481  vs->new_start = 0;
2482  vs->duration = (double)(pkt->pts - vs->end_pts)
2483  * st->time_base.num / st->time_base.den;
2484  vs->dpp = (double)(pkt->duration) * st->time_base.num / st->time_base.den;
2485  } else {
2486  if (pkt->duration) {
2487  vs->duration += (double)(pkt->duration) * st->time_base.num / st->time_base.den;
2488  } else {
2489  av_log(s, AV_LOG_WARNING, "Stream %d packet with pts %" PRId64 " has duration 0. The segment duration may not be precise.\n",
2490  pkt->stream_index, pkt->pts);
2491  vs->duration = (double)(pkt->pts - vs->end_pts) * st->time_base.num / st->time_base.den;
2492  }
2493  }
2494  }
2495 
2496  can_split = can_split && (pkt->pts - vs->end_pts > 0);
2497  if (vs->packets_written && can_split && av_compare_ts(pkt->pts - vs->start_pts, st->time_base,
2498  end_pts, AV_TIME_BASE_Q) >= 0) {
2499  int64_t new_start_pos;
2500  int byterange_mode = (hls->flags & HLS_SINGLE_FILE) || (hls->max_seg_size > 0);
2501 
2502  av_write_frame(oc, NULL); /* Flush any buffered data */
2503  new_start_pos = avio_tell(oc->pb);
2504  vs->size = new_start_pos - vs->start_pos;
2505  avio_flush(oc->pb);
2506  if (hls->segment_type == SEGMENT_TYPE_FMP4) {
2507  if (!vs->init_range_length) {
2508  range_length = avio_close_dyn_buf(oc->pb, &vs->init_buffer);
2509  if (range_length <= 0)
2510  return AVERROR(EINVAL);
2511  avio_write(vs->out, vs->init_buffer, range_length);
2512  if (!hls->resend_init_file)
2513  av_freep(&vs->init_buffer);
2514  vs->init_range_length = range_length;
2515  avio_open_dyn_buf(&oc->pb);
2516  vs->packets_written = 0;
2517  vs->start_pos = range_length;
2518  if (!byterange_mode) {
2520  }
2521  }
2522  }
2523  if (!byterange_mode) {
2524  if (vs->vtt_avf) {
2525  hlsenc_io_close(s, &vs->vtt_avf->pb, vs->vtt_avf->url);
2526  }
2527  }
2528 
2529  if (hls->flags & HLS_SINGLE_FILE) {
2530  ret = flush_dynbuf(vs, &range_length);
2531  av_freep(&vs->temp_buffer);
2532  if (ret < 0) {
2533  return ret;
2534  }
2535  vs->size = range_length;
2536  if (hls->key_info_file || hls->encrypt)
2537  vs->size = append_single_file(s, vs);
2538  } else {
2539  if (oc->url[0]) {
2540  proto = avio_find_protocol_name(oc->url);
2541  use_temp_file = proto && !strcmp(proto, "file")
2542  && (hls->flags & HLS_TEMP_FILE);
2543  }
2544 
2545  if ((hls->max_seg_size > 0 && (vs->size + vs->start_pos >= hls->max_seg_size)) || !byterange_mode) {
2547  char *filename = NULL;
2548  if (hls->key_info_file || hls->encrypt) {
2549  av_dict_set(&options, "encryption_key", vs->key_string, 0);
2550  av_dict_set(&options, "encryption_iv", vs->iv_string, 0);
2551  filename = av_asprintf("crypto:%s", oc->url);
2552  } else {
2553  filename = av_asprintf("%s", oc->url);
2554  }
2555  if (!filename) {
2557  return AVERROR(ENOMEM);
2558  }
2559 
2560  // look to rename the asset name
2561  if (use_temp_file)
2562  av_dict_set(&options, "mpegts_flags", "resend_headers", 0);
2563 
2564  set_http_options(s, &options, hls);
2565 
2566  ret = hlsenc_io_open(s, &vs->out, filename, &options);
2567  if (ret < 0) {
2569  "Failed to open file '%s'\n", filename);
2570  av_freep(&filename);
2572  return hls->ignore_io_errors ? 0 : ret;
2573  }
2574  if (hls->segment_type == SEGMENT_TYPE_FMP4) {
2575  write_styp(vs->out);
2576  }
2577  ret = flush_dynbuf(vs, &range_length);
2578  if (ret < 0) {
2579  av_freep(&filename);
2581  return ret;
2582  }
2583  ret = hlsenc_io_close(s, &vs->out, filename);
2584  if (ret < 0) {
2585  av_log(s, AV_LOG_WARNING, "upload segment failed,"
2586  " will retry with a new http session.\n");
2587  ff_format_io_close(s, &vs->out);
2588  ret = hlsenc_io_open(s, &vs->out, filename, &options);
2589  reflush_dynbuf(vs, &range_length);
2590  ret = hlsenc_io_close(s, &vs->out, filename);
2591  }
2593  av_freep(&vs->temp_buffer);
2594  av_freep(&filename);
2595  }
2596 
2597  if (use_temp_file)
2598  hls_rename_temp_file(s, oc);
2599  }
2600 
2601  old_filename = av_strdup(oc->url);
2602  if (!old_filename) {
2603  return AVERROR(ENOMEM);
2604  }
2605 
2606  if (vs->start_pos || hls->segment_type != SEGMENT_TYPE_FMP4) {
2607  double cur_duration = (double)(pkt->pts - vs->end_pts) * st->time_base.num / st->time_base.den;
2608  ret = hls_append_segment(s, hls, vs, cur_duration, vs->start_pos, vs->size);
2609  vs->end_pts = pkt->pts;
2610  vs->duration = 0;
2611  if (ret < 0) {
2612  av_freep(&old_filename);
2613  return ret;
2614  }
2615  }
2616 
2617  // if we're building a VOD playlist, skip writing the manifest multiple times, and just wait until the end
2618  if (hls->pl_type != PLAYLIST_TYPE_VOD) {
2619  if ((ret = hls_window(s, 0, vs)) < 0) {
2620  av_log(s, AV_LOG_WARNING, "upload playlist failed, will retry with a new http session.\n");
2621  ff_format_io_close(s, &vs->out);
2622  if ((ret = hls_window(s, 0, vs)) < 0) {
2623  av_freep(&old_filename);
2624  return ret;
2625  }
2626  }
2627  }
2628 
2629  if (hls->resend_init_file && hls->segment_type == SEGMENT_TYPE_FMP4) {
2630  ret = hls_init_file_resend(s, vs);
2631  if (ret < 0) {
2632  av_freep(&old_filename);
2633  return ret;
2634  }
2635  }
2636 
2637  if (hls->flags & HLS_SINGLE_FILE) {
2638  vs->start_pos += vs->size;
2639  if (hls->key_info_file || hls->encrypt)
2640  ret = hls_start(s, vs);
2641  if (hls->segment_type == SEGMENT_TYPE_MPEGTS && oc->oformat->priv_class && oc->priv_data) {
2642  av_opt_set(oc->priv_data, "mpegts_flags", "resend_headers", 0);
2643  }
2644  } else if (hls->max_seg_size > 0) {
2645  if (vs->size + vs->start_pos >= hls->max_seg_size) {
2646  vs->sequence++;
2647  sls_flag_file_rename(hls, vs, old_filename);
2648  ret = hls_start(s, vs);
2649  vs->start_pos = 0;
2650  /* When split segment by byte, the duration is short than hls_time,
2651  * so it is not enough one segment duration as hls_time, */
2652  } else {
2653  vs->start_pos = new_start_pos;
2654  }
2655  } else {
2656  vs->start_pos = new_start_pos;
2657  sls_flag_file_rename(hls, vs, old_filename);
2658  ret = hls_start(s, vs);
2659  }
2660  vs->number++;
2661  av_freep(&old_filename);
2662 
2663  if (ret < 0) {
2664  return ret;
2665  }
2666  }
2667 
2668  vs->packets_written++;
2669  if (oc->pb) {
2670  ret = ff_write_chained(oc, stream_index, pkt, s, 0);
2671  vs->video_keyframe_size += pkt->size;
2673  vs->video_keyframe_size = avio_tell(oc->pb);
2674  } else {
2675  vs->video_keyframe_pos = avio_tell(vs->out);
2676  }
2677  if (hls->ignore_io_errors)
2678  ret = 0;
2679  }
2680 
2681  return ret;
2682 }
2683 
2685 {
2686  HLSContext *hls = s->priv_data;
2687  int i = 0;
2688  VariantStream *vs = NULL;
2689 
2690  for (i = 0; i < hls->nb_varstreams; i++) {
2691  vs = &hls->var_streams[i];
2692 
2693  av_freep(&vs->basename);
2696  av_freep(&vs->vtt_basename);
2697  av_freep(&vs->vtt_m3u8_name);
2698 
2701  if (hls->resend_init_file)
2702  av_freep(&vs->init_buffer);
2705  av_freep(&vs->m3u8_name);
2706  av_freep(&vs->streams);
2707  }
2708 
2709  ff_format_io_close(s, &hls->m3u8_out);
2712  av_freep(&hls->key_basename);
2713  av_freep(&hls->var_streams);
2714  av_freep(&hls->cc_streams);
2715  av_freep(&hls->master_m3u8_url);
2716 }
2717 
2719 {
2720  HLSContext *hls = s->priv_data;
2721  AVFormatContext *oc = NULL;
2722  AVFormatContext *vtt_oc = NULL;
2723  char *old_filename = NULL;
2724  const char *proto = NULL;
2725  int use_temp_file = 0;
2726  int i;
2727  int ret = 0;
2728  VariantStream *vs = NULL;
2730  int range_length, byterange_mode;
2731 
2732  for (i = 0; i < hls->nb_varstreams; i++) {
2733  char *filename = NULL;
2734  vs = &hls->var_streams[i];
2735  oc = vs->avf;
2736  vtt_oc = vs->vtt_avf;
2737  old_filename = av_strdup(oc->url);
2738  use_temp_file = 0;
2739 
2740  if (!old_filename) {
2741  return AVERROR(ENOMEM);
2742  }
2743  if (hls->key_info_file || hls->encrypt) {
2744  av_dict_set(&options, "encryption_key", vs->key_string, 0);
2745  av_dict_set(&options, "encryption_iv", vs->iv_string, 0);
2746  filename = av_asprintf("crypto:%s", oc->url);
2747  } else {
2748  filename = av_asprintf("%s", oc->url);
2749  }
2750  if (!filename) {
2751  av_freep(&old_filename);
2752  return AVERROR(ENOMEM);
2753  }
2754 
2755  if (hls->segment_type == SEGMENT_TYPE_FMP4) {
2756  int range_length = 0;
2757  if (!vs->init_range_length) {
2758  uint8_t *buffer = NULL;
2759  av_write_frame(oc, NULL); /* Flush any buffered data */
2760 
2761  range_length = avio_close_dyn_buf(oc->pb, &buffer);
2762  avio_write(vs->out, buffer, range_length);
2763  av_freep(&buffer);
2764  vs->init_range_length = range_length;
2765  avio_open_dyn_buf(&oc->pb);
2766  vs->packets_written = 0;
2767  vs->start_pos = range_length;
2768  byterange_mode = (hls->flags & HLS_SINGLE_FILE) || (hls->max_seg_size > 0);
2769  if (!byterange_mode) {
2770  ff_format_io_close(s, &vs->out);
2772  }
2773  }
2774  }
2775  if (!(hls->flags & HLS_SINGLE_FILE)) {
2776  set_http_options(s, &options, hls);
2777  ret = hlsenc_io_open(s, &vs->out, filename, &options);
2778  if (ret < 0) {
2779  av_log(s, AV_LOG_ERROR, "Failed to open file '%s'\n", oc->url);
2780  goto failed;
2781  }
2782  if (hls->segment_type == SEGMENT_TYPE_FMP4)
2783  write_styp(vs->out);
2784  }
2785  ret = flush_dynbuf(vs, &range_length);
2786  if (ret < 0)
2787  goto failed;
2788 
2789  vs->size = range_length;
2790  ret = hlsenc_io_close(s, &vs->out, filename);
2791  if (ret < 0) {
2792  av_log(s, AV_LOG_WARNING, "upload segment failed, will retry with a new http session.\n");
2793  ff_format_io_close(s, &vs->out);
2794  ret = hlsenc_io_open(s, &vs->out, filename, &options);
2795  if (ret < 0) {
2796  av_log(s, AV_LOG_ERROR, "Failed to open file '%s'\n", oc->url);
2797  goto failed;
2798  }
2799  reflush_dynbuf(vs, &range_length);
2800  ret = hlsenc_io_close(s, &vs->out, filename);
2801  if (ret < 0)
2802  av_log(s, AV_LOG_WARNING, "Failed to upload file '%s' at the end.\n", oc->url);
2803  }
2804  if (hls->flags & HLS_SINGLE_FILE) {
2805  if (hls->key_info_file || hls->encrypt) {
2806  vs->size = append_single_file(s, vs);
2807  }
2809  }
2810 failed:
2811  av_freep(&vs->temp_buffer);
2813  av_freep(&filename);
2814  av_write_trailer(oc);
2815  if (oc->url[0]) {
2816  proto = avio_find_protocol_name(oc->url);
2817  use_temp_file = proto && !strcmp(proto, "file") && (hls->flags & HLS_TEMP_FILE);
2818  }
2819 
2820  // rename that segment from .tmp to the real one
2821  if (use_temp_file && !(hls->flags & HLS_SINGLE_FILE)) {
2822  hls_rename_temp_file(s, oc);
2823  av_freep(&old_filename);
2824  old_filename = av_strdup(oc->url);
2825 
2826  if (!old_filename) {
2827  return AVERROR(ENOMEM);
2828  }
2829  }
2830 
2831  /* after av_write_trailer, then duration + 1 duration per packet */
2832  hls_append_segment(s, hls, vs, vs->duration + vs->dpp, vs->start_pos, vs->size);
2833 
2834  sls_flag_file_rename(hls, vs, old_filename);
2835 
2836  if (vtt_oc) {
2837  if (vtt_oc->pb)
2838  av_write_trailer(vtt_oc);
2839  vs->size = avio_tell(vs->vtt_avf->pb) - vs->start_pos;
2840  ff_format_io_close(s, &vtt_oc->pb);
2841  }
2842  ret = hls_window(s, 1, vs);
2843  if (ret < 0) {
2844  av_log(s, AV_LOG_WARNING, "upload playlist failed, will retry with a new http session.\n");
2845  ff_format_io_close(s, &vs->out);
2846  hls_window(s, 1, vs);
2847  }
2848  ffio_free_dyn_buf(&oc->pb);
2849 
2850  av_free(old_filename);
2851  }
2852 
2853  return 0;
2854 }
2855 
2856 
2858 {
2859  int ret = 0;
2860  int i = 0;
2861  int j = 0;
2862  HLSContext *hls = s->priv_data;
2863  const char *pattern;
2864  VariantStream *vs = NULL;
2865  const char *vtt_pattern = hls->flags & HLS_SINGLE_FILE ? ".vtt" : "%d.vtt";
2866  char *p = NULL;
2867  int http_base_proto = ff_is_http_proto(s->url);
2868  int fmp4_init_filename_len = strlen(hls->fmp4_init_filename) + 1;
2869  double initial_program_date_time = av_gettime() / 1000000.0;
2870 
2871  if (hls->use_localtime) {
2873  } else {
2874  pattern = hls->segment_type == SEGMENT_TYPE_FMP4 ? "%d.m4s" : "%d.ts";
2875  if (hls->flags & HLS_SINGLE_FILE)
2876  pattern += 2;
2877  }
2878 
2879  hls->has_default_key = 0;
2880  hls->has_video_m3u8 = 0;
2882  if (ret < 0) {
2883  av_log(s, AV_LOG_ERROR, "Variant stream info update failed with status %x\n",
2884  ret);
2885  return ret;
2886  }
2887 
2888  if (!hls->method && http_base_proto) {
2889  av_log(hls, AV_LOG_WARNING, "No HTTP method set, hls muxer defaulting to method PUT.\n");
2890  }
2891 
2892  ret = validate_name(hls->nb_varstreams, s->url);
2893  if (ret < 0)
2894  return ret;
2895 
2896  if (hls->segment_filename) {
2898  if (ret < 0)
2899  return ret;
2900  }
2901 
2902  if (av_strcasecmp(hls->fmp4_init_filename, "init.mp4")) {
2904  if (ret < 0)
2905  return ret;
2906  }
2907 
2908  if (hls->subtitle_filename) {
2910  if (ret < 0)
2911  return ret;
2912  }
2913 
2914  if (hls->master_pl_name) {
2916  if (ret < 0) {
2917  av_log(s, AV_LOG_ERROR, "Master stream info update failed with status %x\n",
2918  ret);
2919  return ret;
2920  }
2921  }
2922 
2926  time_t t = time(NULL);
2928  hls->start_sequence = av_gettime();
2930  hls->start_sequence = (int64_t)t;
2932  char b[15];
2933  struct tm *p, tmbuf;
2934  if (!(p = localtime_r(&t, &tmbuf)))
2935  return AVERROR(errno);
2936  if (!strftime(b, sizeof(b), "%Y%m%d%H%M%S", p))
2937  return AVERROR(ENOMEM);
2938  hls->start_sequence = strtoll(b, NULL, 10);
2939  }
2940  av_log(hls, AV_LOG_DEBUG, "start_number evaluated to %"PRId64"\n", hls->start_sequence);
2941  }
2942 
2943  hls->recording_time = hls->init_time && hls->max_nb_segments > 0 ? hls->init_time : hls->time;
2944 
2945  if (hls->flags & HLS_SPLIT_BY_TIME && hls->flags & HLS_INDEPENDENT_SEGMENTS) {
2946  // Independent segments cannot be guaranteed when splitting by time
2949  "'split_by_time' and 'independent_segments' cannot be "
2950  "enabled together. Disabling 'independent_segments' flag\n");
2951  }
2952 
2953  for (i = 0; i < hls->nb_varstreams; i++) {
2954  vs = &hls->var_streams[i];
2955 
2956  ret = format_name(s->url, &vs->m3u8_name, i, vs->varname);
2957  if (ret < 0)
2958  return ret;
2959 
2960  vs->sequence = hls->start_sequence;
2961  vs->start_pts = AV_NOPTS_VALUE;
2962  vs->end_pts = AV_NOPTS_VALUE;
2963  vs->current_segment_final_filename_fmt[0] = '\0';
2964  vs->initial_prog_date_time = initial_program_date_time;
2965 
2966  for (j = 0; j < vs->nb_streams; j++) {
2968  /* Get one video stream to reference for split segments
2969  * so use the first video stream index. */
2970  if ((vs->has_video == 1) && (vs->streams[j]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)) {
2971  vs->reference_stream_index = vs->streams[j]->index;
2972  }
2974  }
2975 
2976  if (vs->has_video > 1)
2977  av_log(s, AV_LOG_WARNING, "More than a single video stream present, expect issues decoding it.\n");
2978  if (hls->segment_type == SEGMENT_TYPE_FMP4) {
2979  vs->oformat = av_guess_format("mp4", NULL, NULL);
2980  } else {
2981  vs->oformat = av_guess_format("mpegts", NULL, NULL);
2982  }
2983  if (!vs->oformat)
2984  return AVERROR_MUXER_NOT_FOUND;
2985 
2986  if (hls->segment_filename) {
2987  ret = format_name(hls->segment_filename, &vs->basename, i, vs->varname);
2988  if (ret < 0)
2989  return ret;
2990  } else {
2991  p = strrchr(vs->m3u8_name, '.');
2992  if (p)
2993  *p = '\0';
2994 
2995  vs->basename = av_asprintf("%s%s", vs->m3u8_name, pattern);
2996  if (!vs->basename)
2997  return AVERROR(ENOMEM);
2998 
2999  if (p)
3000  *p = '.';
3001  }
3002 
3003  if (hls->segment_type == SEGMENT_TYPE_FMP4) {
3004  if (hls->nb_varstreams > 1)
3005  fmp4_init_filename_len += strlen(POSTFIX_PATTERN);
3006  if (hls->flags & HLS_SINGLE_FILE) {
3008  if (!vs->fmp4_init_filename)
3009  return AVERROR(ENOMEM);
3010  } else {
3011  vs->fmp4_init_filename = av_malloc(fmp4_init_filename_len);
3012  if (!vs->fmp4_init_filename)
3013  return AVERROR(ENOMEM);
3015  fmp4_init_filename_len);
3016  if (hls->nb_varstreams > 1) {
3017  if (av_stristr(vs->fmp4_init_filename, "%v")) {
3020  &vs->fmp4_init_filename, i, vs->varname);
3021  } else {
3022  ret = append_postfix(vs->fmp4_init_filename, fmp4_init_filename_len, i);
3023  }
3024  if (ret < 0)
3025  return ret;
3026  }
3027 
3028  if (hls->use_localtime) {
3029  int r;
3030  char *expanded = NULL;
3031 
3032  r = strftime_expand(vs->fmp4_init_filename, &expanded);
3033  if (r < 0) {
3034  av_log(s, AV_LOG_ERROR, "Could not get segment filename with strftime\n");
3035  return r;
3036  }
3038  vs->fmp4_init_filename = expanded;
3039  }
3040 
3041  p = strrchr(vs->m3u8_name, '/');
3042  if (p) {
3043  char tmp = *(++p);
3044  *p = '\0';
3045  vs->base_output_dirname = av_asprintf("%s%s", vs->m3u8_name,
3046  vs->fmp4_init_filename);
3047  *p = tmp;
3048  } else {
3050  }
3051  if (!vs->base_output_dirname)
3052  return AVERROR(ENOMEM);
3053  }
3054  }
3055 
3057  if (ret < 0)
3058  return ret;
3059 
3060  if (vs->has_subtitle) {
3061  vs->vtt_oformat = av_guess_format("webvtt", NULL, NULL);
3062  if (!vs->vtt_oformat)
3063  return AVERROR_MUXER_NOT_FOUND;
3064 
3065  p = strrchr(vs->m3u8_name, '.');
3066  if (p)
3067  *p = '\0';
3068 
3069  vs->vtt_basename = av_asprintf("%s%s", vs->m3u8_name, vtt_pattern);
3070  if (!vs->vtt_basename)
3071  return AVERROR(ENOMEM);
3072 
3073  if (hls->subtitle_filename) {
3075  if (ret < 0)
3076  return ret;
3077  } else {
3078  vs->vtt_m3u8_name = av_asprintf("%s_vtt.m3u8", vs->m3u8_name);
3079  if (!vs->vtt_m3u8_name)
3080  return AVERROR(ENOMEM);
3081  }
3082  if (p)
3083  *p = '.';
3084  }
3085 
3086  if ((ret = hls_mux_init(s, vs)) < 0)
3087  return ret;
3088 
3089  if (hls->flags & HLS_APPEND_LIST) {
3090  parse_playlist(s, vs->m3u8_name, vs);
3091  vs->discontinuity = 1;
3092  if (hls->init_time > 0) {
3093  av_log(s, AV_LOG_WARNING, "append_list mode does not support hls_init_time,"
3094  " hls_init_time value will have no effect\n");
3095  hls->init_time = 0;
3096  hls->recording_time = hls->time;
3097  }
3098  }
3099 
3100  if ((ret = hls_start(s, vs)) < 0)
3101  return ret;
3102  vs->number++;
3103  }
3104 
3105  return ret;
3106 }
3107 
3108 #define OFFSET(x) offsetof(HLSContext, x)
3109 #define E AV_OPT_FLAG_ENCODING_PARAM
3110 static const AVOption options[] = {
3111  {"start_number", "set first number in the sequence", OFFSET(start_sequence),AV_OPT_TYPE_INT64, {.i64 = 0}, 0, INT64_MAX, E},
3112  {"hls_time", "set segment length", OFFSET(time), AV_OPT_TYPE_DURATION, {.i64 = 2000000}, 0, INT64_MAX, E},
3113  {"hls_init_time", "set segment length at init list", OFFSET(init_time), AV_OPT_TYPE_DURATION, {.i64 = 0}, 0, INT64_MAX, E},
3114  {"hls_list_size", "set maximum number of playlist entries", OFFSET(max_nb_segments), AV_OPT_TYPE_INT, {.i64 = 5}, 0, INT_MAX, E},
3115  {"hls_delete_threshold", "set number of unreferenced segments to keep before deleting", OFFSET(hls_delete_threshold), AV_OPT_TYPE_INT, {.i64 = 1}, 1, INT_MAX, E},
3116  {"hls_vtt_options","set hls vtt list of options for the container format used for hls", OFFSET(vtt_format_options_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
3117  {"hls_allow_cache", "explicitly set whether the client MAY (1) or MUST NOT (0) cache media segments", OFFSET(allowcache), AV_OPT_TYPE_INT, {.i64 = -1}, INT_MIN, INT_MAX, E},
3118  {"hls_base_url", "url to prepend to each playlist entry", OFFSET(baseurl), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
3119  {"hls_segment_filename", "filename template for segment files", OFFSET(segment_filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
3120  {"hls_segment_options","set segments files format options of hls", OFFSET(format_options), AV_OPT_TYPE_DICT, {.str = NULL}, 0, 0, E},
3121  {"hls_segment_size", "maximum size per segment file, (in bytes)", OFFSET(max_seg_size), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, E},
3122  {"hls_key_info_file", "file with key URI and key file path", OFFSET(key_info_file), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
3123  {"hls_enc", "enable AES128 encryption support", OFFSET(encrypt), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, E},
3124  {"hls_enc_key", "hex-coded 16 byte key to encrypt the segments", OFFSET(key), AV_OPT_TYPE_STRING, .flags = E},
3125  {"hls_enc_key_url", "url to access the key to decrypt the segments", OFFSET(key_url), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
3126  {"hls_enc_iv", "hex-coded 16 byte initialization vector", OFFSET(iv), AV_OPT_TYPE_STRING, .flags = E},
3127  {"hls_subtitle_path", "set path of hls subtitles", OFFSET(subtitle_filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
3128  {"hls_segment_type", "set hls segment files type", OFFSET(segment_type), AV_OPT_TYPE_INT, {.i64 = SEGMENT_TYPE_MPEGTS }, 0, SEGMENT_TYPE_FMP4, E, "segment_type"},
3129  {"mpegts", "make segment file to mpegts files in m3u8", 0, AV_OPT_TYPE_CONST, {.i64 = SEGMENT_TYPE_MPEGTS }, 0, UINT_MAX, E, "segment_type"},
3130  {"fmp4", "make segment file to fragment mp4 files in m3u8", 0, AV_OPT_TYPE_CONST, {.i64 = SEGMENT_TYPE_FMP4 }, 0, UINT_MAX, E, "segment_type"},
3131  {"hls_fmp4_init_filename", "set fragment mp4 file init filename", OFFSET(fmp4_init_filename), AV_OPT_TYPE_STRING, {.str = "init.mp4"}, 0, 0, E},
3132  {"hls_fmp4_init_resend", "resend fragment mp4 init file after refresh m3u8 every time", OFFSET(resend_init_file), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
3133  {"hls_flags", "set flags affecting HLS playlist and media file generation", OFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = 0 }, 0, UINT_MAX, E, "flags"},
3134  {"single_file", "generate a single media file indexed with byte ranges", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_SINGLE_FILE }, 0, UINT_MAX, E, "flags"},
3135  {"temp_file", "write segment and playlist to temporary file and rename when complete", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_TEMP_FILE }, 0, UINT_MAX, E, "flags"},
3136  {"delete_segments", "delete segment files that are no longer part of the playlist", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_DELETE_SEGMENTS }, 0, UINT_MAX, E, "flags"},
3137  {"round_durations", "round durations in m3u8 to whole numbers", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_ROUND_DURATIONS }, 0, UINT_MAX, E, "flags"},
3138  {"discont_start", "start the playlist with a discontinuity tag", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_DISCONT_START }, 0, UINT_MAX, E, "flags"},
3139  {"omit_endlist", "Do not append an endlist when ending stream", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_OMIT_ENDLIST }, 0, UINT_MAX, E, "flags"},
3140  {"split_by_time", "split the hls segment by time which user set by hls_time", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_SPLIT_BY_TIME }, 0, UINT_MAX, E, "flags"},
3141  {"append_list", "append the new segments into old hls segment list", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_APPEND_LIST }, 0, UINT_MAX, E, "flags"},
3142  {"program_date_time", "add EXT-X-PROGRAM-DATE-TIME", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_PROGRAM_DATE_TIME }, 0, UINT_MAX, E, "flags"},
3143  {"second_level_segment_index", "include segment index in segment filenames when use_localtime", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_SECOND_LEVEL_SEGMENT_INDEX }, 0, UINT_MAX, E, "flags"},
3144  {"second_level_segment_duration", "include segment duration in segment filenames when use_localtime", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_SECOND_LEVEL_SEGMENT_DURATION }, 0, UINT_MAX, E, "flags"},
3145  {"second_level_segment_size", "include segment size in segment filenames when use_localtime", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_SECOND_LEVEL_SEGMENT_SIZE }, 0, UINT_MAX, E, "flags"},
3146  {"periodic_rekey", "reload keyinfo file periodically for re-keying", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_PERIODIC_REKEY }, 0, UINT_MAX, E, "flags"},
3147  {"independent_segments", "add EXT-X-INDEPENDENT-SEGMENTS, whenever applicable", 0, AV_OPT_TYPE_CONST, { .i64 = HLS_INDEPENDENT_SEGMENTS }, 0, UINT_MAX, E, "flags"},
3148  {"iframes_only", "add EXT-X-I-FRAMES-ONLY, whenever applicable", 0, AV_OPT_TYPE_CONST, { .i64 = HLS_I_FRAMES_ONLY }, 0, UINT_MAX, E, "flags"},
3149  {"strftime", "set filename expansion with strftime at segment creation", OFFSET(use_localtime), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
3150  {"strftime_mkdir", "create last directory component in strftime-generated filename", OFFSET(use_localtime_mkdir), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
3151  {"hls_playlist_type", "set the HLS playlist type", OFFSET(pl_type), AV_OPT_TYPE_INT, {.i64 = PLAYLIST_TYPE_NONE }, 0, PLAYLIST_TYPE_NB-1, E, "pl_type" },
3152  {"event", "EVENT playlist", 0, AV_OPT_TYPE_CONST, {.i64 = PLAYLIST_TYPE_EVENT }, INT_MIN, INT_MAX, E, "pl_type" },
3153  {"vod", "VOD playlist", 0, AV_OPT_TYPE_CONST, {.i64 = PLAYLIST_TYPE_VOD }, INT_MIN, INT_MAX, E, "pl_type" },
3154  {"method", "set the HTTP method(default: PUT)", OFFSET(method), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
3155  {"hls_start_number_source", "set source of first number in sequence", OFFSET(start_sequence_source_type), AV_OPT_TYPE_INT, {.i64 = HLS_START_SEQUENCE_AS_START_NUMBER }, 0, HLS_START_SEQUENCE_LAST-1, E, "start_sequence_source_type" },
3156  {"generic", "start_number value (default)", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_START_SEQUENCE_AS_START_NUMBER }, INT_MIN, INT_MAX, E, "start_sequence_source_type" },
3157  {"epoch", "seconds since epoch", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_START_SEQUENCE_AS_SECONDS_SINCE_EPOCH }, INT_MIN, INT_MAX, E, "start_sequence_source_type" },
3158  {"epoch_us", "microseconds since epoch", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_START_SEQUENCE_AS_MICROSECONDS_SINCE_EPOCH }, INT_MIN, INT_MAX, E, "start_sequence_source_type" },
3159  {"datetime", "current datetime as YYYYMMDDhhmmss", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_START_SEQUENCE_AS_FORMATTED_DATETIME }, INT_MIN, INT_MAX, E, "start_sequence_source_type" },
3160  {"http_user_agent", "override User-Agent field in HTTP header", OFFSET(user_agent), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
3161  {"var_stream_map", "Variant stream map string", OFFSET(var_stream_map), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
3162  {"cc_stream_map", "Closed captions stream map string", OFFSET(cc_stream_map), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
3163  {"master_pl_name", "Create HLS master playlist with this name", OFFSET(master_pl_name), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
3164  {"master_pl_publish_rate", "Publish master play list every after this many segment intervals", OFFSET(master_publish_rate), AV_OPT_TYPE_INT, {.i64 = 0}, 0, UINT_MAX, E},
3165  {"http_persistent", "Use persistent HTTP connections", OFFSET(http_persistent), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
3166  {"timeout", "set timeout for socket I/O operations", OFFSET(timeout), AV_OPT_TYPE_DURATION, { .i64 = -1 }, -1, INT_MAX, .flags = E },
3167  {"ignore_io_errors", "Ignore IO errors for stable long-duration runs with network output", OFFSET(ignore_io_errors), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
3168  {"headers", "set custom HTTP headers, can override built in default headers", OFFSET(headers), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, E },
3169  { NULL },
3170 };
3171 
3172 static const AVClass hls_class = {
3173  .class_name = "hls muxer",
3174  .item_name = av_default_item_name,
3175  .option = options,
3176  .version = LIBAVUTIL_VERSION_INT,
3177 };
3178 
3179 
3181  .p.name = "hls",
3182  .p.long_name = NULL_IF_CONFIG_SMALL("Apple HTTP Live Streaming"),
3183  .p.extensions = "m3u8",
3184  .p.audio_codec = AV_CODEC_ID_AAC,
3185  .p.video_codec = AV_CODEC_ID_H264,
3186  .p.subtitle_codec = AV_CODEC_ID_WEBVTT,
3188  .p.priv_class = &hls_class,
3189  .priv_data_size = sizeof(HLSContext),
3190  .init = hls_init,
3194  .deinit = hls_deinit,
3195 };
M
#define M(a, b)
Definition: vp3dsp.c:48
ff_get_chomp_line
int ff_get_chomp_line(AVIOContext *s, char *buf, int maxlen)
Same as ff_get_line but strip the white-space characters in the text tail.
Definition: aviobuf.c:833
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
VariantStream::vtt_avf
AVFormatContext * vtt_avf
Definition: hlsenc.c:131
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
hls_write_header
static int hls_write_header(AVFormatContext *s)
Definition: hlsenc.c:2297
av_codec_get_id
enum AVCodecID av_codec_get_id(const struct AVCodecTag *const *tags, unsigned int tag)
Get the AVCodecID for the given codec tag tag.
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
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:76
get_relative_url
static const char * get_relative_url(const char *master_url, const char *media_url)
Definition: hlsenc.c:1334
name
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 default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
find_segment_by_filename
static HLSSegment * find_segment_by_filename(HLSSegment *segment, const char *filename)
Definition: hlsenc.c:962
append_postfix
static int append_postfix(char *name, int name_buf_len, int i)
Definition: hlsenc.c:1880
level
uint8_t level
Definition: svq3.c:204
AV_CODEC_ID_AC3
@ AV_CODEC_ID_AC3
Definition: codec_id.h:445
HLSContext::timeout
int64_t timeout
Definition: hlsenc.c:253
sls_flag_use_localtime_filename
static int sls_flag_use_localtime_filename(AVFormatContext *oc, HLSContext *c, VariantStream *vs)
Definition: hlsenc.c:1062
HLS_TEMP_FILE
@ HLS_TEMP_FILE
Definition: hlsenc.c:106
AVOutputFormat::name
const char * name
Definition: avformat.h:509
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
r
const char * r
Definition: vf_curves.c:126
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
strftime_expand
static int strftime_expand(const char *fmt, char **dest)
Definition: hlsenc.c:260
VariantStream::has_subtitle
int has_subtitle
Definition: hlsenc.c:134
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:58
HLSContext::resend_init_file
int resend_init_file
resend init file into disk after refresh m3u8
Definition: hlsenc.c:207
HLSContext::hls_delete_threshold
int hls_delete_threshold
Definition: hlsenc.c:201
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
AVFMT_NODIMENSIONS
#define AVFMT_NODIMENSIONS
Format does not need width/height.
Definition: avformat.h:484
VariantStream::codec_attr
char codec_attr[128]
Definition: hlsenc.c:175
ffio_wfourcc
static av_always_inline void ffio_wfourcc(AVIOContext *pb, const uint8_t *s)
Definition: avio_internal.h:128
avio_close
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
Definition: aviobuf.c:1271
HLSContext::key_file
char key_file[LINE_BUFFER_SIZE+1]
Definition: hlsenc.c:228
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
ff_hls_write_end_list
void ff_hls_write_end_list(AVIOContext *out)
Definition: hlsplaylist.c:190
hls_init_file_resend
static int hls_init_file_resend(AVFormatContext *s, VariantStream *vs)
Definition: hlsenc.c:2358
av_stristr
char * av_stristr(const char *s1, const char *s2)
Locate the first case-independent occurrence in the string haystack of the string needle.
Definition: avstring.c:58
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
HLSSegment::filename
char filename[MAX_URL_SIZE]
Definition: hlsenc.c:76
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
av_dict_count
int av_dict_count(const AVDictionary *m)
Get number of entries in dictionary.
Definition: dict.c:39
fn1
#define fn1(name, depth)
Definition: blend_modes.c:86
PLAYLIST_TYPE_VOD
@ PLAYLIST_TYPE_VOD
Definition: hlsplaylist.h:34
VariantStream::key_uri
char key_uri[LINE_BUFFER_SIZE+1]
Definition: hlsenc.c:170
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:264
VariantStream::init_range_length
int init_range_length
Definition: hlsenc.c:126
av_asprintf
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:115
av_strcasecmp
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:207
write_styp
static void write_styp(AVIOContext *pb)
Definition: hlsenc.c:532
VariantStream::var_stream_idx
unsigned var_stream_idx
Definition: hlsenc.c:118
HLSContext::cc_stream_map
char * cc_stream_map
Definition: hlsenc.c:246
PLAYLIST_TYPE_EVENT
@ PLAYLIST_TYPE_EVENT
Definition: hlsplaylist.h:33
HLS_APPEND_LIST
@ HLS_APPEND_LIST
Definition: hlsenc.c:101
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:1173
deinit
static void deinit(AVFormatContext *s)
Definition: chromaprint.c:50
HLS_SECOND_LEVEL_SEGMENT_INDEX
@ HLS_SECOND_LEVEL_SEGMENT_INDEX
Definition: hlsenc.c:103
HLS_DELETE_SEGMENTS
@ HLS_DELETE_SEGMENTS
Definition: hlsenc.c:96
AVFormatContext::strict_std_compliance
int strict_std_compliance
Allow non-standard and experimental extension.
Definition: avformat.h:1401
HLSContext::ignore_io_errors
int ignore_io_errors
Definition: hlsenc.c:254
KEYSIZE
#define KEYSIZE
Definition: hlsenc.c:69
HLS_MICROSECOND_UNIT
#define HLS_MICROSECOND_UNIT
Definition: hlsenc.c:71
ClosedCaptionsStream
Definition: hlsenc.c:187
AVOption
AVOption.
Definition: opt.h:251
HLS_START_SEQUENCE_AS_MICROSECONDS_SINCE_EPOCH
@ HLS_START_SEQUENCE_AS_MICROSECONDS_SINCE_EPOCH
Definition: hlsenc.c:60
b
#define b
Definition: input.c:41
data
const char data[16]
Definition: mxf.c:148
HLS_INDEPENDENT_SEGMENTS
@ HLS_INDEPENDENT_SEGMENTS
Definition: hlsenc.c:108
HLS_OMIT_ENDLIST
@ HLS_OMIT_ENDLIST
Definition: hlsenc.c:99
HLSContext::iv
char * iv
Definition: hlsenc.c:223
VariantStream::iv_string
char iv_string[KEYSIZE *2+1]
Definition: hlsenc.c:172
AV_OPT_TYPE_DURATION
@ AV_OPT_TYPE_DURATION
Definition: opt.h:239
fn
#define fn(a)
Definition: adynamicequalizer_template.c:61
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
ffio_open_whitelist
int ffio_open_whitelist(AVIOContext **s, const char *url, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options, const char *whitelist, const char *blacklist)
Definition: aviobuf.c:1244
VariantStream::start_pts
int64_t start_pts
Definition: hlsenc.c:138
HLSContext::nb_ccstreams
unsigned int nb_ccstreams
Definition: hlsenc.c:240
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:392
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:66
PLAYLIST_TYPE_NONE
@ PLAYLIST_TYPE_NONE
Definition: hlsplaylist.h:32
mathematics.h
AVDictionary
Definition: dict.c:34
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
BUFSIZE
#define BUFSIZE
Definition: hlsenc.c:72
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
hls_write_trailer
static int hls_write_trailer(struct AVFormatContext *s)
Definition: hlsenc.c:2718
get_nth_codec_stream_index
static int get_nth_codec_stream_index(AVFormatContext *s, enum AVMediaType codec_type, int64_t stream_id)
Definition: hlsenc.c:1979
LINE_BUFFER_SIZE
#define LINE_BUFFER_SIZE
Definition: hlsenc.c:70
codec_type
enum AVMediaType codec_type
Definition: rtp.c:37
E
#define E
Definition: hlsenc.c:3109
os_support.h
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:429
update_variant_stream_info
static int update_variant_stream_info(AVFormatContext *s)
Definition: hlsenc.c:2217
av_basename
const char * av_basename(const char *path)
Thread safe basename.
Definition: avstring.c:252
AV_WB64
#define AV_WB64(p, v)
Definition: intreadwrite.h:431
FFOutputFormat::p
AVOutputFormat p
The public AVOutputFormat.
Definition: mux.h:34
hlsplaylist.h
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
HLSContext::allowcache
int allowcache
Definition: hlsenc.c:211
HLSContext::user_agent
char * user_agent
Definition: hlsenc.c:235
sls_flag_check_duration_size
static int sls_flag_check_duration_size(HLSContext *hls, VariantStream *vs)
Definition: hlsenc.c:1035
av_append_path_component
char * av_append_path_component(const char *path, const char *component)
Append path component to the existing path.
Definition: avstring.c:296
VariantStream::key_file
char key_file[LINE_BUFFER_SIZE+1]
Definition: hlsenc.c:169
HLSSegment::duration
double duration
Definition: hlsenc.c:78
AVFormatContext::interrupt_callback
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
Definition: avformat.h:1371
do_encrypt
static int do_encrypt(AVFormatContext *s, VariantStream *vs)
Definition: hlsenc.c:710
HLSContext::use_localtime
int use_localtime
flag to expand filename with localtime
Definition: hlsenc.c:209
SEGMENT_TYPE_FMP4
@ SEGMENT_TYPE_FMP4
Definition: hlsenc.c:114
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: avformat.c:787
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:99
segment::duration
int64_t duration
Definition: hls.c:77
fail
#define fail()
Definition: checkasm.h:138
ff_hls_muxer
const FFOutputFormat ff_hls_muxer
Definition: hlsenc.c:3180
sls_flags_filename_process
static int sls_flags_filename_process(struct AVFormatContext *s, HLSContext *hls, VariantStream *vs, HLSSegment *en, double duration, int64_t pos, int64_t size)
Definition: hlsenc.c:972
hls_start
static int hls_start(AVFormatContext *s, VariantStream *vs)
Definition: hlsenc.c:1679
hls_delete_file
static int hls_delete_file(HLSContext *hls, AVFormatContext *avf, char *path, const char *proto)
Definition: hlsenc.c:575
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:513
ff_hls_write_audio_rendition
void ff_hls_write_audio_rendition(AVIOContext *out, const char *agroup, const char *filename, const char *language, int name_id, int is_default)
Definition: hlsplaylist.c:40
val
static double val(void *priv, double ch)
Definition: aeval.c:78
VariantStream::oformat
const AVOutputFormat * oformat
Definition: hlsenc.c:121
av_opt_set
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:487
VariantStream::start_pts_from_audio
int start_pts_from_audio
Definition: hlsenc.c:136
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:443
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:674
ff_data_to_hex
char * ff_data_to_hex(char *buf, const uint8_t *src, int size, int lowercase)
Write hexadecimal string corresponding to given binary data.
Definition: utils.c:455
AVRational::num
int num
Numerator.
Definition: rational.h:59
HLS_PERIODIC_REKEY
@ HLS_PERIODIC_REKEY
Definition: hlsenc.c:107
av_dirname
const char * av_dirname(char *path)
Thread safe dirname.
Definition: avstring.c:275
sls_flag_file_rename
static void sls_flag_file_rename(HLSContext *hls, VariantStream *vs, char *old_filename)
Definition: hlsenc.c:1055
HLS_ROUND_DURATIONS
@ HLS_ROUND_DURATIONS
Definition: hlsenc.c:97
HLSContext::use_localtime_mkdir
int use_localtime_mkdir
flag to mkdir dirname in timebased filename
Definition: hlsenc.c:210
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:1552
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
AVFormatContext::metadata
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1333
get_stream_bit_rate
static int64_t get_stream_bit_rate(AVStream *stream)
Definition: hlsenc.c:1354
HLSSegment::keyframe_pos
int64_t keyframe_pos
Definition: hlsenc.c:82
HLSSegment::discont
int discont
Definition: hlsenc.c:79
AV_PROFILE_UNKNOWN
#define AV_PROFILE_UNKNOWN
Definition: defs.h:65
ff_hls_write_subtitle_rendition
void ff_hls_write_subtitle_rendition(AVIOContext *out, const char *sgroup, const char *filename, const char *language, int name_id, int is_default)
Definition: hlsplaylist.c:55
HLSContext::key_basename
char * key_basename
Definition: hlsenc.c:224
HLSContext::m3u8_out
AVIOContext * m3u8_out
Definition: hlsenc.c:250
duration
int64_t duration
Definition: movenc.c:64
avio_open_dyn_buf
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1507
HLSContext::encrypt_started
int encrypt_started
Definition: hlsenc.c:225
HLSSegment::next
struct HLSSegment * next
Definition: hlsenc.c:89
validate_name
static int validate_name(int nb_vs, const char *fn)
Definition: hlsenc.c:1899
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
HLSContext::method
char * method
Definition: hlsenc.c:234
set_http_options
static void set_http_options(AVFormatContext *s, AVDictionary **options, HLSContext *c)
Definition: hlsenc.c:324
CODEC_ATTRIBUTE_WRITTEN
@ CODEC_ATTRIBUTE_WRITTEN
Definition: hlsenc.c:65
VariantStream::vtt_oformat
const AVOutputFormat * vtt_oformat
Definition: hlsenc.c:122
ff_nal_unit_extract_rbsp
uint8_t * ff_nal_unit_extract_rbsp(const uint8_t *src, uint32_t src_len, uint32_t *dst_len, int header_len)
Definition: avc.c:303
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
HLSContext::has_default_key
int has_default_key
Definition: hlsenc.c:256
AV_CODEC_ID_MP2
@ AV_CODEC_ID_MP2
Definition: codec_id.h:442
av_strtok
char * av_strtok(char *s, const char *delim, char **saveptr)
Split the string into several tokens which can be accessed by successive calls to av_strtok().
Definition: avstring.c:178
flush_dynbuf
static int flush_dynbuf(VariantStream *vs, int *range_length)
Definition: hlsenc.c:542
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:365
hls_deinit
static void hls_deinit(AVFormatContext *s)
Definition: hlsenc.c:2684
HLS_SECOND_LEVEL_SEGMENT_SIZE
@ HLS_SECOND_LEVEL_SEGMENT_SIZE
Definition: hlsenc.c:105
AV_OPT_TYPE_INT64
@ AV_OPT_TYPE_INT64
Definition: opt.h:226
VariantStream::has_video
int has_video
Definition: hlsenc.c:133
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:637
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
VariantStream::language
const char * language
Definition: hlsenc.c:180
ctx
AVFormatContext * ctx
Definition: movenc.c:48
nb_streams
static int nb_streams
Definition: ffprobe.c:315
HLSContext::time
int64_t time
Definition: hlsenc.c:198
HLSContext::key_url
char * key_url
Definition: hlsenc.c:222
AVOutputFormat::codec_tag
const struct AVCodecTag *const * codec_tag
List of supported codec_id-codec_tag pairs, ordered by "better choice first".
Definition: avformat.h:534
av_stristart
int av_stristart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str independent of case.
Definition: avstring.c:47
AVFormatContext::opaque
void * opaque
User data.
Definition: avformat.h:1610
VariantStream::key_string
char key_string[KEYSIZE *2+1]
Definition: hlsenc.c:171
key
const char * key
Definition: hwcontext_opencl.c:174
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: defs.h:261
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
VariantStream::attr_status
CodecAttributeStatus attr_status
Definition: hlsenc.c:176
VariantStream::video_lastpos
int64_t video_lastpos
Definition: hlsenc.c:140
VariantStream::reference_stream_index
int reference_stream_index
Definition: hlsenc.c:149
VariantStream::base_output_dirname
char * base_output_dirname
Definition: hlsenc.c:165
VariantStream::segments
HLSSegment * segments
Definition: hlsenc.c:151
write_codec_attr
static void write_codec_attr(AVStream *st, VariantStream *vs)
Definition: hlsenc.c:343
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
avio_flush
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:270
AV_CODEC_ID_WEBVTT
@ AV_CODEC_ID_WEBVTT
Definition: codec_id.h:568
AVFormatContext
Format I/O context.
Definition: avformat.h:1105
VariantStream::video_keyframe_pos
int64_t video_keyframe_pos
Definition: hlsenc.c:141
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:862
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
replace_str_data_in_filename
static int replace_str_data_in_filename(char **s, const char *filename, char placeholder, const char *datastring)
Definition: hlsenc.c:444
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
reflush_dynbuf
static void reflush_dynbuf(VariantStream *vs, int *range_length)
Definition: hlsenc.c:563
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:878
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
StartSequenceSourceType
StartSequenceSourceType
Definition: hlsenc.c:56
VariantStream::m3u8_name
char * m3u8_name
Definition: hlsenc.c:159
write_trailer
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:101
VariantStream::new_start
int new_start
Definition: hlsenc.c:135
HLS_PROGRAM_DATE_TIME
@ HLS_PROGRAM_DATE_TIME
Definition: hlsenc.c:102
AV_LEVEL_UNKNOWN
#define AV_LEVEL_UNKNOWN
Definition: defs.h:196
HLSSegment::sub_filename
char sub_filename[MAX_URL_SIZE]
Definition: hlsenc.c:77
HLSSegment::iv_string
char iv_string[KEYSIZE *2+1]
Definition: hlsenc.c:87
period
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 default minimum maximum flags name is the option keep it simple and lowercase description are in without period
Definition: writing_filters.txt:89
HLSSegment::key_uri
char key_uri[LINE_BUFFER_SIZE+1]
Definition: hlsenc.c:86
HLSContext::vtt_format_options_str
char * vtt_format_options_str
Definition: hlsenc.c:216
HLSContext::http_delete
AVIOContext * http_delete
Definition: hlsenc.c:252
AV_OPT_TYPE_DICT
@ AV_OPT_TYPE_DICT
Definition: opt.h:232
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
ffurl_shutdown
int ffurl_shutdown(URLContext *h, int flags)
Signal the URLContext that we are done reading or writing the stream.
Definition: avio.c:660
AVFormatContext::pb
AVIOContext * pb
I/O context.
Definition: avformat.h:1147
avc.h
HLS_START_SEQUENCE_LAST
@ HLS_START_SEQUENCE_LAST
Definition: hlsenc.c:61
hlsenc_io_open
static int hlsenc_io_open(AVFormatContext *s, AVIOContext **pb, const char *filename, AVDictionary **options)
Definition: hlsenc.c:283
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:919
FFOutputFormat
Definition: mux.h:30
double
double
Definition: af_crystalizer.c:131
HLSSegment
Definition: hlsenc.c:75
AV_DICT_DONT_OVERWRITE
#define AV_DICT_DONT_OVERWRITE
Don't overwrite existing entries.
Definition: dict.h:81
time.h
VariantStream::discontinuity_set
int discontinuity_set
Definition: hlsenc.c:147
AVOutputFormat::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:537
av_write_frame
int av_write_frame(AVFormatContext *s, AVPacket *pkt)
Write a packet to an output media file.
Definition: mux.c:1202
HLSContext::vtt_format_options
AVDictionary * vtt_format_options
Definition: hlsenc.c:232
PLAYLIST_TYPE_NB
@ PLAYLIST_TYPE_NB
Definition: hlsplaylist.h:35
SegmentType
SegmentType
Definition: hlsenc.c:112
AVCodecParameters::level
int level
Definition: codec_par.h:123
index
int index
Definition: gxfenc.c:89
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
HLS_START_SEQUENCE_AS_START_NUMBER
@ HLS_START_SEQUENCE_AS_START_NUMBER
Definition: hlsenc.c:57
HLSContext::key
char * key
Definition: hlsenc.c:221
VariantStream::old_segments
HLSSegment * old_segments
Definition: hlsenc.c:153
AV_CODEC_ID_EAC3
@ AV_CODEC_ID_EAC3
Definition: codec_id.h:482
VariantStream::is_default
int is_default
Definition: hlsenc.c:179
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:80
HLS_I_FRAMES_ONLY
@ HLS_I_FRAMES_ONLY
Definition: hlsenc.c:109
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:444
av_strncasecmp
int av_strncasecmp(const char *a, const char *b, size_t n)
Locale-independent case-insensitive compare.
Definition: avstring.c:217
VariantStream::initial_prog_date_time
double initial_prog_date_time
Definition: hlsenc.c:161
HLSContext::segment_filename
char * segment_filename
Definition: hlsenc.c:204
hls_append_segment
static int hls_append_segment(struct AVFormatContext *s, HLSContext *hls, VariantStream *vs, double duration, int64_t pos, int64_t size)
Definition: hlsenc.c:1106
HLSFlags
HLSFlags
Definition: hlsenc.c:93
HLSContext::cc_streams
ClosedCaptionsStream * cc_streams
Definition: hlsenc.c:239
ff_hls_write_playlist_version
void ff_hls_write_playlist_version(AVIOContext *out, int version)
Definition: hlsplaylist.c:32
HLSContext::has_video_m3u8
int has_video_m3u8
Definition: hlsenc.c:257
VariantStream::init_buffer
uint8_t * init_buffer
Definition: hlsenc.c:128
AVIOContext
Bytestream IO Context.
Definition: avio.h:166
VariantStream::ccgroup
const char * ccgroup
Definition: hlsenc.c:183
HLSSegment::keyframe_size
int64_t keyframe_size
Definition: hlsenc.c:83
hls_rename_temp_file
static int hls_rename_temp_file(AVFormatContext *s, AVFormatContext *oc)
Definition: hlsenc.c:1319
AVMediaType
AVMediaType
Definition: avutil.h:199
AVPacket::size
int size
Definition: packet.h:375
HLSContext::master_pl_name
char * master_pl_name
Definition: hlsenc.c:247
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
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.
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:240
HLS_SPLIT_BY_TIME
@ HLS_SPLIT_BY_TIME
Definition: hlsenc.c:100
create_master_playlist
static int create_master_playlist(AVFormatContext *s, VariantStream *const input_vs)
Definition: hlsenc.c:1370
VariantStream::basename_tmp
char * basename_tmp
Definition: hlsenc.c:155
localtime_r
#define localtime_r
Definition: time_internal.h:46
HLSContext::start_sequence_source_type
uint32_t start_sequence_source_type
Definition: hlsenc.c:196
AVFormatContext::url
char * url
input or output URL.
Definition: avformat.h:1188
ffio_geturlcontext
struct URLContext * ffio_geturlcontext(AVIOContext *s)
Return the URLContext associated with the AVIOContext.
Definition: aviobuf.c:1028
size
int size
Definition: twinvq_data.h:10344
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
HLSSegment::pos
int64_t pos
Definition: hlsenc.c:80
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
AVFMT_ALLOW_FLUSH
#define AVFMT_ALLOW_FLUSH
Format allows flushing.
Definition: avformat.h:489
HLSContext::pl_type
uint32_t pl_type
Definition: hlsenc.c:203
AVCodecParameters::profile
int profile
Codec-specific bitstream restrictions that the stream conforms to.
Definition: codec_par.h:122
CODEC_ATTRIBUTE_WILL_NOT_BE_WRITTEN
@ CODEC_ATTRIBUTE_WILL_NOT_BE_WRITTEN
Definition: hlsenc.c:66
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:469
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
ff_format_io_close
int ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
Definition: avformat.c:869
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:123
HLSSegment::discont_program_date_time
double discont_program_date_time
Definition: hlsenc.c:90
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:917
parse_variant_stream_mapstring
static int parse_variant_stream_mapstring(AVFormatContext *s)
Definition: hlsenc.c:1997
hls_init
static int hls_init(AVFormatContext *s)
Definition: hlsenc.c:2857
VariantStream::agroup
const char * agroup
Definition: hlsenc.c:181
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:248
avio_wb32
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:412
av_isdigit
static av_const int av_isdigit(int c)
Locale-independent conversion of ASCII isdigit.
Definition: avstring.h:202
VariantStream::sequence
int64_t sequence
Definition: hlsenc.c:120
line
Definition: graph2dot.c:48
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:380
HLSContext::start_sequence
int64_t start_sequence
Definition: hlsenc.c:195
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:225
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
VariantStream::temp_buffer
uint8_t * temp_buffer
Definition: hlsenc.c:127
HLSContext::format_options
AVDictionary * format_options
Definition: hlsenc.c:218
OFFSET
#define OFFSET(x)
Definition: hlsenc.c:3108
HLS_DISCONT_START
@ HLS_DISCONT_START
Definition: hlsenc.c:98
VariantStream::video_keyframe_size
int64_t video_keyframe_size
Definition: hlsenc.c:142
VariantStream::basename
char * basename
Definition: hlsenc.c:156
HLS_START_SEQUENCE_AS_FORMATTED_DATETIME
@ HLS_START_SEQUENCE_AS_FORMATTED_DATETIME
Definition: hlsenc.c:59
parse_playlist
static int parse_playlist(AVFormatContext *s, const char *url, VariantStream *vs)
Definition: hlsenc.c:1195
hls_write_packet
static int hls_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: hlsenc.c:2406
VariantStream::last_segment
HLSSegment * last_segment
Definition: hlsenc.c:152
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:1264
VariantStream::m3u8_created
int m3u8_created
Definition: hlsenc.c:178
bprint.h
URLContext
Definition: url.h:37
HLSContext::iv_string
char iv_string[KEYSIZE *2+1]
Definition: hlsenc.c:231
log.h
AVFMT_GLOBALHEADER
#define AVFMT_GLOBALHEADER
Format wants global header.
Definition: avformat.h:479
AVOutputFormat
Definition: avformat.h:508
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:244
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:367
avio_internal.h
round
static av_always_inline av_const double round(double x)
Definition: libm.h:444
AVERROR_MUXER_NOT_FOUND
#define AVERROR_MUXER_NOT_FOUND
Muxer not found.
Definition: error.h:62
HLSContext::key_string
char key_string[KEYSIZE *2+1]
Definition: hlsenc.c:230
VariantStream::sgroup
const char * sgroup
Definition: hlsenc.c:182
HLSContext::max_nb_segments
int max_nb_segments
Definition: hlsenc.c:200
VariantStream::start_pos
int64_t start_pos
Definition: hlsenc.c:144
AVCPBProperties::max_bitrate
int64_t max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: defs.h:266
VariantStream::nb_streams
unsigned int nb_streams
Definition: hlsenc.c:177
HLSContext::sub_m3u8_out
AVIOContext * sub_m3u8_out
Definition: hlsenc.c:251
hls_encryption_start
static int hls_encryption_start(AVFormatContext *s, VariantStream *vs)
Definition: hlsenc.c:783
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:226
HLSContext
Definition: hls.c:204
options
static const AVOption options[]
Definition: hlsenc.c:3110
url.h
hlsenc_io_close
static int hlsenc_io_close(AVFormatContext *s, AVIOContext **pb, char *filename)
Definition: hlsenc.c:304
av_random_bytes
int av_random_bytes(uint8_t *buf, size_t len)
Generate cryptographically secure random data, i.e.
Definition: random_seed.c:130
AVFormatContext::max_delay
int max_delay
Definition: avformat.h:1217
VariantStream::number
unsigned number
Definition: hlsenc.c:119
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
ff_get_line
int ff_get_line(AVIOContext *s, char *buf, int maxlen)
Read a whole line of text from AVIOContext.
Definition: aviobuf.c:816
HLSSegment::var_stream_idx
unsigned var_stream_idx
Definition: hlsenc.c:84
AV_PKT_DATA_CPB_PROPERTIES
@ AV_PKT_DATA_CPB_PROPERTIES
This side data corresponds to the AVCPBProperties struct.
Definition: packet.h:146
len
int len
Definition: vorbis_enc_data.h:426
start_sequence
static const uint8_t start_sequence[]
Definition: rtpdec_h264.c:65
profile
int profile
Definition: mxfenc.c:2111
VariantStream::duration
double duration
Definition: hlsenc.c:143
VariantStream::streams
AVStream ** streams
Definition: hlsenc.c:174
write_packet
static int write_packet(Muxer *mux, OutputStream *ost, AVPacket *pkt)
Definition: ffmpeg_mux.c:61
HLSContext::fmp4_init_filename
char * fmp4_init_filename
Definition: hlsenc.c:205
fn2
#define fn2(a, b)
Definition: adynamicequalizer_template.c:60
HLSContext::encrypt
int encrypt
Definition: hlsenc.c:220
HLSContext::http_persistent
int http_persistent
Definition: hls.c:226
HLS_SINGLE_FILE
@ HLS_SINGLE_FILE
Definition: hlsenc.c:95
ffio_free_dyn_buf
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
Definition: aviobuf.c:1580
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:851
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:839
VariantStream::out_single_file
AVIOContext * out_single_file
Definition: hlsenc.c:124
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:133
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:278
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
VariantStream::fmp4_init_filename
char * fmp4_init_filename
Definition: hlsenc.c:164
HLSContext::subtitle_filename
char * subtitle_filename
Definition: hlsenc.c:217
AVFormatContext::oformat
const struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1124
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
replace_int_data_in_filename
static int replace_int_data_in_filename(char **s, const char *filename, char placeholder, int64_t number)
Definition: hlsenc.c:484
hls_delete_old_segments
static int hls_delete_old_segments(AVFormatContext *s, HLSContext *hls, VariantStream *vs)
Definition: hlsenc.c:599
pos
unsigned int pos
Definition: spdifenc.c:413
avformat.h
av_stream_get_side_data
uint8_t * av_stream_get_side_data(const AVStream *st, enum AVPacketSideDataType type, size_t *size)
Get side information from stream.
Definition: avformat.c:143
VariantStream::end_pts
int64_t end_pts
Definition: hlsenc.c:139
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:99
VariantStream::encrypt_started
int encrypt_started
Definition: hlsenc.c:167
VariantStream::discontinuity
int discontinuity
Definition: hlsenc.c:148
VariantStream::nb_entries
int nb_entries
Definition: hlsenc.c:146
SEGMENT_TYPE_MPEGTS
@ SEGMENT_TYPE_MPEGTS
Definition: hlsenc.c:113
avio_printf
int avio_printf(AVIOContext *s, const char *fmt,...) av_printf_format(2
Writes a formatted string to the context.
VariantStream::current_segment_final_filename_fmt
char current_segment_final_filename_fmt[MAX_URL_SIZE]
Definition: hlsenc.c:162
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:845
random_seed.h
format_name
static int format_name(const char *buf, char **s, int index, const char *varname)
Definition: hlsenc.c:1933
MAX_URL_SIZE
#define MAX_URL_SIZE
Definition: internal.h:30
get_default_pattern_localtime_fmt
static const char * get_default_pattern_localtime_fmt(AVFormatContext *s)
Definition: hlsenc.c:1864
SEPARATOR
#define SEPARATOR
Definition: hlsenc.c:572
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
AVRational::den
int den
Denominator.
Definition: rational.h:60
VariantStream::packets_written
int packets_written
Definition: hlsenc.c:125
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:70
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
headers
FFmpeg currently uses a custom build this text attempts to document some of its obscure features and options Makefile the full command issued by make and its output will be shown on the screen DBG Preprocess x86 external assembler files to a dbg asm file in the object which then gets compiled Helps in developing those assembler files DESTDIR Destination directory for the install useful to prepare packages or install FFmpeg in cross environments GEN Set to ‘1’ to generate the missing or mismatched references Makefile builds all the libraries and the executables fate Run the fate test note that you must have installed it fate list List all fate regression test targets install Install headers
Definition: build_system.txt:34
defs.h
av_bprint_clear
void av_bprint_clear(AVBPrint *buf)
Reset the string to "" but keep internal allocated data.
Definition: bprint.c:232
avformat_free_context
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: avformat.c:98
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:659
update_master_pl_info
static int update_master_pl_info(AVFormatContext *s)
Definition: hlsenc.c:2255
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:1664
sls_flag_check_duration_size_index
static int sls_flag_check_duration_size_index(HLSContext *hls)
Definition: hlsenc.c:1012
ClosedCaptionsStream::language
const char * language
Definition: hlsenc.c:190
VariantStream::vtt_m3u8_name
char * vtt_m3u8_name
Definition: hlsenc.c:158
HLSContext::baseurl
char * baseurl
Definition: hlsenc.c:215
AVPacket::stream_index
int stream_index
Definition: packet.h:376
CodecAttributeStatus
CodecAttributeStatus
Definition: hlsenc.c:64
segment
Definition: hls.c:76
HLSContext::key_info_file
char * key_info_file
Definition: hlsenc.c:227
av_gettime
int64_t av_gettime(void)
Get the current time in microseconds.
Definition: time.c:39
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
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:169
AVIO_FLAG_READ
#define AVIO_FLAG_READ
read-only
Definition: avio.h:636
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:270
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
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:79
VariantStream::out
AVIOContext * out
Definition: hlsenc.c:123
HLSContext::nb_varstreams
unsigned int nb_varstreams
Definition: hlsenc.c:238
HLSContext::master_m3u8_created
int master_m3u8_created
Definition: hlsenc.c:242
VariantStream::size
int64_t size
Definition: hlsenc.c:145
HLSContext::version
int version
Definition: hlsenc.c:244
ff_mkdir_p
int ff_mkdir_p(const char *path)
Automatically create sub-directories.
Definition: utils.c:421
HLSContext::var_streams
VariantStream * var_streams
Definition: hlsenc.c:237
VariantStream::dpp
double dpp
Definition: hlsenc.c:137
VariantStream::avf
AVFormatContext * avf
Definition: hlsenc.c:130
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:62
POSTFIX_PATTERN
#define POSTFIX_PATTERN
Definition: hlsenc.c:73
AVPacket
This structure stores compressed data.
Definition: packet.h:351
hls_free_segments
static void hls_free_segments(HLSSegment *p)
Definition: hlsenc.c:1308
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
HLSContext::flags
uint32_t flags
Definition: hlsenc.c:202
hls_mux_init
static int hls_mux_init(AVFormatContext *s, VariantStream *vs)
Definition: hlsenc.c:842
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
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:239
VariantStream::varname
const char * varname
Definition: hlsenc.c:184
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:1716
append_single_file
static int64_t append_single_file(AVFormatContext *s, VariantStream *vs)
Definition: hlsenc.c:2375
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:468
d
d
Definition: ffmpeg_filter.c:331
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Definition: opt.h:224
HLSContext::init_time
int64_t init_time
Definition: hlsenc.c:199
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:467
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:91
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
hls_window
static int hls_window(AVFormatContext *s, int last, VariantStream *vs)
Definition: hlsenc.c:1536
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
h
h
Definition: vp9dsp_template.c:2038
avstring.h
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
write_header
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:346
HLSContext::key_uri
char key_uri[LINE_BUFFER_SIZE+1]
Definition: hlsenc.c:229
AV_RB24
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_RB24
Definition: bytestream.h:97
avformat_alloc_output_context2
int avformat_alloc_output_context2(AVFormatContext **ctx, const AVOutputFormat *oformat, const char *format_name, const char *filename)
Allocate an AVFormatContext for an output format.
Definition: mux.c:93
AVStream::pts_wrap_bits
int pts_wrap_bits
Number of bits in timestamps.
Definition: avformat.h:1006
http.h
HLS_SECOND_LEVEL_SEGMENT_DURATION
@ HLS_SECOND_LEVEL_SEGMENT_DURATION
Definition: hlsenc.c:104
av_bprint_append_data
void av_bprint_append_data(AVBPrint *buf, const char *data, unsigned size)
Append data to a print buffer.
Definition: bprint.c:163
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
snprintf
#define snprintf
Definition: snprintf.h:34
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1133
ff_format_set_url
void ff_format_set_url(AVFormatContext *s, char *url)
Set AVFormatContext url field to the provided pointer.
Definition: avformat.c:862
parse_cc_stream_mapstring
static int parse_cc_stream_mapstring(AVFormatContext *s)
Definition: hlsenc.c:2140
HLSContext::segment_type
int segment_type
Definition: hlsenc.c:206
HLSContext::master_m3u8_url
char * master_m3u8_url
Definition: hlsenc.c:243
HLSContext::recording_time
int64_t recording_time
Definition: hlsenc.c:212
HLSContext::max_seg_size
int64_t max_seg_size
Definition: hlsenc.c:213
HLSContext::master_publish_rate
unsigned int master_publish_rate
Definition: hlsenc.c:248
ClosedCaptionsStream::instreamid
const char * instreamid
Definition: hlsenc.c:189
HLSSegment::size
int64_t size
Definition: hlsenc.c:81
HLS_START_SEQUENCE_AS_SECONDS_SINCE_EPOCH
@ HLS_START_SEQUENCE_AS_SECONDS_SINCE_EPOCH
Definition: hlsenc.c:58
avcodec_parameters_copy
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: codec_par.c:75
VariantStream::vtt_basename
char * vtt_basename
Definition: hlsenc.c:157
ClosedCaptionsStream::ccgroup
const char * ccgroup
Definition: hlsenc.c:188
HLSContext::headers
char * headers
Definition: hlsenc.c:255
av_fourcc2str
#define av_fourcc2str(fourcc)
Definition: avutil.h:358
hls_class
static const AVClass hls_class
Definition: hlsenc.c:3172
VariantStream
Definition: hlsenc.c:117
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:393
HLSContext::var_stream_map
char * var_stream_map
Definition: hlsenc.c:245
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:1363