git.sesse.net Git - ffmpeg/blob - libavformat/segment.c

   1 /*
   2  * Generic segmenter
   3  * Copyright (c) 2011, Luca Barbato
   4  *
   5  * This file is part of Libav.
   6  *
   7  * Libav is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * Libav is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with Libav; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include <float.h>
  23
  24 #include "avformat.h"
  25 #include "internal.h"
  26
  27 #include "libavutil/log.h"
  28 #include "libavutil/opt.h"
  29 #include "libavutil/avstring.h"
  30 #include "libavutil/parseutils.h"
  31 #include "libavutil/mathematics.h"
  32
  33 typedef struct {
  34     const AVClass *class;  /**< Class for private options. */
  35     int number;
  36     AVOutputFormat *oformat;
  37     AVFormatContext *avf;
  38     char *format;          /**< Set by a private option. */
  39     char *list;            /**< Set by a private option. */
  40     char *entry_prefix;    /**< Set by a private option. */
  41     int  list_type;        /**< Set by a private option. */
  42     float time;            /**< Set by a private option. */
  43     int  size;             /**< Set by a private option. */
  44     int  wrap;             /**< Set by a private option. */
  45     int  individual_header_trailer; /**< Set by a private option. */
  46     int  write_header_trailer; /**< Set by a private option. */
  47     int64_t offset_time;
  48     int64_t recording_time;
  49     int has_video;
  50     AVIOContext *pb;
  51 } SegmentContext;
  52
  53 enum {
  54     LIST_FLAT,
  55     LIST_HLS
  56 };
  57
  58 static int segment_mux_init(AVFormatContext *s)
  59 {
  60     SegmentContext *seg = s->priv_data;
  61     AVFormatContext *oc;
  62     int i;
  63
  64     seg->avf = oc = avformat_alloc_context();
  65     if (!oc)
  66         return AVERROR(ENOMEM);
  67
  68     oc->oformat            = seg->oformat;
  69     oc->interrupt_callback = s->interrupt_callback;
  70
  71     for (i = 0; i < s->nb_streams; i++) {
  72         AVStream *st;
  73         if (!(st = avformat_new_stream(oc, NULL)))
  74             return AVERROR(ENOMEM);
  75         avcodec_copy_context(st->codec, s->streams[i]->codec);
  76         st->sample_aspect_ratio = s->streams[i]->sample_aspect_ratio;
  77         st->time_base = s->streams[i]->time_base;
  78     }
  79
  80     return 0;
  81 }
  82
  83 static int segment_hls_window(AVFormatContext *s, int last)
  84 {
  85     SegmentContext *seg = s->priv_data;
  86     int i, ret = 0;
  87     char buf[1024];
  88
  89     if ((ret = avio_open2(&seg->pb, seg->list, AVIO_FLAG_WRITE,
  90                               &s->interrupt_callback, NULL)) < 0)
  91         goto fail;
  92
  93     avio_printf(seg->pb, "#EXTM3U\n");
  94     avio_printf(seg->pb, "#EXT-X-VERSION:3\n");
  95     avio_printf(seg->pb, "#EXT-X-TARGETDURATION:%d\n", (int)seg->time);
  96     avio_printf(seg->pb, "#EXT-X-MEDIA-SEQUENCE:%d\n",
  97                 FFMAX(0, seg->number - seg->size));
  98
  99     av_log(s, AV_LOG_VERBOSE, "EXT-X-MEDIA-SEQUENCE:%d\n",
 100            FFMAX(0, seg->number - seg->size));
 101
 102     for (i = FFMAX(0, seg->number - seg->size);
 103          i < seg->number; i++) {
 104         avio_printf(seg->pb, "#EXTINF:%d,\n", (int)seg->time);
 105         if (seg->entry_prefix) {
 106             avio_printf(seg->pb, "%s", seg->entry_prefix);
 107         }
 108         av_get_frame_filename(buf, sizeof(buf), s->filename, i);
 109         avio_printf(seg->pb, "%s\n", buf);
 110     }
 111
 112     if (last)
 113         avio_printf(seg->pb, "#EXT-X-ENDLIST\n");
 114 fail:
 115     avio_closep(&seg->pb);
 116     return ret;
 117 }
 118
 119 static int segment_start(AVFormatContext *s, int write_header)
 120 {
 121     SegmentContext *c = s->priv_data;
 122     AVFormatContext *oc = c->avf;
 123     int err = 0;
 124
 125     if (write_header) {
 126         avformat_free_context(oc);
 127         c->avf = NULL;
 128         if ((err = segment_mux_init(s)) < 0)
 129             return err;
 130         oc = c->avf;
 131     }
 132
 133     if (c->wrap)
 134         c->number %= c->wrap;
 135
 136     if (av_get_frame_filename(oc->filename, sizeof(oc->filename),
 137                               s->filename, c->number++) < 0)
 138         return AVERROR(EINVAL);
 139
 140     if ((err = avio_open2(&oc->pb, oc->filename, AVIO_FLAG_WRITE,
 141                           &s->interrupt_callback, NULL)) < 0)
 142         return err;
 143
 144     if (oc->oformat->priv_class && oc->priv_data)
 145         av_opt_set(oc->priv_data, "resend_headers", "1", 0); /* mpegts specific */
 146
 147     if (write_header) {
 148         if ((err = avformat_write_header(oc, NULL)) < 0)
 149             return err;
 150     }
 151
 152     return 0;
 153 }
 154
 155 static int segment_end(AVFormatContext *oc, int write_trailer)
 156 {
 157     int ret = 0;
 158
 159     av_write_frame(oc, NULL); /* Flush any buffered data (fragmented mp4) */
 160     if (write_trailer)
 161         av_write_trailer(oc);
 162     avio_close(oc->pb);
 163
 164     return ret;
 165 }
 166
 167 static int open_null_ctx(AVIOContext **ctx)
 168 {
 169     int buf_size = 32768;
 170     uint8_t *buf = av_malloc(buf_size);
 171     if (!buf)
 172         return AVERROR(ENOMEM);
 173     *ctx = avio_alloc_context(buf, buf_size, AVIO_FLAG_WRITE, NULL, NULL, NULL, NULL);
 174     if (!*ctx) {
 175         av_free(buf);
 176         return AVERROR(ENOMEM);
 177     }
 178     return 0;
 179 }
 180
 181 static void close_null_ctx(AVIOContext *pb)
 182 {
 183     av_free(pb->buffer);
 184     av_free(pb);
 185 }
 186
 187 static int seg_write_header(AVFormatContext *s)
 188 {
 189     SegmentContext *seg = s->priv_data;
 190     AVFormatContext *oc = NULL;
 191     int ret, i;
 192
 193     seg->number = 0;
 194     seg->offset_time = 0;
 195     seg->recording_time = seg->time * 1000000;
 196     if (!seg->write_header_trailer)
 197         seg->individual_header_trailer = 0;
 198
 199     if (seg->list && seg->list_type != LIST_HLS)
 200         if ((ret = avio_open2(&seg->pb, seg->list, AVIO_FLAG_WRITE,
 201                               &s->interrupt_callback, NULL)) < 0)
 202             goto fail;
 203
 204     for (i = 0; i < s->nb_streams; i++)
 205         seg->has_video +=
 206             (s->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO);
 207
 208     if (seg->has_video > 1)
 209         av_log(s, AV_LOG_WARNING,
 210                "More than a single video stream present, "
 211                "expect issues decoding it.\n");
 212
 213     seg->oformat = av_guess_format(seg->format, s->filename, NULL);
 214
 215     if (!seg->oformat) {
 216         ret = AVERROR_MUXER_NOT_FOUND;
 217         goto fail;
 218     }
 219     if (seg->oformat->flags & AVFMT_NOFILE) {
 220         av_log(s, AV_LOG_ERROR, "format %s not supported.\n",
 221                seg->oformat->name);
 222         ret = AVERROR(EINVAL);
 223         goto fail;
 224     }
 225
 226     if ((ret = segment_mux_init(s)) < 0)
 227         goto fail;
 228     oc = seg->avf;
 229
 230     if (av_get_frame_filename(oc->filename, sizeof(oc->filename),
 231                               s->filename, seg->number++) < 0) {
 232         ret = AVERROR(EINVAL);
 233         goto fail;
 234     }
 235
 236     if (seg->write_header_trailer) {
 237         if ((ret = avio_open2(&oc->pb, oc->filename, AVIO_FLAG_WRITE,
 238                               &s->interrupt_callback, NULL)) < 0)
 239             goto fail;
 240     } else {
 241         if ((ret = open_null_ctx(&oc->pb)) < 0)
 242             goto fail;
 243     }
 244
 245     if ((ret = avformat_write_header(oc, NULL)) < 0) {
 246         avio_close(oc->pb);
 247         goto fail;
 248     }
 249
 250     if (!seg->write_header_trailer) {
 251         close_null_ctx(oc->pb);
 252         if ((ret = avio_open2(&oc->pb, oc->filename, AVIO_FLAG_WRITE,
 253                               &s->interrupt_callback, NULL)) < 0)
 254             goto fail;
 255     }
 256
 257     if (seg->list) {
 258         if (seg->list_type == LIST_HLS) {
 259             if ((ret = segment_hls_window(s, 0)) < 0)
 260                 goto fail;
 261         } else {
 262             avio_printf(seg->pb, "%s\n", oc->filename);
 263             avio_flush(seg->pb);
 264         }
 265     }
 266
 267 fail:
 268     if (ret) {
 269         if (seg->list)
 270             avio_close(seg->pb);
 271         if (seg->avf)
 272             avformat_free_context(seg->avf);
 273     }
 274     return ret;
 275 }
 276
 277 static int seg_write_packet(AVFormatContext *s, AVPacket *pkt)
 278 {
 279     SegmentContext *seg = s->priv_data;
 280     AVFormatContext *oc = seg->avf;
 281     AVStream *st = s->streams[pkt->stream_index];
 282     int64_t end_pts = seg->recording_time * seg->number;
 283     int ret, can_split = 1;
 284
 285     if (seg->has_video) {
 286         can_split = st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
 287                     pkt->flags & AV_PKT_FLAG_KEY;
 288     }
 289
 290     if (can_split && av_compare_ts(pkt->pts, st->time_base, end_pts,
 291                                    AV_TIME_BASE_Q) >= 0) {
 292         av_log(s, AV_LOG_DEBUG, "Next segment starts at %d %"PRId64"\n",
 293                pkt->stream_index, pkt->pts);
 294
 295         ret = segment_end(oc, seg->individual_header_trailer);
 296
 297         if (!ret)
 298             ret = segment_start(s, seg->individual_header_trailer);
 299
 300         if (ret)
 301             goto fail;
 302
 303         oc = seg->avf;
 304
 305         if (seg->list) {
 306             if (seg->list_type == LIST_HLS) {
 307                 if ((ret = segment_hls_window(s, 0)) < 0)
 308                     goto fail;
 309             } else {
 310                 avio_printf(seg->pb, "%s\n", oc->filename);
 311                 avio_flush(seg->pb);
 312                 if (seg->size && !(seg->number % seg->size)) {
 313                     avio_closep(&seg->pb);
 314                     if ((ret = avio_open2(&seg->pb, seg->list, AVIO_FLAG_WRITE,
 315                                           &s->interrupt_callback, NULL)) < 0)
 316                         goto fail;
 317                 }
 318             }
 319         }
 320     }
 321
 322     ret = ff_write_chained(oc, pkt->stream_index, pkt, s);
 323
 324 fail:
 325     if (ret < 0) {
 326         if (seg->list)
 327             avio_close(seg->pb);
 328         avformat_free_context(oc);
 329     }
 330
 331     return ret;
 332 }
 333
 334 static int seg_write_trailer(struct AVFormatContext *s)
 335 {
 336     SegmentContext *seg = s->priv_data;
 337     AVFormatContext *oc = seg->avf;
 338     int ret;
 339     if (!seg->write_header_trailer) {
 340         if ((ret = segment_end(oc, 0)) < 0)
 341             goto fail;
 342         open_null_ctx(&oc->pb);
 343         ret = av_write_trailer(oc);
 344         close_null_ctx(oc->pb);
 345     } else {
 346         ret = segment_end(oc, 1);
 347     }
 348
 349     if (ret < 0)
 350         goto fail;
 351
 352     if (seg->list && seg->list_type == LIST_HLS) {
 353         if ((ret = segment_hls_window(s, 1) < 0))
 354             goto fail;
 355     }
 356
 357 fail:
 358     avio_close(seg->pb);
 359     avformat_free_context(oc);
 360     return ret;
 361 }
 362
 363 #define OFFSET(x) offsetof(SegmentContext, x)
 364 #define E AV_OPT_FLAG_ENCODING_PARAM
 365 static const AVOption options[] = {
 366     { "segment_format",    "container format used for the segments",  OFFSET(format),  AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,       E },
 367     { "segment_time",      "segment length in seconds",               OFFSET(time),    AV_OPT_TYPE_FLOAT,  {.dbl = 2},     0, FLT_MAX, E },
 368     { "segment_list",      "output the segment list",                 OFFSET(list),    AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,       E },
 369     { "segment_list_size", "maximum number of playlist entries",      OFFSET(size),    AV_OPT_TYPE_INT,    {.i64 = 5},     0, INT_MAX, E },
 370     { "segment_list_type", "segment list format",                     OFFSET(list_type),    AV_OPT_TYPE_INT,    {.i64 = LIST_FLAT},     0, 2, E, "list_type" },
 371     {   "flat",            "plain list (default)",                    0,               AV_OPT_TYPE_CONST,  {.i64 = LIST_FLAT}, 0, 0, E, "list_type" },
 372     {   "hls",             "Apple HTTP Live Streaming compatible",    0,               AV_OPT_TYPE_CONST,  {.i64 = LIST_HLS},  0, 0, E, "list_type" },
 373     { "segment_wrap",      "number after which the index wraps",      OFFSET(wrap),    AV_OPT_TYPE_INT,    {.i64 = 0},     0, INT_MAX, E },
 374     { "segment_list_entry_prefix",  "base url prefix for segments",   OFFSET(entry_prefix), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,       E },
 375     { "individual_header_trailer", "write header/trailer to each segment", OFFSET(individual_header_trailer), AV_OPT_TYPE_INT, {.i64 = 1}, 0, 1, E },
 376     { "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 },
 377     { NULL },
 378 };
 379
 380 static const AVClass seg_class = {
 381     .class_name = "segment muxer",
 382     .item_name  = av_default_item_name,
 383     .option     = options,
 384     .version    = LIBAVUTIL_VERSION_INT,
 385 };
 386
 387
 388 AVOutputFormat ff_segment_muxer = {
 389     .name           = "segment",
 390     .long_name      = NULL_IF_CONFIG_SMALL("segment"),
 391     .priv_data_size = sizeof(SegmentContext),
 392     .flags          = AVFMT_NOFILE,
 393     .write_header   = seg_write_header,
 394     .write_packet   = seg_write_packet,
 395     .write_trailer  = seg_write_trailer,
 396     .priv_class     = &seg_class,
 397 };