segment.c 26.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
/*
 * Copyright (c) 2011, Luca Barbato
 *
 * This file is part of Libav.
 *
 * Libav is free software; you can redistribute it and/or
 * 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.
 *
 * Libav is distributed in the hope that it will be useful,
 * 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
 * License along with Libav; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

21 22
/**
 * @file generic segmenter
23 24
 * M3U8 specification can be find here:
 * @url{http://tools.ietf.org/id/draft-pantos-http-live-streaming-08.txt}
25 26
 */

27 28
/* #define DEBUG */

29 30 31 32 33 34 35 36 37 38
#include <float.h>

#include "avformat.h"
#include "internal.h"

#include "libavutil/log.h"
#include "libavutil/opt.h"
#include "libavutil/avstring.h"
#include "libavutil/parseutils.h"
#include "libavutil/mathematics.h"
39
#include "libavutil/timestamp.h"
40

41
typedef enum {
42
    LIST_TYPE_UNDEFINED = -1,
43
    LIST_TYPE_FLAT = 0,
44
    LIST_TYPE_CSV,
45
    LIST_TYPE_M3U8,
46
    LIST_TYPE_EXT, ///< deprecated
47 48 49
    LIST_TYPE_NB,
} ListType;

50 51 52
#define SEGMENT_LIST_FLAG_CACHE 1
#define SEGMENT_LIST_FLAG_LIVE  2

53 54
typedef struct {
    const AVClass *class;  /**< Class for private options. */
55 56 57
    int segment_idx;       ///< index of the segment file to write, starting from 0
    int segment_idx_wrap;  ///< number after which the index wraps
    int segment_count;     ///< number of segment files already written
58
    AVOutputFormat *oformat;
59
    AVFormatContext *avf;
60 61
    char *format;          ///< format to use for output segment files
    char *list;            ///< filename for the segment list file
62
    int   list_flags;      ///< flags affecting list generation
63
    int   list_size;       ///< number of entries for the segment list file
64
    double list_max_segment_time; ///< max segment time in the current list
65
    ListType list_type;    ///< set the list type
66
    AVIOContext *list_pb;  ///< list file put-byte context
67 68
    char *time_str;        ///< segment duration specification string
    int64_t time;          ///< segment duration
69

70 71 72
    char *times_str;       ///< segment times specification string
    int64_t *times;        ///< list of segment interval specification
    int nb_times;          ///< number of elments in the times array
73 74 75 76 77 78

    char *frames_str;      ///< segment frame numbers specification string
    int *frames;           ///< list of frame number specification
    int nb_frames;         ///< number of elments in the frames array
    int frame_count;

79 80
    char *time_delta_str;  ///< approximation value duration used for the segment times
    int64_t time_delta;
81
    int  individual_header_trailer; /**< Set by a private option. */
82
    int  write_header_trailer; /**< Set by a private option. */
83 84

    int reset_timestamps;  ///< reset timestamps at the begin of each segment
85 86 87
    char *reference_stream_specifier; ///< reference stream specifier
    int   reference_stream_index;

88
    double start_time, end_time;
89
    int64_t start_pts, start_dts;
90
    int is_first_pkt;      ///< tells if it is the first packet in the segment
91 92
} SegmentContext;

93 94
static void print_csv_escaped_str(AVIOContext *ctx, const char *str)
{
95
    int needs_quoting = !!str[strcspn(str, "\",\n\r")];
96

97
    if (needs_quoting)
98 99
        avio_w8(ctx, '"');

100 101
    for (; *str; str++) {
        if (*str == '"')
102
            avio_w8(ctx, '"');
103
        avio_w8(ctx, *str);
104
    }
105
    if (needs_quoting)
106 107 108
        avio_w8(ctx, '"');
}

