@@ -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.

@@ -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

@@ -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, ///<if set, frame is keyframe

@@ -85,6 +87,7 @@ typedef struct ChapterContext {

 } ChapterContext;

 typedef struct NUTContext {

+    const AVClass *av_class;

     AVFormatContext *avf;

 //    int written_packet_size;

 //    int64_t packet_start;

@@ -100,6 +103,10 @@ typedef struct NUTContext {

     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[];

@@ -213,8 +213,8 @@ static int decode_main_header(NUTContext *nut)

     end  = get_packetheader(nut, bc, 1, MAIN_STARTCODE);

     end += avio_tell(bc);

-    tmp = ffio_read_varlen(bc);

-    if (tmp < 2 && tmp > 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)

@@ -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,

 };