hlsenc.c 98.3 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

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

137
    char *basename;
138 139
    char *vtt_basename;
    char *vtt_m3u8_name;
140 141 142 143 144 145 146 147 148 149
    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;
150 151
    char codec_attr[128];
    CodecAttributeStatus attr_status;
152
    unsigned int nb_streams;
153
    int m3u8_created; /* status of media play-list creation */
154
    char *agroup; /* audio group name */
155
    char *ccgroup; /* closed caption group name */
156 157 158
    char *baseurl;
} VariantStream;

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

165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187
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

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

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

201 202 203 204 205
    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];
206 207
    AVDictionary *vtt_format_options;

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

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

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

228 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
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;
}

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

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

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

    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);
305 306
    if (c->http_persistent)
        av_dict_set_int(options, "multiple_requests", 1, 0);
307 308 309

}

310 311 312 313 314 315 316 317 318 319 320
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;
321
        if (data && (data[0] | data[1] | data[2]) == 0 && data[3] == 1 && (data[4] & 0x1F) == 7) {
322 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
            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;
}

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

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

    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) {
382
                av_bprintf(&buf, "%0*"PRId64, (number < 0) ? nd : nd++, number);
383 384 385 386 387 388 389 390
                p += (addchar_count + 1);
                addchar_count = 0;
                found_count++;
            }

        } else
            addchar_count = 1;

391 392
        av_bprint_append_data(&buf, p, addchar_count);
        p += addchar_count;
393
    }
394 395 396 397 398 399 400
    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;
401 402 403
    return found_count;
}

404 405 406 407 408 409 410 411 412 413
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");
}

414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436
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);
}

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

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

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

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

466
    if (segment && !hls->use_localtime_mkdir) {
467 468 469
        if (hls->segment_filename) {
            dirname = av_strdup(hls->segment_filename);
        } else {
470
            dirname = av_strdup(vs->avf->url);
471 472 473 474 475 476 477 478 479 480 481 482
        }
        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);
483
        path_size =  (hls->use_localtime_mkdir ? 0 : strlen(dirname)) + strlen(segment->filename) + 1;
484 485 486 487 488
        path = av_malloc(path_size);
        if (!path) {
            ret = AVERROR(ENOMEM);
            goto fail;
        }
489

490 491 492 493 494 495 496
        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);
        }

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

508 509
        if ((segment->sub_filename[0] != '\0')) {
            sub_path_size = strlen(segment->sub_filename) + 1 + (dirname ? strlen(dirname) : 0);
510 511 512 513 514 515 516 517
            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);
518

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

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

    return ret;
}

545 546 547 548 549 550 551 552 553 554 555 556 557 558
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);
}

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

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

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

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

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

        if (!hls->iv) {
588
            AV_WB64(iv + 8, vs->sequence);
589 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
        } 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;
}


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

635
    if ((ret = s->io_open(s, &pb, hls->key_info_file, AVIO_FLAG_READ, NULL)) < 0) {
636 637 638 639 640 641 642 643 644 645 646 647 648 649
        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';

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

    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);
    }

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

    ret = avio_read(pb, key, sizeof(key));
668
    ff_format_io_close(s, &pb);
669 670 671 672 673 674 675 676 677 678 679
    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;
}

680 681 682 683 684 685 686 687
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;
}

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

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

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

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

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

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

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

742 743 744
        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);
745
    }
746 747 748 749 750

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

752
    if (hls->segment_type == SEGMENT_TYPE_FMP4) {
753 754 755 756
        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;
        }
757 758 759 760

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

765 766 767
        ret = hlsenc_io_open(s, &vs->out, vs->base_output_dirname, &options);
        av_dict_free(&options);
        if (ret < 0) {
768
            av_log(s, AV_LOG_ERROR, "Failed to open segment '%s'\n", vs->fmp4_init_filename);
769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784
            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);
785 786
        if (ret < 0)
            return ret;
787 788 789 790 791
        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);
        }
792
        avio_flush(oc->pb);
793 794
        av_dict_free(&options);
    }
795 796 797
    return 0;
}

798 799 800 801 802 803 804 805 806 807
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;
}

808 809 810
static int sls_flags_filename_process(struct AVFormatContext *s, HLSContext *hls,
                                      VariantStream *vs, HLSSegment *en,
                                      double duration, int64_t pos, int64_t size)