109
static int segment_mux_init(AVFormatContext *s)
110
{
111
    SegmentContext *seg = s->priv_data;
112 113 114 115 116 117 118 119 120 121 122 123
    AVFormatContext *oc;
    int i;

    seg->avf = oc = avformat_alloc_context();
    if (!oc)
        return AVERROR(ENOMEM);

    oc->oformat            = seg->oformat;
    oc->interrupt_callback = s->interrupt_callback;

    for (i = 0; i < s->nb_streams; i++) {
        AVStream *st;
124 125
        AVCodecContext *icodec, *ocodec;

126 127
        if (!(st = avformat_new_stream(oc, NULL)))
            return AVERROR(ENOMEM);
128 129 130 131 132 133 134 135 136 137
        icodec = s->streams[i]->codec;
        ocodec = st->codec;
        avcodec_copy_context(ocodec, icodec);
        if (!oc->oformat->codec_tag ||
            av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == ocodec->codec_id ||
            av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0) {
            ocodec->codec_tag = icodec->codec_tag;
        } else {
            ocodec->codec_tag = 0;
        }
138 139 140 141 142 143
        st->sample_aspect_ratio = s->streams[i]->sample_aspect_ratio;
    }

    return 0;
}

144 145 146 147 148 149 150 151 152 153 154 155 156 157 158
static int set_segment_filename(AVFormatContext *s)
{
    SegmentContext *seg = s->priv_data;
    AVFormatContext *oc = seg->avf;

    if (seg->segment_idx_wrap)
        seg->segment_idx %= seg->segment_idx_wrap;
    if (av_get_frame_filename(oc->filename, sizeof(oc->filename),
                              s->filename, seg->segment_idx) < 0) {
        av_log(oc, AV_LOG_ERROR, "Invalid segment filename template '%s'\n", s->filename);
        return AVERROR(EINVAL);
    }
    return 0;
}

159
static int segment_start(AVFormatContext *s, int write_header)
160
{
161 162
    SegmentContext *seg = s->priv_data;
    AVFormatContext *oc = seg->avf;
163 164
    int err = 0;

165 166
    if (write_header) {
        avformat_free_context(oc);
167
        seg->avf = NULL;
168 169
        if ((err = segment_mux_init(s)) < 0)
            return err;
170
        oc = seg->avf;
171
    }
172

173
    seg->segment_idx++;
174 175
    if ((err = set_segment_filename(s)) < 0)
        return err;
176
    seg->segment_count++;
177 178 179 180 181

    if ((err = avio_open2(&oc->pb, oc->filename, AVIO_FLAG_WRITE,
                          &s->interrupt_callback, NULL)) < 0)
        return err;

182
    if (oc->oformat->priv_class && oc->priv_data)
183
        av_opt_set(oc->priv_data, "resend_headers", "1", 0); /* mpegts specific */
184

185 186 187 188
    if (write_header) {
        if ((err = avformat_write_header(oc, NULL)) < 0)
            return err;
    }
189

190
    seg->is_first_pkt = 1;
191 192 193
    return 0;
}

194 195 196
static int segment_list_open(AVFormatContext *s)
{
    SegmentContext *seg = s->priv_data;
197 198 199 200 201 202 203
    int ret;

    ret = avio_open2(&seg->list_pb, seg->list, AVIO_FLAG_WRITE,
                     &s->interrupt_callback, NULL);
    if (ret < 0)
        return ret;
    seg->list_max_segment_time = 0;
204 205 206

    if (seg->list_type == LIST_TYPE_M3U8) {
        avio_printf(seg->list_pb, "#EXTM3U\n");
207
        avio_printf(seg->list_pb, "#EXT-X-VERSION:3\n");
208
        avio_printf(seg->list_pb, "#EXT-X-MEDIA-SEQUENCE:%d\n", seg->segment_idx);
209 210 211 212 213
        avio_printf(seg->list_pb, "#EXT-X-ALLOWCACHE:%d\n",
                    !!(seg->list_flags & SEGMENT_LIST_FLAG_CACHE));
        if (seg->list_flags & SEGMENT_LIST_FLAG_LIVE)
            avio_printf(seg->list_pb,
                        "#EXT-X-TARGETDURATION:%"PRId64"\n", seg->time / 1000000);
214 215
    }

216
    return ret;
217 218 219 220 221
}

