hlsenc.c 98.8 KB
Newer Older
1 2 3
/*
 * Apple HTTP Live Streaming segmenter
 * Copyright (c) 2012, Luca Barbato
4
 * Copyright (c) 2017 Akamai Technologies, Inc.
5
 *
6
 * This file is part of FFmpeg.
7
 *
8
 * FFmpeg is free software; you can redistribute it and/or
9 10 11 12
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
13
 * FFmpeg is distributed in the hope that it will be useful,
14 15 16 17 18
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
19
 * License along with FFmpeg; if not, write to the Free Software
20 21 22
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

23
#include "config.h"
24
#include <float.h>
25
#include <stdint.h>
26 27 28
#if HAVE_UNISTD_H
#include <unistd.h>
#endif
29

30 31 32 33 34 35
#if CONFIG_GCRYPT
#include <gcrypt.h>
#elif CONFIG_OPENSSL
#include <openssl/rand.h>
#endif

36
#include "libavutil/avassert.h"
37 38 39
#include "libavutil/mathematics.h"
#include "libavutil/parseutils.h"
#include "libavutil/avstring.h"
40 41
#include "libavutil/intreadwrite.h"
#include "libavutil/random_seed.h"
42 43
#include "libavutil/opt.h"
#include "libavutil/log.h"
44
#include "libavutil/time_internal.h"
45 46

#include "avformat.h"
47
#include "avio_internal.h"
48
#if CONFIG_HTTP_PROTOCOL
49
#include "http.h"
50
#endif
51
#include "hlsplaylist.h"
52
#include "internal.h"
53
#include "os_support.h"
54

55 56 57 58 59 60
typedef enum {
  HLS_START_SEQUENCE_AS_START_NUMBER = 0,
  HLS_START_SEQUENCE_AS_SECONDS_SINCE_EPOCH = 1,
  HLS_START_SEQUENCE_AS_FORMATTED_DATETIME = 2,  // YYYYMMDDhhmmss
} StartSequenceSourceType;

61 62 63 64 65
typedef enum {
    CODEC_ATTRIBUTE_WRITTEN = 0,
    CODEC_ATTRIBUTE_WILL_NOT_BE_WRITTEN,
} CodecAttributeStatus;

66 67
#define KEYSIZE 16
#define LINE_BUFFER_SIZE 1024
68
#define HLS_MICROSECOND_UNIT   1000000
69
#define POSTFIX_PATTERN "_%d"
70

71 72
typedef struct HLSSegment {
    char filename[1024];
73
    char sub_filename[1024];
74
    double duration; /* in seconds */
75
    int discont;
76 77
    int64_t pos;
    int64_t size;
78

79 80 81
    char key_uri[LINE_BUFFER_SIZE + 1];
    char iv_string[KEYSIZE*2 + 1];

82 83
    struct HLSSegment *next;
} HLSSegment;
84

85 86 87
typedef enum HLSFlags {
    // Generate a single media file and use byte ranges in the playlist.
    HLS_SINGLE_FILE = (1 << 0),
88
    HLS_DELETE_SEGMENTS = (1 << 1),
89
    HLS_ROUND_DURATIONS = (1 << 2),
90
    HLS_DISCONT_START = (1 << 3),
91
    HLS_OMIT_ENDLIST = (1 << 4),
92
    HLS_SPLIT_BY_TIME = (1 << 5),
93
    HLS_APPEND_LIST = (1 << 6),
94
    HLS_PROGRAM_DATE_TIME = (1 << 7),
95
    HLS_SECOND_LEVEL_SEGMENT_INDEX = (1 << 8), // include segment index in segment filenames when use_localtime  e.g.: %%03d
96 97
    HLS_SECOND_LEVEL_SEGMENT_DURATION = (1 << 9), // include segment duration (microsec) in segment filenames when use_localtime  e.g.: %%09t
    HLS_SECOND_LEVEL_SEGMENT_SIZE = (1 << 10), // include segment size (bytes) in segment filenames when use_localtime  e.g.: %%014s
98
    HLS_TEMP_FILE = (1 << 11),
99
    HLS_PERIODIC_REKEY = (1 << 12),
100
    HLS_INDEPENDENT_SEGMENTS = (1 << 13),
101 102
} HLSFlags;

103 104 105 106 107
typedef enum {
    SEGMENT_TYPE_MPEGTS,
    SEGMENT_TYPE_FMP4,
} SegmentType;

108
typedef struct VariantStream {
109
    unsigned number;
110
    int64_t sequence;
111
    AVOutputFormat *oformat;
112
    AVOutputFormat *vtt_oformat;
113 114 115
    AVIOContext *out;
    int packets_written;
    int init_range_length;
116

117
    AVFormatContext *avf;
118
    AVFormatContext *vtt_avf;
119

120
    int has_video;
121
    int has_subtitle;
122 123
    int new_start;
    double dpp;           // duration per packet
124 125
    int64_t start_pts;
    int64_t end_pts;
126
    double duration;      // last segment duration computed so far, in seconds
127 128
    int64_t start_pos;    // last segment starting position
    int64_t size;         // last segment size
129
    int nb_entries;
130
    int discontinuity_set;
131
    int discontinuity;
132
    int reference_stream_index;
133

134 135
    HLSSegment *segments;
    HLSSegment *last_segment;
136
    HLSSegment *old_segments;
137

138
    char *basename;
139 140
    char *vtt_basename;
    char *vtt_m3u8_name;
141 142 143 144 145 146 147 148 149 150
    char *m3u8_name;

    double initial_prog_date_time;
    char current_segment_final_filename_fmt[1024]; // when renaming segments

    char *fmp4_init_filename;
    char *base_output_dirname;
    int fmp4_init_mode;

    AVStream **streams;
151 152
    char codec_attr[128];
    CodecAttributeStatus attr_status;
153
    unsigned int nb_streams;
154
    int m3u8_created; /* status of media play-list creation */
155
    char *agroup; /* audio group name */
156
    char *ccgroup; /* closed caption group name */
157 158 159
    char *baseurl;
} VariantStream;

160 161 162 163 164 165
typedef struct ClosedCaptionsStream {
    char *ccgroup; /* closed caption group name */
    char *instreamid; /* closed captions INSTREAM-ID */
    char *language; /* closed captions langauge */
} ClosedCaptionsStream;

166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188
typedef struct HLSContext {
    const AVClass *class;  // Class for private options.
    int64_t start_sequence;
    uint32_t start_sequence_source_type;  // enum StartSequenceSourceType

    float time;            // Set by a private option.
    float init_time;       // Set by a private option.
    int max_nb_segments;   // Set by a private option.
#if FF_API_HLS_WRAP
    int  wrap;             // Set by a private option.
#endif
    uint32_t flags;        // enum HLSFlags
    uint32_t pl_type;      // enum PlaylistType
    char *segment_filename;
    char *fmp4_init_filename;
    int segment_type;

    int use_localtime;      ///< flag to expand filename with localtime
    int use_localtime_mkdir;///< flag to mkdir dirname in timebased filename
    int allowcache;
    int64_t recording_time;
    int64_t max_seg_size; // every segment file max size

189
    char *baseurl;
Steven Liu's avatar
Steven Liu committed
190
    char *format_options_str;
191 192
    char *vtt_format_options_str;
    char *subtitle_filename;
Steven Liu's avatar
Steven Liu committed
193
    AVDictionary *format_options;
194

195 196 197 198 199
    int encrypt;
    char *key;
    char *key_url;
    char *iv;
    char *key_basename;
200
    int encrypt_started;
201

202 203 204 205 206
    char *key_info_file;
    char key_file[LINE_BUFFER_SIZE + 1];
    char key_uri[LINE_BUFFER_SIZE + 1];
    char key_string[KEYSIZE*2 + 1];
    char iv_string[KEYSIZE*2 + 1];
207 208
    AVDictionary *vtt_format_options;

209
    char *method;
210
    char *user_agent;
211 212 213

    VariantStream *var_streams;
    unsigned int nb_varstreams;
214 215
    ClosedCaptionsStream *cc_streams;
    unsigned int nb_ccstreams;
216 217 218 219

    int master_m3u8_created; /* status of master play-list creation */
    char *master_m3u8_url; /* URL of the master m3u8 file */
    int version; /* HLS version */
220
    char *var_stream_map; /* user specified variant stream map string */
221
    char *cc_stream_map; /* user specified closed caption streams map string */
222 223
    char *master_pl_name;
    unsigned int master_publish_rate;
224
    int http_persistent;
225 226
    AVIOContext *m3u8_out;
    AVIOContext *sub_m3u8_out;
227 228
} HLSContext;

229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261
static int mkdir_p(const char *path) {
    int ret = 0;
    char *temp = av_strdup(path);
    char *pos = temp;
    char tmp_ch = '\0';

    if (!path || !temp) {
        return -1;
    }

    if (!strncmp(temp, "/", 1) || !strncmp(temp, "\\", 1)) {
        pos++;
    } else if (!strncmp(temp, "./", 2) || !strncmp(temp, ".\\", 2)) {
        pos += 2;
    }

    for ( ; *pos != '\0'; ++pos) {
        if (*pos == '/' || *pos == '\\') {
            tmp_ch = *pos;
            *pos = '\0';
            ret = mkdir(temp, 0755);
            *pos = tmp_ch;
        }
    }

    if ((*(pos - 1) != '/') || (*(pos - 1) != '\\')) {
        ret = mkdir(temp, 0755);
    }

    av_free(temp);
    return ret;
}

262 263 264
static int hlsenc_io_open(AVFormatContext *s, AVIOContext **pb, char *filename,
                          AVDictionary **options) {
    HLSContext *hls = s->priv_data;
265
    int http_base_proto = filename ? ff_is_http_proto(filename) : 0;
266
    int err = AVERROR_MUXER_NOT_FOUND;
267 268
    if (!*pb || !http_base_proto || !hls->http_persistent) {
        err = s->io_open(s, pb, filename, AVIO_FLAG_WRITE, options);
269
#if CONFIG_HTTP_PROTOCOL
270 271 272 273
    } else {
        URLContext *http_url_context = ffio_geturlcontext(*pb);
        av_assert0(http_url_context);
        err = ff_http_do_new_request(http_url_context, filename);
274
#endif
275 276 277 278 279 280
    }
    return err;
}

static void hlsenc_io_close(AVFormatContext *s, AVIOContext **pb, char *filename) {
    HLSContext *hls = s->priv_data;
281
    int http_base_proto = filename ? ff_is_http_proto(filename) : 0;
282 283
    if (!http_base_proto || !hls->http_persistent || hls->key_info_file || hls->encrypt) {
        ff_format_io_close(s, pb);
284
#if CONFIG_HTTP_PROTOCOL
285
    } else {
286 287
        URLContext *http_url_context = ffio_geturlcontext(*pb);
        av_assert0(http_url_context);
288
        avio_flush(*pb);
289 290
        ffurl_shutdown(http_url_context, AVIO_FLAG_WRITE);
#endif
291 292 293
    }
}

294 295
static void set_http_options(AVFormatContext *s, AVDictionary **options, HLSContext *c)
{
296
    int http_base_proto = ff_is_http_proto(s->url);
297 298 299 300 301 302 303 304 305

    if (c->method) {
        av_dict_set(options, "method", c->method, 0);
    } else if (http_base_proto) {
        av_log(c, AV_LOG_WARNING, "No HTTP method set, hls muxer defaulting to method PUT.\n");
        av_dict_set(options, "method", "PUT", 0);
    }
    if (c->user_agent)
        av_dict_set(options, "user_agent", c->user_agent, 0);
306 307
    if (c->http_persistent)
        av_dict_set_int(options, "multiple_requests", 1, 0);
308 309 310

}

311 312 313 314 315 316 317 318 319 320 321
static void write_codec_attr(AVStream *st, VariantStream *vs) {
    int codec_strlen = strlen(vs->codec_attr);
    char attr[32];

    if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
        return;
    if (vs->attr_status == CODEC_ATTRIBUTE_WILL_NOT_BE_WRITTEN)
        return;

    if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
        uint8_t *data = st->codecpar->extradata;
322
        if (data && (data[0] | data[1] | data[2]) == 0 && data[3] == 1 && (data[4] & 0x1F) == 7) {
323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355
            snprintf(attr, sizeof(attr),
                     "avc1.%02x%02x%02x", data[5], data[6], data[7]);
        } else {
            goto fail;
        }
    } else if (st->codecpar->codec_id == AV_CODEC_ID_MP2) {
        snprintf(attr, sizeof(attr), "mp4a.40.33");
    } else if (st->codecpar->codec_id == AV_CODEC_ID_MP3) {
        snprintf(attr, sizeof(attr), "mp4a.40.34");
    } else if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
        /* TODO : For HE-AAC, HE-AACv2, the last digit needs to be set to 5 and 29 respectively */
        snprintf(attr, sizeof(attr), "mp4a.40.2");
    } else if (st->codecpar->codec_id == AV_CODEC_ID_AC3) {
        snprintf(attr, sizeof(attr), "ac-3");
    } else if (st->codecpar->codec_id == AV_CODEC_ID_EAC3) {
        snprintf(attr, sizeof(attr), "ec-3");
    } else {
        goto fail;
    }
    // Don't write the same attribute multiple times
    if (!av_stristr(vs->codec_attr, attr)) {
        snprintf(vs->codec_attr + codec_strlen,
                 sizeof(vs->codec_attr) - codec_strlen,
                 "%s%s", codec_strlen ? "," : "", attr);
    }
    return;

fail:
    vs->codec_attr[0] = '\0';
    vs->attr_status = CODEC_ATTRIBUTE_WILL_NOT_BE_WRITTEN;
    return;
}

356
static int replace_int_data_in_filename(char **s, const char *filename, char placeholder, int64_t number)
357 358
{
    const char *p;
359 360 361
    char *new_filename;
    char c;
    int nd, addchar_count;
362
    int found_count = 0;
363 364 365
    AVBPrint buf;

    av_bprint_init(&buf, 0, AV_BPRINT_SIZE_UNLIMITED);
366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382

    p = filename;
    for (;;) {
        c = *p;
        if (c == '\0')
            break;
        if (c == '%' && *(p+1) == '%')  // %%
            addchar_count = 2;
        else if (c == '%' && (av_isdigit(*(p+1)) || *(p+1) == placeholder)) {
            nd = 0;
            addchar_count = 1;
            while (av_isdigit(*(p + addchar_count))) {
                nd = nd * 10 + *(p + addchar_count) - '0';
                addchar_count++;
            }

            if (*(p + addchar_count) == placeholder) {
383
                av_bprintf(&buf, "%0*"PRId64, (number < 0) ? nd : nd++, number);
384 385 386 387 388 389 390 391
                p += (addchar_count + 1);
                addchar_count = 0;
                found_count++;
            }

        } else
            addchar_count = 1;

392 393
        av_bprint_append_data(&buf, p, addchar_count);
        p += addchar_count;
394
    }
395 396 397 398 399 400 401
    if (!av_bprint_is_complete(&buf)) {
        av_bprint_finalize(&buf, NULL);
        return -1;
    }
    if (av_bprint_finalize(&buf, &new_filename) < 0 || !new_filename)
        return -1;
    *s = new_filename;
402 403 404
    return found_count;
}