811
{
812
    if ((hls->flags & (HLS_SECOND_LEVEL_SEGMENT_SIZE | HLS_SECOND_LEVEL_SEGMENT_DURATION)) &&
813
        strlen(vs->current_segment_final_filename_fmt)) {
814 815 816 817 818 819
        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);
820
        if (hls->flags & HLS_SECOND_LEVEL_SEGMENT_SIZE) {
821
            char *filename = NULL;
822
            if (replace_int_data_in_filename(&filename, vs->avf->url, 's', pos + size) < 1) {
823 824 825
                av_log(hls, AV_LOG_ERROR,
                       "Invalid second level segment filename template '%s', "
                        "you can try to remove second_level_segment_size flag\n",
826
                       vs->avf->url);
827
                av_free(filename);
828
                av_free(en);
829 830
                return AVERROR(EINVAL);
            }
831
            ff_format_set_url(vs->avf, filename);
832 833
        }
        if (hls->flags & HLS_SECOND_LEVEL_SEGMENT_DURATION) {
834
            char *filename = NULL;
835
            if (replace_int_data_in_filename(&filename, vs->avf->url,
836
                't',  (int64_t)round(duration * HLS_MICROSECOND_UNIT)) < 1) {
837 838 839
                av_log(hls, AV_LOG_ERROR,
                       "Invalid second level segment filename template '%s', "
                        "you can try to remove second_level_segment_time flag\n",
840
                       vs->avf->url);
841
                av_free(filename);
842
                av_free(en);
843 844
                return AVERROR(EINVAL);
            }
845
            ff_format_set_url(vs->avf, filename);
846 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
    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;
}

874
static int sls_flag_check_duration_size(HLSContext *hls, VariantStream *vs)
875
{
876
    const char *proto = avio_find_protocol_name(vs->basename);
877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893
    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;
}

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

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

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

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

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

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

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

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

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

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

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

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

1003
    vs->last_segment = en;
1004

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

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

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

1033 1034 1035
    return 0;
}

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

    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;
    }

1057
    vs->discontinuity = 0;
1058 1059 1060
    while (!avio_feof(in)) {
        read_chomp_line(in, line, sizeof(line));
        if (av_strstart(line, "#EXT-X-MEDIA-SEQUENCE:", &ptr)) {
1061
            int64_t tmp_sequence = strtoll(ptr, NULL, 10);
1062
            if (tmp_sequence < vs->sequence)
1063 1064 1065 1066 1067 1068
              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);
1069
              vs->sequence = tmp_sequence;
1070
            }
1071 1072
        } else if (av_strstart(line, "#EXT-X-DISCONTINUITY", &ptr)) {
            is_segment = 1;
1073
            vs->discontinuity = 1;
1074 1075
        } else if (av_strstart(line, "#EXTINF:", &ptr)) {
            is_segment = 1;
1076
            vs->duration = atof(ptr);
1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099
        } 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));
                }
            }

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

fail:
    avio_close(in);
    return ret;
}

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

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

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

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

1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173
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;
1174
    VariantStream *vs, *temp_vs;
1175 1176 1177 1178
    AVStream *vid_st, *aud_st;
    AVDictionary *options = NULL;
    unsigned int i, j;
    int m3u8_name_size, ret, bandwidth;
1179 1180
    char *m3u8_rel_name, *ccgroup;
    ClosedCaptionsStream *ccs;
1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194

    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;
    }

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

1197
    ret = hlsenc_io_open(s, &hls->m3u8_out, hls->master_m3u8_url, &options);
1198 1199 1200 1201 1202 1203 1204
    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;
    }

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

1207 1208 1209 1210 1211 1212 1213 1214 1215 1216
    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);
    }