static void segment_list_close(AVFormatContext *s)
{
    SegmentContext *seg = s->priv_data;
222 223

    if (seg->list_type == LIST_TYPE_M3U8) {
224 225 226
        if (!(seg->list_flags & SEGMENT_LIST_FLAG_LIVE))
            avio_printf(seg->list_pb, "#EXT-X-TARGETDURATION:%d\n",
                        (int)ceil(seg->list_max_segment_time));
227 228 229
        avio_printf(seg->list_pb, "#EXT-X-ENDLIST\n");
    }

230 231 232
    avio_close(seg->list_pb);
}

233
static int segment_end(AVFormatContext *s, int write_trailer)
234
{
235 236
    SegmentContext *seg = s->priv_data;
    AVFormatContext *oc = seg->avf;
237 238
    int ret = 0;

239
    av_write_frame(oc, NULL); /* Flush any buffered data (fragmented mp4) */
240
    if (write_trailer)
241
        ret = av_write_trailer(oc);
242

243
    if (ret < 0)
244
        av_log(s, AV_LOG_ERROR, "Failure occurred when ending segment '%s'\n",
245 246
               oc->filename);

247
    if (seg->list) {
248
        if (seg->list_size && !(seg->segment_count % seg->list_size)) {
249 250
            segment_list_close(s);
            if ((ret = segment_list_open(s)) < 0)
251 252
                goto end;
        }
253 254 255

        if (seg->list_type == LIST_TYPE_FLAT) {
            avio_printf(seg->list_pb, "%s\n", oc->filename);
256
        } else if (seg->list_type == LIST_TYPE_CSV || seg->list_type == LIST_TYPE_EXT) {
257 258
            print_csv_escaped_str(seg->list_pb, oc->filename);
            avio_printf(seg->list_pb, ",%f,%f\n", seg->start_time, seg->end_time);
259 260 261
        } else if (seg->list_type == LIST_TYPE_M3U8) {
            avio_printf(seg->list_pb, "#EXTINF:%f,\n%s\n",
                        seg->end_time - seg->start_time, oc->filename);
262
        }
263
        seg->list_max_segment_time = FFMAX(seg->end_time - seg->start_time, seg->list_max_segment_time);
264
        avio_flush(seg->list_pb);
265 266 267
    }

end:
268 269 270 271 272
    avio_close(oc->pb);

    return ret;
}

273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302
static int parse_times(void *log_ctx, int64_t **times, int *nb_times,
                       const char *times_str)
{
    char *p;
    int i, ret = 0;
    char *times_str1 = av_strdup(times_str);
    char *saveptr = NULL;

    if (!times_str1)
        return AVERROR(ENOMEM);

#define FAIL(err) ret = err; goto end

    *nb_times = 1;
    for (p = times_str1; *p; p++)
        if (*p == ',')
            (*nb_times)++;

    *times = av_malloc(sizeof(**times) * *nb_times);
    if (!*times) {
        av_log(log_ctx, AV_LOG_ERROR, "Could not allocate forced times array\n");
        FAIL(AVERROR(ENOMEM));
    }

    p = times_str1;
    for (i = 0; i < *nb_times; i++) {
        int64_t t;
        char *tstr = av_strtok(p, ",", &saveptr);
        p = NULL;

303 304 305 306 307 308
        if (!tstr || !tstr[0]) {
            av_log(log_ctx, AV_LOG_ERROR, "Empty time specification in times list %s\n",
                   times_str);
            FAIL(AVERROR(EINVAL));
        }

309 310 311
        ret = av_parse_time(&t, tstr, 1);
        if (ret < 0) {
            av_log(log_ctx, AV_LOG_ERROR,
312
                   "Invalid time duration specification '%s' in times list %s\n", tstr, times_str);
313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330
            FAIL(AVERROR(EINVAL));
        }
        (*times)[i] = t;

        /* check on monotonicity */
        if (i && (*times)[i-1] > (*times)[i]) {
            av_log(log_ctx, AV_LOG_ERROR,
                   "Specified time %f is greater than the following time %f\n",
                   (float)((*times)[i])/1000000, (float)((*times)[i-1])/1000000);
            FAIL(AVERROR(EINVAL));
        }
    }

end:
    av_free(times_str1);
    return ret;
}

