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