405 406 407 408 409 410 411 412 413 414
static void write_styp(AVIOContext *pb)
{
    avio_wb32(pb, 24);
    ffio_wfourcc(pb, "styp");
    ffio_wfourcc(pb, "msdh");
    avio_wb32(pb, 0); /* minor */
    ffio_wfourcc(pb, "msdh");
    ffio_wfourcc(pb, "msix");
}

415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437
static int flush_dynbuf(VariantStream *vs, int *range_length)
{
    AVFormatContext *ctx = vs->avf;
    uint8_t *buffer;

    if (!ctx->pb) {
        return AVERROR(EINVAL);
    }

    // flush
    av_write_frame(ctx, NULL);
    avio_flush(ctx->pb);

    // write out to file
    *range_length = avio_close_dyn_buf(ctx->pb, &buffer);
    ctx->pb = NULL;
    avio_write(vs->out, buffer, *range_length);
    av_free(buffer);

    // re-open buffer
    return avio_open_dyn_buf(&ctx->pb);
}

438 439
static int hls_delete_old_segments(AVFormatContext *s, HLSContext *hls,
                                   VariantStream *vs) {
440 441 442

    HLSSegment *segment, *previous_segment = NULL;
    float playlist_duration = 0.0f;
443
    int ret = 0, path_size, sub_path_size;
444 445
    char *dirname = NULL, *p, *sub_path;
    char *path = NULL;
446 447
    AVDictionary *options = NULL;
    AVIOContext *out = NULL;
448
    const char *proto = NULL;
449

450
    segment = vs->segments;
451 452 453 454 455
    while (segment) {
        playlist_duration += segment->duration;
        segment = segment->next;
    }

456
    segment = vs->old_segments;
457 458 459 460 461 462 463 464 465 466
    while (segment) {
        playlist_duration -= segment->duration;
        previous_segment = segment;
        segment = previous_segment->next;
        if (playlist_duration <= -previous_segment->duration) {
            previous_segment->next = NULL;
            break;
        }
    }

467
    if (segment && !hls->use_localtime_mkdir) {
468 469 470
        if (hls->segment_filename) {
            dirname = av_strdup(hls->segment_filename);
        } else {
471
            dirname = av_strdup(vs->avf->url);
472 473 474 475 476 477 478 479 480 481 482 483
        }
        if (!dirname) {
            ret = AVERROR(ENOMEM);
            goto fail;
        }
        p = (char *)av_basename(dirname);
        *p = '\0';
    }

    while (segment) {
        av_log(hls, AV_LOG_DEBUG, "deleting old segment %s\n",
                                  segment->filename);
484
        path_size =  (hls->use_localtime_mkdir ? 0 : strlen(dirname)) + strlen(segment->filename) + 1;
485 486 487 488 489
        path = av_malloc(path_size);
        if (!path) {
            ret = AVERROR(ENOMEM);
            goto fail;
        }
490

491 492 493 494 495 496 497
        if (hls->use_localtime_mkdir)
            av_strlcpy(path, segment->filename, path_size);
        else { // segment->filename contains basename only
            av_strlcpy(path, dirname, path_size);
            av_strlcat(path, segment->filename, path_size);
        }

498
        proto = avio_find_protocol_name(s->url);
499
        if (hls->method || (proto && !av_strcasecmp(proto, "http"))) {
500
            av_dict_set(&options, "method", "DELETE", 0);
501
            if ((ret = vs->avf->io_open(vs->avf, &out, path, AVIO_FLAG_WRITE, &options)) < 0)
502
                goto fail;
503
            ff_format_io_close(vs->avf, &out);
504
        } else if (unlink(path) < 0) {
505 506 507
            av_log(hls, AV_LOG_ERROR, "failed to delete old segment %s: %s\n",
                                     path, strerror(errno));
        }
508

509 510
        if ((segment->sub_filename[0] != '\0')) {
            sub_path_size = strlen(segment->sub_filename) + 1 + (dirname ? strlen(dirname) : 0);
511 512 513 514 515 516 517 518
            sub_path = av_malloc(sub_path_size);
            if (!sub_path) {
                ret = AVERROR(ENOMEM);
                goto fail;
            }

            av_strlcpy(sub_path, dirname, sub_path_size);
            av_strlcat(sub_path, segment->sub_filename, sub_path_size);
519

520
            if (hls->method || (proto && !av_strcasecmp(proto, "http"))) {
521
                av_dict_set(&options, "method", "DELETE", 0);
522
                if ((ret = vs->avf->io_open(vs->avf, &out, sub_path, AVIO_FLAG_WRITE, &options)) < 0) {
523 524 525
                    av_free(sub_path);
                    goto fail;
                }
526
                ff_format_io_close(vs->avf, &out);
527
            } else if (unlink(sub_path) < 0) {
528 529 530 531
                av_log(hls, AV_LOG_ERROR, "failed to delete old segment %s: %s\n",
                                         sub_path, strerror(errno));
            }
            av_free(sub_path);
532
        }
533
        av_freep(&path);
534 535 536 537 538 539
        previous_segment = segment;
        segment = previous_segment->next;
        av_free(previous_segment);
    }

fail:
540
    av_free(path);
541 542 543 544 545
    av_free(dirname);

    return ret;
}

546 547 548 549 550 551 552 553 554 555 556 557 558 559
static int randomize(uint8_t *buf, int len)
{
#if CONFIG_GCRYPT
    gcry_randomize(buf, len, GCRY_VERY_STRONG_RANDOM);
    return 0;
#elif CONFIG_OPENSSL
    if (RAND_bytes(buf, len))
        return 0;
#else
    return AVERROR(ENOSYS);
#endif
    return AVERROR(EINVAL);
}

560
static int do_encrypt(AVFormatContext *s, VariantStream *vs)
561 562 563 564 565 566 567
{
    HLSContext *hls = s->priv_data;
    int ret;
    int len;
    AVIOContext *pb;
    uint8_t key[KEYSIZE];

568
    len = strlen(s->url) + 4 + 1;
569 570 571 572
    hls->key_basename = av_mallocz(len);
    if (!hls->key_basename)
        return AVERROR(ENOMEM);

573
    av_strlcpy(hls->key_basename, s->url, len);
574 575 576
    av_strlcat(hls->key_basename, ".key", len);

    if (hls->key_url) {
577 578
        av_strlcpy(hls->key_file, hls->key_url, sizeof(hls->key_file));
        av_strlcpy(hls->key_uri, hls->key_url, sizeof(hls->key_uri));
579
    } else {
580 581
        av_strlcpy(hls->key_file, hls->key_basename, sizeof(hls->key_file));
        av_strlcpy(hls->key_uri, hls->key_basename, sizeof(hls->key_uri));
582 583 584 585 586 587 588
    }

    if (!*hls->iv_string) {
        uint8_t iv[16] = { 0 };
        char buf[33];

        if (!hls->iv) {
589
            AV_WB64(iv + 8, vs->sequence);
590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628
        } else {
            memcpy(iv, hls->iv, sizeof(iv));
        }
        ff_data_to_hex(buf, iv, sizeof(iv), 0);
        buf[32] = '\0';
        memcpy(hls->iv_string, buf, sizeof(hls->iv_string));
    }

    if (!*hls->key_uri) {
        av_log(hls, AV_LOG_ERROR, "no key URI specified in key info file\n");
        return AVERROR(EINVAL);
    }

    if (!*hls->key_file) {
        av_log(hls, AV_LOG_ERROR, "no key file specified in key info file\n");
        return AVERROR(EINVAL);
    }

    if (!*hls->key_string) {
        if (!hls->key) {
            if ((ret = randomize(key, sizeof(key))) < 0) {
                av_log(s, AV_LOG_ERROR, "Cannot generate a strong random key\n");
                return ret;
            }
        } else {
            memcpy(key, hls->key, sizeof(key));
        }

        ff_data_to_hex(hls->key_string, key, sizeof(key), 0);
        if ((ret = s->io_open(s, &pb, hls->key_file, AVIO_FLAG_WRITE, NULL)) < 0)
            return ret;
        avio_seek(pb, 0, SEEK_CUR);
        avio_write(pb, key, KEYSIZE);
        avio_close(pb);
    }
    return 0;
}


629 630 631 632 633 634 635
static int hls_encryption_start(AVFormatContext *s)
{
    HLSContext *hls = s->priv_data;
    int ret;
    AVIOContext *pb;
    uint8_t key[KEYSIZE];

636
    if ((ret = s->io_open(s, &pb, hls->key_info_file, AVIO_FLAG_READ, NULL)) < 0) {
637 638 639 640 641 642 643 644 645 646 647 648 649 650
        av_log(hls, AV_LOG_ERROR,
                "error opening key info file %s\n", hls->key_info_file);
        return ret;
    }

    ff_get_line(pb, hls->key_uri, sizeof(hls->key_uri));
    hls->key_uri[strcspn(hls->key_uri, "\r\n")] = '\0';

    ff_get_line(pb, hls->key_file, sizeof(hls->key_file));
    hls->key_file[strcspn(hls->key_file, "\r\n")] = '\0';

    ff_get_line(pb, hls->iv_string, sizeof(hls->iv_string));
    hls->iv_string[strcspn(hls->iv_string, "\r\n")] = '\0';

651
    ff_format_io_close(s, &pb);
652 653 654 655 656 657 658 659 660 661 662

    if (!*hls->key_uri) {
        av_log(hls, AV_LOG_ERROR, "no key URI specified in key info file\n");
        return AVERROR(EINVAL);
    }

    if (!*hls->key_file) {
        av_log(hls, AV_LOG_ERROR, "no key file specified in key info file\n");
        return AVERROR(EINVAL);
    }

663
    if ((ret = s->io_open(s, &pb, hls->key_file, AVIO_FLAG_READ, NULL)) < 0) {
664 665 666 667 668
        av_log(hls, AV_LOG_ERROR, "error opening key file %s\n", hls->key_file);
        return ret;
    }

    ret = avio_read(pb, key, sizeof(key));
669
    ff_format_io_close(s, &pb);
670 671 672 673 674 675 676 677 678 679 680
    if (ret != sizeof(key)) {
        av_log(hls, AV_LOG_ERROR, "error reading key file %s\n", hls->key_file);
        if (ret >= 0 || ret == AVERROR_EOF)
            ret = AVERROR(EINVAL);
        return ret;
    }
    ff_data_to_hex(hls->key_string, key, sizeof(key), 0);

    return 0;
}

681 682 683 684 685 686 687 688
static int read_chomp_line(AVIOContext *s, char *buf, int maxlen)
{
    int len = ff_get_line(s, buf, maxlen);
    while (len > 0 && av_isspace(buf[len - 1]))
        buf[--len] = '\0';
    return len;
}