331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389
static int parse_frames(void *log_ctx, int **frames, int *nb_frames,
                        const char *frames_str)
{
    char *p;
    int i, ret = 0;
    char *frames_str1 = av_strdup(frames_str);
    char *saveptr = NULL;

    if (!frames_str1)
        return AVERROR(ENOMEM);

#define FAIL(err) ret = err; goto end

    *nb_frames = 1;
    for (p = frames_str1; *p; p++)
        if (*p == ',')
            (*nb_frames)++;

    *frames = av_malloc(sizeof(**frames) * *nb_frames);
    if (!*frames) {
        av_log(log_ctx, AV_LOG_ERROR, "Could not allocate forced frames array\n");
        FAIL(AVERROR(ENOMEM));
    }

    p = frames_str1;
    for (i = 0; i < *nb_frames; i++) {
        long int f;
        char *tailptr;
        char *fstr = av_strtok(p, ",", &saveptr);

        p = NULL;
        if (!fstr) {
            av_log(log_ctx, AV_LOG_ERROR, "Empty frame specification in frame list %s\n",
                   frames_str);
            FAIL(AVERROR(EINVAL));
        }
        f = strtol(fstr, &tailptr, 10);
        if (*tailptr || f <= 0 || f >= INT_MAX) {
            av_log(log_ctx, AV_LOG_ERROR,
                   "Invalid argument '%s', must be a positive integer <= INT64_MAX\n",
                   fstr);
            FAIL(AVERROR(EINVAL));
        }
        (*frames)[i] = f;

        /* check on monotonicity */
        if (i && (*frames)[i-1] > (*frames)[i]) {
            av_log(log_ctx, AV_LOG_ERROR,
                   "Specified frame %d is greater than the following frame %d\n",
                   (*frames)[i], (*frames)[i-1]);
            FAIL(AVERROR(EINVAL));
        }
    }

end:
    av_free(frames_str1);
    return ret;
}

390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409
static int open_null_ctx(AVIOContext **ctx)
{
    int buf_size = 32768;
    uint8_t *buf = av_malloc(buf_size);
    if (!buf)
        return AVERROR(ENOMEM);
    *ctx = avio_alloc_context(buf, buf_size, AVIO_FLAG_WRITE, NULL, NULL, NULL, NULL);
    if (!*ctx) {
        av_free(buf);
        return AVERROR(ENOMEM);
    }
    return 0;
}

static void close_null_ctx(AVIOContext *pb)
{
    av_free(pb->buffer);
    av_free(pb);
}

