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