Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

nut: Support experimental NUT 4 features

Browse Source 
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 <lu_zero@gentoo.org>
pull/74/head
Luca Barbato 11 years ago
parent 6d212599aa
commit c94e2e85cb
5 changed files with 112 additions and 9 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 17
      doc/muxers.texi
  2. 21
      doc/nut.texi
  3. 9
      libavformat/nut.h
  4. 29
      libavformat/nutdec.c
  5. 45
      libavformat/nutenc.c

17
doc/muxers.texi
Unescape View File

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

21
doc/nut.texi
Unescape View File

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

9
libavformat/nut.h
Unescape View File

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

29
libavformat/nutdec.c
Unescape View File

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

45
libavformat/nutenc.c
Unescape View File

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

Write Preview
Loading…
Cancel
Save