1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237
    /* 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;
        }

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

1240 1241 1242
        av_freep(&m3u8_rel_name);
    }

1243 1244 1245 1246 1247
    /* 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;
1248 1249
        m3u8_rel_name = av_malloc(m3u8_name_size);
        if (!m3u8_rel_name) {
1250 1251 1252
            ret = AVERROR(ENOMEM);
            goto fail;
        }
1253
        av_strlcpy(m3u8_rel_name, vs->m3u8_name, m3u8_name_size);
1254
        ret = get_relative_url(hls->master_m3u8_url, vs->m3u8_name,
1255
                               m3u8_rel_name, m3u8_name_size);
1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274
        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;
        }

1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293
        /**
         * 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];
                }
            }
        }

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

1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315
        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);
        }

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

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

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

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

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

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

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

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

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

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

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

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

1401 1402 1403 1404
        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);
1405 1406 1407
        if (ret < 0) {
            av_log(s, AV_LOG_WARNING, "ff_hls_write_file_entry get error\n");
        }
1408 1409
    }

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

1413
    if( vs->vtt_m3u8_name ) {
1414
        if ((ret = hlsenc_io_open(s, &hls->sub_m3u8_out, vs->vtt_m3u8_name, &options)) < 0)
1415
            goto fail;
1416
        ff_hls_write_playlist_header(hls->sub_m3u8_out, hls->version, hls->allowcache,
1417
                                     target_duration, sequence, PLAYLIST_TYPE_NONE);
1418
        for (en = vs->segments; en; en = en->next) {
1419 1420 1421
            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);
1422 1423 1424
            if (ret < 0) {
                av_log(s, AV_LOG_WARNING, "ff_hls_write_file_entry get error\n");
            }
1425 1426 1427
        }

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

    }

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

    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");

1443 1444 1445
    return ret;
}

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

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

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

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

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

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

1554 1555 1556 1557 1558
    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");
        }
1559

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

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

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

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

1607 1608 1609 1610
            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);
        }
1611
    }
1612

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

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

    return err;
1624 1625
}

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

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

1642
static int append_postfix(char *name, int name_buf_len, int i)
1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660
{
    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;
}

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

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

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

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

1681
    if (nb_vs > 1 && !av_stristr(filename, "%v") && !av_stristr(subdir_name, "%v")) {
1682 1683 1684 1685 1686 1687
        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;
    }

1688 1689 1690 1691 1692 1693 1694
    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;
    }

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

static int format_name(char *buf, int buf_len, int index)
{
1702
    const char *proto, *dir;
1703
    char *orig_buf_dup = NULL, *mod_buf = NULL, *mod_buf_dup = NULL;
1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714
    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;
    }

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

1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738
    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;
        }
    }

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

1746 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
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"
1777
     * "a:0,agroup:a0 a:1,agroup:a1 v:0,agroup:a0  v:1,agroup:a1"
1778 1779 1780 1781 1782 1783 1784 1785
     * 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)
     *
1786
     * agroup: is key to specify audio group. A string can be given as value.
1787 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
     */
    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;

1825 1826 1827 1828 1829
            if (av_strstart(keyval, "agroup:", &val)) {
                vs->agroup = av_strdup(val);
                if (!vs->agroup)
                    return AVERROR(ENOMEM);
                continue;
1830 1831 1832 1833 1834
            } else if (av_strstart(keyval, "ccgroup:", &val)) {
                vs->ccgroup = av_strdup(val);
                if (!vs->ccgroup)
                    return AVERROR(ENOMEM);
                continue;
1835
            } else if (av_strstart(keyval, "v:", &val)) {
1836 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
                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;
}

1865 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
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;
}

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

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

    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);

1970 1971 1972 1973 1974 1975 1976
        //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);
        }

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

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

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

1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009
    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);
    }

2010 2011 2012 2013 2014 2015 2016 2017
    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;
2018 2019
    }

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

2024
    return ret;
2025 2026
}

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

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

2037 2038 2039 2040 2041 2042 2043 2044
        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;
        }
2045
        av_dict_free(&options);
2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057
        //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);
                }
2058 2059
            }

2060 2061 2062 2063 2064 2065 2066 2067 2068 2069
            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);
2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082
            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);
                }
            }
2083
        }
2084
    }
2085
fail:
Steven Liu's avatar
Steven Liu committed
2086

2087 2088 2089 2090 2091 2092
    return ret;
}

static int hls_write_packet(AVFormatContext *s, AVPacket *pkt)
{
    HLSContext *hls = s->priv_data;
2093
    AVFormatContext *oc = NULL;
2094
    AVStream *st = s->streams[pkt->stream_index];
2095
    int64_t end_pts = 0;
2096
    int is_ref_pkt = 1;
2097
    int ret = 0, can_split = 1, i, j;
2098
    int stream_index = 0;
2099 2100
    int range_length = 0;
    uint8_t *buffer = NULL;
2101 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
    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;
2128

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

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

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

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

2166
    }
