X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavformat%2Fsegment.c;h=744c14799044312a192579f94861c40658fde169;hb=18b0c39f99eee508107c47345494e535b8757434;hp=a6ddf9017a26e9c1868cd3d05e9f5e7bf4c5e1ab;hpb=aa1cceb5eb7866d42d05ce22d97b06c620af18cb;p=ffmpeg diff --git a/libavformat/segment.c b/libavformat/segment.c index a6ddf9017a2..744c1479904 100644 --- a/libavformat/segment.c +++ b/libavformat/segment.c @@ -24,25 +24,38 @@ #include "avformat.h" #include "internal.h" +#include "libavutil/avassert.h" #include "libavutil/log.h" #include "libavutil/opt.h" #include "libavutil/avstring.h" #include "libavutil/parseutils.h" #include "libavutil/mathematics.h" +typedef enum { + LIST_TYPE_FLAT = 0, + LIST_TYPE_EXT, + LIST_TYPE_NB, +} ListType; + typedef struct { const AVClass *class; /**< Class for private options. */ int number; AVFormatContext *avf; - char *format; /**< Set by a private option. */ - char *list; /**< Set by a private option. */ - int list_size; /**< Set by a private option. */ - float time; /**< Set by a private option. */ - int wrap; /**< Set by a private option. */ - int64_t offset_time; - int64_t recording_time; + char *format; ///< format to use for output segment files + char *list; ///< filename for the segment list file + int list_size; ///< number of entries for the segment list file + ListType list_type; ///< set the list type + AVIOContext *list_pb; ///< list file put-byte context + int wrap; ///< number after which the index wraps + char *time_str; ///< segment duration specification string + int64_t time; ///< segment duration + 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 + char *time_delta_str; ///< approximation value duration used for the segment times + int64_t time_delta; int has_video; - AVIOContext *pb; + double start_time, end_time; } SegmentContext; static int segment_start(AVFormatContext *s) @@ -55,8 +68,10 @@ static int segment_start(AVFormatContext *s) seg->number %= seg->wrap; if (av_get_frame_filename(oc->filename, sizeof(oc->filename), - s->filename, seg->number++) < 0) + s->filename, seg->number++) < 0) { + av_log(oc, AV_LOG_ERROR, "Invalid segment filename template '%s'\n", s->filename); return AVERROR(EINVAL); + } if ((err = avio_open2(&oc->pb, oc->filename, AVIO_FLAG_WRITE, &s->interrupt_callback, NULL)) < 0) @@ -102,6 +117,23 @@ static int segment_end(AVFormatContext *s) av_log(s, AV_LOG_ERROR, "Failure occurred when ending segment '%s'\n", oc->filename); + if (seg->list) { + if (seg->list_size && !(seg->number % seg->list_size)) { + avio_close(seg->list_pb); + if ((ret = avio_open2(&seg->list_pb, seg->list, AVIO_FLAG_WRITE, + &s->interrupt_callback, NULL)) < 0) + goto end; + } + + if (seg->list_type == LIST_TYPE_FLAT) { + avio_printf(seg->list_pb, "%s\n", oc->filename); + } else if (seg->list_type == LIST_TYPE_EXT) { + avio_printf(seg->list_pb, "%s,%f,%f\n", oc->filename, seg->start_time, seg->end_time); + } + avio_flush(seg->list_pb); + } + +end: avio_close(oc->pb); if (oc->oformat->priv_class) av_opt_free(oc->priv_data); @@ -110,6 +142,59 @@ static int segment_end(AVFormatContext *s) return ret; } +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); + av_assert0(tstr); + p = NULL; + + ret = av_parse_time(&t, tstr, 1); + if (ret < 0) { + av_log(log_ctx, AV_LOG_ERROR, + "Invalid time duration specification in %s\n", p); + 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; +} + static int seg_write_header(AVFormatContext *s) { SegmentContext *seg = s->priv_data; @@ -117,8 +202,36 @@ static int seg_write_header(AVFormatContext *s) int ret, i; seg->number = 0; - seg->offset_time = 0; - seg->recording_time = seg->time * 1000000; + + if (seg->time_str && seg->times_str) { + av_log(s, AV_LOG_ERROR, + "segment_time and segment_times options are mutually exclusive, select just one of them\n"); + return AVERROR(EINVAL); + } + + if (seg->times_str) { + if ((ret = parse_times(s, &seg->times, &seg->nb_times, seg->times_str)) < 0) + return ret; + } 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; + } + } + + 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; + } + } oc = avformat_alloc_context(); @@ -126,7 +239,7 @@ static int seg_write_header(AVFormatContext *s) return AVERROR(ENOMEM); if (seg->list) - if ((ret = avio_open2(&seg->pb, seg->list, AVIO_FLAG_WRITE, + if ((ret = avio_open2(&seg->list_pb, seg->list, AVIO_FLAG_WRITE, &s->interrupt_callback, NULL)) < 0) goto fail; @@ -172,11 +285,6 @@ static int seg_write_header(AVFormatContext *s) goto fail; } - if (seg->list) { - avio_printf(seg->pb, "%s\n", oc->filename); - avio_flush(seg->pb); - } - fail: if (ret) { if (oc) { @@ -185,7 +293,7 @@ fail: avformat_free_context(oc); } if (seg->list) - avio_close(seg->pb); + avio_close(seg->list_pb); } return ret; } @@ -195,35 +303,30 @@ static int seg_write_packet(AVFormatContext *s, AVPacket *pkt) SegmentContext *seg = s->priv_data; AVFormatContext *oc = seg->avf; AVStream *st = oc->streams[pkt->stream_index]; - int64_t end_pts = seg->recording_time * seg->number; + int64_t end_pts; int ret; - if ((seg->has_video && st->codec->codec_type == AVMEDIA_TYPE_VIDEO) && + if (seg->times) { + end_pts = seg->number <= seg->nb_times ? seg->times[seg->number-1] : INT64_MAX; + } else { + end_pts = seg->time * seg->number; + } + + /* if the segment has video, start a new segment *only* with a key video frame */ + if ((st->codec->codec_type == AVMEDIA_TYPE_VIDEO || !seg->has_video) && av_compare_ts(pkt->pts, st->time_base, - end_pts, AV_TIME_BASE_Q) >= 0 && + end_pts-seg->time_delta, AV_TIME_BASE_Q) >= 0 && pkt->flags & AV_PKT_FLAG_KEY) { - av_log(s, AV_LOG_DEBUG, "Next segment starts at %d %"PRId64"\n", - pkt->stream_index, pkt->pts); - - ret = segment_end(s); + av_log(s, AV_LOG_DEBUG, "Next segment starts with packet stream:%d pts:%"PRId64" pts_time:%f\n", + pkt->stream_index, pkt->pts, pkt->pts * av_q2d(st->time_base)); - if (!ret) - ret = segment_start(s); - - if (ret) + if ((ret = segment_end(s)) < 0 || (ret = segment_start(s)) < 0) goto fail; - - if (seg->list) { - avio_printf(seg->pb, "%s\n", oc->filename); - avio_flush(seg->pb); - if (seg->list_size && !(seg->number % seg->list_size)) { - avio_close(seg->pb); - if ((ret = avio_open2(&seg->pb, seg->list, AVIO_FLAG_WRITE, - &s->interrupt_callback, NULL)) < 0) - goto fail; - } - } + seg->start_time = (double)pkt->pts * av_q2d(st->time_base); + } else if (pkt->pts != AV_NOPTS_VALUE) { + seg->end_time = FFMAX(seg->end_time, + (double)(pkt->pts + pkt->duration) * av_q2d(st->time_base)); } ret = oc->oformat->write_packet(oc, pkt); @@ -233,7 +336,7 @@ fail: oc->streams = NULL; oc->nb_streams = 0; if (seg->list) - avio_close(seg->pb); + avio_close(seg->list_pb); avformat_free_context(oc); } @@ -246,7 +349,11 @@ static int seg_write_trailer(struct AVFormatContext *s) AVFormatContext *oc = seg->avf; int ret = segment_end(s); if (seg->list) - avio_close(seg->pb); + avio_close(seg->list_pb); + + av_opt_free(seg); + av_freep(&seg->times); + oc->streams = NULL; oc->nb_streams = 0; avformat_free_context(oc); @@ -256,11 +363,16 @@ static int seg_write_trailer(struct AVFormatContext *s) #define OFFSET(x) offsetof(SegmentContext, x) #define E AV_OPT_FLAG_ENCODING_PARAM static const AVOption options[] = { - { "segment_format", "container format used for the segments", OFFSET(format), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E }, - { "segment_time", "segment length in seconds", OFFSET(time), AV_OPT_TYPE_FLOAT, {.dbl = 2}, 0, FLT_MAX, E }, - { "segment_list", "output the segment list", OFFSET(list), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E }, - { "segment_list_size", "maximum number of playlist entries", OFFSET(list_size), AV_OPT_TYPE_INT, {.dbl = 5}, 0, INT_MAX, E }, - { "segment_wrap", "number after which the index wraps", OFFSET(wrap), AV_OPT_TYPE_INT, {.dbl = 0}, 0, INT_MAX, E }, + { "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 }, + { "segment_list_size", "set the maximum number of playlist entries", OFFSET(list_size), AV_OPT_TYPE_INT, {.dbl = 5}, 0, INT_MAX, E }, + { "segment_list_type", "set the segment list type", OFFSET(list_type), AV_OPT_TYPE_INT, {.dbl = LIST_TYPE_FLAT}, 0, LIST_TYPE_NB-1, E, "list_type" }, + { "flat", "flat format", 0, AV_OPT_TYPE_CONST, {.dbl=LIST_TYPE_FLAT }, INT_MIN, INT_MAX, 0, "list_type" }, + { "ext", "extended format", 0, AV_OPT_TYPE_CONST, {.dbl=LIST_TYPE_EXT }, INT_MIN, INT_MAX, 0, "list_type" }, + { "segment_time", "set segment duration", OFFSET(time_str),AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E }, + { "segment_time_delta","set approximation value used for the segment times", OFFSET(time_delta_str), AV_OPT_TYPE_STRING, {.str = "0"}, 0, 0, E }, + { "segment_times", "set segment split time points", OFFSET(times_str),AV_OPT_TYPE_STRING,{.str = NULL}, 0, 0, E }, + { "segment_wrap", "set number after which the index wraps", OFFSET(wrap), AV_OPT_TYPE_INT, {.dbl = 0}, 0, INT_MAX, E }, { NULL }, }; @@ -273,7 +385,7 @@ static const AVClass seg_class = { AVOutputFormat ff_segment_muxer = { .name = "segment", - .long_name = NULL_IF_CONFIG_SMALL("segment muxer"), + .long_name = NULL_IF_CONFIG_SMALL("segment"), .priv_data_size = sizeof(SegmentContext), .flags = AVFMT_GLOBALHEADER | AVFMT_NOFILE, .write_header = seg_write_header,