410 411 412
static int seg_write_header(AVFormatContext *s)
{
    SegmentContext *seg = s->priv_data;
413
    AVFormatContext *oc = NULL;
414 415
    int ret, i;

416
    seg->segment_count = 0;
417 418
    if (!seg->write_header_trailer)
        seg->individual_header_trailer = 0;
419

420
    if (!!seg->time_str + !!seg->times_str + !!seg->frames_str > 1) {
421
        av_log(s, AV_LOG_ERROR,
422 423
               "segment_time, segment_times, and segment_frames options "
               "are mutually exclusive, select just one of them\n");
424 425 426
        return AVERROR(EINVAL);
    }

427
    if ((seg->list_flags & SEGMENT_LIST_FLAG_LIVE) && (seg->times_str || seg->frames_str)) {
428
        av_log(s, AV_LOG_ERROR,
429 430
               "segment_flags +live and segment_times or segment_frames options are mutually exclusive: "
               "specify segment_time option if you want a live-friendly list\n");
431 432 433
        return AVERROR(EINVAL);
    }

434 435 436
    if (seg->times_str) {
        if ((ret = parse_times(s, &seg->times, &seg->nb_times, seg->times_str)) < 0)
            return ret;
437 438 439
    } else if (seg->frames_str) {
        if ((ret = parse_frames(s, &seg->frames, &seg->nb_frames, seg->frames_str)) < 0)
            return ret;
440 441 442 443 444 445 446 447 448 449
    } else {
        /* set default value if not specified */
        if (!seg->time_str)
            seg->time_str = av_strdup("2");
        if ((ret = av_parse_time(&seg->time, seg->time_str, 1)) < 0) {
            av_log(s, AV_LOG_ERROR,
                   "Invalid time duration specification '%s' for segment_time option\n",
                   seg->time_str);
            return ret;
        }
450
    }
451

452 453 454 455 456 457 458 459 460
    if (seg->time_delta_str) {
        if ((ret = av_parse_time(&seg->time_delta, seg->time_delta_str, 1)) < 0) {
            av_log(s, AV_LOG_ERROR,
                   "Invalid time duration specification '%s' for delta option\n",
                   seg->time_delta_str);
            return ret;
        }
    }

461 462
    if (seg->list) {
        if (seg->list_type == LIST_TYPE_UNDEFINED) {
463 464
            if      (av_match_ext(seg->list, "csv" )) seg->list_type = LIST_TYPE_CSV;
            else if (av_match_ext(seg->list, "ext" )) seg->list_type = LIST_TYPE_EXT;
465 466 467
            else if (av_match_ext(seg->list, "m3u8")) seg->list_type = LIST_TYPE_M3U8;
            else                                      seg->list_type = LIST_TYPE_FLAT;
        }
468
        if ((ret = segment_list_open(s)) < 0)
469
            goto fail;
470
    }
471 472
    if (seg->list_type == LIST_TYPE_EXT)
        av_log(s, AV_LOG_WARNING, "'ext' list type option is deprecated in favor of 'csv'\n");
473

474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520
    seg->reference_stream_index = -1;
    if (!strcmp(seg->reference_stream_specifier, "auto")) {
        /* select first index of type with highest priority */
        int type_index_map[AVMEDIA_TYPE_NB];
        static const enum AVMediaType type_priority_list[] = {
            AVMEDIA_TYPE_VIDEO,
            AVMEDIA_TYPE_AUDIO,
            AVMEDIA_TYPE_SUBTITLE,
            AVMEDIA_TYPE_DATA,
            AVMEDIA_TYPE_ATTACHMENT
        };
        enum AVMediaType type;

        for (i = 0; i < AVMEDIA_TYPE_NB; i++)
            type_index_map[i] = -1;

        /* select first index for each type */
        for (i = 0; i < s->nb_streams; i++) {
            type = s->streams[i]->codec->codec_type;
            if ((unsigned)type < AVMEDIA_TYPE_NB && type_index_map[type] == -1)
                type_index_map[type] = i;
        }

        for (i = 0; i < FF_ARRAY_ELEMS(type_priority_list); i++) {
            type = type_priority_list[i];
            if ((seg->reference_stream_index = type_index_map[type]) >= 0)
                break;
        }
    } else {
        for (i = 0; i < s->nb_streams; i++) {
            ret = avformat_match_stream_specifier(s, s->streams[i],
                                                  seg->reference_stream_specifier);
            if (ret < 0)
                goto fail;
            if (ret > 0) {
                seg->reference_stream_index = i;
                break;
            }
        }
    }

    if (seg->reference_stream_index < 0) {
        av_log(s, AV_LOG_ERROR, "Could not select stream matching identifier '%s'\n",
               seg->reference_stream_specifier);
        ret = AVERROR(EINVAL);
        goto fail;
    }
521

522 523 524
    av_log(s, AV_LOG_VERBOSE, "Selected stream id:%d type:%s\n",
           seg->reference_stream_index,
           av_get_media_type_string(s->streams[seg->reference_stream_index]->codec->codec_type));
525

526
    seg->oformat = av_guess_format(seg->format, s->filename, NULL);
527

528
    if (!seg->oformat) {
529 530 531
        ret = AVERROR_MUXER_NOT_FOUND;
        goto fail;
    }
532
    if (seg->oformat->flags & AVFMT_NOFILE) {
533
        av_log(s, AV_LOG_ERROR, "format %s not supported.\n",
534
               seg->oformat->name);
535 536 537 538
        ret = AVERROR(EINVAL);
        goto fail;
    }

539 540 541
    if ((ret = segment_mux_init(s)) < 0)
        goto fail;
    oc = seg->avf;
542

543
    if ((ret = set_segment_filename(s)) < 0)
544
        goto fail;
545
    seg->segment_count++;
546

547 548 549 550 551 552 553 554
    if (seg->write_header_trailer) {
        if ((ret = avio_open2(&oc->pb, oc->filename, AVIO_FLAG_WRITE,
                              &s->interrupt_callback, NULL)) < 0)
            goto fail;
    } else {
        if ((ret = open_null_ctx(&oc->pb)) < 0)
            goto fail;
    }
555 556 557 558 559

    if ((ret = avformat_write_header(oc, NULL)) < 0) {
        avio_close(oc->pb);
        goto fail;
    }
560
    seg->is_first_pkt = 1;
561

562 563 564
    if (oc->avoid_negative_ts > 0 && s->avoid_negative_ts < 0)
        s->avoid_negative_ts = 1;

565 566 567 568 569 570 571
    if (!seg->write_header_trailer) {
        close_null_ctx(oc->pb);
        if ((ret = avio_open2(&oc->pb, oc->filename, AVIO_FLAG_WRITE,
                              &s->interrupt_callback, NULL)) < 0)
            goto fail;
    }

572 573 574
fail:
    if (ret) {
        if (seg->list)
575
            segment_list_close(s);
576 577
        if (seg->avf)
            avformat_free_context(seg->avf);
578 579 580 581 582 583 584 585
    }
    return ret;
}