689
static int hls_mux_init(AVFormatContext *s, VariantStream *vs)
690
{
691
    AVDictionary *options = NULL;
692 693
    HLSContext *hls = s->priv_data;
    AVFormatContext *oc;
694
    AVFormatContext *vtt_oc = NULL;
695
    int byterange_mode = (hls->flags & HLS_SINGLE_FILE) || (hls->max_seg_size > 0);
696
    int i, ret;
697

698
    ret = avformat_alloc_output_context2(&vs->avf, vs->oformat, NULL, NULL);
699 700
    if (ret < 0)
        return ret;
701
    oc = vs->avf;
702

703 704 705 706
    oc->url                = av_strdup("");
    if (!oc->url)
        return AVERROR(ENOMEM);

707
    oc->oformat            = vs->oformat;
708
    oc->interrupt_callback = s->interrupt_callback;
709
    oc->max_delay          = s->max_delay;
710 711 712
    oc->opaque             = s->opaque;
    oc->io_open            = s->io_open;
    oc->io_close           = s->io_close;
713
    av_dict_copy(&oc->metadata, s->metadata, 0);
714

715 716
    if(vs->vtt_oformat) {
        ret = avformat_alloc_output_context2(&vs->vtt_avf, vs->vtt_oformat, NULL, NULL);
717 718
        if (ret < 0)
            return ret;
719 720
        vtt_oc          = vs->vtt_avf;
        vtt_oc->oformat = vs->vtt_oformat;
721 722 723
        av_dict_copy(&vtt_oc->metadata, s->metadata, 0);
    }

724
    for (i = 0; i < vs->nb_streams; i++) {
725
        AVStream *st;
726
        AVFormatContext *loc;
727
        if (vs->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
728 729 730 731 732
            loc = vtt_oc;
        else
            loc = oc;

        if (!(st = avformat_new_stream(loc, NULL)))
733
            return AVERROR(ENOMEM);
734
        avcodec_parameters_copy(st->codecpar, vs->streams[i]->codecpar);
735
        if (!oc->oformat->codec_tag ||
736 737 738
            av_codec_get_id (oc->oformat->codec_tag, vs->streams[i]->codecpar->codec_tag) == st->codecpar->codec_id ||
            av_codec_get_tag(oc->oformat->codec_tag, vs->streams[i]->codecpar->codec_id) <= 0) {
            st->codecpar->codec_tag = vs->streams[i]->codecpar->codec_tag;
739 740 741 742
        } else {
            st->codecpar->codec_tag = 0;
        }

743 744 745
        st->sample_aspect_ratio = vs->streams[i]->sample_aspect_ratio;
        st->time_base = vs->streams[i]->time_base;
        av_dict_copy(&st->metadata, vs->streams[i]->metadata, 0);
746
    }
747 748 749 750 751

    vs->packets_written = 1;
    vs->start_pos = 0;
    vs->new_start = 1;
    vs->fmp4_init_mode = 0;
752

753
    if (hls->segment_type == SEGMENT_TYPE_FMP4) {
754 755 756 757
        if (hls->max_seg_size > 0) {
            av_log(s, AV_LOG_WARNING, "Multi-file byterange mode is currently unsupported in the HLS muxer.\n");
            return AVERROR_PATCHWELCOME;
        }
758 759 760 761

        vs->packets_written = 0;
        vs->init_range_length = 0;
        vs->fmp4_init_mode = !byterange_mode;
762
        set_http_options(s, &options, hls);
763 764 765
        if ((ret = avio_open_dyn_buf(&oc->pb)) < 0)
            return ret;

766 767 768
        ret = hlsenc_io_open(s, &vs->out, vs->base_output_dirname, &options);
        av_dict_free(&options);
        if (ret < 0) {
769
            av_log(s, AV_LOG_ERROR, "Failed to open segment '%s'\n", vs->fmp4_init_filename);
770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785
            return ret;
        }

        if (hls->format_options_str) {
            ret = av_dict_parse_string(&hls->format_options, hls->format_options_str, "=", ":", 0);
            if (ret < 0) {
                av_log(s, AV_LOG_ERROR, "Could not parse format options list '%s'\n",
                       hls->format_options_str);
                return ret;
            }
        }

        av_dict_copy(&options, hls->format_options, 0);
        av_dict_set(&options, "fflags", "-autobsf", 0);
        av_dict_set(&options, "movflags", "frag_custom+dash+delay_moov", 0);
        ret = avformat_init_output(oc, &options);
786 787
        if (ret < 0)
            return ret;
788 789 790 791 792
        if (av_dict_count(options)) {
            av_log(s, AV_LOG_ERROR, "Some of the provided format options in '%s' are not recognized\n", hls->format_options_str);
            av_dict_free(&options);
            return AVERROR(EINVAL);
        }
793
        avio_flush(oc->pb);
794 795
        av_dict_free(&options);
    }
796 797 798
    return 0;
}

799 800 801 802 803 804 805 806 807 808
static HLSSegment *find_segment_by_filename(HLSSegment *segment, const char *filename)
{
    while (segment) {
        if (!av_strcasecmp(segment->filename,filename))
            return segment;
        segment = segment->next;
    }
    return (HLSSegment *) NULL;
}

809 810 811
static int sls_flags_filename_process(struct AVFormatContext *s, HLSContext *hls,
                                      VariantStream *vs, HLSSegment *en,
                                      double duration, int64_t pos, int64_t size)
812
{
813
    if ((hls->flags & (HLS_SECOND_LEVEL_SEGMENT_SIZE | HLS_SECOND_LEVEL_SEGMENT_DURATION)) &&
814
        strlen(vs->current_segment_final_filename_fmt)) {
815 816 817 818 819 820
        char * new_url = av_strdup(vs->current_segment_final_filename_fmt);
        if (!new_url) {
            av_free(en);
            return AVERROR(ENOMEM);
        }
        ff_format_set_url(vs->avf, new_url);
821
        if (hls->flags & HLS_SECOND_LEVEL_SEGMENT_SIZE) {
822
            char *filename = NULL;
823
            if (replace_int_data_in_filename(&filename, vs->avf->url, 's', pos + size) < 1) {
824 825 826
                av_log(hls, AV_LOG_ERROR,
                       "Invalid second level segment filename template '%s', "
                        "you can try to remove second_level_segment_size flag\n",
827
                       vs->avf->url);
828
                av_free(filename);
829
                av_free(en);
830 831
                return AVERROR(EINVAL);
            }
832
            ff_format_set_url(vs->avf, filename);
833 834
        }
        if (hls->flags & HLS_SECOND_LEVEL_SEGMENT_DURATION) {
835
            char *filename = NULL;
836
            if (replace_int_data_in_filename(&filename, vs->avf->url,
837
                't',  (int64_t)round(duration * HLS_MICROSECOND_UNIT)) < 1) {
838 839 840
                av_log(hls, AV_LOG_ERROR,
                       "Invalid second level segment filename template '%s', "
                        "you can try to remove second_level_segment_time flag\n",
841
                       vs->avf->url);
842
                av_free(filename);
843
                av_free(en);
844 845
                return AVERROR(EINVAL);
            }
846
            ff_format_set_url(vs->avf, filename);
847 848
        }
    }
849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874
    return 0;
}

static int sls_flag_check_duration_size_index(HLSContext *hls)
{
    int ret = 0;

    if (hls->flags & HLS_SECOND_LEVEL_SEGMENT_DURATION) {
         av_log(hls, AV_LOG_ERROR,
                "second_level_segment_duration hls_flag requires use_localtime to be true\n");
         ret = AVERROR(EINVAL);
    }
    if (hls->flags & HLS_SECOND_LEVEL_SEGMENT_SIZE) {
         av_log(hls, AV_LOG_ERROR,
                "second_level_segment_size hls_flag requires use_localtime to be true\n");
         ret = AVERROR(EINVAL);
    }
    if (hls->flags & HLS_SECOND_LEVEL_SEGMENT_INDEX) {
        av_log(hls, AV_LOG_ERROR,
               "second_level_segment_index hls_flag requires use_localtime to be true\n");
        ret = AVERROR(EINVAL);
    }

    return ret;
}

875
static int sls_flag_check_duration_size(HLSContext *hls, VariantStream *vs)
876
{
877
    const char *proto = avio_find_protocol_name(vs->basename);
878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894
    int segment_renaming_ok = proto && !strcmp(proto, "file");
    int ret = 0;

    if ((hls->flags & HLS_SECOND_LEVEL_SEGMENT_DURATION) && !segment_renaming_ok) {
         av_log(hls, AV_LOG_ERROR,
                "second_level_segment_duration hls_flag works only with file protocol segment names\n");
         ret = AVERROR(EINVAL);
    }
    if ((hls->flags & HLS_SECOND_LEVEL_SEGMENT_SIZE) && !segment_renaming_ok) {
         av_log(hls, AV_LOG_ERROR,
                "second_level_segment_size hls_flag works only with file protocol segment names\n");
         ret = AVERROR(EINVAL);
    }

    return ret;
}

895
static void sls_flag_file_rename(HLSContext *hls, VariantStream *vs, char *old_filename) {
896
    if ((hls->flags & (HLS_SECOND_LEVEL_SEGMENT_SIZE | HLS_SECOND_LEVEL_SEGMENT_DURATION)) &&
897
        strlen(vs->current_segment_final_filename_fmt)) {
898
        ff_rename(old_filename, vs->avf->url, hls);
899 900 901
    }
}

902
static int sls_flag_use_localtime_filename(AVFormatContext *oc, HLSContext *c, VariantStream *vs)
903 904
{
    if (c->flags & HLS_SECOND_LEVEL_SEGMENT_INDEX) {
905 906
        char *filename = NULL;
        if (replace_int_data_in_filename(&filename,
907
#if FF_API_HLS_WRAP
908
            oc->url, 'd', c->wrap ? vs->sequence % c->wrap : vs->sequence) < 1) {
909
#else
910
            oc->url, 'd', vs->sequence) < 1) {
911 912 913
#endif
            av_log(c, AV_LOG_ERROR, "Invalid second level segment filename template '%s', "
                    "you can try to remove second_level_segment_index flag\n",
914
                   oc->url);
915 916 917
            av_free(filename);
            return AVERROR(EINVAL);
        }
918
        ff_format_set_url(oc, filename);
919 920
    }
    if (c->flags & (HLS_SECOND_LEVEL_SEGMENT_SIZE | HLS_SECOND_LEVEL_SEGMENT_DURATION)) {
921
        av_strlcpy(vs->current_segment_final_filename_fmt, oc->url,
922
                   sizeof(vs->current_segment_final_filename_fmt));
923
        if (c->flags & HLS_SECOND_LEVEL_SEGMENT_SIZE) {
924
            char *filename = NULL;
925
            if (replace_int_data_in_filename(&filename, oc->url, 's', 0) < 1) {
926 927
                av_log(c, AV_LOG_ERROR, "Invalid second level segment filename template '%s', "
                        "you can try to remove second_level_segment_size flag\n",
928
                       oc->url);
929 930 931
                av_free(filename);
                return AVERROR(EINVAL);
            }
932
            ff_format_set_url(oc, filename);
933 934
        }
        if (c->flags & HLS_SECOND_LEVEL_SEGMENT_DURATION) {
935
            char *filename = NULL;
936
            if (replace_int_data_in_filename(&filename, oc->url, 't', 0) < 1) {
937 938
                av_log(c, AV_LOG_ERROR, "Invalid second level segment filename template '%s', "
                        "you can try to remove second_level_segment_time flag\n",
939
                       oc->url);
940 941 942
                av_free(filename);
                return AVERROR(EINVAL);
            }
943
            ff_format_set_url(oc, filename);
944 945 946 947 948 949
        }
    }
    return 0;
}

/* Create a new segment and append it to the segment list */
950 951 952
static int hls_append_segment(struct AVFormatContext *s, HLSContext *hls,
                              VariantStream *vs, double duration, int64_t pos,
                              int64_t size)
953 954 955
{
    HLSSegment *en = av_malloc(sizeof(*en));
    const char  *filename;
956
    int byterange_mode = (hls->flags & HLS_SINGLE_FILE) || (hls->max_seg_size > 0);
957
    int ret;
958

959 960 961
    if (!en)
        return AVERROR(ENOMEM);

962
    ret = sls_flags_filename_process(s, hls, vs, en, duration, pos, size);
963 964 965
    if (ret < 0) {
        return ret;
    }
966

967
    filename = av_basename(vs->avf->url);
968 969

    if (hls->use_localtime_mkdir) {
970
        filename = vs->avf->url;
971
    }
972
    if ((find_segment_by_filename(vs->segments, filename) || find_segment_by_filename(vs->old_segments, filename))
973
        && !byterange_mode) {
974 975
        av_log(hls, AV_LOG_WARNING, "Duplicated segment filename detected: %s\n", filename);
    }
976
    av_strlcpy(en->filename, filename, sizeof(en->filename));
977

978
    if(vs->has_subtitle)
979
        av_strlcpy(en->sub_filename, av_basename(vs->vtt_avf->url), sizeof(en->sub_filename));
980 981
    else
        en->sub_filename[0] = '\0';
982

983
    en->duration = duration;
984 985
    en->pos      = pos;
    en->size     = size;
986
    en->next     = NULL;
987 988
    en->discont  = 0;

989
    if (vs->discontinuity) {
990
        en->discont = 1;
991
        vs->discontinuity = 0;
992
    }
993

994
    if (hls->key_info_file || hls->encrypt) {
995 996 997 998
        av_strlcpy(en->key_uri, hls->key_uri, sizeof(en->key_uri));
        av_strlcpy(en->iv_string, hls->iv_string, sizeof(en->iv_string));
    }

999 1000
    if (!vs->segments)
        vs->segments = en;
1001
    else
1002
        vs->last_segment->next = en;
1003

1004
    vs->last_segment = en;
1005

1006 1007 1008 1009
    // EVENT or VOD playlists imply sliding window cannot be used
    if (hls->pl_type != PLAYLIST_TYPE_NONE)
        hls->max_nb_segments = 0;

1010 1011 1012 1013
    if (hls->max_nb_segments && vs->nb_entries >= hls->max_nb_segments) {
        en = vs->segments;
        vs->initial_prog_date_time += en->duration;
        vs->segments = en->next;
1014
        if (en && hls->flags & HLS_DELETE_SEGMENTS &&
1015
#if FF_API_HLS_WRAP
1016
                !(hls->flags & HLS_SINGLE_FILE || hls->wrap)) {
1017 1018 1019
#else
                !(hls->flags & HLS_SINGLE_FILE)) {
#endif
1020 1021 1022
            en->next = vs->old_segments;
            vs->old_segments = en;
            if ((ret = hls_delete_old_segments(s, hls, vs)) < 0)
1023 1024 1025
                return ret;
        } else
            av_free(en);
1026
    } else
1027
        vs->nb_entries++;
1028

1029 1030 1031
    if (hls->max_seg_size > 0) {
        return 0;
    }
1032
    vs->sequence++;
1033

1034 1035 1036
    return 0;
}

1037
static int parse_playlist(AVFormatContext *s, const char *url, VariantStream *vs)
1038 1039 1040 1041 1042 1043 1044
{
    HLSContext *hls = s->priv_data;
    AVIOContext *in;
    int ret = 0, is_segment = 0;
    int64_t new_start_pos;
    char line[1024];
    const char *ptr;
1045
    const char *end;
1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057

    if ((ret = ffio_open_whitelist(&in, url, AVIO_FLAG_READ,
                                   &s->interrupt_callback, NULL,
                                   s->protocol_whitelist, s->protocol_blacklist)) < 0)
        return ret;

    read_chomp_line(in, line, sizeof(line));
    if (strcmp(line, "#EXTM3U")) {
        ret = AVERROR_INVALIDDATA;
        goto fail;
    }

1058
    vs->discontinuity = 0;
1059 1060 1061
    while (!avio_feof(in)) {
        read_chomp_line(in, line, sizeof(line));
        if (av_strstart(line, "#EXT-X-MEDIA-SEQUENCE:", &ptr)) {
1062
            int64_t tmp_sequence = strtoll(ptr, NULL, 10);
1063
            if (tmp_sequence < vs->sequence)
1064 1065 1066 1067 1068 1069
              av_log(hls, AV_LOG_VERBOSE,
                     "Found playlist sequence number was smaller """
                     "than specified start sequence number: %"PRId64" < %"PRId64", "
                     "omitting\n", tmp_sequence, hls->start_sequence);
            else {
              av_log(hls, AV_LOG_DEBUG, "Found playlist sequence number: %"PRId64"\n", tmp_sequence);
1070
              vs->sequence = tmp_sequence;
1071
            }
1072 1073
        } else if (av_strstart(line, "#EXT-X-DISCONTINUITY", &ptr)) {
            is_segment = 1;
1074
            vs->discontinuity = 1;
1075 1076
        } else if (av_strstart(line, "#EXTINF:", &ptr)) {
            is_segment = 1;
1077
            vs->duration = atof(ptr);
1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100
        } else if (av_stristart(line, "#EXT-X-KEY:", &ptr)) {
            ptr = av_stristr(line, "URI=\"");
            if (ptr) {
                ptr += strlen("URI=\"");
                end = av_stristr(ptr, ",");
                if (end) {
                    av_strlcpy(hls->key_uri, ptr, end - ptr);
                } else {
                    av_strlcpy(hls->key_uri, ptr, sizeof(hls->key_uri));
                }
            }

            ptr = av_stristr(line, "IV=0x");
            if (ptr) {
                ptr += strlen("IV=0x");
                end = av_stristr(ptr, ",");
                if (end) {
                    av_strlcpy(hls->iv_string, ptr, end - ptr);
                } else {
                    av_strlcpy(hls->iv_string, ptr, sizeof(hls->iv_string));
                }
            }

1101 1102 1103 1104
        } else if (av_strstart(line, "#", NULL)) {
            continue;
        } else if (line[0]) {
            if (is_segment) {
1105 1106 1107 1108 1109 1110
                char *new_file = av_strdup(line);
                if (!new_file) {
                    ret = AVERROR(ENOMEM);
                    goto fail;
                }
                ff_format_set_url(vs->avf, new_file);
1111
                is_segment = 0;
1112 1113 1114
                new_start_pos = avio_tell(vs->avf->pb);
                vs->size = new_start_pos - vs->start_pos;
                ret = hls_append_segment(s, hls, vs, vs->duration, vs->start_pos, vs->size);
1115 1116
                if (ret < 0)
                    goto fail;
1117
                vs->start_pos = new_start_pos;
1118 1119 1120 1121 1122 1123 1124 1125 1126
            }
        }
    }

fail:
    avio_close(in);
    return ret;
}

1127
static void hls_free_segments(HLSSegment *p)
1128
{
1129
    HLSSegment *en;
1130 1131 1132 1133 1134 1135 1136 1137

    while(p) {
        en = p;
        p = p->next;
        av_free(en);
    }
}

