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.

Luca Barbato committed 12 years ago

Commit c94e2e81 parent 6d212595 files · +112 −9Browse files

Unified · Split

5 files

doc/muxers.texi +17 −0
doc/nut.texi +21 −0
libavformat/nut.h +8 −1
libavformat/nutdec.c +24 −5
libavformat/nutenc.c +42 −3

doc/muxers.texi+17−0

@@ -444,6 +444,23 @@ Alternatively you can write the command as: · 443 unmodified lines
444	avconv -benchmark -i INPUT -f null -	444	avconv -benchmark -i INPUT -f null -
445	@end example	445	@end example
446		446
		447	@section nut
		448
		449	@table @option
		450	@item -syncpoints @var{flags}
		451	Change the syncpoint usage in nut:
		452	@table @option
		453	@item @var{default} use the normal low-overhead seeking aids.
		454	@item @var{none} do not use the syncpoints at all, reducing the overhead but making the stream non-seekable;
		455	@item @var{timestamped} extend the syncpoint with a wallclock field.
		456	@end table
		457	The @var{none} and @var{timestamped} flags are experimental.
		458	@end table
		459
		460	@example
		461	avconv -i INPUT -f_strict experimental -syncpoints none - \| processor
		462	@end example
		463
447	@section ogg	464	@section ogg
448		465
449	Ogg container muxer.	466	Ogg container muxer.

doc/nut.texi+21−0

@@ -17,6 +17,27 @@ subtitle and user-defined streams in a simple, yet efficient, way. · 16 unmodified lines
17	It was created by a group of FFmpeg and MPlayer developers in 2003	17	It was created by a group of FFmpeg and MPlayer developers in 2003
18	and was finalized in 2008.	18	and was finalized in 2008.
19		19
		20	@chapter Modes
		21	NUT has some variants signaled by using the flags field in its main header.
		22
		23	@multitable @columnfractions .4 .4
		24	@item BROADCAST @tab Extend the syncpoint to report the sender wallclock
		25	@item PIPE @tab Omit completely the syncpoint
		26	@end multitable
		27
		28	@section BROADCAST
		29
		30	The BROADCAST variant provides a secondary time reference to facilitate
		31	detecting endpoint latency and network delays.
		32	It assumes all the endpoint clocks are syncronized.
		33	To be used in real-time scenarios.
		34
		35	@section PIPE
		36
		37	The PIPE variant assumes NUT is used as non-seekable intermediate container,
		38	by not using syncpoint removes unneeded overhead and reduces the overall
		39	memory usage.
		40
20	@chapter Container-specific codec tags	41	@chapter Container-specific codec tags
21		42
22	@section Generic raw YUVA formats	43	@section Generic raw YUVA formats

libavformat/nut.h+8−1

 #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, ///<if set, frame is keyframe
 } ChapterContext;
 typedef struct NUTContext {
+    const AVClass *av_class;
     AVFormatContext *avf;
 //    int written_packet_size;
 //    int64_t packet_start;
     int header_count;
     AVRational *time_base;
     struct AVTreeNode *syncpoints;
+#define NUT_BROADCAST 1 // use extended syncpoints
+#define NUT_PIPE 2      // do not write syncpoints
+    int flags;
+    int version; // version currently in use
 } NUTContext;
 extern const AVCodecTag ff_nut_subtitle_tags[];

libavformat/nutdec.c+24−5

     end  = get_packetheader(nut, bc, 1, MAIN_STARTCODE);
     end += avio_tell(bc);
-    tmp = ffio_read_varlen(bc);
+    nut->version = ffio_read_varlen(bc);
-    if (tmp < 2 && tmp > NUT_VERSION) {
+    if (tmp < NUT_MIN_VERSION && tmp > NUT_MAX_VERSION) {
         av_log(s, AV_LOG_ERROR, "Version %"PRId64" not supported.\n",
                tmp);
         return AVERROR(ENOSYS);
         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;
     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;
     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);
     if (flags & FLAG_CHECKSUM) {
         avio_rb32(bc); // FIXME check this
-    } else if (size > 2 * nut->max_distance || FFABS(stc->last_pts - *pts) >
+    } else if (!(nut->flags & NUT_PIPE) &&
-               stc->max_pts_distance) {
+               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;
     }
     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)

libavformat/nutenc.c+42−3

 #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"
         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);
         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,
     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);
 //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);
             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)
     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,
     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"),
     .write_trailer  = nut_write_trailer,
     .flags          = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS,
     .codec_tag      = ff_nut_codec_tags,
+    .priv_class     = &class,
 };

nut: Support experimental NUT 4 features

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code