2167 2168

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

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

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

2180 2181
        new_start_pos = avio_tell(vs->avf->pb);
        vs->size = new_start_pos - vs->start_pos;
2182

2183
        if (!byterange_mode) {
2184 2185
            if (hls->segment_type == SEGMENT_TYPE_FMP4) {
                if (!vs->init_range_length) {
2186 2187 2188 2189 2190 2191 2192 2193
                    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);
2194
                }
2195
            } else {
2196
                hlsenc_io_close(s, &oc->pb, oc->url);
2197
            }
2198
            if (vs->vtt_avf) {
2199
                hlsenc_io_close(s, &vs->vtt_avf->pb, vs->vtt_avf->url);
2200
            }
2201
        }
2202
        if ((hls->flags & HLS_TEMP_FILE) && oc->url[0]) {
2203
            if (!(hls->flags & HLS_SINGLE_FILE) || (hls->max_seg_size <= 0))
2204 2205
                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);
2206 2207 2208
            hls_rename_temp_file(s, oc);
        }

2209 2210
        if (vs->fmp4_init_mode) {
            vs->number--;
2211 2212
        }

2213
        if (hls->segment_type == SEGMENT_TYPE_FMP4) {
2214
            ret = hlsenc_io_open(s, &vs->out, vs->avf->url, NULL);
2215 2216
            if (ret < 0) {
                av_log(NULL, AV_LOG_ERROR, "Failed to open file '%s'\n",
2217
                    vs->avf->url);
2218
                av_free(old_filename);
2219 2220 2221 2222 2223
                return ret;
            }
            write_styp(vs->out);
            ret = flush_dynbuf(vs, &range_length);
            if (ret < 0) {
2224
                av_free(old_filename);
2225 2226 2227 2228
                return ret;
            }
            ff_format_io_close(s, &vs->out);
        }
2229
        ret = hls_append_segment(s, hls, vs, vs->duration, vs->start_pos, vs->size);
2230
        vs->start_pos = new_start_pos;
2231 2232
        if (ret < 0) {
            av_free(old_filename);
2233
            return ret;
2234
        }
2235

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

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

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

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

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

    return ret;
}

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

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

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

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

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

2317
        if ((hls->flags & HLS_TEMP_FILE) && oc->url[0]) {
2318 2319 2320
            hls_rename_temp_file(s, oc);
        }

2321
        /* after av_write_trailer, then duration + 1 duration per packet */
2322
        hls_append_segment(s, hls, vs, vs->duration + vs->dpp, vs->start_pos, vs->size);
2323
    }
2324

2325
    sls_flag_file_rename(hls, vs, old_filename);
2326

2327 2328 2329
    if (vtt_oc) {
        if (vtt_oc->pb)
            av_write_trailer(vtt_oc);
2330
        vs->size = avio_tell(vs->vtt_avf->pb) - vs->start_pos;
2331
        ff_format_io_close(s, &vtt_oc->pb);
2332
    }
2333 2334
    av_freep(&vs->basename);
    av_freep(&vs->base_output_dirname);
2335
    avformat_free_context(oc);
2336

2337 2338
    vs->avf = NULL;
    hls_window(s, 1, vs);
2339

2340
    av_freep(&vs->fmp4_init_filename);
2341
    if (vtt_oc) {
2342 2343
        av_freep(&vs->vtt_basename);
        av_freep(&vs->vtt_m3u8_name);
2344 2345 2346
        avformat_free_context(vtt_oc);
    }

2347 2348
    hls_free_segments(vs->segments);
    hls_free_segments(vs->old_segments);
2349
    av_free(old_filename);
2350 2351
    av_freep(&vs->m3u8_name);
    av_freep(&vs->streams);
2352
    av_freep(&vs->agroup);
2353
    av_freep(&vs->ccgroup);
2354 2355 2356
    av_freep(&vs->baseurl);
    }

2357 2358 2359 2360 2361 2362 2363
    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);
    }

2364 2365
    ff_format_io_close(s, &hls->m3u8_out);
    ff_format_io_close(s, &hls->sub_m3u8_out);