1138
static int hls_rename_temp_file(AVFormatContext *s, AVFormatContext *oc)
1139
{
1140 1141 1142
    size_t len = strlen(oc->url);
    char *final_filename = av_strdup(oc->url);
    int ret;
1143

1144 1145
    if (!final_filename)
        return AVERROR(ENOMEM);
1146
    final_filename[len-4] = '\0';
1147 1148 1149 1150
    ret = ff_rename(oc->url, final_filename, s);
    oc->url[len-4] = '\0';
    av_freep(&final_filename);
    return ret;
1151 1152
}

1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174
static int get_relative_url(const char *master_url, const char *media_url,
                            char *rel_url, int rel_url_buf_size)
{
    char *p = NULL;
    int base_len = -1;
    p = strrchr(master_url, '/') ? strrchr(master_url, '/') :\
            strrchr(master_url, '\\');
    if (p) {
        base_len = FFABS(p - master_url);
        if (av_strncasecmp(master_url, media_url, base_len)) {
            av_log(NULL, AV_LOG_WARNING, "Unable to find relative url\n");
            return AVERROR(EINVAL);
        }
    }
    av_strlcpy(rel_url, &(media_url[base_len + 1]), rel_url_buf_size);
    return 0;
}

static int create_master_playlist(AVFormatContext *s,
                                  VariantStream * const input_vs)
{
    HLSContext *hls = s->priv_data;
1175
    VariantStream *vs, *temp_vs;
1176 1177 1178 1179
    AVStream *vid_st, *aud_st;
    AVDictionary *options = NULL;
    unsigned int i, j;
    int m3u8_name_size, ret, bandwidth;
1180 1181
    char *m3u8_rel_name, *ccgroup;
    ClosedCaptionsStream *ccs;
1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195

    input_vs->m3u8_created = 1;
    if (!hls->master_m3u8_created) {
        /* For the first time, wait until all the media playlists are created */
        for (i = 0; i < hls->nb_varstreams; i++)
            if (!hls->var_streams[i].m3u8_created)
                return 0;
    } else {
         /* Keep publishing the master playlist at the configured rate */
        if (&hls->var_streams[0] != input_vs || !hls->master_publish_rate ||
            input_vs->number % hls->master_publish_rate)
            return 0;
    }

1196
    set_http_options(s, &options, hls);
1197

1198
    ret = hlsenc_io_open(s, &hls->m3u8_out, hls->master_m3u8_url, &options);
1199 1200 1201 1202 1203 1204 1205
    av_dict_free(&options);
    if (ret < 0) {
        av_log(NULL, AV_LOG_ERROR, "Failed to open master play list file '%s'\n",
                hls->master_m3u8_url);
        goto fail;
    }

1206
    ff_hls_write_playlist_version(hls->m3u8_out, hls->version);
1207

1208 1209 1210 1211 1212 1213 1214 1215 1216 1217
    for (i = 0; i < hls->nb_ccstreams; i++) {
        ccs = &(hls->cc_streams[i]);
        avio_printf(hls->m3u8_out, "#EXT-X-MEDIA:TYPE=CLOSED-CAPTIONS");
        avio_printf(hls->m3u8_out, ",GROUP-ID=\"%s\"", ccs->ccgroup);
        avio_printf(hls->m3u8_out, ",NAME=\"%s\"", ccs->instreamid);
        if (ccs->language)
            avio_printf(hls->m3u8_out, ",LANGUAGE=\"%s\"", ccs->language);
        avio_printf(hls->m3u8_out, ",INSTREAM-ID=\"%s\"\n", ccs->instreamid);
    }

1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238
    /* For audio only variant streams add #EXT-X-MEDIA tag with attributes*/
    for (i = 0; i < hls->nb_varstreams; i++) {
        vs = &(hls->var_streams[i]);

        if (vs->has_video || vs->has_subtitle || !vs->agroup)
            continue;

        m3u8_name_size = strlen(vs->m3u8_name) + 1;
        m3u8_rel_name = av_malloc(m3u8_name_size);
        if (!m3u8_rel_name) {
            ret = AVERROR(ENOMEM);
            goto fail;
        }
        av_strlcpy(m3u8_rel_name, vs->m3u8_name, m3u8_name_size);
        ret = get_relative_url(hls->master_m3u8_url, vs->m3u8_name,
                               m3u8_rel_name, m3u8_name_size);
        if (ret < 0) {
            av_log(s, AV_LOG_ERROR, "Unable to find relative URL\n");
            goto fail;
        }

1239
        ff_hls_write_audio_rendition(hls->m3u8_out, vs->agroup, m3u8_rel_name, 0, 1);
1240

1241 1242 1243
        av_freep(&m3u8_rel_name);
    }

1244 1245 1246 1247 1248
    /* For variant streams with video add #EXT-X-STREAM-INF tag with attributes*/
    for (i = 0; i < hls->nb_varstreams; i++) {
        vs = &(hls->var_streams[i]);

        m3u8_name_size = strlen(vs->m3u8_name) + 1;
1249 1250
        m3u8_rel_name = av_malloc(m3u8_name_size);
        if (!m3u8_rel_name) {
1251 1252 1253
            ret = AVERROR(ENOMEM);
            goto fail;
        }
1254
        av_strlcpy(m3u8_rel_name, vs->m3u8_name, m3u8_name_size);
1255
        ret = get_relative_url(hls->master_m3u8_url, vs->m3u8_name,
1256
                               m3u8_rel_name, m3u8_name_size);
1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275
        if (ret < 0) {
            av_log(NULL, AV_LOG_ERROR, "Unable to find relative URL\n");
            goto fail;
        }

        vid_st = NULL;
        aud_st = NULL;
        for (j = 0; j < vs->nb_streams; j++) {
            if (vs->streams[j]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
                vid_st = vs->streams[j];
            else if (vs->streams[j]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
                aud_st = vs->streams[j];
        }

        if (!vid_st && !aud_st) {
            av_log(NULL, AV_LOG_WARNING, "Media stream not found\n");
            continue;
        }

1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294
        /**
         * Traverse through the list of audio only rendition streams and find
         * the rendition which has highest bitrate in the same audio group
         */
        if (vs->agroup) {
            for (j = 0; j < hls->nb_varstreams; j++) {
                temp_vs = &(hls->var_streams[j]);
                if (!temp_vs->has_video && !temp_vs->has_subtitle &&
                    temp_vs->agroup &&
                    !av_strcasecmp(temp_vs->agroup, vs->agroup)) {
                    if (!aud_st)
                        aud_st = temp_vs->streams[0];
                    if (temp_vs->streams[0]->codecpar->bit_rate >
                            aud_st->codecpar->bit_rate)
                        aud_st = temp_vs->streams[0];
                }
            }
        }

1295 1296 1297 1298 1299 1300 1301
        bandwidth = 0;
        if (vid_st)
            bandwidth += vid_st->codecpar->bit_rate;
        if (aud_st)
            bandwidth += aud_st->codecpar->bit_rate;
        bandwidth += bandwidth / 10;

1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316
        ccgroup = NULL;
        if (vid_st && vs->ccgroup) {
            /* check if this group name is available in the cc map string */
            for (j = 0; j < hls->nb_ccstreams; j++) {
                ccs = &(hls->cc_streams[j]);
                if (!av_strcasecmp(ccs->ccgroup, vs->ccgroup)) {
                    ccgroup = vs->ccgroup;
                    break;
                }
            }
            if (j == hls->nb_ccstreams)
                av_log(NULL, AV_LOG_WARNING, "mapping ccgroup %s not found\n",
                        vs->ccgroup);
        }

1317
        ff_hls_write_stream_info(vid_st, hls->m3u8_out, bandwidth, m3u8_rel_name,
1318
                aud_st ? vs->agroup : NULL, vs->codec_attr, ccgroup);
1319

1320
        av_freep(&m3u8_rel_name);
1321 1322 1323 1324
    }
fail:
    if(ret >=0)
        hls->master_m3u8_created = 1;
1325
    av_freep(&m3u8_rel_name);
1326
    hlsenc_io_close(s, &hls->m3u8_out, hls->master_m3u8_url);
1327 1328 1329
    return ret;
}

1330
static int hls_window(AVFormatContext *s, int last, VariantStream *vs)
1331 1332
{
    HLSContext *hls = s->priv_data;
1333
    HLSSegment *en;
1334
    int target_duration = 0;
1335
    int ret = 0;
1336
    char temp_filename[1024];
1337
    int64_t sequence = FFMAX(hls->start_sequence, vs->sequence - vs->nb_entries);
1338
    const char *proto = avio_find_protocol_name(s->url);
1339
    int use_rename = proto && !strcmp(proto, "file");
1340
    static unsigned warned_non_file;
1341 1342
    char *key_uri = NULL;
    char *iv_string = NULL;
1343
    AVDictionary *options = NULL;
1344
    double prog_date_time = vs->initial_prog_date_time;
1345
    double *prog_date_time_p = (hls->flags & HLS_PROGRAM_DATE_TIME) ? &prog_date_time : NULL;
1346 1347
    int byterange_mode = (hls->flags & HLS_SINGLE_FILE) || (hls->max_seg_size > 0);

1348
    hls->version = 3;
1349
    if (byterange_mode) {
1350
        hls->version = 4;
1351 1352
        sequence = 0;
    }
1353

1354 1355 1356 1357
    if (hls->flags & HLS_INDEPENDENT_SEGMENTS) {
        hls->version = 6;
    }

1358
    if (hls->segment_type == SEGMENT_TYPE_FMP4) {
1359
        hls->version = 7;
1360 1361
    }

1362
    if (!use_rename && !warned_non_file++)
Moritz Barsnick's avatar
Moritz Barsnick committed
1363
        av_log(s, AV_LOG_ERROR, "Cannot use rename on non file protocol, this may lead to races and temporary partial files\n");
1364

1365
    set_http_options(s, &options, hls);
1366
    snprintf(temp_filename, sizeof(temp_filename), use_rename ? "%s.tmp" : "%s", vs->m3u8_name);
1367
    if ((ret = hlsenc_io_open(s, &hls->m3u8_out, temp_filename, &options)) < 0)
1368 1369
        goto fail;

1370
    for (en = vs->segments; en; en = en->next) {
1371
        if (target_duration <= en->duration)
1372
            target_duration = lrint(en->duration);
1373 1374
    }

1375
    vs->discontinuity_set = 0;
1376
    ff_hls_write_playlist_header(hls->m3u8_out, hls->version, hls->allowcache,
1377
                                 target_duration, sequence, hls->pl_type);
1378

1379
    if((hls->flags & HLS_DISCONT_START) && sequence==hls->start_sequence && vs->discontinuity_set==0 ){
1380
        avio_printf(hls->m3u8_out, "#EXT-X-DISCONTINUITY\n");
1381
        vs->discontinuity_set = 1;
1382
    }
1383
    if (vs->has_video && (hls->flags & HLS_INDEPENDENT_SEGMENTS)) {
1384
        avio_printf(hls->m3u8_out, "#EXT-X-INDEPENDENT-SEGMENTS\n");
1385
    }
1386
    for (en = vs->segments; en; en = en->next) {
1387
        if ((hls->encrypt || hls->key_info_file) && (!key_uri || strcmp(en->key_uri, key_uri) ||
1388
                                    av_strcasecmp(en->iv_string, iv_string))) {
1389
            avio_printf(hls->m3u8_out, "#EXT-X-KEY:METHOD=AES-128,URI=\"%s\"", en->key_uri);
1390
            if (*en->iv_string)
1391 1392
                avio_printf(hls->m3u8_out, ",IV=0x%s", en->iv_string);
            avio_printf(hls->m3u8_out, "\n");
1393 1394 1395 1396
            key_uri = en->key_uri;
            iv_string = en->iv_string;
        }

1397
        if ((hls->segment_type == SEGMENT_TYPE_FMP4) && (en == vs->segments)) {
1398
            ff_hls_write_init_file(hls->m3u8_out, vs->fmp4_init_filename,
1399
                                   hls->flags & HLS_SINGLE_FILE, en->size, en->pos);
1400
        }
1401

1402 1403 1404 1405
        ret = ff_hls_write_file_entry(hls->m3u8_out, en->discont, byterange_mode,
                                      en->duration, hls->flags & HLS_ROUND_DURATIONS,
                                      en->size, en->pos, vs->baseurl,
                                      en->filename, prog_date_time_p);
1406 1407 1408
        if (ret < 0) {
            av_log(s, AV_LOG_WARNING, "ff_hls_write_file_entry get error\n");
        }
1409 1410
    }

1411
    if (last && (hls->flags & HLS_OMIT_ENDLIST)==0)
1412
        ff_hls_write_end_list(hls->m3u8_out);
1413

1414
    if( vs->vtt_m3u8_name ) {
1415
        if ((ret = hlsenc_io_open(s, &hls->sub_m3u8_out, vs->vtt_m3u8_name, &options)) < 0)
1416
            goto fail;
1417
        ff_hls_write_playlist_header(hls->sub_m3u8_out, hls->version, hls->allowcache,
1418
                                     target_duration, sequence, PLAYLIST_TYPE_NONE);
1419
        for (en = vs->segments; en; en = en->next) {
1420 1421 1422
            ret = ff_hls_write_file_entry(hls->sub_m3u8_out, 0, byterange_mode,
                                          en->duration, 0, en->size, en->pos,
                                          vs->baseurl, en->sub_filename, NULL);
1423 1424 1425
            if (ret < 0) {
                av_log(s, AV_LOG_WARNING, "ff_hls_write_file_entry get error\n");
            }
1426 1427 1428
        }

        if (last)
1429
            ff_hls_write_end_list(hls->sub_m3u8_out);
1430 1431 1432

    }

1433
fail:
1434
    av_dict_free(&options);
1435 1436
    hlsenc_io_close(s, &hls->m3u8_out, temp_filename);
    hlsenc_io_close(s, &hls->sub_m3u8_out, vs->vtt_m3u8_name);
1437
    if (ret >= 0 && use_rename)
1438
        ff_rename(temp_filename, vs->m3u8_name, s);
1439 1440 1441 1442 1443

    if (ret >= 0 && hls->master_pl_name)
        if (create_master_playlist(s, vs) < 0)
            av_log(s, AV_LOG_WARNING, "Master playlist creation failed\n");

1444 1445 1446
    return ret;
}

1447
static int hls_start(AVFormatContext *s, VariantStream *vs)
1448 1449
{
    HLSContext *c = s->priv_data;
1450 1451
    AVFormatContext *oc = vs->avf;
    AVFormatContext *vtt_oc = vs->vtt_avf;
1452 1453
    AVDictionary *options = NULL;
    char *filename, iv_string[KEYSIZE*2 + 1];
1454 1455
    int err = 0;

1456
    if (c->flags & HLS_SINGLE_FILE) {
1457 1458 1459 1460 1461 1462 1463 1464 1465 1466
        char *new_name = av_strdup(vs->basename);
        if (!new_name)
            return AVERROR(ENOMEM);
        ff_format_set_url(oc, new_name);
        if (vs->vtt_basename) {
            new_name = av_strdup(vs->vtt_basename);
            if (!new_name)
                return AVERROR(ENOMEM);
            ff_format_set_url(vtt_oc, new_name);
        }
1467
    } else if (c->max_seg_size > 0) {
1468 1469
        char *filename = NULL;
        if (replace_int_data_in_filename(&filename,
1470
#if FF_API_HLS_WRAP
1471
            vs->basename, 'd', c->wrap ? vs->sequence % c->wrap : vs->sequence) < 1) {
1472
#else
1473
            vs->basename, 'd', vs->sequence) < 1) {
1474
#endif
1475
                av_free(filename);
1476
                av_log(oc, AV_LOG_ERROR, "Invalid segment filename template '%s', you can try to use -use_localtime 1 with it\n", vs->basename);
1477 1478
                return AVERROR(EINVAL);
        }
1479
        ff_format_set_url(oc, filename);
1480
    } else {
1481 1482 1483
        if (c->use_localtime) {
            time_t now0;
            struct tm *tm, tmpbuf;
1484 1485 1486 1487
            int bufsize = strlen(vs->basename) + 1024;
            char *buf = av_mallocz(bufsize);
            if (!buf)
                return AVERROR(ENOMEM);
1488 1489
            time(&now0);
            tm = localtime_r(&now0, &tmpbuf);
1490 1491
            ff_format_set_url(oc, buf);
            if (!strftime(oc->url, bufsize, vs->basename, tm)) {
1492 1493 1494
                av_log(oc, AV_LOG_ERROR, "Could not get segment filename with use_localtime\n");
                return AVERROR(EINVAL);
            }
1495

1496
            err = sls_flag_use_localtime_filename(oc, c, vs);
1497 1498
            if (err < 0) {
                return AVERROR(ENOMEM);
1499
            }
1500

1501 1502
            if (c->use_localtime_mkdir) {
                const char *dir;
1503
                char *fn_copy = av_strdup(oc->url);
1504 1505 1506 1507
                if (!fn_copy) {
                    return AVERROR(ENOMEM);
                }
                dir = av_dirname(fn_copy);
1508
                if (mkdir_p(dir) == -1 && errno != EEXIST) {
1509 1510 1511 1512 1513 1514
                    av_log(oc, AV_LOG_ERROR, "Could not create directory %s with use_localtime_mkdir\n", dir);
                    av_free(fn_copy);
                    return AVERROR(errno);
                }
                av_free(fn_copy);
            }
1515 1516 1517
        } else {
            char *filename = NULL;
            if (replace_int_data_in_filename(&filename,
1518
#if FF_API_HLS_WRAP
1519
                   vs->basename, 'd', c->wrap ? vs->sequence % c->wrap : vs->sequence) < 1) {
1520
#else
1521
                   vs->basename, 'd', vs->sequence) < 1) {
1522
#endif
1523 1524 1525 1526
                av_free(filename);
                av_log(oc, AV_LOG_ERROR, "Invalid segment filename template '%s' you can try to use -use_localtime 1 with it\n", vs->basename);
                return AVERROR(EINVAL);
            }
1527
            ff_format_set_url(oc, filename);
1528
        }
1529
        if( vs->vtt_basename) {
1530 1531
            char *filename = NULL;
            if (replace_int_data_in_filename(&filename,
1532
#if FF_API_HLS_WRAP
1533
                vs->vtt_basename, 'd', c->wrap ? vs->sequence % c->wrap : vs->sequence) < 1) {
1534
#else
1535
                vs->vtt_basename, 'd', vs->sequence) < 1) {
1536
#endif
1537
                av_free(filename);
1538
                av_log(vtt_oc, AV_LOG_ERROR, "Invalid segment filename template '%s'\n", vs->vtt_basename);
1539 1540
                return AVERROR(EINVAL);
            }
1541
            ff_format_set_url(vtt_oc, filename);
1542 1543
       }
    }
