git.sesse.net Git - ffmpeg/blob - libavformat/hlsenc.c

   1 /*
   2  * Apple HTTP Live Streaming segmenter
   3  * Copyright (c) 2012, Luca Barbato
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "config.h"
  23 #include <float.h>
  24 #include <stdint.h>
  25 #if HAVE_UNISTD_H
  26 #include <unistd.h>
  27 #endif
  28
  29 #include "libavutil/avassert.h"
  30 #include "libavutil/mathematics.h"
  31 #include "libavutil/parseutils.h"
  32 #include "libavutil/avstring.h"
  33 #include "libavutil/opt.h"
  34 #include "libavutil/log.h"
  35 #include "libavutil/time_internal.h"
  36
  37 #include "avformat.h"
  38 #include "avio_internal.h"
  39 #include "internal.h"
  40 #include "os_support.h"
  41
  42 #define KEYSIZE 16
  43 #define LINE_BUFFER_SIZE 1024
  44
  45 typedef struct HLSSegment {
  46     char filename[1024];
  47     char sub_filename[1024];
  48     double duration; /* in seconds */
  49     int discont;
  50     int64_t pos;
  51     int64_t size;
  52
  53     char key_uri[LINE_BUFFER_SIZE + 1];
  54     char iv_string[KEYSIZE*2 + 1];
  55
  56     struct HLSSegment *next;
  57 } HLSSegment;
  58
  59 typedef enum HLSFlags {
  60     // Generate a single media file and use byte ranges in the playlist.
  61     HLS_SINGLE_FILE = (1 << 0),
  62     HLS_DELETE_SEGMENTS = (1 << 1),
  63     HLS_ROUND_DURATIONS = (1 << 2),
  64     HLS_DISCONT_START = (1 << 3),
  65     HLS_OMIT_ENDLIST = (1 << 4),
  66     HLS_SPLIT_BY_TIME = (1 << 5),
  67     HLS_APPEND_LIST = (1 << 6),
  68     HLS_PROGRAM_DATE_TIME = (1 << 7),
  69 } HLSFlags;
  70
  71 typedef enum {
  72     PLAYLIST_TYPE_NONE,
  73     PLAYLIST_TYPE_EVENT,
  74     PLAYLIST_TYPE_VOD,
  75     PLAYLIST_TYPE_NB,
  76 } PlaylistType;
  77
  78 typedef struct HLSContext {
  79     const AVClass *class;  // Class for private options.
  80     unsigned number;
  81     int64_t sequence;
  82     int64_t start_sequence;
  83     AVOutputFormat *oformat;
  84     AVOutputFormat *vtt_oformat;
  85
  86     AVFormatContext *avf;
  87     AVFormatContext *vtt_avf;
  88
  89     float time;            // Set by a private option.
  90     float init_time;       // Set by a private option.
  91     int max_nb_segments;   // Set by a private option.
  92     int  wrap;             // Set by a private option.
  93     uint32_t flags;        // enum HLSFlags
  94     uint32_t pl_type;      // enum PlaylistType
  95     char *segment_filename;
  96
  97     int use_localtime;      ///< flag to expand filename with localtime
  98     int use_localtime_mkdir;///< flag to mkdir dirname in timebased filename
  99     int allowcache;
 100     int64_t recording_time;
 101     int has_video;
 102     int has_subtitle;
 103     int64_t start_pts;
 104     int64_t end_pts;
 105     double duration;      // last segment duration computed so far, in seconds
 106     int64_t start_pos;    // last segment starting position
 107     int64_t size;         // last segment size
 108     int64_t max_seg_size; // every segment file max size
 109     int nb_entries;
 110     int discontinuity_set;
 111     int discontinuity;
 112
 113     HLSSegment *segments;
 114     HLSSegment *last_segment;
 115     HLSSegment *old_segments;
 116
 117     char *basename;
 118     char *vtt_basename;
 119     char *vtt_m3u8_name;
 120     char *baseurl;
 121     char *format_options_str;
 122     char *vtt_format_options_str;
 123     char *subtitle_filename;
 124     AVDictionary *format_options;
 125
 126     char *key_info_file;
 127     char key_file[LINE_BUFFER_SIZE + 1];
 128     char key_uri[LINE_BUFFER_SIZE + 1];
 129     char key_string[KEYSIZE*2 + 1];
 130     char iv_string[KEYSIZE*2 + 1];
 131     AVDictionary *vtt_format_options;
 132
 133     char *method;
 134
 135     double initial_prog_date_time;
 136 } HLSContext;
 137
 138 static int mkdir_p(const char *path) {
 139     int ret = 0;
 140     char *temp = av_strdup(path);
 141     char *pos = temp;
 142     char tmp_ch = '\0';
 143
 144     if (!path || !temp) {
 145         return -1;
 146     }
 147
 148     if (!strncmp(temp, "/", 1) || !strncmp(temp, "\\", 1)) {
 149         pos++;
 150     } else if (!strncmp(temp, "./", 2) || !strncmp(temp, ".\\", 2)) {
 151         pos += 2;
 152     }
 153
 154     for ( ; *pos != '\0'; ++pos) {
 155         if (*pos == '/' || *pos == '\\') {
 156             tmp_ch = *pos;
 157             *pos = '\0';
 158             ret = mkdir(temp, 0755);
 159             *pos = tmp_ch;
 160         }
 161     }
 162
 163     if ((*(pos - 1) != '/') || (*(pos - 1) != '\\')) {
 164         ret = mkdir(temp, 0755);
 165     }
 166
 167     av_free(temp);
 168     return ret;
 169 }
 170
 171 static int hls_delete_old_segments(HLSContext *hls) {
 172
 173     HLSSegment *segment, *previous_segment = NULL;
 174     float playlist_duration = 0.0f;
 175     int ret = 0, path_size, sub_path_size;
 176     char *dirname = NULL, *p, *sub_path;
 177     char *path = NULL;
 178
 179     segment = hls->segments;
 180     while (segment) {
 181         playlist_duration += segment->duration;
 182         segment = segment->next;
 183     }
 184
 185     segment = hls->old_segments;
 186     while (segment) {
 187         playlist_duration -= segment->duration;
 188         hls->initial_prog_date_time += segment->duration;
 189         previous_segment = segment;
 190         segment = previous_segment->next;
 191         if (playlist_duration <= -previous_segment->duration) {
 192             previous_segment->next = NULL;
 193             break;
 194         }
 195     }
 196
 197     if (segment) {
 198         if (hls->segment_filename) {
 199             dirname = av_strdup(hls->segment_filename);
 200         } else {
 201             dirname = av_strdup(hls->avf->filename);
 202         }
 203         if (!dirname) {
 204             ret = AVERROR(ENOMEM);
 205             goto fail;
 206         }
 207         p = (char *)av_basename(dirname);
 208         *p = '\0';
 209     }
 210
 211     while (segment) {
 212         av_log(hls, AV_LOG_DEBUG, "deleting old segment %s\n",
 213                                   segment->filename);
 214         path_size = strlen(dirname) + strlen(segment->filename) + 1;
 215         path = av_malloc(path_size);
 216         if (!path) {
 217             ret = AVERROR(ENOMEM);
 218             goto fail;
 219         }
 220
 221         av_strlcpy(path, dirname, path_size);
 222         av_strlcat(path, segment->filename, path_size);
 223         if (unlink(path) < 0) {
 224             av_log(hls, AV_LOG_ERROR, "failed to delete old segment %s: %s\n",
 225                                      path, strerror(errno));
 226         }
 227
 228         if (segment->sub_filename[0] != '\0') {
 229             sub_path_size = strlen(dirname) + strlen(segment->sub_filename) + 1;
 230             sub_path = av_malloc(sub_path_size);
 231             if (!sub_path) {
 232                 ret = AVERROR(ENOMEM);
 233                 goto fail;
 234             }
 235
 236             av_strlcpy(sub_path, dirname, sub_path_size);
 237             av_strlcat(sub_path, segment->sub_filename, sub_path_size);
 238             if (unlink(sub_path) < 0) {
 239                 av_log(hls, AV_LOG_ERROR, "failed to delete old segment %s: %s\n",
 240                                          sub_path, strerror(errno));
 241             }
 242             av_free(sub_path);
 243         }
 244         av_freep(&path);
 245         previous_segment = segment;
 246         segment = previous_segment->next;
 247         av_free(previous_segment);
 248     }
 249
 250 fail:
 251     av_free(path);
 252     av_free(dirname);
 253
 254     return ret;
 255 }
 256
 257 static int hls_encryption_start(AVFormatContext *s)
 258 {
 259     HLSContext *hls = s->priv_data;
 260     int ret;
 261     AVIOContext *pb;
 262     uint8_t key[KEYSIZE];
 263
 264     if ((ret = s->io_open(s, &pb, hls->key_info_file, AVIO_FLAG_READ, NULL)) < 0) {
 265         av_log(hls, AV_LOG_ERROR,
 266                 "error opening key info file %s\n", hls->key_info_file);
 267         return ret;
 268     }
 269
 270     ff_get_line(pb, hls->key_uri, sizeof(hls->key_uri));
 271     hls->key_uri[strcspn(hls->key_uri, "\r\n")] = '\0';
 272
 273     ff_get_line(pb, hls->key_file, sizeof(hls->key_file));
 274     hls->key_file[strcspn(hls->key_file, "\r\n")] = '\0';
 275
 276     ff_get_line(pb, hls->iv_string, sizeof(hls->iv_string));
 277     hls->iv_string[strcspn(hls->iv_string, "\r\n")] = '\0';
 278
 279     ff_format_io_close(s, &pb);
 280
 281     if (!*hls->key_uri) {
 282         av_log(hls, AV_LOG_ERROR, "no key URI specified in key info file\n");
 283         return AVERROR(EINVAL);
 284     }
 285
 286     if (!*hls->key_file) {
 287         av_log(hls, AV_LOG_ERROR, "no key file specified in key info file\n");
 288         return AVERROR(EINVAL);
 289     }
 290
 291     if ((ret = s->io_open(s, &pb, hls->key_file, AVIO_FLAG_READ, NULL)) < 0) {
 292         av_log(hls, AV_LOG_ERROR, "error opening key file %s\n", hls->key_file);
 293         return ret;
 294     }
 295
 296     ret = avio_read(pb, key, sizeof(key));
 297     ff_format_io_close(s, &pb);
 298     if (ret != sizeof(key)) {
 299         av_log(hls, AV_LOG_ERROR, "error reading key file %s\n", hls->key_file);
 300         if (ret >= 0 || ret == AVERROR_EOF)
 301             ret = AVERROR(EINVAL);
 302         return ret;
 303     }
 304     ff_data_to_hex(hls->key_string, key, sizeof(key), 0);
 305
 306     return 0;
 307 }
 308
 309 static int read_chomp_line(AVIOContext *s, char *buf, int maxlen)
 310 {
 311     int len = ff_get_line(s, buf, maxlen);
 312     while (len > 0 && av_isspace(buf[len - 1]))
 313         buf[--len] = '\0';
 314     return len;
 315 }
 316
 317 static int hls_mux_init(AVFormatContext *s)
 318 {
 319     HLSContext *hls = s->priv_data;
 320     AVFormatContext *oc;
 321     AVFormatContext *vtt_oc = NULL;
 322     int i, ret;
 323
 324     ret = avformat_alloc_output_context2(&hls->avf, hls->oformat, NULL, NULL);
 325     if (ret < 0)
 326         return ret;
 327     oc = hls->avf;
 328
 329     oc->oformat            = hls->oformat;
 330     oc->interrupt_callback = s->interrupt_callback;
 331     oc->max_delay          = s->max_delay;
 332     oc->opaque             = s->opaque;
 333     oc->io_open            = s->io_open;
 334     oc->io_close           = s->io_close;
 335     av_dict_copy(&oc->metadata, s->metadata, 0);
 336
 337     if(hls->vtt_oformat) {
 338         ret = avformat_alloc_output_context2(&hls->vtt_avf, hls->vtt_oformat, NULL, NULL);
 339         if (ret < 0)
 340             return ret;
 341         vtt_oc          = hls->vtt_avf;
 342         vtt_oc->oformat = hls->vtt_oformat;
 343         av_dict_copy(&vtt_oc->metadata, s->metadata, 0);
 344     }
 345
 346     for (i = 0; i < s->nb_streams; i++) {
 347         AVStream *st;
 348         AVFormatContext *loc;
 349         if (s->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
 350             loc = vtt_oc;
 351         else
 352             loc = oc;
 353
 354         if (!(st = avformat_new_stream(loc, NULL)))
 355             return AVERROR(ENOMEM);
 356         avcodec_parameters_copy(st->codecpar, s->streams[i]->codecpar);
 357         st->sample_aspect_ratio = s->streams[i]->sample_aspect_ratio;
 358         st->time_base = s->streams[i]->time_base;
 359     }
 360     hls->start_pos = 0;
 361
 362     return 0;
 363 }
 364
 365 /* Create a new segment and append it to the segment list */
 366 static int hls_append_segment(struct AVFormatContext *s, HLSContext *hls, double duration,
 367                               int64_t pos, int64_t size)
 368 {
 369     HLSSegment *en = av_malloc(sizeof(*en));
 370     const char  *filename;
 371     int ret;
 372
 373     if (!en)
 374         return AVERROR(ENOMEM);
 375
 376     filename = av_basename(hls->avf->filename);
 377
 378     if (hls->use_localtime_mkdir) {
 379         filename = hls->avf->filename;
 380     }
 381     av_strlcpy(en->filename, filename, sizeof(en->filename));
 382
 383     if(hls->has_subtitle)
 384         av_strlcpy(en->sub_filename, av_basename(hls->vtt_avf->filename), sizeof(en->sub_filename));
 385     else
 386         en->sub_filename[0] = '\0';
 387
 388     en->duration = duration;
 389     en->pos      = pos;
 390     en->size     = size;
 391     en->next     = NULL;
 392     en->discont  = 0;
 393
 394     if (hls->discontinuity) {
 395         en->discont = 1;
 396         hls->discontinuity = 0;
 397     }
 398
 399     if (hls->key_info_file) {
 400         av_strlcpy(en->key_uri, hls->key_uri, sizeof(en->key_uri));
 401         av_strlcpy(en->iv_string, hls->iv_string, sizeof(en->iv_string));
 402     }
 403
 404     if (!hls->segments)
 405         hls->segments = en;
 406     else
 407         hls->last_segment->next = en;
 408
 409     hls->last_segment = en;
 410
 411     // EVENT or VOD playlists imply sliding window cannot be used
 412     if (hls->pl_type != PLAYLIST_TYPE_NONE)
 413         hls->max_nb_segments = 0;
 414
 415     if (hls->max_nb_segments && hls->nb_entries >= hls->max_nb_segments) {
 416         en = hls->segments;
 417         hls->segments = en->next;
 418         if (en && hls->flags & HLS_DELETE_SEGMENTS &&
 419                 !(hls->flags & HLS_SINGLE_FILE || hls->wrap)) {
 420             en->next = hls->old_segments;
 421             hls->old_segments = en;
 422             if ((ret = hls_delete_old_segments(hls)) < 0)
 423                 return ret;
 424         } else
 425             av_free(en);
 426     } else
 427         hls->nb_entries++;
 428
 429     if (hls->max_seg_size > 0) {
 430         return 0;
 431     }
 432     hls->sequence++;
 433
 434     return 0;
 435 }
 436
 437 static int parse_playlist(AVFormatContext *s, const char *url)
 438 {
 439     HLSContext *hls = s->priv_data;
 440     AVIOContext *in;
 441     int ret = 0, is_segment = 0;
 442     int64_t new_start_pos;
 443     char line[1024];
 444     const char *ptr;
 445
 446     if ((ret = ffio_open_whitelist(&in, url, AVIO_FLAG_READ,
 447                                    &s->interrupt_callback, NULL,
 448                                    s->protocol_whitelist, s->protocol_blacklist)) < 0)
 449         return ret;
 450
 451     read_chomp_line(in, line, sizeof(line));
 452     if (strcmp(line, "#EXTM3U")) {
 453         ret = AVERROR_INVALIDDATA;
 454         goto fail;
 455     }
 456
 457     hls->discontinuity = 0;
 458     while (!avio_feof(in)) {
 459         read_chomp_line(in, line, sizeof(line));
 460         if (av_strstart(line, "#EXT-X-MEDIA-SEQUENCE:", &ptr)) {
 461             hls->sequence = atoi(ptr);
 462         } else if (av_strstart(line, "#EXT-X-DISCONTINUITY", &ptr)) {
 463             is_segment = 1;
 464             hls->discontinuity = 1;
 465         } else if (av_strstart(line, "#EXTINF:", &ptr)) {
 466             is_segment = 1;
 467             hls->duration = atof(ptr);
 468         } else if (av_strstart(line, "#", NULL)) {
 469             continue;
 470         } else if (line[0]) {
 471             if (is_segment) {
 472                 is_segment = 0;
 473                 new_start_pos = avio_tell(hls->avf->pb);
 474                 hls->size = new_start_pos - hls->start_pos;
 475                 av_strlcpy(hls->avf->filename, line, sizeof(line));
 476                 ret = hls_append_segment(s, hls, hls->duration, hls->start_pos, hls->size);
 477                 if (ret < 0)
 478                     goto fail;
 479                 hls->start_pos = new_start_pos;
 480             }
 481         }
 482     }
 483
 484 fail:
 485     avio_close(in);
 486     return ret;
 487 }
 488
 489 static void hls_free_segments(HLSSegment *p)
 490 {
 491     HLSSegment *en;
 492
 493     while(p) {
 494         en = p;
 495         p = p->next;
 496         av_free(en);
 497     }
 498 }
 499
 500 static void set_http_options(AVDictionary **options, HLSContext *c)
 501 {
 502     if (c->method)
 503         av_dict_set(options, "method", c->method, 0);
 504 }
 505
 506 static int hls_window(AVFormatContext *s, int last)
 507 {
 508     HLSContext *hls = s->priv_data;
 509     HLSSegment *en;
 510     int target_duration = 0;
 511     int ret = 0;
 512     AVIOContext *out = NULL;
 513     AVIOContext *sub_out = NULL;
 514     char temp_filename[1024];
 515     int64_t sequence = FFMAX(hls->start_sequence, hls->sequence - hls->nb_entries);
 516     int version = 3;
 517     const char *proto = avio_find_protocol_name(s->filename);
 518     int use_rename = proto && !strcmp(proto, "file");
 519     static unsigned warned_non_file;
 520     char *key_uri = NULL;
 521     char *iv_string = NULL;
 522     AVDictionary *options = NULL;
 523     double prog_date_time = hls->initial_prog_date_time;
 524     int byterange_mode = (hls->flags & HLS_SINGLE_FILE) || (hls->max_seg_size > 0);
 525
 526     if (byterange_mode) {
 527         version = 4;
 528         sequence = 0;
 529     }
 530
 531     if (!use_rename && !warned_non_file++)
 532         av_log(s, AV_LOG_ERROR, "Cannot use rename on non file protocol, this may lead to races and temporary partial files\n");
 533
 534     set_http_options(&options, hls);
 535     snprintf(temp_filename, sizeof(temp_filename), use_rename ? "%s.tmp" : "%s", s->filename);
 536     if ((ret = s->io_open(s, &out, temp_filename, AVIO_FLAG_WRITE, &options)) < 0)
 537         goto fail;
 538
 539     for (en = hls->segments; en; en = en->next) {
 540         if (target_duration < en->duration)
 541             target_duration = ceil(en->duration);
 542     }
 543
 544     hls->discontinuity_set = 0;
 545     avio_printf(out, "#EXTM3U\n");
 546     avio_printf(out, "#EXT-X-VERSION:%d\n", version);
 547     if (hls->allowcache == 0 || hls->allowcache == 1) {
 548         avio_printf(out, "#EXT-X-ALLOW-CACHE:%s\n", hls->allowcache == 0 ? "NO" : "YES");
 549     }
 550     avio_printf(out, "#EXT-X-TARGETDURATION:%d\n", target_duration);
 551     avio_printf(out, "#EXT-X-MEDIA-SEQUENCE:%"PRId64"\n", sequence);
 552     if (hls->pl_type == PLAYLIST_TYPE_EVENT) {
 553         avio_printf(out, "#EXT-X-PLAYLIST-TYPE:EVENT\n");
 554     } else if (hls->pl_type == PLAYLIST_TYPE_VOD) {
 555         avio_printf(out, "#EXT-X-PLAYLIST-TYPE:VOD\n");
 556     }
 557
 558     av_log(s, AV_LOG_VERBOSE, "EXT-X-MEDIA-SEQUENCE:%"PRId64"\n",
 559            sequence);
 560     if((hls->flags & HLS_DISCONT_START) && sequence==hls->start_sequence && hls->discontinuity_set==0 ){
 561         avio_printf(out, "#EXT-X-DISCONTINUITY\n");
 562         hls->discontinuity_set = 1;
 563     }
 564     for (en = hls->segments; en; en = en->next) {
 565         if (hls->key_info_file && (!key_uri || strcmp(en->key_uri, key_uri) ||
 566                                     av_strcasecmp(en->iv_string, iv_string))) {
 567             avio_printf(out, "#EXT-X-KEY:METHOD=AES-128,URI=\"%s\"", en->key_uri);
 568             if (*en->iv_string)
 569                 avio_printf(out, ",IV=0x%s", en->iv_string);
 570             avio_printf(out, "\n");
 571             key_uri = en->key_uri;
 572             iv_string = en->iv_string;
 573         }
 574
 575         if (en->discont) {
 576             avio_printf(out, "#EXT-X-DISCONTINUITY\n");
 577         }
 578
 579         if (hls->flags & HLS_ROUND_DURATIONS)
 580             avio_printf(out, "#EXTINF:%ld,\n",  lrint(en->duration));
 581         else
 582             avio_printf(out, "#EXTINF:%f,\n", en->duration);
 583         if (byterange_mode)
 584              avio_printf(out, "#EXT-X-BYTERANGE:%"PRIi64"@%"PRIi64"\n",
 585                          en->size, en->pos);
 586         if (hls->flags & HLS_PROGRAM_DATE_TIME) {
 587             time_t tt, wrongsecs;
 588             int milli;
 589             struct tm *tm, tmpbuf;
 590             char buf0[128], buf1[128];
 591             tt = (int64_t)prog_date_time;
 592             milli = av_clip(lrint(1000*(prog_date_time - tt)), 0, 999);
 593             tm = localtime_r(&tt, &tmpbuf);
 594             strftime(buf0, sizeof(buf0), "%Y-%m-%dT%H:%M:%S", tm);
 595             if (!strftime(buf1, sizeof(buf1), "%z", tm) || buf1[1]<'0' ||buf1[1]>'2') {
 596                 int tz_min, dst = tm->tm_isdst;
 597                 tm = gmtime_r(&tt, &tmpbuf);
 598                 tm->tm_isdst = dst;
 599                 wrongsecs = mktime(tm);
 600                 tz_min = (abs(wrongsecs - tt) + 30) / 60;
 601                 snprintf(buf1, sizeof(buf1),
 602                          "%c%02d%02d",
 603                          wrongsecs <= tt ? '+' : '-',
 604                          tz_min / 60,
 605                          tz_min % 60);
 606             }
 607             avio_printf(out, "#EXT-X-PROGRAM-DATE-TIME:%s.%03d%s\n", buf0, milli, buf1);
 608             prog_date_time += en->duration;
 609         }
 610         if (hls->baseurl)
 611             avio_printf(out, "%s", hls->baseurl);
 612         avio_printf(out, "%s\n", en->filename);
 613     }
 614
 615     if (last && (hls->flags & HLS_OMIT_ENDLIST)==0)
 616         avio_printf(out, "#EXT-X-ENDLIST\n");
 617
 618     if( hls->vtt_m3u8_name ) {
 619         if ((ret = s->io_open(s, &sub_out, hls->vtt_m3u8_name, AVIO_FLAG_WRITE, &options)) < 0)
 620             goto fail;
 621         avio_printf(sub_out, "#EXTM3U\n");
 622         avio_printf(sub_out, "#EXT-X-VERSION:%d\n", version);
 623         if (hls->allowcache == 0 || hls->allowcache == 1) {
 624             avio_printf(sub_out, "#EXT-X-ALLOW-CACHE:%s\n", hls->allowcache == 0 ? "NO" : "YES");
 625         }
 626         avio_printf(sub_out, "#EXT-X-TARGETDURATION:%d\n", target_duration);
 627         avio_printf(sub_out, "#EXT-X-MEDIA-SEQUENCE:%"PRId64"\n", sequence);
 628
 629         av_log(s, AV_LOG_VERBOSE, "EXT-X-MEDIA-SEQUENCE:%"PRId64"\n",
 630                sequence);
 631
 632         for (en = hls->segments; en; en = en->next) {
 633             avio_printf(sub_out, "#EXTINF:%f,\n", en->duration);
 634             if (byterange_mode)
 635                  avio_printf(sub_out, "#EXT-X-BYTERANGE:%"PRIi64"@%"PRIi64"\n",
 636                          en->size, en->pos);
 637             if (hls->baseurl)
 638                 avio_printf(sub_out, "%s", hls->baseurl);
 639             avio_printf(sub_out, "%s\n", en->sub_filename);
 640         }
 641
 642         if (last)
 643             avio_printf(sub_out, "#EXT-X-ENDLIST\n");
 644
 645     }
 646
 647 fail:
 648     av_dict_free(&options);
 649     ff_format_io_close(s, &out);
 650     ff_format_io_close(s, &sub_out);
 651     if (ret >= 0 && use_rename)
 652         ff_rename(temp_filename, s->filename, s);
 653     return ret;
 654 }
 655
 656 static HLSSegment *find_segment_by_filename(HLSSegment *segment, const char *filename)
 657 {
 658     /* filename may contain rel/abs path, but segments store only basename */
 659     char *p = NULL, *dirname = NULL, *path = NULL;
 660     int path_size;
 661     HLSSegment *ret_segment = NULL;
 662     dirname = av_strdup(filename);
 663     if (!dirname)
 664         return NULL;
 665     p = (char *)av_basename(dirname); // av_dirname would return . in case of no dir
 666     *p = '\0'; // maybe empty
 667
 668     while (segment) {
 669         path_size = strlen(dirname) + strlen(segment->filename) + 1;
 670         path = av_malloc(path_size);
 671         if (!path)
 672             goto end;
 673         av_strlcpy(path, dirname, path_size);
 674         av_strlcat(path, segment->filename, path_size);
 675         if (!strcmp(path,filename)) {
 676             ret_segment = segment;
 677             av_free(path);
 678             goto end;
 679         }
 680         av_free(path);
 681         segment = segment->next;
 682     }
 683 end:
 684     av_free(dirname);
 685     return ret_segment;
 686 }
 687
 688 static int hls_start(AVFormatContext *s)
 689 {
 690     HLSContext *c = s->priv_data;
 691     AVFormatContext *oc = c->avf;
 692     AVFormatContext *vtt_oc = c->vtt_avf;
 693     AVDictionary *options = NULL;
 694     char *filename, iv_string[KEYSIZE*2 + 1];
 695     int err = 0;
 696
 697     if (c->flags & HLS_SINGLE_FILE) {
 698         av_strlcpy(oc->filename, c->basename,
 699                    sizeof(oc->filename));
 700         if (c->vtt_basename)
 701             av_strlcpy(vtt_oc->filename, c->vtt_basename,
 702                   sizeof(vtt_oc->filename));
 703     } else if (c->max_seg_size > 0) {
 704         if (av_get_frame_filename2(oc->filename, sizeof(oc->filename),
 705             c->basename, c->wrap ? c->sequence % c->wrap : c->sequence,
 706             AV_FRAME_FILENAME_FLAGS_MULTIPLE) < 0) {
 707                 av_log(oc, AV_LOG_ERROR, "Invalid segment filename template '%s', you can try to use -use_localtime 1 with it\n", c->basename);
 708                 return AVERROR(EINVAL);
 709         }
 710     } else {
 711         if (c->use_localtime) {
 712             time_t now0;
 713             struct tm *tm, tmpbuf;
 714             time(&now0);
 715             tm = localtime_r(&now0, &tmpbuf);
 716             if (!strftime(oc->filename, sizeof(oc->filename), c->basename, tm)) {
 717                 av_log(oc, AV_LOG_ERROR, "Could not get segment filename with use_localtime\n");
 718                 return AVERROR(EINVAL);
 719             }
 720
 721             if (find_segment_by_filename(c->segments, oc->filename)
 722                 || find_segment_by_filename(c->old_segments, oc->filename)) {
 723                 av_log(c, AV_LOG_WARNING, "Duplicated segment filename detected: %s\n", oc->filename);
 724             }
 725             if (c->use_localtime_mkdir) {
 726                 const char *dir;
 727                 char *fn_copy = av_strdup(oc->filename);
 728                 if (!fn_copy) {
 729                     return AVERROR(ENOMEM);
 730                 }
 731                 dir = av_dirname(fn_copy);
 732                 if (mkdir_p(dir) == -1 && errno != EEXIST) {
 733                     av_log(oc, AV_LOG_ERROR, "Could not create directory %s with use_localtime_mkdir\n", dir);
 734                     av_free(fn_copy);
 735                     return AVERROR(errno);
 736                 }
 737                 av_free(fn_copy);
 738             }
 739         } else if (av_get_frame_filename2(oc->filename, sizeof(oc->filename),
 740                                   c->basename, c->wrap ? c->sequence % c->wrap : c->sequence,
 741                                   AV_FRAME_FILENAME_FLAGS_MULTIPLE) < 0) {
 742             av_log(oc, AV_LOG_ERROR, "Invalid segment filename template '%s' you can try to use -use_localtime 1 with it\n", c->basename);
 743             return AVERROR(EINVAL);
 744         }
 745         if( c->vtt_basename) {
 746             if (av_get_frame_filename2(vtt_oc->filename, sizeof(vtt_oc->filename),
 747                               c->vtt_basename, c->wrap ? c->sequence % c->wrap : c->sequence,
 748                               AV_FRAME_FILENAME_FLAGS_MULTIPLE) < 0) {
 749                 av_log(vtt_oc, AV_LOG_ERROR, "Invalid segment filename template '%s'\n", c->vtt_basename);
 750                 return AVERROR(EINVAL);
 751             }
 752        }
 753     }
 754     c->number++;
 755
 756     set_http_options(&options, c);
 757
 758     if (c->key_info_file) {
 759         if ((err = hls_encryption_start(s)) < 0)
 760             goto fail;
 761         if ((err = av_dict_set(&options, "encryption_key", c->key_string, 0))
 762                 < 0)
 763             goto fail;
 764         err = av_strlcpy(iv_string, c->iv_string, sizeof(iv_string));
 765         if (!err)
 766             snprintf(iv_string, sizeof(iv_string), "%032"PRIx64, c->sequence);
 767         if ((err = av_dict_set(&options, "encryption_iv", iv_string, 0)) < 0)
 768            goto fail;
 769
 770         filename = av_asprintf("crypto:%s", oc->filename);
 771         if (!filename) {
 772             err = AVERROR(ENOMEM);
 773             goto fail;
 774         }
 775         err = s->io_open(s, &oc->pb, filename, AVIO_FLAG_WRITE, &options);
 776         av_free(filename);
 777         av_dict_free(&options);
 778         if (err < 0)
 779             return err;
 780     } else
 781         if ((err = s->io_open(s, &oc->pb, oc->filename, AVIO_FLAG_WRITE, &options)) < 0)
 782             goto fail;
 783     if (c->vtt_basename) {
 784         set_http_options(&options, c);
 785         if ((err = s->io_open(s, &vtt_oc->pb, vtt_oc->filename, AVIO_FLAG_WRITE, &options)) < 0)
 786             goto fail;
 787     }
 788     av_dict_free(&options);
 789
 790     /* We only require one PAT/PMT per segment. */
 791     if (oc->oformat->priv_class && oc->priv_data) {
 792         char period[21];
 793
 794         snprintf(period, sizeof(period), "%d", (INT_MAX / 2) - 1);
 795
 796         av_opt_set(oc->priv_data, "mpegts_flags", "resend_headers", 0);
 797         av_opt_set(oc->priv_data, "sdt_period", period, 0);
 798         av_opt_set(oc->priv_data, "pat_period", period, 0);
 799     }
 800
 801     if (c->vtt_basename) {
 802         err = avformat_write_header(vtt_oc,NULL);
 803         if (err < 0)
 804             return err;
 805     }
 806
 807     return 0;
 808 fail:
 809     av_dict_free(&options);
 810
 811     return err;
 812 }
 813
 814 static int hls_write_header(AVFormatContext *s)
 815 {
 816     HLSContext *hls = s->priv_data;
 817     int ret, i;
 818     char *p;
 819     const char *pattern = "%d.ts";
 820     const char *pattern_localtime_fmt = "-%s.ts";
 821     const char *vtt_pattern = "%d.vtt";
 822     AVDictionary *options = NULL;
 823     int basename_size;
 824     int vtt_basename_size;
 825
 826     hls->sequence       = hls->start_sequence;
 827     hls->recording_time = (hls->init_time ? hls->init_time : hls->time) * AV_TIME_BASE;
 828     hls->start_pts      = AV_NOPTS_VALUE;
 829
 830     if (hls->flags & HLS_PROGRAM_DATE_TIME) {
 831         time_t now0;
 832         time(&now0);
 833         hls->initial_prog_date_time = now0;
 834     }
 835
 836     if (hls->format_options_str) {
 837         ret = av_dict_parse_string(&hls->format_options, hls->format_options_str, "=", ":", 0);
 838         if (ret < 0) {
 839             av_log(s, AV_LOG_ERROR, "Could not parse format options list '%s'\n", hls->format_options_str);
 840             goto fail;
 841         }
 842     }
 843
 844     for (i = 0; i < s->nb_streams; i++) {
 845         hls->has_video +=
 846             s->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO;
 847         hls->has_subtitle +=
 848             s->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE;
 849     }
 850
 851     if (hls->has_video > 1)
 852         av_log(s, AV_LOG_WARNING,
 853                "More than a single video stream present, "
 854                "expect issues decoding it.\n");
 855
 856     hls->oformat = av_guess_format("mpegts", NULL, NULL);
 857
 858     if (!hls->oformat) {
 859         ret = AVERROR_MUXER_NOT_FOUND;
 860         goto fail;
 861     }
 862
 863     if(hls->has_subtitle) {
 864         hls->vtt_oformat = av_guess_format("webvtt", NULL, NULL);
 865         if (!hls->oformat) {
 866             ret = AVERROR_MUXER_NOT_FOUND;
 867             goto fail;
 868         }
 869     }
 870
 871     if (hls->segment_filename) {
 872         hls->basename = av_strdup(hls->segment_filename);
 873         if (!hls->basename) {
 874             ret = AVERROR(ENOMEM);
 875             goto fail;
 876         }
 877     } else {
 878         if (hls->flags & HLS_SINGLE_FILE)
 879             pattern = ".ts";
 880
 881         if (hls->use_localtime) {
 882             basename_size = strlen(s->filename) + strlen(pattern_localtime_fmt) + 1;
 883         } else {
 884             basename_size = strlen(s->filename) + strlen(pattern) + 1;
 885         }
 886         hls->basename = av_malloc(basename_size);
 887         if (!hls->basename) {
 888             ret = AVERROR(ENOMEM);
 889             goto fail;
 890         }
 891
 892         av_strlcpy(hls->basename, s->filename, basename_size);
 893
 894         p = strrchr(hls->basename, '.');
 895         if (p)
 896             *p = '\0';
 897         if (hls->use_localtime) {
 898             av_strlcat(hls->basename, pattern_localtime_fmt, basename_size);
 899         } else {
 900             av_strlcat(hls->basename, pattern, basename_size);
 901         }
 902     }
 903
 904     if(hls->has_subtitle) {
 905
 906         if (hls->flags & HLS_SINGLE_FILE)
 907             vtt_pattern = ".vtt";
 908         vtt_basename_size = strlen(s->filename) + strlen(vtt_pattern) + 1;
 909         hls->vtt_basename = av_malloc(vtt_basename_size);
 910         if (!hls->vtt_basename) {
 911             ret = AVERROR(ENOMEM);
 912             goto fail;
 913         }
 914         hls->vtt_m3u8_name = av_malloc(vtt_basename_size);
 915         if (!hls->vtt_m3u8_name ) {
 916             ret = AVERROR(ENOMEM);
 917             goto fail;
 918         }
 919         av_strlcpy(hls->vtt_basename, s->filename, vtt_basename_size);
 920         p = strrchr(hls->vtt_basename, '.');
 921         if (p)
 922             *p = '\0';
 923
 924         if( hls->subtitle_filename ) {
 925             strcpy(hls->vtt_m3u8_name, hls->subtitle_filename);
 926         } else {
 927             strcpy(hls->vtt_m3u8_name, hls->vtt_basename);
 928             av_strlcat(hls->vtt_m3u8_name, "_vtt.m3u8", vtt_basename_size);
 929         }
 930         av_strlcat(hls->vtt_basename, vtt_pattern, vtt_basename_size);
 931     }
 932
 933     if ((ret = hls_mux_init(s)) < 0)
 934         goto fail;
 935
 936     if (hls->flags & HLS_APPEND_LIST) {
 937         parse_playlist(s, s->filename);
 938         hls->discontinuity = 1;
 939         if (hls->init_time > 0) {
 940             av_log(s, AV_LOG_WARNING, "append_list mode does not support hls_init_time,"
 941                    " hls_init_time value will have no effect\n");
 942             hls->init_time = 0;
 943             hls->recording_time = hls->time * AV_TIME_BASE;
 944         }
 945     }
 946
 947     if ((ret = hls_start(s)) < 0)
 948         goto fail;
 949
 950     av_dict_copy(&options, hls->format_options, 0);
 951     ret = avformat_write_header(hls->avf, &options);
 952     if (av_dict_count(options)) {
 953         av_log(s, AV_LOG_ERROR, "Some of provided format options in '%s' are not recognized\n", hls->format_options_str);
 954         ret = AVERROR(EINVAL);
 955         goto fail;
 956     }
 957     //av_assert0(s->nb_streams == hls->avf->nb_streams);
 958     for (i = 0; i < s->nb_streams; i++) {
 959         AVStream *inner_st;
 960         AVStream *outer_st = s->streams[i];
 961
 962         if (hls->max_seg_size > 0) {
 963             if ((outer_st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) &&
 964                 (outer_st->codecpar->bit_rate > hls->max_seg_size)) {
 965                 av_log(s, AV_LOG_WARNING, "Your video bitrate is bigger than hls_segment_size, "
 966                        "(%"PRId64 " > %"PRId64 "), the result maybe not be what you want.",
 967                        outer_st->codecpar->bit_rate, hls->max_seg_size);
 968             }
 969         }
 970
 971         if (outer_st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE)
 972             inner_st = hls->avf->streams[i];
 973         else if (hls->vtt_avf)
 974             inner_st = hls->vtt_avf->streams[0];
 975         else {
 976             /* We have a subtitle stream, when the user does not want one */
 977             inner_st = NULL;
 978             continue;
 979         }
 980         avpriv_set_pts_info(outer_st, inner_st->pts_wrap_bits, inner_st->time_base.num, inner_st->time_base.den);
 981     }
 982 fail:
 983
 984     av_dict_free(&options);
 985     if (ret < 0) {
 986         av_freep(&hls->basename);
 987         av_freep(&hls->vtt_basename);
 988         if (hls->avf)
 989             avformat_free_context(hls->avf);
 990         if (hls->vtt_avf)
 991             avformat_free_context(hls->vtt_avf);
 992
 993     }
 994     return ret;
 995 }
 996
 997 static int hls_write_packet(AVFormatContext *s, AVPacket *pkt)
 998 {
 999     HLSContext *hls = s->priv_data;
1000     AVFormatContext *oc = NULL;
1001     AVStream *st = s->streams[pkt->stream_index];
1002     int64_t end_pts = hls->recording_time * hls->number;
1003     int is_ref_pkt = 1;
1004     int ret, can_split = 1;
1005     int stream_index = 0;
1006
1007     if (hls->sequence - hls->nb_entries > hls->start_sequence && hls->init_time > 0) {
1008         /* reset end_pts, hls->recording_time at end of the init hls list */
1009         int init_list_dur = hls->init_time * hls->nb_entries * AV_TIME_BASE;
1010         int after_init_list_dur = (hls->sequence - hls->nb_entries ) * hls->time * AV_TIME_BASE;
1011         hls->recording_time = hls->time * AV_TIME_BASE;
1012         end_pts = init_list_dur + after_init_list_dur ;
1013     }
1014
1015     if( st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE ) {
1016         oc = hls->vtt_avf;
1017         stream_index = 0;
1018     } else {
1019         oc = hls->avf;
1020         stream_index = pkt->stream_index;
1021     }
1022     if (hls->start_pts == AV_NOPTS_VALUE) {
1023         hls->start_pts = pkt->pts;
1024         hls->end_pts   = pkt->pts;
1025     }
1026
1027     if (hls->has_video) {
1028         can_split = st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
1029                     ((pkt->flags & AV_PKT_FLAG_KEY) || (hls->flags & HLS_SPLIT_BY_TIME));
1030         is_ref_pkt = st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO;
1031     }
1032     if (pkt->pts == AV_NOPTS_VALUE)
1033         is_ref_pkt = can_split = 0;
1034
1035     if (is_ref_pkt)
1036         hls->duration = (double)(pkt->pts - hls->end_pts)
1037                                    * st->time_base.num / st->time_base.den;
1038
1039     if (can_split && av_compare_ts(pkt->pts - hls->start_pts, st->time_base,
1040                                    end_pts, AV_TIME_BASE_Q) >= 0) {
1041         int64_t new_start_pos;
1042         av_write_frame(oc, NULL); /* Flush any buffered data */
1043
1044         new_start_pos = avio_tell(hls->avf->pb);
1045         hls->size = new_start_pos - hls->start_pos;
1046         ret = hls_append_segment(s, hls, hls->duration, hls->start_pos, hls->size);
1047         hls->start_pos = new_start_pos;
1048         if (ret < 0)
1049             return ret;
1050
1051         hls->end_pts = pkt->pts;
1052         hls->duration = 0;
1053
1054         if (hls->flags & HLS_SINGLE_FILE) {
1055             if (hls->avf->oformat->priv_class && hls->avf->priv_data)
1056                 av_opt_set(hls->avf->priv_data, "mpegts_flags", "resend_headers", 0);
1057             hls->number++;
1058         } else if (hls->max_seg_size > 0) {
1059             if (hls->avf->oformat->priv_class && hls->avf->priv_data)
1060                 av_opt_set(hls->avf->priv_data, "mpegts_flags", "resend_headers", 0);
1061             if (hls->start_pos >= hls->max_seg_size) {
1062                 hls->sequence++;
1063                 ff_format_io_close(s, &oc->pb);
1064                 if (hls->vtt_avf)
1065                     ff_format_io_close(s, &hls->vtt_avf->pb);
1066                 ret = hls_start(s);
1067                 hls->start_pos = 0;
1068                 /* When split segment by byte, the duration is short than hls_time,
1069                  * so it is not enough one segment duration as hls_time, */
1070                 hls->number--;
1071             }
1072             hls->number++;
1073         } else {
1074             ff_format_io_close(s, &oc->pb);
1075             if (hls->vtt_avf)
1076                 ff_format_io_close(s, &hls->vtt_avf->pb);
1077
1078             ret = hls_start(s);
1079         }
1080
1081         if (ret < 0)
1082             return ret;
1083
1084         if( st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE )
1085             oc = hls->vtt_avf;
1086         else
1087         oc = hls->avf;
1088
1089         if ((ret = hls_window(s, 0)) < 0)
1090             return ret;
1091     }
1092
1093     ret = ff_write_chained(oc, stream_index, pkt, s, 0);
1094
1095     return ret;
1096 }
1097
1098 static int hls_write_trailer(struct AVFormatContext *s)
1099 {
1100     HLSContext *hls = s->priv_data;
1101     AVFormatContext *oc = hls->avf;
1102     AVFormatContext *vtt_oc = hls->vtt_avf;
1103
1104     av_write_trailer(oc);
1105     if (oc->pb) {
1106         hls->size = avio_tell(hls->avf->pb) - hls->start_pos;
1107         ff_format_io_close(s, &oc->pb);
1108         hls_append_segment(s, hls, hls->duration, hls->start_pos, hls->size);
1109     }
1110
1111     if (vtt_oc) {
1112         if (vtt_oc->pb)
1113             av_write_trailer(vtt_oc);
1114         hls->size = avio_tell(hls->vtt_avf->pb) - hls->start_pos;
1115         ff_format_io_close(s, &vtt_oc->pb);
1116     }
1117     av_freep(&hls->basename);
1118     avformat_free_context(oc);
1119
1120     hls->avf = NULL;
1121     hls_window(s, 1);
1122
1123     if (vtt_oc) {
1124         av_freep(&hls->vtt_basename);
1125         av_freep(&hls->vtt_m3u8_name);
1126         avformat_free_context(vtt_oc);
1127     }
1128
1129     hls_free_segments(hls->segments);
1130     hls_free_segments(hls->old_segments);
1131     return 0;
1132 }
1133
1134 #define OFFSET(x) offsetof(HLSContext, x)
1135 #define E AV_OPT_FLAG_ENCODING_PARAM
1136 static const AVOption options[] = {
1137     {"start_number",  "set first number in the sequence",        OFFSET(start_sequence),AV_OPT_TYPE_INT64,  {.i64 = 0},     0, INT64_MAX, E},
1138     {"hls_time",      "set segment length in seconds",           OFFSET(time),    AV_OPT_TYPE_FLOAT,  {.dbl = 2},     0, FLT_MAX, E},
1139     {"hls_init_time", "set segment length in seconds at init list",           OFFSET(init_time),    AV_OPT_TYPE_FLOAT,  {.dbl = 0},     0, FLT_MAX, E},
1140     {"hls_list_size", "set maximum number of playlist entries",  OFFSET(max_nb_segments),    AV_OPT_TYPE_INT,    {.i64 = 5},     0, INT_MAX, E},
1141     {"hls_ts_options","set hls mpegts list of options for the container format used for hls", OFFSET(format_options_str), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,    E},
1142     {"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},
1143     {"hls_wrap",      "set number after which the index wraps",  OFFSET(wrap),    AV_OPT_TYPE_INT,    {.i64 = 0},     0, INT_MAX, E},
1144     {"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},
1145     {"hls_base_url",  "url to prepend to each playlist entry",   OFFSET(baseurl), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,       E},
1146     {"hls_segment_filename", "filename template for segment files", OFFSET(segment_filename),   AV_OPT_TYPE_STRING, {.str = NULL},            0,       0,         E},
1147     {"hls_segment_size", "maximum size per segment file, (in bytes)",  OFFSET(max_seg_size),    AV_OPT_TYPE_INT,    {.i64 = 0},               0,       INT_MAX,   E},
1148     {"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},
1149     {"hls_subtitle_path",     "set path of hls subtitles", OFFSET(subtitle_filename), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,    E},
1150     {"hls_flags",     "set flags affecting HLS playlist and media file generation", OFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = 0 }, 0, UINT_MAX, E, "flags"},
1151     {"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"},
1152     {"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"},
1153     {"round_durations", "round durations in m3u8 to whole numbers", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_ROUND_DURATIONS }, 0, UINT_MAX,   E, "flags"},
1154     {"discont_start", "start the playlist with a discontinuity tag", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_DISCONT_START }, 0, UINT_MAX,   E, "flags"},
1155     {"omit_endlist", "Do not append an endlist when ending stream", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_OMIT_ENDLIST }, 0, UINT_MAX,   E, "flags"},
1156     {"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"},
1157     {"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"},
1158     {"program_date_time", "add EXT-X-PROGRAM-DATE-TIME", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_PROGRAM_DATE_TIME }, 0, UINT_MAX,   E, "flags"},
1159     {"use_localtime", "set filename expansion with strftime at segment creation", OFFSET(use_localtime), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
1160     {"use_localtime_mkdir", "create last directory component in strftime-generated filename", OFFSET(use_localtime_mkdir), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
1161     {"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" },
1162     {"event", "EVENT playlist", 0, AV_OPT_TYPE_CONST, {.i64 = PLAYLIST_TYPE_EVENT }, INT_MIN, INT_MAX, E, "pl_type" },
1163     {"vod", "VOD playlist", 0, AV_OPT_TYPE_CONST, {.i64 = PLAYLIST_TYPE_VOD }, INT_MIN, INT_MAX, E, "pl_type" },
1164     {"method", "set the HTTP method", OFFSET(method), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,    E},
1165
1166     { NULL },
1167 };
1168
1169 static const AVClass hls_class = {
1170     .class_name = "hls muxer",
1171     .item_name  = av_default_item_name,
1172     .option     = options,
1173     .version    = LIBAVUTIL_VERSION_INT,
1174 };
1175
1176
1177 AVOutputFormat ff_hls_muxer = {
1178     .name           = "hls",
1179     .long_name      = NULL_IF_CONFIG_SMALL("Apple HTTP Live Streaming"),
1180     .extensions     = "m3u8",
1181     .priv_data_size = sizeof(HLSContext),
1182     .audio_codec    = AV_CODEC_ID_AAC,
1183     .video_codec    = AV_CODEC_ID_H264,
1184     .subtitle_codec = AV_CODEC_ID_WEBVTT,
1185     .flags          = AVFMT_NOFILE | AVFMT_ALLOW_FLUSH,
1186     .write_header   = hls_write_header,
1187     .write_packet   = hls_write_packet,
1188     .write_trailer  = hls_write_trailer,
1189     .priv_class     = &hls_class,
1190 };