From c94e2e85cb6af8a570d8542a830556243bd32873 Mon Sep 17 00:00:00 2001 From: Luca Barbato Date: Thu, 6 Mar 2014 17:58:34 +0100 Subject: [PATCH] nut: Support experimental NUT 4 features Add the low overhead pipe mode and the extended broadcast mode. Export the options as 'syncponts' since it impacts only that. Signed-off-by: Luca Barbato --- doc/muxers.texi | 17 +++++++++++++++++ doc/nut.texi | 21 +++++++++++++++++++++ libavformat/nut.h | 9 ++++++++- libavformat/nutdec.c | 29 +++++++++++++++++++++++----- libavformat/nutenc.c | 45 +++++++++++++++++++++++++++++++++++++++++--- 5 files changed, 112 insertions(+), 9 deletions(-) diff --git a/doc/muxers.texi b/doc/muxers.texi index e1c0383eac..2d1f53ccde 100644 --- a/doc/muxers.texi +++ b/doc/muxers.texi @@ -444,6 +444,23 @@ Alternatively you can write the command as: avconv -benchmark -i INPUT -f null - @end example +@section nut + +@table @option +@item -syncpoints @var{flags} +Change the syncpoint usage in nut: +@table @option +@item @var{default} use the normal low-overhead seeking aids. +@item @var{none} do not use the syncpoints at all, reducing the overhead but making the stream non-seekable; +@item @var{timestamped} extend the syncpoint with a wallclock field. +@end table +The @var{none} and @var{timestamped} flags are experimental. +@end table + +@example +avconv -i INPUT -f_strict experimental -syncpoints none - | processor +@end example + @section ogg Ogg container muxer. diff --git a/doc/nut.texi b/doc/nut.texi index 39a22ff3ea..042c88a3ab 100644 --- a/doc/nut.texi +++ b/doc/nut.texi @@ -17,6 +17,27 @@ subtitle and user-defined streams in a simple, yet efficient, way. It was created by a group of FFmpeg and MPlayer developers in 2003 and was finalized in 2008. +@chapter Modes +NUT has some variants signaled by using the flags field in its main header. + +@multitable @columnfractions .4 .4 +@item BROADCAST @tab Extend the syncpoint to report the sender wallclock +@item PIPE @tab Omit completely the syncpoint +@end multitable + +@section BROADCAST + +The BROADCAST variant provides a secondary time reference to facilitate +detecting endpoint latency and network delays. +It assumes all the endpoint clocks are syncronized. +To be used in real-time scenarios. + +@section PIPE + +The PIPE variant assumes NUT is used as non-seekable intermediate container, +by not using syncpoint removes unneeded overhead and reduces the overall +memory usage. + @chapter Container-specific codec tags @section Generic raw YUVA formats diff --git a/libavformat/nut.h b/libavformat/nut.h index 6357b3d2b1..16f3c123a1 100644 --- a/libavformat/nut.h +++ b/libavformat/nut.h @@ -36,7 +36,9 @@ #define MAX_DISTANCE (1024*32-1) -#define NUT_VERSION 3 +#define NUT_MAX_VERSION 4 +#define NUT_STABLE_VERSION 3 +#define NUT_MIN_VERSION 2 typedef enum{ FLAG_KEY = 1, /// NUT_VERSION) { + nut->version = ffio_read_varlen(bc); + if (tmp < NUT_MIN_VERSION && tmp > NUT_MAX_VERSION) { av_log(s, AV_LOG_ERROR, "Version %"PRId64" not supported.\n", tmp); return AVERROR(ENOSYS); @@ -320,6 +320,11 @@ static int decode_main_header(NUTContext *nut) assert(nut->header_len[0] == 0); } + // flags had been effectively introduced in version 4 + if (nut->version > NUT_STABLE_VERSION) { + nut->flags = ffio_read_varlen(bc); + } + if (skip_reserved(bc, end) || ffio_get_checksum(bc)) { av_log(s, AV_LOG_ERROR, "main header checksum mismatch\n"); return AVERROR_INVALIDDATA; @@ -547,6 +552,14 @@ static int decode_syncpoint(NUTContext *nut, int64_t *ts, int64_t *back_ptr) ff_nut_reset_ts(nut, nut->time_base[tmp % nut->time_base_count], tmp / nut->time_base_count); + if (nut->flags & NUT_BROADCAST) { + tmp = ffio_read_varlen(bc); + av_log(s, AV_LOG_VERBOSE, "Syncpoint wallclock %"PRId64"\n", + av_rescale_q(tmp / nut->time_base_count, + nut->time_base[tmp % nut->time_base_count], + AV_TIME_BASE_Q)); + } + if (skip_reserved(bc, end) || ffio_get_checksum(bc)) { av_log(s, AV_LOG_ERROR, "sync point checksum mismatch\n"); return AVERROR_INVALIDDATA; @@ -728,7 +741,8 @@ static int decode_frame_header(NUTContext *nut, int64_t *pts, int *stream_id, int size, flags, size_mul, pts_delta, i, reserved_count; uint64_t tmp; - if (avio_tell(bc) > nut->last_syncpoint_pos + nut->max_distance) { + if (!(nut->flags & NUT_PIPE) && + avio_tell(bc) > nut->last_syncpoint_pos + nut->max_distance) { av_log(s, AV_LOG_ERROR, "Last frame must have been damaged %"PRId64" > %"PRId64" + %d\n", avio_tell(bc), nut->last_syncpoint_pos, nut->max_distance); @@ -781,8 +795,9 @@ static int decode_frame_header(NUTContext *nut, int64_t *pts, int *stream_id, if (flags & FLAG_CHECKSUM) { avio_rb32(bc); // FIXME check this - } else if (size > 2 * nut->max_distance || FFABS(stc->last_pts - *pts) > - stc->max_pts_distance) { + } else if (!(nut->flags & NUT_PIPE) && + size > 2 * nut->max_distance || + FFABS(stc->last_pts - *pts) > stc->max_pts_distance) { av_log(s, AV_LOG_ERROR, "frame size > 2max_distance and no checksum\n"); return AVERROR_INVALIDDATA; } @@ -933,6 +948,10 @@ static int read_seek(AVFormatContext *s, int stream_index, int64_t pos, pos2, ts; int i; + if (nut->flags & NUT_PIPE) { + return AVERROR(ENOSYS); + } + if (st->index_entries) { int index = av_index_search_timestamp(st, pts, flags); if (index < 0) diff --git a/libavformat/nutenc.c b/libavformat/nutenc.c index 2d3862d9e2..0c06c8bc74 100644 --- a/libavformat/nutenc.c +++ b/libavformat/nutenc.c @@ -25,6 +25,8 @@ #include "libavutil/mathematics.h" #include "libavutil/tree.h" #include "libavutil/dict.h" +#include "libavutil/time.h" +#include "libavutil/opt.h" #include "libavcodec/mpegaudiodata.h" #include "nut.h" #include "internal.h" @@ -325,7 +327,7 @@ static void write_mainheader(NUTContext *nut, AVIOContext *bc) tmp_head_idx; int64_t tmp_match; - ff_put_v(bc, NUT_VERSION); + ff_put_v(bc, nut->version); ff_put_v(bc, nut->avf->nb_streams); ff_put_v(bc, nut->max_distance); ff_put_v(bc, nut->time_base_count); @@ -405,6 +407,9 @@ static void write_mainheader(NUTContext *nut, AVIOContext *bc) ff_put_v(bc, nut->header_len[i]); avio_write(bc, nut->header[i], nut->header_len[i]); } + // flags had been effectively introduced in version 4 + if (nut->version > NUT_STABLE_VERSION) + ff_put_v(bc, nut->flags); } static int write_streamheader(AVFormatContext *avctx, AVIOContext *bc, @@ -643,6 +648,16 @@ static int nut_write_header(AVFormatContext *s) nut->avf = s; + nut->version = NUT_STABLE_VERSION + !!nut->flags; + if (nut->flags && s->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) { + av_log(s, AV_LOG_ERROR, + "The additional syncpoint modes require version %d, " + "that is currently not finalized, " + "please set -f_strict experimental in order to enable it.\n", + nut->version); + return AVERROR_EXPERIMENTAL; + } + nut->stream = av_mallocz(sizeof(StreamContext) * s->nb_streams); if (s->nb_chapters) nut->chapter = av_mallocz(sizeof(ChapterContext) * s->nb_chapters); @@ -789,7 +804,8 @@ static int nut_write_packet(AVFormatContext *s, AVPacket *pkt) //FIXME: Ensure store_sp is 1 in the first place. - if (store_sp) { + if (store_sp && + (!(nut->flags & NUT_PIPE) || nut->last_syncpoint_pos == INT_MIN)) { Syncpoint *sp, dummy = { .pos = INT64_MAX }; ff_nut_reset_ts(nut, *nus->time_base, pkt->dts); @@ -815,6 +831,11 @@ static int nut_write_packet(AVFormatContext *s, AVPacket *pkt) return ret; put_tt(nut, nus->time_base, dyn_bc, pkt->dts); ff_put_v(dyn_bc, sp ? (nut->last_syncpoint_pos - sp->pos) >> 4 : 0); + + if (nut->flags & NUT_BROADCAST) { + put_tt(nut, nus->time_base, dyn_bc, + av_rescale_q(av_gettime(), AV_TIME_BASE_Q, *nus->time_base)); + } put_packet(nut, bc, dyn_bc, 1, SYNCPOINT_STARTCODE); if ((ret = ff_nut_add_sp(nut, nut->last_syncpoint_pos, 0 /*unused*/, pkt->dts)) < 0) @@ -917,7 +938,7 @@ static int nut_write_packet(AVFormatContext *s, AVPacket *pkt) nus->last_pts = pkt->pts; //FIXME just store one per syncpoint - if (flags & FLAG_KEY) + if (flags & FLAG_KEY && !(nut->flags & NUT_PIPE)) av_add_index_entry( s->streams[pkt->stream_index], nut->last_syncpoint_pos, @@ -945,6 +966,23 @@ static int nut_write_trailer(AVFormatContext *s) return 0; } +#define OFFSET(x) offsetof(NUTContext, x) +#define E AV_OPT_FLAG_ENCODING_PARAM +static const AVOption options[] = { + { "syncpoints", "NUT syncpoint behaviour", OFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, E, "syncpoints" }, + { "default", "", 0, AV_OPT_TYPE_CONST, {.i64 = 0}, INT_MIN, INT_MAX, E, "syncpoints" }, + { "none", "Disable syncpoints, low overhead and unseekable", 0, AV_OPT_TYPE_CONST, {.i64 = NUT_PIPE}, INT_MIN, INT_MAX, E, "syncpoints" }, + { "timestamped", "Extend syncpoints with a wallclock timestamp", 0, AV_OPT_TYPE_CONST, {.i64 = NUT_BROADCAST}, INT_MIN, INT_MAX, E, "syncpoints" }, + { NULL }, +}; + +static const AVClass class = { + .class_name = "nutenc", + .item_name = av_default_item_name, + .option = options, + .version = LIBAVUTIL_VERSION_INT, +}; + AVOutputFormat ff_nut_muxer = { .name = "nut", .long_name = NULL_IF_CONFIG_SMALL("NUT"), @@ -959,4 +997,5 @@ AVOutputFormat ff_nut_muxer = { .write_trailer = nut_write_trailer, .flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS, .codec_tag = ff_nut_codec_tags, + .priv_class = &class, };