1544
    vs->number++;
1545

1546
    set_http_options(s, &options, c);
1547

1548
    if (c->flags & HLS_TEMP_FILE) {
1549 1550 1551 1552
        char *new_name = av_asprintf("%s.tmp", oc->url);
        if (!new_name)
            return AVERROR(ENOMEM);
        ff_format_set_url(oc, new_name);
1553 1554
    }

1555 1556 1557 1558 1559
    if (c->key_info_file || c->encrypt) {
        if (c->key_info_file && c->encrypt) {
            av_log(s, AV_LOG_WARNING, "Cannot use both -hls_key_info_file and -hls_enc,"
                  " will use -hls_key_info_file priority\n");
        }
1560

1561
        if (!c->encrypt_started || (c->flags & HLS_PERIODIC_REKEY)) {
1562 1563 1564 1565
            if (c->key_info_file) {
                if ((err = hls_encryption_start(s)) < 0)
                    goto fail;
            } else {
1566
                if ((err = do_encrypt(s, vs)) < 0)
1567 1568
                    goto fail;
            }
1569
            c->encrypt_started = 1;
1570
        }
1571 1572
        if ((err = av_dict_set(&options, "encryption_key", c->key_string, 0))
                < 0)
1573
            goto fail;
1574 1575
        err = av_strlcpy(iv_string, c->iv_string, sizeof(iv_string));
        if (!err)
1576
            snprintf(iv_string, sizeof(iv_string), "%032"PRIx64, vs->sequence);
1577
        if ((err = av_dict_set(&options, "encryption_iv", iv_string, 0)) < 0)
1578
           goto fail;
1579

1580
        filename = av_asprintf("crypto:%s", oc->url);
1581
        if (!filename) {
1582 1583
            err = AVERROR(ENOMEM);
            goto fail;
1584
        }
1585
        err = hlsenc_io_open(s, &oc->pb, filename, &options);
1586 1587 1588 1589
        av_free(filename);
        av_dict_free(&options);
        if (err < 0)
            return err;
1590
    } else if (c->segment_type != SEGMENT_TYPE_FMP4) {
1591
        if ((err = hlsenc_io_open(s, &oc->pb, oc->url, &options)) < 0)
1592
            goto fail;
1593
    }
1594
    if (vs->vtt_basename) {
1595
        set_http_options(s, &options, c);
1596
        if ((err = hlsenc_io_open(s, &vtt_oc->pb, vtt_oc->url, &options)) < 0)
1597
            goto fail;
1598
    }
1599
    av_dict_free(&options);
1600

1601
    if (c->segment_type != SEGMENT_TYPE_FMP4) {
1602 1603 1604
        /* We only require one PAT/PMT per segment. */
        if (oc->oformat->priv_class && oc->priv_data) {
            char period[21];
1605

1606
            snprintf(period, sizeof(period), "%d", (INT_MAX / 2) - 1);
1607

1608 1609 1610 1611
            av_opt_set(oc->priv_data, "mpegts_flags", "resend_headers", 0);
            av_opt_set(oc->priv_data, "sdt_period", period, 0);
            av_opt_set(oc->priv_data, "pat_period", period, 0);
        }
1612
    }
1613

1614
    if (vs->vtt_basename) {
1615 1616 1617 1618
        err = avformat_write_header(vtt_oc,NULL);
        if (err < 0)
            return err;
    }
1619

1620
    return 0;
1621 1622 1623 1624
fail:
    av_dict_free(&options);

    return err;
1625 1626
}

1627
static const char * get_default_pattern_localtime_fmt(AVFormatContext *s)
1628 1629 1630 1631
{
    char b[21];
    time_t t = time(NULL);
    struct tm *p, tmbuf;
1632 1633
    HLSContext *hls = s->priv_data;

1634 1635
    p = localtime_r(&t, &tmbuf);
    // no %s support when strftime returned error or left format string unchanged
1636
    // also no %s support on MSVC, which invokes the invalid parameter handler on unsupported format strings, instead of returning an error
1637 1638 1639
    if (hls->segment_type == SEGMENT_TYPE_FMP4) {
        return (HAVE_LIBC_MSVCRT || !strftime(b, sizeof(b), "%s", p) || !strcmp(b, "%s")) ? "-%Y%m%d%H%M%S.m4s" : "-%s.m4s";
    }
1640
    return (HAVE_LIBC_MSVCRT || !strftime(b, sizeof(b), "%s", p) || !strcmp(b, "%s")) ? "-%Y%m%d%H%M%S.ts" : "-%s.ts";
1641 1642
}

1643
static int append_postfix(char *name, int name_buf_len, int i)
1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661
{
    char *p;
    char extension[10] = {'\0'};

    p = strrchr(name, '.');
    if (p) {
        av_strlcpy(extension, p, sizeof(extension));
        *p = '\0';
    }

    snprintf(name + strlen(name), name_buf_len - strlen(name), POSTFIX_PATTERN, i);

    if (strlen(extension))
        av_strlcat(name, extension, name_buf_len);

    return 0;
}

1662 1663
static int validate_name(int nb_vs, const char *fn)
{
1664 1665
    const char *filename, *subdir_name;
    char *fn_dup = NULL;
1666 1667 1668 1669 1670 1671 1672
    int ret = 0;

    if (!fn) {
        ret = AVERROR(EINVAL);
        goto fail;
    }

1673 1674 1675 1676 1677 1678
    fn_dup = av_strdup(fn);
    if (!fn_dup) {
        ret = AVERROR(ENOMEM);
        goto fail;
    }

1679
    filename = av_basename(fn);
1680
    subdir_name = av_dirname(fn_dup);
1681

1682
    if (nb_vs > 1 && !av_stristr(filename, "%v") && !av_stristr(subdir_name, "%v")) {
1683 1684 1685 1686 1687 1688
        av_log(NULL, AV_LOG_ERROR, "More than 1 variant streams are present, %%v is expected in the filename %s\n",
                fn);
        ret = AVERROR(EINVAL);
        goto fail;
    }

1689 1690 1691 1692 1693 1694 1695
    if (av_stristr(filename, "%v") && av_stristr(subdir_name, "%v")) {
        av_log(NULL, AV_LOG_ERROR, "%%v is expected either in filename or in the sub-directory name of file %s\n",
                fn);
        ret = AVERROR(EINVAL);
        goto fail;
    }

1696
fail:
1697
    av_freep(&fn_dup);
1698 1699 1700 1701 1702
    return ret;
}

static int format_name(char *buf, int buf_len, int index)
{
1703
    const char *proto, *dir;
1704
    char *orig_buf_dup = NULL, *mod_buf = NULL, *mod_buf_dup = NULL;
1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715
    int ret = 0;

    if (!av_stristr(buf, "%v"))
        return ret;

    orig_buf_dup = av_strdup(buf);
    if (!orig_buf_dup) {
        ret = AVERROR(ENOMEM);
        goto fail;
    }

1716
    if (replace_int_data_in_filename(&mod_buf, orig_buf_dup, 'v', index) < 1) {
1717 1718 1719
        ret = AVERROR(EINVAL);
        goto fail;
    }
1720
    av_strlcpy(buf, mod_buf, buf_len);
1721

1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739
    proto = avio_find_protocol_name(orig_buf_dup);
    dir = av_dirname(orig_buf_dup);

    /* if %v is present in the file's directory, create sub-directory */
    if (av_stristr(dir, "%v") && proto && !strcmp(proto, "file")) {
        mod_buf_dup = av_strdup(buf);
        if (!mod_buf_dup) {
            ret = AVERROR(ENOMEM);
            goto fail;
        }

        dir = av_dirname(mod_buf_dup);
        if (mkdir_p(dir) == -1 && errno != EEXIST) {
            ret = AVERROR(errno);
            goto fail;
        }
    }

1740 1741
fail:
    av_freep(&orig_buf_dup);
1742
    av_freep(&mod_buf_dup);
1743
    av_freep(&mod_buf);
1744 1745 1746
    return ret;
}

1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777
static int get_nth_codec_stream_index(AVFormatContext *s,
                                      enum AVMediaType codec_type,
                                      int stream_id)
{
    unsigned int stream_index, cnt;
    if (stream_id < 0 || stream_id > s->nb_streams - 1)
        return -1;
    cnt = 0;
    for (stream_index = 0; stream_index < s->nb_streams; stream_index++) {
        if (s->streams[stream_index]->codecpar->codec_type != codec_type)
            continue;
        if (cnt == stream_id)
            return stream_index;
        cnt++;
    }
    return -1;
}

static int parse_variant_stream_mapstring(AVFormatContext *s)
{
    HLSContext *hls = s->priv_data;
    VariantStream *vs;
    int stream_index;
    enum AVMediaType codec_type;
    int nb_varstreams, nb_streams;
    char *p, *q, *saveptr1, *saveptr2, *varstr, *keyval;
    const char *val;

    /**
     * Expected format for var_stream_map string is as below:
     * "a:0,v:0 a:1,v:1"
1778
     * "a:0,agroup:a0 a:1,agroup:a1 v:0,agroup:a0  v:1,agroup:a1"
1779 1780 1781 1782 1783 1784 1785 1786
     * This string specifies how to group the audio, video and subtitle streams
     * into different variant streams. The variant stream groups are separated
     * by space.
     *
     * a:, v:, s: are keys to specify audio, video and subtitle streams
     * respectively. Allowed values are 0 to 9 digits (limited just based on
     * practical usage)
     *
1787
     * agroup: is key to specify audio group. A string can be given as value.
1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825
     */
    p = av_strdup(hls->var_stream_map);
    q = p;
    while(av_strtok(q, " \t", &saveptr1)) {
        q = NULL;
        hls->nb_varstreams++;
    }
    av_freep(&p);

    hls->var_streams = av_mallocz(sizeof(*hls->var_streams) * hls->nb_varstreams);
    if (!hls->var_streams)
        return AVERROR(ENOMEM);

    p = hls->var_stream_map;
    nb_varstreams = 0;
    while (varstr = av_strtok(p, " \t", &saveptr1)) {
        p = NULL;

        if (nb_varstreams < hls->nb_varstreams)
            vs = &(hls->var_streams[nb_varstreams++]);
        else
            return AVERROR(EINVAL);

        q = varstr;
        while (q < varstr + strlen(varstr)) {
            if (!av_strncasecmp(q, "a:", 2) || !av_strncasecmp(q, "v:", 2) ||
                !av_strncasecmp(q, "s:", 2))
                vs->nb_streams++;
            q++;
        }
        vs->streams = av_mallocz(sizeof(AVStream *) * vs->nb_streams);
        if (!vs->streams)
            return AVERROR(ENOMEM);

        nb_streams = 0;
        while (keyval = av_strtok(varstr, ",", &saveptr2)) {
            varstr = NULL;

1826 1827 1828 1829 1830
            if (av_strstart(keyval, "agroup:", &val)) {
                vs->agroup = av_strdup(val);
                if (!vs->agroup)
                    return AVERROR(ENOMEM);
                continue;
1831 1832 1833 1834 1835
            } else if (av_strstart(keyval, "ccgroup:", &val)) {
                vs->ccgroup = av_strdup(val);
                if (!vs->ccgroup)
                    return AVERROR(ENOMEM);
                continue;
1836
            } else if (av_strstart(keyval, "v:", &val)) {
1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865
                codec_type = AVMEDIA_TYPE_VIDEO;
            } else if (av_strstart(keyval, "a:", &val)) {
                codec_type = AVMEDIA_TYPE_AUDIO;
            } else if (av_strstart(keyval, "s:", &val)) {
                codec_type = AVMEDIA_TYPE_SUBTITLE;
            } else {
                av_log(s, AV_LOG_ERROR, "Invalid keyval %s\n", keyval);
                return AVERROR(EINVAL);
            }

            stream_index = -1;
            if (av_isdigit(*val))
                stream_index = get_nth_codec_stream_index (s, codec_type,
                                                           atoi(val));

            if (stream_index >= 0 && nb_streams < vs->nb_streams) {
                vs->streams[nb_streams++] = s->streams[stream_index];
            } else {
                av_log(s, AV_LOG_ERROR, "Unable to map stream at %s\n", keyval);
                return AVERROR(EINVAL);
            }
        }
    }
    av_log(s, AV_LOG_DEBUG, "Number of variant streams %d\n",
            hls->nb_varstreams);

    return 0;
}