2366 2367
    av_freep(&hls->key_basename);
    av_freep(&hls->var_streams);
2368
    av_freep(&hls->cc_streams);
2369
    av_freep(&hls->master_m3u8_url);
2370 2371 2372
    return 0;
}

2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385

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;
2386
    int vtt_basename_size = 0;
2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401
    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;
    }

2402
    ret = validate_name(hls->nb_varstreams, s->url);
2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423
    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;
    }

2424 2425 2426 2427 2428 2429 2430 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
    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];
2456

2457
        vs->m3u8_name = av_strdup(s->url);
2458 2459 2460 2461
        if (!vs->m3u8_name ) {
            ret = AVERROR(ENOMEM);
            goto fail;
        }
2462
        ret = format_name(vs->m3u8_name, strlen(s->url) + 1, i);
2463 2464 2465
        if (ret < 0)
            goto fail;

2466 2467 2468 2469 2470 2471 2472 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 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525
        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;
            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);
2526 2527 2528
            ret = format_name(vs->basename, basename_size, i);
            if (ret < 0)
                goto fail;
2529 2530 2531 2532 2533 2534 2535 2536 2537 2538
        } else {
            if (hls->flags & HLS_SINGLE_FILE) {
                if (hls->segment_type == SEGMENT_TYPE_FMP4) {
                    pattern = ".m4s";
                } else {
                    pattern = ".ts";
                }
            }

            if (hls->use_localtime) {
2539
                basename_size = strlen(vs->m3u8_name) + strlen(pattern_localtime_fmt) + 1;
2540
            } else {
2541
                basename_size = strlen(vs->m3u8_name) + strlen(pattern) + 1;
2542 2543 2544 2545 2546 2547 2548 2549
            }

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

2550
            av_strlcpy(vs->basename, vs->m3u8_name, basename_size);
2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571

            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);
2572 2573

            if (av_strcasecmp(hls->fmp4_init_filename, "init.mp4")) {
2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586
                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 {
2587 2588 2589 2590 2591 2592
                if (hls->nb_varstreams > 1) {
                    ret = append_postfix(vs->fmp4_init_filename, fmp4_init_filename_len, i);
                    if (ret < 0)
                         goto fail;
                }

2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 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
                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";
2631
            vtt_basename_size = strlen(vs->m3u8_name) + strlen(vtt_pattern) + 1;
2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642

            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;
            }
2643
            av_strlcpy(vs->vtt_basename, vs->m3u8_name, vtt_basename_size);
2644 2645 2646 2647 2648 2649
            p = strrchr(vs->vtt_basename, '.');
            if (p)
                *p = '\0';

            if ( hls->subtitle_filename ) {
                strcpy(vs->vtt_m3u8_name, hls->subtitle_filename);
2650 2651 2652
                ret = format_name(vs->vtt_m3u8_name, vtt_basename_size, i);
                if (ret < 0)
                    goto fail;
2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688
            } 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;
            }
        }

2689 2690
        if ((ret = hls_start(s, vs)) < 0)
            goto fail;
2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703
    }

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);
2704
            av_freep(&vs->agroup);
2705
            av_freep(&vs->ccgroup);
2706 2707 2708 2709 2710 2711
            av_freep(&vs->baseurl);
            if (vs->avf)
                avformat_free_context(vs->avf);
            if (vs->vtt_avf)
                avformat_free_context(vs->vtt_avf);
        }
2712 2713 2714 2715 2716 2717
        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);
        }
2718
        av_freep(&hls->var_streams);
2719
        av_freep(&hls->cc_streams);
2720 2721 2722 2723 2724 2725
        av_freep(&hls->master_m3u8_url);
    }

    return ret;
}