static int seg_write_packet(AVFormatContext *s, AVPacket *pkt)
{
    SegmentContext *seg = s->priv_data;
    AVFormatContext *oc = seg->avf;
586
    AVStream *st = s->streams[pkt->stream_index];
587 588
    int64_t end_pts = INT64_MAX;
    int start_frame = INT_MAX;
589 590
    int ret;

591
    if (seg->times) {
592 593
        end_pts = seg->segment_count <= seg->nb_times ?
            seg->times[seg->segment_count-1] : INT64_MAX;
594 595 596
    } else if (seg->frames) {
        start_frame = seg->segment_count <= seg->nb_frames ?
            seg->frames[seg->segment_count-1] : INT_MAX;
597
    } else {
598
        end_pts = seg->time * seg->segment_count;
599 600
    }

601 602 603 604 605
    av_dlog(s, "packet stream:%d pts:%s pts_time:%s is_key:%d frame:%d\n",
           pkt->stream_index, av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &st->time_base),
           pkt->flags & AV_PKT_FLAG_KEY,
           pkt->stream_index == seg->reference_stream_index ? seg->frame_count : -1);

606
    if (pkt->stream_index == seg->reference_stream_index &&
607 608 609 610 611
        pkt->flags & AV_PKT_FLAG_KEY &&
        (seg->frame_count >= start_frame ||
         (pkt->pts != AV_NOPTS_VALUE &&
          av_compare_ts(pkt->pts, st->time_base,
                        end_pts-seg->time_delta, AV_TIME_BASE_Q) >= 0))) {
612
        ret = segment_end(s, seg->individual_header_trailer);
613 614

        if (!ret)
615
            ret = segment_start(s, seg->individual_header_trailer);
616 617 618 619

        if (ret)
            goto fail;

620 621
        oc = seg->avf;

622
        seg->start_time = (double)pkt->pts * av_q2d(st->time_base);
623 624 625
        seg->start_pts = av_rescale_q(pkt->pts, st->time_base, AV_TIME_BASE_Q);
        seg->start_dts = pkt->dts != AV_NOPTS_VALUE ?
            av_rescale_q(pkt->dts, st->time_base, AV_TIME_BASE_Q) : seg->start_pts;
626 627 628
    } else if (pkt->pts != AV_NOPTS_VALUE) {
        seg->end_time = FFMAX(seg->end_time,
                              (double)(pkt->pts + pkt->duration) * av_q2d(st->time_base));
629 630
    }