1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943
static int parse_cc_stream_mapstring(AVFormatContext *s)
{
    HLSContext *hls = s->priv_data;
    int nb_ccstreams;
    char *p, *q, *saveptr1, *saveptr2, *ccstr, *keyval;
    const char *val;
    ClosedCaptionsStream *ccs;

    p = av_strdup(hls->cc_stream_map);
    q = p;
    while(av_strtok(q, " \t", &saveptr1)) {
        q = NULL;
        hls->nb_ccstreams++;
    }
    av_freep(&p);

    hls->cc_streams = av_mallocz(sizeof(*hls->cc_streams) * hls->nb_ccstreams);
    if (!hls->cc_streams)
        return AVERROR(ENOMEM);

    p = hls->cc_stream_map;
    nb_ccstreams = 0;
    while (ccstr = av_strtok(p, " \t", &saveptr1)) {
        p = NULL;

        if (nb_ccstreams < hls->nb_ccstreams)
            ccs = &(hls->cc_streams[nb_ccstreams++]);
        else
            return AVERROR(EINVAL);

        while (keyval = av_strtok(ccstr, ",", &saveptr2)) {
            ccstr = NULL;

            if (av_strstart(keyval, "ccgroup:", &val)) {
                ccs->ccgroup = av_strdup(val);
                if (!ccs->ccgroup)
                    return AVERROR(ENOMEM);
            } else if (av_strstart(keyval, "instreamid:", &val)) {
                ccs->instreamid = av_strdup(val);
                if (!ccs->instreamid)
                    return AVERROR(ENOMEM);
            } else if (av_strstart(keyval, "language:", &val)) {
                ccs->language = av_strdup(val);
                if (!ccs->language)
                    return AVERROR(ENOMEM);
            } else {
                av_log(s, AV_LOG_ERROR, "Invalid keyval %s\n", keyval);
                return AVERROR(EINVAL);
            }
        }

        if (!ccs->ccgroup || !ccs->instreamid) {
            av_log(s, AV_LOG_ERROR, "Insufficient parameters in cc stream map string\n");
            return AVERROR(EINVAL);
        }

        if (av_strstart(ccs->instreamid, "CC", &val)) {
            if(atoi(val) < 1 || atoi(val) > 4) {
                av_log(s, AV_LOG_ERROR, "Invalid instream ID CC index %d in %s, range 1-4\n",
                       atoi(val), ccs->instreamid);
                return AVERROR(EINVAL);
            }
        } else if (av_strstart(ccs->instreamid, "SERVICE", &val)) {
            if(atoi(val) < 1 || atoi(val) > 63) {
                av_log(s, AV_LOG_ERROR, "Invalid instream ID SERVICE index %d in %s, range 1-63 \n",
                       atoi(val), ccs->instreamid);
                return AVERROR(EINVAL);
            }
        } else {
            av_log(s, AV_LOG_ERROR, "Invalid instream ID %s, supported are CCn or SERIVICEn\n",
                   ccs->instreamid);
            return AVERROR(EINVAL);
        }
    }

    return 0;
}

1944 1945 1946
static int update_variant_stream_info(AVFormatContext *s) {
    HLSContext *hls = s->priv_data;
    unsigned int i;
1947 1948 1949 1950 1951 1952 1953
    int ret = 0;

    if (hls->cc_stream_map) {
        ret = parse_cc_stream_mapstring(s);
        if (ret < 0)
            return ret;
    }
1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970

    if (hls->var_stream_map) {
        return parse_variant_stream_mapstring(s);
    } else {
        //By default, a single variant stream with all the codec streams is created
        hls->nb_varstreams = 1;
        hls->var_streams = av_mallocz(sizeof(*hls->var_streams) *
                                             hls->nb_varstreams);
        if (!hls->var_streams)
            return AVERROR(ENOMEM);

        hls->var_streams[0].nb_streams = s->nb_streams;
        hls->var_streams[0].streams = av_mallocz(sizeof(AVStream *) *
                                            hls->var_streams[0].nb_streams);
        if (!hls->var_streams[0].streams)
            return AVERROR(ENOMEM);

1971 1972 1973 1974 1975 1976 1977
        //by default, the first available ccgroup is mapped to the variant stream
        if (hls->nb_ccstreams) {
            hls->var_streams[0].ccgroup = av_strdup(hls->cc_streams[0].ccgroup);
            if (!hls->var_streams[0].ccgroup)
                return AVERROR(ENOMEM);
        }

1978 1979 1980 1981 1982 1983
        for (i = 0; i < s->nb_streams; i++)
            hls->var_streams[0].streams[i] = s->streams[i];
    }
    return 0;
}

1984 1985
static int update_master_pl_info(AVFormatContext *s) {
    HLSContext *hls = s->priv_data;
1986
    const char *dir;
1987
    char *fn1= NULL, *fn2 = NULL;
1988
    int ret = 0;
1989

1990
    fn1 = av_strdup(s->url);
1991
    if (!fn1) {
1992
        ret = AVERROR(ENOMEM);
1993
        goto fail;
1994 1995
    }

1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010
    dir = av_dirname(fn1);

    /**
     * if output file's directory has %v, variants are created in sub-directories
     * then master is created at the sub-directories level
     */
    if (dir && av_stristr(av_basename(dir), "%v")) {
        fn2 = av_strdup(dir);
        if (!fn2) {
            ret = AVERROR(ENOMEM);
            goto fail;
        }
        dir = av_dirname(fn2);
    }

2011 2012 2013 2014 2015 2016 2017 2018
    if (dir && strcmp(dir, "."))
        hls->master_m3u8_url = av_append_path_component(dir, hls->master_pl_name);
    else
        hls->master_m3u8_url = av_strdup(hls->master_pl_name);

    if (!hls->master_m3u8_url) {
        ret = AVERROR(ENOMEM);
        goto fail;
2019 2020
    }

2021
fail:
2022 2023 2024
    av_freep(&fn1);
    av_freep(&fn2);

2025
    return ret;
2026 2027
}

2028 2029 2030
static int hls_write_header(AVFormatContext *s)
{
    HLSContext *hls = s->priv_data;
2031
    int ret, i, j;
Steven Liu's avatar
Steven Liu committed
2032
    AVDictionary *options = NULL;
2033
    VariantStream *vs = NULL;
2034

2035 2036 2037
    for (i = 0; i < hls->nb_varstreams; i++) {
        vs = &hls->var_streams[i];

2038 2039 2040 2041 2042 2043 2044 2045
        av_dict_copy(&options, hls->format_options, 0);
        ret = avformat_write_header(vs->avf, &options);
        if (av_dict_count(options)) {
            av_log(s, AV_LOG_ERROR, "Some of provided format options in '%s' are not recognized\n", hls->format_options_str);
            ret = AVERROR(EINVAL);
            av_dict_free(&options);
            goto fail;
        }
2046
        av_dict_free(&options);
2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058
        //av_assert0(s->nb_streams == hls->avf->nb_streams);
        for (j = 0; j < vs->nb_streams; j++) {
            AVStream *inner_st;
            AVStream *outer_st = vs->streams[j];

            if (hls->max_seg_size > 0) {
                if ((outer_st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) &&
                    (outer_st->codecpar->bit_rate > hls->max_seg_size)) {
                    av_log(s, AV_LOG_WARNING, "Your video bitrate is bigger than hls_segment_size, "
                           "(%"PRId64 " > %"PRId64 "), the result maybe not be what you want.",
                           outer_st->codecpar->bit_rate, hls->max_seg_size);
                }
2059 2060
            }

2061 2062 2063 2064 2065 2066 2067 2068 2069 2070
            if (outer_st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE)
                inner_st = vs->avf->streams[j];
            else if (vs->vtt_avf)
                inner_st = vs->vtt_avf->streams[0];
            else {
                /* We have a subtitle stream, when the user does not want one */
                inner_st = NULL;
                continue;
            }
            avpriv_set_pts_info(outer_st, inner_st->pts_wrap_bits, inner_st->time_base.num, inner_st->time_base.den);
2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083
            write_codec_attr(outer_st, vs);

        }
        /* Update the Codec Attr string for the mapped audio groups */
        if (vs->has_video && vs->agroup) {
            for (j = 0; j < hls->nb_varstreams; j++) {
                VariantStream *vs_agroup = &(hls->var_streams[j]);
                if (!vs_agroup->has_video && !vs_agroup->has_subtitle &&
                    vs_agroup->agroup &&
                    !av_strcasecmp(vs_agroup->agroup, vs->agroup)) {
                    write_codec_attr(vs_agroup->streams[0], vs);
                }
            }
2084
        }
2085
    }
2086
fail:
Steven Liu's avatar
Steven Liu committed
2087

2088 2089 2090 2091 2092 2093
    return ret;
}

static int hls_write_packet(AVFormatContext *s, AVPacket *pkt)
{
    HLSContext *hls = s->priv_data;
2094
    AVFormatContext *oc = NULL;
2095
    AVStream *st = s->streams[pkt->stream_index];
2096
    int64_t end_pts = 0;
2097
    int is_ref_pkt = 1;
2098
    int ret = 0, can_split = 1, i, j;
2099
    int stream_index = 0;
2100 2101
    int range_length = 0;
    uint8_t *buffer = NULL;
2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128
    VariantStream *vs = NULL;

    for (i = 0; i < hls->nb_varstreams; i++) {
        vs = &hls->var_streams[i];
        for (j = 0; j < vs->nb_streams; j++) {
            if (vs->streams[j] == st) {
                if( st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE ) {
                    oc = vs->vtt_avf;
                    stream_index = 0;
                } else {
                    oc = vs->avf;
                    stream_index = j;
                }
                break;
            }
        }

        if (oc)
            break;
    }

    if (!oc) {
        av_log(s, AV_LOG_ERROR, "Unable to find mapping variant stream\n");
        return AVERROR(ENOMEM);
    }

    end_pts = hls->recording_time * vs->number;
2129

2130
    if (vs->sequence - vs->nb_entries > hls->start_sequence && hls->init_time > 0) {
2131
        /* reset end_pts, hls->recording_time at end of the init hls list */
2132 2133
        int init_list_dur = hls->init_time * vs->nb_entries * AV_TIME_BASE;
        int after_init_list_dur = (vs->sequence - vs->nb_entries ) * hls->time * AV_TIME_BASE;
2134 2135 2136 2137
        hls->recording_time = hls->time * AV_TIME_BASE;
        end_pts = init_list_dur + after_init_list_dur ;
    }

2138 2139
    if (vs->start_pts == AV_NOPTS_VALUE) {
        vs->start_pts = pkt->pts;
2140 2141
    }

2142
    if (vs->has_video) {
2143
        can_split = st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2144
                    ((pkt->flags & AV_PKT_FLAG_KEY) || (hls->flags & HLS_SPLIT_BY_TIME));
2145
        is_ref_pkt = (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) && (pkt->stream_index == vs->reference_stream_index);
2146
    }
2147 2148
    if (pkt->pts == AV_NOPTS_VALUE)
        is_ref_pkt = can_split = 0;
2149

2150
    if (is_ref_pkt) {
2151 2152
        if (vs->end_pts == AV_NOPTS_VALUE)
            vs->end_pts = pkt->pts;
2153 2154 2155
        if (vs->new_start) {
            vs->new_start = 0;
            vs->duration = (double)(pkt->pts - vs->end_pts)
2156
                                       * st->time_base.num / st->time_base.den;
2157
            vs->dpp = (double)(pkt->duration) * st->time_base.num / st->time_base.den;
2158
        } else {
2159
            if (pkt->duration) {
2160
                vs->duration += (double)(pkt->duration) * st->time_base.num / st->time_base.den;
2161 2162
            } else {
                av_log(s, AV_LOG_WARNING, "pkt->duration = 0, maybe the hls segment duration will not precise\n");
2163
                vs->duration = (double)(pkt->pts - vs->end_pts) * st->time_base.num / st->time_base.den;
2164
            }
2165
        }
2166

2167
    }
2168 2169

    if (vs->packets_written && can_split && av_compare_ts(pkt->pts - vs->start_pts, st->time_base,
2170
                                   end_pts, AV_TIME_BASE_Q) >= 0) {
2171
        int64_t new_start_pos;
2172
        char *old_filename = NULL;
2173
        int byterange_mode = (hls->flags & HLS_SINGLE_FILE) || (hls->max_seg_size > 0);
2174

2175
        av_write_frame(vs->avf, NULL); /* Flush any buffered data */
2176

2177 2178
        new_start_pos = avio_tell(vs->avf->pb);
        vs->size = new_start_pos - vs->start_pos;
2179

2180
        if (!byterange_mode) {
2181 2182
            if (hls->segment_type == SEGMENT_TYPE_FMP4) {
                if (!vs->init_range_length) {
2183 2184 2185 2186 2187 2188 2189 2190
                    avio_flush(oc->pb);
                    range_length = avio_close_dyn_buf(oc->pb, &buffer);
                    avio_write(vs->out, buffer, range_length);
                    vs->init_range_length = range_length;
                    avio_open_dyn_buf(&oc->pb);
                    vs->packets_written = 0;
                    ff_format_io_close(s, &vs->out);
                    hlsenc_io_close(s, &vs->out, vs->base_output_dirname);
2191
                }
2192
            } else {
2193
                hlsenc_io_close(s, &oc->pb, oc->url);
2194
            }
2195
            if (vs->vtt_avf) {
2196
                hlsenc_io_close(s, &vs->vtt_avf->pb, vs->vtt_avf->url);
2197
            }
2198
        }
2199
        if ((hls->flags & HLS_TEMP_FILE) && oc->url[0]) {
2200
            if (!(hls->flags & HLS_SINGLE_FILE) || (hls->max_seg_size <= 0))
2201 2202
                if ((vs->avf->oformat->priv_class && vs->avf->priv_data) && hls->segment_type != SEGMENT_TYPE_FMP4)
                    av_opt_set(vs->avf->priv_data, "mpegts_flags", "resend_headers", 0);
2203 2204 2205
            hls_rename_temp_file(s, oc);
        }

2206 2207
        if (vs->fmp4_init_mode) {
            vs->number--;
2208 2209
        }

2210
        if (hls->segment_type == SEGMENT_TYPE_FMP4) {
2211
            ret = hlsenc_io_open(s, &vs->out, vs->avf->url, NULL);
2212 2213
            if (ret < 0) {
                av_log(NULL, AV_LOG_ERROR, "Failed to open file '%s'\n",
2214
                    vs->avf->url);
2215 2216 2217 2218 2219 2220 2221 2222 2223
                return ret;
            }
            write_styp(vs->out);
            ret = flush_dynbuf(vs, &range_length);
            if (ret < 0) {
                return ret;
            }
            ff_format_io_close(s, &vs->out);
        }
2224 2225 2226 2227 2228 2229

        old_filename = av_strdup(vs->avf->url);
        if (!old_filename) {
            return AVERROR(ENOMEM);
        }

2230
        ret = hls_append_segment(s, hls, vs, vs->duration, vs->start_pos, vs->size);
2231
        vs->start_pos = new_start_pos;
2232 2233
        if (ret < 0) {
            av_free(old_filename);
2234
            return ret;
2235
        }
2236

2237 2238
        vs->end_pts = pkt->pts;
        vs->duration = 0;
2239

2240
        vs->fmp4_init_mode = 0;
2241
        if (hls->flags & HLS_SINGLE_FILE) {
2242
            vs->number++;
2243
        } else if (hls->max_seg_size > 0) {
2244 2245 2246 2247 2248
            if (vs->start_pos >= hls->max_seg_size) {
                vs->sequence++;
                sls_flag_file_rename(hls, vs, old_filename);
                ret = hls_start(s, vs);
                vs->start_pos = 0;
2249 2250
                /* When split segment by byte, the duration is short than hls_time,
                 * so it is not enough one segment duration as hls_time, */
2251
                vs->number--;
2252
            }
2253
            vs->number++;
2254
        } else {
2255 2256
            sls_flag_file_rename(hls, vs, old_filename);
            ret = hls_start(s, vs);
2257
        }
2258
        av_free(old_filename);
2259

2260
        if (ret < 0) {
2261
            return ret;
2262
        }
2263

2264 2265
        if (!vs->fmp4_init_mode || byterange_mode)
            if ((ret = hls_window(s, 0, vs)) < 0) {
2266 2267
                return ret;
            }
2268 2269
    }

2270
    vs->packets_written++;
2271
    ret = ff_write_chained(oc, stream_index, pkt, s, 0);
2272 2273 2274 2275 2276 2277 2278

    return ret;
}