2726 2727 2728
#define OFFSET(x) offsetof(HLSContext, x)
#define E AV_OPT_FLAG_ENCODING_PARAM
static const AVOption options[] = {
2729
    {"start_number",  "set first number in the sequence",        OFFSET(start_sequence),AV_OPT_TYPE_INT64,  {.i64 = 0},     0, INT64_MAX, E},
2730
    {"hls_time",      "set segment length in seconds",           OFFSET(time),    AV_OPT_TYPE_FLOAT,  {.dbl = 2},     0, FLT_MAX, E},
2731
    {"hls_init_time", "set segment length in seconds at init list",           OFFSET(init_time),    AV_OPT_TYPE_FLOAT,  {.dbl = 0},     0, FLT_MAX, E},
2732
    {"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
2733
    {"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},
2734
    {"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},
2735 2736 2737
#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
2738
    {"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},
2739
    {"hls_base_url",  "url to prepend to each playlist entry",   OFFSET(baseurl), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,       E},
2740
    {"hls_segment_filename", "filename template for segment files", OFFSET(segment_filename),   AV_OPT_TYPE_STRING, {.str = NULL},            0,       0,         E},
2741
    {"hls_segment_size", "maximum size per segment file, (in bytes)",  OFFSET(max_seg_size),    AV_OPT_TYPE_INT,    {.i64 = 0},               0,       INT_MAX,   E},
2742
    {"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},
2743 2744 2745 2746
    {"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},
2747
    {"hls_subtitle_path",     "set path of hls subtitles", OFFSET(subtitle_filename), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,    E},
2748
    {"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"},
2749
    {"mpegts",   "make segment file to mpegts files in m3u8", 0, AV_OPT_TYPE_CONST, {.i64 = SEGMENT_TYPE_MPEGTS }, 0, UINT_MAX,   E, "segment_type"},
2750
    {"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"},
2751
    {"hls_fmp4_init_filename", "set fragment mp4 file init filename", OFFSET(fmp4_init_filename),   AV_OPT_TYPE_STRING, {.str = "init.mp4"},            0,       0,         E},
2752 2753
    {"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"},
2754
    {"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"},
2755
    {"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"},
2756
    {"round_durations", "round durations in m3u8 to whole numbers", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_ROUND_DURATIONS }, 0, UINT_MAX,   E, "flags"},
2757
    {"discont_start", "start the playlist with a discontinuity tag", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_DISCONT_START }, 0, UINT_MAX,   E, "flags"},
2758
    {"omit_endlist", "Do not append an endlist when ending stream", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_OMIT_ENDLIST }, 0, UINT_MAX,   E, "flags"},
2759
    {"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"},
2760
    {"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"},
2761
    {"program_date_time", "add EXT-X-PROGRAM-DATE-TIME", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_PROGRAM_DATE_TIME }, 0, UINT_MAX,   E, "flags"},
2762
    {"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"},
2763 2764
    {"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"},
2765
    {"periodic_rekey", "reload keyinfo file periodically for re-keying", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_PERIODIC_REKEY }, 0, UINT_MAX,   E, "flags"},
2766
    {"independent_segments", "add EXT-X-INDEPENDENT-SEGMENTS, whenever applicable", 0, AV_OPT_TYPE_CONST, { .i64 = HLS_INDEPENDENT_SEGMENTS }, 0, UINT_MAX, E, "flags"},
2767 2768
    {"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 },
2769 2770 2771
    {"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" },
2772
    {"method", "set the HTTP method(default: PUT)", OFFSET(method), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,    E},
2773 2774 2775 2776
    {"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" },
2777
    {"http_user_agent", "override User-Agent field in HTTP header", OFFSET(user_agent), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,    E},
2778
    {"var_stream_map", "Variant stream map string", OFFSET(var_stream_map), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,    E},
2779
    {"cc_stream_map", "Closed captions stream map string", OFFSET(cc_stream_map), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,    E},
2780 2781
    {"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},
2782
    {"http_persistent", "Use persistent HTTP connections", OFFSET(http_persistent), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795
    { 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",
2796
    .long_name      = NULL_IF_CONFIG_SMALL("Apple HTTP Live Streaming"),
2797 2798
    .extensions     = "m3u8",
    .priv_data_size = sizeof(HLSContext),
2799 2800
    .audio_codec    = AV_CODEC_ID_AAC,
    .video_codec    = AV_CODEC_ID_H264,
2801
    .subtitle_codec = AV_CODEC_ID_WEBVTT,
2802
    .flags          = AVFMT_NOFILE | AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH,
2803
    .init           = hls_init,
2804 2805 2806 2807 2808
    .write_header   = hls_write_header,
    .write_packet   = hls_write_packet,
    .write_trailer  = hls_write_trailer,
    .priv_class     = &hls_class,
};