631
    if (seg->is_first_pkt) {
632
        av_log(s, AV_LOG_DEBUG, "segment:'%s' starts with packet stream:%d pts:%s pts_time:%s frame:%d\n",
633
               seg->avf->filename, pkt->stream_index,
634
               av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &st->time_base), seg->frame_count);
635 636 637
        seg->is_first_pkt = 0;
    }

638 639 640 641 642 643 644 645 646 647 648 649 650 651 652
    if (seg->reset_timestamps) {
        av_log(s, AV_LOG_DEBUG, "start_pts:%s pts:%s start_dts:%s dts:%s",
               av_ts2timestr(seg->start_pts, &AV_TIME_BASE_Q), av_ts2timestr(pkt->pts, &st->time_base),
               av_ts2timestr(seg->start_dts, &AV_TIME_BASE_Q), av_ts2timestr(pkt->dts, &st->time_base));

        /* compute new timestamps */
        if (pkt->pts != AV_NOPTS_VALUE)
            pkt->pts -= av_rescale_q(seg->start_pts, AV_TIME_BASE_Q, st->time_base);
        if (pkt->dts != AV_NOPTS_VALUE)
            pkt->dts -= av_rescale_q(seg->start_dts, AV_TIME_BASE_Q, st->time_base);

        av_log(s, AV_LOG_DEBUG, " -> pts:%s dts:%s\n",
               av_ts2timestr(pkt->pts, &st->time_base), av_ts2timestr(pkt->dts, &st->time_base));
    }

653
    ret = ff_write_chained(oc, pkt->stream_index, pkt, s);
654 655

fail:
656 657 658
    if (pkt->stream_index == seg->reference_stream_index)
        seg->frame_count++;

659 660
    if (ret < 0) {
        if (seg->list)
661
            avio_close(seg->list_pb);
662 663 664 665 666 667 668 669 670 671
        avformat_free_context(oc);
    }

    return ret;
}

static int seg_write_trailer(struct AVFormatContext *s)
{
    SegmentContext *seg = s->priv_data;
    AVFormatContext *oc = seg->avf;
672 673
    int ret;
    if (!seg->write_header_trailer) {
674
        if ((ret = segment_end(s, 0)) < 0)
675
            goto fail;
676
        open_null_ctx(&oc->pb);
677
        ret = av_write_trailer(oc);
678 679
        close_null_ctx(oc->pb);
    } else {
680
        ret = segment_end(s, 1);
681
    }
682
fail:
683
    if (seg->list)
684
        segment_list_close(s);
685 686

    av_opt_free(seg);
687
    av_freep(&seg->times);
688
    av_freep(&seg->frames);
689

690 691 692 693 694 695 696
    avformat_free_context(oc);
    return ret;
}