static int hls_write_trailer(struct AVFormatContext *s)
{
    HLSContext *hls = s->priv_data;
2279 2280 2281 2282
    AVFormatContext *oc = NULL;
    AVFormatContext *vtt_oc = NULL;
    char *old_filename = NULL;
    int i;
2283
    int ret = 0;
2284 2285 2286 2287 2288 2289 2290
    VariantStream *vs = NULL;

    for (i = 0; i < hls->nb_varstreams; i++) {
        vs = &hls->var_streams[i];

    oc = vs->avf;
    vtt_oc = vs->vtt_avf;
2291
    old_filename = av_strdup(vs->avf->url);
2292 2293 2294 2295

    if (!old_filename) {
        return AVERROR(ENOMEM);
    }
2296 2297
    if ( hls->segment_type == SEGMENT_TYPE_FMP4) {
        int range_length = 0;
2298
        ret = hlsenc_io_open(s, &vs->out, vs->avf->url, NULL);
2299
        if (ret < 0) {
2300
            av_log(NULL, AV_LOG_ERROR, "Failed to open file '%s'\n", vs->avf->url);
2301
            goto failed;
2302 2303 2304 2305
        }
        write_styp(vs->out);
        ret = flush_dynbuf(vs, &range_length);
        if (ret < 0) {
2306
            goto failed;
2307 2308 2309
        }
        ff_format_io_close(s, &vs->out);
    }
2310

2311
failed:
2312
    av_write_trailer(oc);
2313
    if (oc->pb) {
2314
        vs->size = avio_tell(vs->avf->pb) - vs->start_pos;
2315
        if (hls->segment_type != SEGMENT_TYPE_FMP4)
2316
            ff_format_io_close(s, &oc->pb);
2317

2318
        if ((hls->flags & HLS_TEMP_FILE) && oc->url[0]) {
2319
            hls_rename_temp_file(s, oc);
2320 2321 2322 2323 2324 2325
            av_free(old_filename);
            old_filename = av_strdup(vs->avf->url);

            if (!old_filename) {
                return AVERROR(ENOMEM);
            }
2326 2327
        }

2328
        /* after av_write_trailer, then duration + 1 duration per packet */
2329
        hls_append_segment(s, hls, vs, vs->duration + vs->dpp, vs->start_pos, vs->size);
2330
    }
2331

2332
    sls_flag_file_rename(hls, vs, old_filename);
2333

2334 2335 2336
    if (vtt_oc) {
        if (vtt_oc->pb)
            av_write_trailer(vtt_oc);
2337
        vs->size = avio_tell(vs->vtt_avf->pb) - vs->start_pos;
2338
        ff_format_io_close(s, &vtt_oc->pb);
2339
    }
2340 2341
    av_freep(&vs->basename);
    av_freep(&vs->base_output_dirname);
2342
    avformat_free_context(oc);
2343

2344 2345
    vs->avf = NULL;
    hls_window(s, 1, vs);
2346

2347
    av_freep(&vs->fmp4_init_filename);
2348
    if (vtt_oc) {
2349 2350
        av_freep(&vs->vtt_basename);
        av_freep(&vs->vtt_m3u8_name);
2351 2352 2353
        avformat_free_context(vtt_oc);
    }

2354 2355
    hls_free_segments(vs->segments);
    hls_free_segments(vs->old_segments);
2356
    av_free(old_filename);
2357 2358
    av_freep(&vs->m3u8_name);
    av_freep(&vs->streams);
2359
    av_freep(&vs->agroup);
2360
    av_freep(&vs->ccgroup);
2361 2362 2363
    av_freep(&vs->baseurl);
    }

2364 2365 2366 2367 2368 2369 2370
    for (i = 0; i < hls->nb_ccstreams; i++) {
        ClosedCaptionsStream *ccs = &hls->cc_streams[i];
        av_freep(&ccs->ccgroup);
        av_freep(&ccs->instreamid);
        av_freep(&ccs->language);
    }

2371 2372
    ff_format_io_close(s, &hls->m3u8_out);
    ff_format_io_close(s, &hls->sub_m3u8_out);
2373 2374
    av_freep(&hls->key_basename);
    av_freep(&hls->var_streams);
2375
    av_freep(&hls->cc_streams);
2376
    av_freep(&hls->master_m3u8_url);
2377 2378 2379
    return 0;
}

2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392

static int hls_init(AVFormatContext *s)
{
    int ret = 0;
    int i = 0;
    int j = 0;
    HLSContext *hls = s->priv_data;
    const char *pattern = "%d.ts";
    VariantStream *vs = NULL;
    int basename_size = 0;
    const char *pattern_localtime_fmt = get_default_pattern_localtime_fmt(s);
    const char *vtt_pattern = "%d.vtt";
    char *p = NULL;
2393
    int vtt_basename_size = 0;
2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408
    int fmp4_init_filename_len = strlen(hls->fmp4_init_filename) + 1;

    ret = update_variant_stream_info(s);
    if (ret < 0) {
        av_log(s, AV_LOG_ERROR, "Variant stream info update failed with status %x\n",
                ret);
        goto fail;
    }
    //TODO: Updates needed to encryption functionality with periodic re-key when more than one variant streams are present
    if (hls->nb_varstreams > 1 && hls->flags & HLS_PERIODIC_REKEY) {
        ret = AVERROR(EINVAL);
        av_log(s, AV_LOG_ERROR, "Periodic re-key not supported when more than one variant streams are present\n");
        goto fail;
    }

2409
    ret = validate_name(hls->nb_varstreams, s->url);
2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430
    if (ret < 0)
        goto fail;

    if (hls->segment_filename) {
        ret = validate_name(hls->nb_varstreams, hls->segment_filename);
        if (ret < 0)
            goto fail;
    }

    if (av_strcasecmp(hls->fmp4_init_filename, "init.mp4")) {
        ret = validate_name(hls->nb_varstreams, hls->fmp4_init_filename);
        if (ret < 0)
            goto fail;
    }

    if (hls->subtitle_filename) {
        ret = validate_name(hls->nb_varstreams, hls->subtitle_filename);
        if (ret < 0)
            goto fail;
    }

2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462
    if (hls->master_pl_name) {
        ret = update_master_pl_info(s);
        if (ret < 0) {
            av_log(s, AV_LOG_ERROR, "Master stream info update failed with status %x\n",
                    ret);
            goto fail;
        }
    }

    if (hls->segment_type == SEGMENT_TYPE_FMP4) {
        pattern = "%d.m4s";
    }
    if ((hls->start_sequence_source_type == HLS_START_SEQUENCE_AS_SECONDS_SINCE_EPOCH) ||
        (hls->start_sequence_source_type == HLS_START_SEQUENCE_AS_FORMATTED_DATETIME)) {
        time_t t = time(NULL); // we will need it in either case
        if (hls->start_sequence_source_type == HLS_START_SEQUENCE_AS_SECONDS_SINCE_EPOCH) {
            hls->start_sequence = (int64_t)t;
        } else if (hls->start_sequence_source_type == HLS_START_SEQUENCE_AS_FORMATTED_DATETIME) {
            char b[15];
            struct tm *p, tmbuf;
            if (!(p = localtime_r(&t, &tmbuf)))
                return AVERROR(ENOMEM);
            if (!strftime(b, sizeof(b), "%Y%m%d%H%M%S", p))
                return AVERROR(ENOMEM);
            hls->start_sequence = strtoll(b, NULL, 10);
        }
        av_log(hls, AV_LOG_DEBUG, "start_number evaluated to %"PRId64"\n", hls->start_sequence);
    }

    hls->recording_time = (hls->init_time ? hls->init_time : hls->time) * AV_TIME_BASE;
    for (i = 0; i < hls->nb_varstreams; i++) {
        vs = &hls->var_streams[i];
2463

2464
        vs->m3u8_name = av_strdup(s->url);
2465 2466 2467 2468
        if (!vs->m3u8_name ) {
            ret = AVERROR(ENOMEM);
            goto fail;
        }
2469
        ret = format_name(vs->m3u8_name, strlen(s->url) + 1, i);
2470 2471 2472
        if (ret < 0)
            goto fail;

2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500
        vs->sequence       = hls->start_sequence;
        vs->start_pts      = AV_NOPTS_VALUE;
        vs->end_pts      = AV_NOPTS_VALUE;
        vs->current_segment_final_filename_fmt[0] = '\0';

        if (hls->flags & HLS_SPLIT_BY_TIME && hls->flags & HLS_INDEPENDENT_SEGMENTS) {
            // Independent segments cannot be guaranteed when splitting by time
            hls->flags &= ~HLS_INDEPENDENT_SEGMENTS;
            av_log(s, AV_LOG_WARNING,
                   "'split_by_time' and 'independent_segments' cannot be enabled together. "
                   "Disabling 'independent_segments' flag\n");
        }

        if (hls->flags & HLS_PROGRAM_DATE_TIME) {
            time_t now0;
            time(&now0);
            vs->initial_prog_date_time = now0;
        }
        if (hls->format_options_str) {
            ret = av_dict_parse_string(&hls->format_options, hls->format_options_str, "=", ":", 0);
            if (ret < 0) {
                av_log(s, AV_LOG_ERROR, "Could not parse format options list '%s'\n", hls->format_options_str);
                goto fail;
            }
        }

        for (j = 0; j < vs->nb_streams; j++) {
            vs->has_video += vs->streams[j]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO;
2501 2502 2503 2504 2505
            /* Get one video stream to reference for split segments
             * so use the first video stream index. */
            if ((vs->has_video == 1) && (vs->streams[j]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)) {
                vs->reference_stream_index = j;
            }
2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537
            vs->has_subtitle += vs->streams[j]->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE;
        }

        if (vs->has_video > 1)
            av_log(s, AV_LOG_WARNING, "More than a single video stream present, expect issues decoding it.\n");
        if (hls->segment_type == SEGMENT_TYPE_FMP4) {
            vs->oformat = av_guess_format("mp4", NULL, NULL);
        } else {
            vs->oformat = av_guess_format("mpegts", NULL, NULL);
        }

        if (!vs->oformat) {
            ret = AVERROR_MUXER_NOT_FOUND;
            goto fail;
        }

        if (vs->has_subtitle) {
            vs->vtt_oformat = av_guess_format("webvtt", NULL, NULL);
            if (!vs->oformat) {
                ret = AVERROR_MUXER_NOT_FOUND;
                goto fail;
            }
        }
        if (hls->segment_filename) {
            basename_size = strlen(hls->segment_filename) + 1;
            vs->basename = av_malloc(basename_size);
            if (!vs->basename) {
                ret = AVERROR(ENOMEM);
                goto fail;
            }

            av_strlcpy(vs->basename, hls->segment_filename, basename_size);
2538 2539 2540
            ret = format_name(vs->basename, basename_size, i);
            if (ret < 0)
                goto fail;
2541 2542 2543 2544 2545 2546 2547 2548 2549 2550
        } else {
            if (hls->flags & HLS_SINGLE_FILE) {
                if (hls->segment_type == SEGMENT_TYPE_FMP4) {
                    pattern = ".m4s";
                } else {
                    pattern = ".ts";
                }
            }

            if (hls->use_localtime) {
2551
                basename_size = strlen(vs->m3u8_name) + strlen(pattern_localtime_fmt) + 1;
2552
            } else {
2553
                basename_size = strlen(vs->m3u8_name) + strlen(pattern) + 1;
2554 2555 2556 2557 2558 2559 2560 2561
            }

            vs->basename = av_malloc(basename_size);
            if (!vs->basename) {
                ret = AVERROR(ENOMEM);
                goto fail;
            }

2562
            av_strlcpy(vs->basename, vs->m3u8_name, basename_size);
2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583

            p = strrchr(vs->basename, '.');
            if (p)
                *p = '\0';
            if (hls->use_localtime) {
                av_strlcat(vs->basename, pattern_localtime_fmt, basename_size);
            } else {
                av_strlcat(vs->basename, pattern, basename_size);
            }
        }

        if (hls->segment_type == SEGMENT_TYPE_FMP4) {
            if (hls->nb_varstreams > 1)
                fmp4_init_filename_len += strlen(POSTFIX_PATTERN);
            vs->fmp4_init_filename = av_malloc(fmp4_init_filename_len);
            if (!vs->fmp4_init_filename ) {
                ret = AVERROR(ENOMEM);
                goto fail;
            }
            av_strlcpy(vs->fmp4_init_filename, hls->fmp4_init_filename,
                       fmp4_init_filename_len);
2584 2585

            if (av_strcasecmp(hls->fmp4_init_filename, "init.mp4")) {
2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598
                ret = format_name(vs->fmp4_init_filename, fmp4_init_filename_len, i);
                if (ret < 0)
                    goto fail;

                fmp4_init_filename_len = strlen(vs->fmp4_init_filename) + 1;
                vs->base_output_dirname = av_malloc(fmp4_init_filename_len);
                if (!vs->base_output_dirname) {
                    ret = AVERROR(ENOMEM);
                    goto fail;
                }
                av_strlcpy(vs->base_output_dirname, vs->fmp4_init_filename,
                           fmp4_init_filename_len);
            } else {
2599 2600 2601 2602 2603 2604
                if (hls->nb_varstreams > 1) {
                    ret = append_postfix(vs->fmp4_init_filename, fmp4_init_filename_len, i);
                    if (ret < 0)
                         goto fail;
                }

2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642
                fmp4_init_filename_len = strlen(vs->m3u8_name) +
                    strlen(vs->fmp4_init_filename) + 1;

                vs->base_output_dirname = av_malloc(fmp4_init_filename_len);
                if (!vs->base_output_dirname) {
                    ret = AVERROR(ENOMEM);
                    goto fail;
                }

                av_strlcpy(vs->base_output_dirname, vs->m3u8_name,
                           fmp4_init_filename_len);
                p = strrchr(vs->base_output_dirname, '/');
                if (p) {
                    *(p + 1) = '\0';
                    av_strlcat(vs->base_output_dirname, vs->fmp4_init_filename,
                               fmp4_init_filename_len);
                } else {
                    av_strlcpy(vs->base_output_dirname, vs->fmp4_init_filename,
                               fmp4_init_filename_len);
                }
            }
        }

        if (!hls->use_localtime) {
            ret = sls_flag_check_duration_size_index(hls);
            if (ret < 0) {
                goto fail;
            }
        } else {
            ret = sls_flag_check_duration_size(hls, vs);
            if (ret < 0) {
                goto fail;
            }
        }
        if (vs->has_subtitle) {

            if (hls->flags & HLS_SINGLE_FILE)
                vtt_pattern = ".vtt";
2643
            vtt_basename_size = strlen(vs->m3u8_name) + strlen(vtt_pattern) + 1;
2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654

            vs->vtt_basename = av_malloc(vtt_basename_size);
            if (!vs->vtt_basename) {
                ret = AVERROR(ENOMEM);
                goto fail;
            }
            vs->vtt_m3u8_name = av_malloc(vtt_basename_size);
            if (!vs->vtt_m3u8_name ) {
                ret = AVERROR(ENOMEM);
                goto fail;
            }
2655
            av_strlcpy(vs->vtt_basename, vs->m3u8_name, vtt_basename_size);
2656 2657 2658 2659 2660 2661
            p = strrchr(vs->vtt_basename, '.');
            if (p)
                *p = '\0';

            if ( hls->subtitle_filename ) {
                strcpy(vs->vtt_m3u8_name, hls->subtitle_filename);
2662 2663 2664
                ret = format_name(vs->vtt_m3u8_name, vtt_basename_size, i);
                if (ret < 0)
                    goto fail;
2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700
            } else {
                strcpy(vs->vtt_m3u8_name, vs->vtt_basename);
                av_strlcat(vs->vtt_m3u8_name, "_vtt.m3u8", vtt_basename_size);
            }
            av_strlcat(vs->vtt_basename, vtt_pattern, vtt_basename_size);
        }

        if (hls->baseurl) {
            vs->baseurl = av_strdup(hls->baseurl);
            if (!vs->baseurl) {
                ret = AVERROR(ENOMEM);
                goto fail;
            }
        }

        if ((hls->flags & HLS_SINGLE_FILE) && (hls->segment_type == SEGMENT_TYPE_FMP4)) {
            vs->fmp4_init_filename  = av_strdup(vs->basename);
            if (!vs->fmp4_init_filename) {
                ret = AVERROR(ENOMEM);
                goto fail;
            }
        }
        if ((ret = hls_mux_init(s, vs)) < 0)
            goto fail;

        if (hls->flags & HLS_APPEND_LIST) {
            parse_playlist(s, vs->m3u8_name, vs);
            vs->discontinuity = 1;
            if (hls->init_time > 0) {
                av_log(s, AV_LOG_WARNING, "append_list mode does not support hls_init_time,"
                       " hls_init_time value will have no effect\n");
                hls->init_time = 0;
                hls->recording_time = hls->time * AV_TIME_BASE;
            }
        }

2701 2702
        if ((ret = hls_start(s, vs)) < 0)
            goto fail;
2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715
    }

fail:
    if (ret < 0) {
        av_freep(&hls->key_basename);
        for (i = 0; i < hls->nb_varstreams && hls->var_streams; i++) {
            vs = &hls->var_streams[i];
            av_freep(&vs->basename);
            av_freep(&vs->vtt_basename);
            av_freep(&vs->fmp4_init_filename);
            av_freep(&vs->m3u8_name);
            av_freep(&vs->vtt_m3u8_name);
            av_freep(&vs->streams);
2716
            av_freep(&vs->agroup);
2717
            av_freep(&vs->ccgroup);
2718 2719 2720 2721 2722 2723
            av_freep(&vs->baseurl);
            if (vs->avf)
                avformat_free_context(vs->avf);
            if (vs->vtt_avf)
                avformat_free_context(vs->vtt_avf);
        }
2724 2725 2726 2727 2728 2729
        for (i = 0; i < hls->nb_ccstreams; i++) {
            ClosedCaptionsStream *ccs = &hls->cc_streams[i];
            av_freep(&ccs->ccgroup);
            av_freep(&ccs->instreamid);
            av_freep(&ccs->language);
        }
2730
        av_freep(&hls->var_streams);
2731
        av_freep(&hls->cc_streams);
2732 2733 2734 2735 2736 2737
        av_freep(&hls->master_m3u8_url);
    }

    return ret;
}

2738 2739 2740
#define OFFSET(x) offsetof(HLSContext, x)
#define E AV_OPT_FLAG_ENCODING_PARAM
static const AVOption options[] = {
2741
    {"start_number",  "set first number in the sequence",        OFFSET(start_sequence),AV_OPT_TYPE_INT64,  {.i64 = 0},     0, INT64_MAX, E},
2742
    {"hls_time",      "set segment length in seconds",           OFFSET(time),    AV_OPT_TYPE_FLOAT,  {.dbl = 2},     0, FLT_MAX, E},
2743
    {"hls_init_time", "set segment length in seconds at init list",           OFFSET(init_time),    AV_OPT_TYPE_FLOAT,  {.dbl = 0},     0, FLT_MAX, E},
2744
    {"hls_list_size", "set maximum number of playlist entries",  OFFSET(max_nb_segments),    AV_OPT_TYPE_INT,    {.i64 = 5},     0, INT_MAX, E},
Steven Liu's avatar
Steven Liu committed
2745
    {"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},
2746
    {"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},
2747 2748 2749
#if FF_API_HLS_WRAP
    {"hls_wrap",      "set number after which the index wraps (will be deprecated)",  OFFSET(wrap),    AV_OPT_TYPE_INT,    {.i64 = 0},     0, INT_MAX, E},
#endif
2750
    {"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},
2751
    {"hls_base_url",  "url to prepend to each playlist entry",   OFFSET(baseurl), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,       E},
2752
    {"hls_segment_filename", "filename template for segment files", OFFSET(segment_filename),   AV_OPT_TYPE_STRING, {.str = NULL},            0,       0,         E},
2753
    {"hls_segment_size", "maximum size per segment file, (in bytes)",  OFFSET(max_seg_size),    AV_OPT_TYPE_INT,    {.i64 = 0},               0,       INT_MAX,   E},
2754
    {"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},
2755 2756 2757 2758
    {"hls_enc",    "enable AES128 encryption support", OFFSET(encrypt),      AV_OPT_TYPE_BOOL, {.i64 = 0},            0,       1,         E},
    {"hls_enc_key",    "hex-coded 16 byte key to encrypt the segments", OFFSET(key),      AV_OPT_TYPE_STRING, .flags = E},
    {"hls_enc_key_url",    "url to access the key to decrypt the segments", OFFSET(key_url),      AV_OPT_TYPE_STRING, {.str = NULL},            0,       0,         E},
    {"hls_enc_iv",    "hex-coded 16 byte initialization vector", OFFSET(iv),      AV_OPT_TYPE_STRING, .flags = E},
2759
    {"hls_subtitle_path",     "set path of hls subtitles", OFFSET(subtitle_filename), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,    E},
2760
    {"hls_segment_type",     "set hls segment files type", OFFSET(segment_type), AV_OPT_TYPE_INT, {.i64 = SEGMENT_TYPE_MPEGTS }, 0, SEGMENT_TYPE_FMP4, E, "segment_type"},
2761
    {"mpegts",   "make segment file to mpegts files in m3u8", 0, AV_OPT_TYPE_CONST, {.i64 = SEGMENT_TYPE_MPEGTS }, 0, UINT_MAX,   E, "segment_type"},
2762
    {"fmp4",   "make segment file to fragment mp4 files in m3u8", 0, AV_OPT_TYPE_CONST, {.i64 = SEGMENT_TYPE_FMP4 }, 0, UINT_MAX,   E, "segment_type"},
2763
    {"hls_fmp4_init_filename", "set fragment mp4 file init filename", OFFSET(fmp4_init_filename),   AV_OPT_TYPE_STRING, {.str = "init.mp4"},            0,       0,         E},
2764 2765
    {"hls_flags",     "set flags affecting HLS playlist and media file generation", OFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = 0 }, 0, UINT_MAX, E, "flags"},
    {"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"},
2766
    {"temp_file", "write segment to temporary file and rename when complete", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_TEMP_FILE }, 0, UINT_MAX,   E, "flags"},
2767
    {"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"},
2768
    {"round_durations", "round durations in m3u8 to whole numbers", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_ROUND_DURATIONS }, 0, UINT_MAX,   E, "flags"},
2769
    {"discont_start", "start the playlist with a discontinuity tag", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_DISCONT_START }, 0, UINT_MAX,   E, "flags"},
2770
    {"omit_endlist", "Do not append an endlist when ending stream", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_OMIT_ENDLIST }, 0, UINT_MAX,   E, "flags"},
2771
    {"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"},
2772
    {"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"},
2773
    {"program_date_time", "add EXT-X-PROGRAM-DATE-TIME", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_PROGRAM_DATE_TIME }, 0, UINT_MAX,   E, "flags"},
2774
    {"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"},
2775 2776
    {"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"},
    {"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"},
2777
    {"periodic_rekey", "reload keyinfo file periodically for re-keying", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_PERIODIC_REKEY }, 0, UINT_MAX,   E, "flags"},
2778
    {"independent_segments", "add EXT-X-INDEPENDENT-SEGMENTS, whenever applicable", 0, AV_OPT_TYPE_CONST, { .i64 = HLS_INDEPENDENT_SEGMENTS }, 0, UINT_MAX, E, "flags"},
2779 2780
    {"use_localtime", "set filename expansion with strftime at segment creation", OFFSET(use_localtime), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
    {"use_localtime_mkdir", "create last directory component in strftime-generated filename", OFFSET(use_localtime_mkdir), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
2781 2782 2783
    {"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" },
    {"event", "EVENT playlist", 0, AV_OPT_TYPE_CONST, {.i64 = PLAYLIST_TYPE_EVENT }, INT_MIN, INT_MAX, E, "pl_type" },
    {"vod", "VOD playlist", 0, AV_OPT_TYPE_CONST, {.i64 = PLAYLIST_TYPE_VOD }, INT_MIN, INT_MAX, E, "pl_type" },
2784
    {"method", "set the HTTP method(default: PUT)", OFFSET(method), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,    E},
2785 2786 2787 2788
    {"hls_start_number_source", "set source of first number in sequence", OFFSET(start_sequence_source_type), AV_OPT_TYPE_INT, {.i64 = HLS_START_SEQUENCE_AS_START_NUMBER }, 0, HLS_START_SEQUENCE_AS_FORMATTED_DATETIME, E, "start_sequence_source_type" },
    {"generic", "start_number value (default)", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_START_SEQUENCE_AS_START_NUMBER }, INT_MIN, INT_MAX, E, "start_sequence_source_type" },
    {"epoch", "seconds since epoch", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_START_SEQUENCE_AS_SECONDS_SINCE_EPOCH }, INT_MIN, INT_MAX, E, "start_sequence_source_type" },
    {"datetime", "current datetime as YYYYMMDDhhmmss", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_START_SEQUENCE_AS_FORMATTED_DATETIME }, INT_MIN, INT_MAX, E, "start_sequence_source_type" },
2789
    {"http_user_agent", "override User-Agent field in HTTP header", OFFSET(user_agent), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,    E},
2790
    {"var_stream_map", "Variant stream map string", OFFSET(var_stream_map), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,    E},
2791
    {"cc_stream_map", "Closed captions stream map string", OFFSET(cc_stream_map), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,    E},
2792 2793
    {"master_pl_name", "Create HLS master playlist with this name", OFFSET(master_pl_name), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,    E},
    {"master_pl_publish_rate", "Publish master play list every after this many segment intervals", OFFSET(master_publish_rate), AV_OPT_TYPE_INT, {.i64 = 0}, 0, UINT_MAX, E},
2794
    {"http_persistent", "Use persistent HTTP connections", OFFSET(http_persistent), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807
    { NULL },
};

static const AVClass hls_class = {
    .class_name = "hls muxer",
    .item_name  = av_default_item_name,
    .option     = options,
    .version    = LIBAVUTIL_VERSION_INT,
};


AVOutputFormat ff_hls_muxer = {
    .name           = "hls",
2808
    .long_name      = NULL_IF_CONFIG_SMALL("Apple HTTP Live Streaming"),
2809 2810
    .extensions     = "m3u8",
    .priv_data_size = sizeof(HLSContext),
2811 2812
    .audio_codec    = AV_CODEC_ID_AAC,
    .video_codec    = AV_CODEC_ID_H264,
2813
    .subtitle_codec = AV_CODEC_ID_WEBVTT,
2814
    .flags          = AVFMT_NOFILE | AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH,
2815
    .init           = hls_init,
2816 2817 2818 2819 2820
    .write_header   = hls_write_header,
    .write_packet   = hls_write_packet,
    .write_trailer  = hls_write_trailer,
    .priv_class     = &hls_class,
};