#define OFFSET(x) offsetof(SegmentContext, x)
#define E AV_OPT_FLAG_ENCODING_PARAM
static const AVOption options[] = {
697
    { "reference_stream",  "set reference stream", OFFSET(reference_stream_specifier), AV_OPT_TYPE_STRING, {.str = "auto"}, CHAR_MIN, CHAR_MAX, E },
698 699
    { "segment_format",    "set container format used for the segments", OFFSET(format),  AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,       E },
    { "segment_list",      "set the segment list filename",              OFFSET(list),    AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,       E },
700 701 702 703 704

    { "segment_list_flags","set flags affecting segment list generation", OFFSET(list_flags), AV_OPT_TYPE_FLAGS, {.i64 = SEGMENT_LIST_FLAG_CACHE }, 0, UINT_MAX, E, "list_flags"},
    { "cache",             "allow list caching",                                    0, AV_OPT_TYPE_CONST, {.i64 = SEGMENT_LIST_FLAG_CACHE }, INT_MIN, INT_MAX,   E, "list_flags"},
    { "live",              "enable live-friendly list generation (useful for HLS)", 0, AV_OPT_TYPE_CONST, {.i64 = SEGMENT_LIST_FLAG_LIVE }, INT_MIN, INT_MAX,    E, "list_flags"},

705
    { "segment_list_size", "set the maximum number of playlist entries", OFFSET(list_size), AV_OPT_TYPE_INT,  {.i64 = 0},     0, INT_MAX, E },
706

707
    { "segment_list_type", "set the segment list type",                  OFFSET(list_type), AV_OPT_TYPE_INT,  {.i64 = LIST_TYPE_UNDEFINED}, -1, LIST_TYPE_NB-1, E, "list_type" },
708 709 710 711 712 713
    { "flat", "flat format",     0, AV_OPT_TYPE_CONST, {.i64=LIST_TYPE_FLAT }, INT_MIN, INT_MAX, E, "list_type" },
    { "csv",  "csv format",      0, AV_OPT_TYPE_CONST, {.i64=LIST_TYPE_CSV  }, INT_MIN, INT_MAX, E, "list_type" },
    { "ext",  "extended format", 0, AV_OPT_TYPE_CONST, {.i64=LIST_TYPE_EXT  }, INT_MIN, INT_MAX, E, "list_type" },
    { "m3u8", "M3U8 format",     0, AV_OPT_TYPE_CONST, {.i64=LIST_TYPE_M3U8 }, INT_MIN, INT_MAX, E, "list_type" },
    { "hls", "Apple HTTP Live Streaming compatible", 0, AV_OPT_TYPE_CONST, {.i64=LIST_TYPE_M3U8 }, INT_MIN, INT_MAX, E, "list_type" },

714
    { "segment_time",      "set segment duration",                       OFFSET(time_str),AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,       E },
715
    { "segment_time_delta","set approximation value used for the segment times", OFFSET(time_delta_str), AV_OPT_TYPE_STRING, {.str = "0"}, 0, 0, E },
716
    { "segment_times",     "set segment split time points",              OFFSET(times_str),AV_OPT_TYPE_STRING,{.str = NULL},  0, 0,       E },
717
    { "segment_frames",    "set segment split frame numbers",            OFFSET(frames_str),AV_OPT_TYPE_STRING,{.str = NULL},  0, 0,       E },
718
    { "segment_wrap",      "set number after which the index wraps",     OFFSET(segment_idx_wrap), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, E },
719
    { "segment_start_number", "set the sequence number of the first segment", OFFSET(segment_idx), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, E },
720

721
    { "individual_header_trailer", "write header/trailer to each segment", OFFSET(individual_header_trailer), AV_OPT_TYPE_INT, {.i64 = 1}, 0, 1, E },
722
    { "write_header_trailer", "write a header to the first segment and a trailer to the last one", OFFSET(write_header_trailer), AV_OPT_TYPE_INT, {.i64 = 1}, 0, 1, E },
723
    { "reset_timestamps", "reset timestamps at the begin of each segment", OFFSET(reset_timestamps), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, E },
724 725 726 727 728 729 730 731 732 733 734 735
    { NULL },
};

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

AVOutputFormat ff_segment_muxer = {
    .name           = "segment",
736
    .long_name      = NULL_IF_CONFIG_SMALL("segment"),
737
    .priv_data_size = sizeof(SegmentContext),
738
    .flags          = AVFMT_NOFILE|AVFMT_GLOBALHEADER,
739 740 741 742 743
    .write_header   = seg_write_header,
    .write_packet   = seg_write_packet,
    .write_trailer  = seg_write_trailer,
    .priv_class     = &seg_class,
};
744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761

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

AVOutputFormat ff_stream_segment_muxer = {
    .name           = "stream_segment,ssegment",
    .long_name      = NULL_IF_CONFIG_SMALL("streaming segment muxer"),
    .priv_data_size = sizeof(SegmentContext),
    .flags          = AVFMT_NOFILE,
    .write_header   = seg_write_header,
    .write_packet   = seg_write_packet,
    .write_trailer  = seg_write_trailer,
    .priv_class     = &sseg_class,
};