36 #define NUT_MAX_STREAMS 256
39 int64_t *pos_arg, int64_t pos_limit);
47 while (len > maxlen) {
55 string[
FFMIN(len, maxlen - 1)] = 0;
90 static inline uint64_t get_v_trace(
AVIOContext *bc,
const char *file,
96 v, v, file, func, line);
100 static inline int64_t get_s_trace(
AVIOContext *bc,
const char *file,
106 v, v, file, func, line);
110 static inline uint64_t get_4cc_trace(
AVIOContext *bc,
char *file,
116 v, v, file, func, line);
119 #define ffio_read_varlen(bc) get_v_trace(bc, __FILE__, __PRETTY_FUNCTION__, __LINE__)
120 #define get_s(bc) get_s_trace(bc, __FILE__, __PRETTY_FUNCTION__, __LINE__)
121 #define get_fourcc(bc) get_4cc_trace(bc, __FILE__, __PRETTY_FUNCTION__, __LINE__)
125 int calculate_checksum, uint64_t startcode)
154 state = (state << 8) |
avio_r8(bc);
155 if ((state >> 56) !=
'N')
180 if (startcode == code)
182 else if (startcode == 0)
192 for (i = 0; i < p->
buf_size-8; i++) {
201 #define GET_V(dst, check) \
203 tmp = ffio_read_varlen(bc); \
205 av_log(s, AV_LOG_ERROR, "Error " #dst " is (%"PRId64")\n", tmp); \
206 return AVERROR_INVALIDDATA; \
232 unsigned int stream_count;
234 int tmp_stream, tmp_mul, tmp_pts, tmp_size, tmp_res, tmp_head_idx;
274 for (i = 0; i < 256;) {
295 count = tmp_mul - tmp_size;
301 while (tmp_fields-- > 8) {
313 if (tmp_stream >= stream_count) {
318 for (j = 0; j <
count; j++, i++) {
369 for (i = 0; i < stream_count; i++)
380 int class, stream_id;
388 stc = &nut->
stream[stream_id];
393 class = ffio_read_varlen(bc);
431 "Unknown codec tag '0x%04x' for stream number %d\n",
432 (
unsigned int) tmp, stream_id);
465 "stream header %d checksum mismatch\n", stream_id);
485 if (stream_id == i || stream_id == -1)
493 uint64_t tmp, chapter_start, chapter_len;
494 unsigned int stream_id_plus1,
count;
495 int chapter_id, i,
ret;
497 char name[256], str_value[1024], type_str[256];
499 int *event_flags =
NULL;
503 int metadata_flag = 0;
509 chapter_id =
get_s(bc);
514 if (chapter_id && !stream_id_plus1) {
519 start, start + chapter_len,
NULL);
525 }
else if (stream_id_plus1) {
526 st = s->
streams[stream_id_plus1 - 1];
536 for (i = 0; i <
count; i++) {
537 ret =
get_str(bc, name,
sizeof(name));
547 get_str(bc, str_value,
sizeof(str_value));
548 }
else if (value == -2) {
549 get_str(bc, type_str,
sizeof(type_str));
551 get_str(bc, str_value,
sizeof(str_value));
552 }
else if (value == -3) {
555 }
else if (value == -4) {
558 }
else if (value < -4) {
570 if (!strcmp(type,
"UTF-8")) {
571 if (chapter_id == 0 && !strcmp(name,
"Disposition")) {
576 if (stream_id_plus1 && !strcmp(name,
"r_frame_rate")) {
587 *event_flags |= metadata_flag;
661 int i, j, syncpoint_count;
665 int8_t *has_keyframe;
690 GET_V(syncpoint_count, tmp < INT_MAX / 8 && tmp > 0);
693 if (!syncpoints || !has_keyframe) {
697 for (i = 0; i < syncpoint_count; i++) {
699 if (syncpoints[i] <= 0)
702 syncpoints[i] += syncpoints[i - 1];
707 for (j = 0; j < syncpoint_count;) {
715 if (n + x >= syncpoint_count + 1) {
716 av_log(s,
AV_LOG_ERROR,
"index overflow A %d + %"PRIu64
" >= %d\n", n, x, syncpoint_count + 1);
720 has_keyframe[n++] = flag;
721 has_keyframe[n++] = !flag;
728 if (n >= syncpoint_count + 1) {
732 has_keyframe[n++] = x & 1;
736 if (has_keyframe[0]) {
741 for (; j < n && j < syncpoint_count; j++) {
742 if (has_keyframe[j]) {
777 int initialized_stream_count,
ret = 0;
794 for (initialized_stream_count = 0; initialized_stream_count < s->
nb_streams;) {
802 initialized_stream_count++;
811 if (startcode == 0) {
839 return FFMIN(ret, 0);
848 int64_t channel_layout = 0;
854 for (i=0; i<
count; i++) {
859 ret =
get_str(bc, name,
sizeof(name));
867 get_str(bc, str_value,
sizeof(str_value));
869 }
else if (value == -2) {
871 int64_t v64, value_len;
873 get_str(bc, type_str,
sizeof(type_str));
875 if (value_len < 0 || value_len >= maxpos -
avio_tell(bc))
877 if (!strcmp(name,
"Palette")) {
879 }
else if (!strcmp(name,
"Extradata")) {
881 }
else if (sscanf(name,
"CodecSpecificSide%"SCNd64
"", &v64) == 1) {
887 }
else if (!strcmp(name,
"ChannelLayout") && value_len == 8) {
898 }
else if (value == -3) {
900 }
else if (value == -4) {
902 }
else if (value < -4) {
905 if (!strcmp(name,
"SkipStart")) {
907 }
else if (!strcmp(name,
"SkipEnd")) {
909 }
else if (!strcmp(name,
"Channels")) {
911 }
else if (!strcmp(name,
"SampleRate")) {
913 }
else if (!strcmp(name,
"Width")) {
915 }
else if (!strcmp(name,
"Height")) {
923 if (channels || channel_layout || sample_rate || width || height) {
927 bytestream_put_le32(&dst,
934 bytestream_put_le32(&dst, channels);
936 bytestream_put_le64(&dst, channel_layout);
938 bytestream_put_le32(&dst, sample_rate);
939 if (width || height){
940 bytestream_put_le32(&dst, width);
941 bytestream_put_le32(&dst, height);
945 if (skip_start || skip_end) {
960 uint8_t *header_idx,
int frame_code)
965 int size,
flags, size_mul, pts_delta, i, reserved_count;
971 "Last frame must have been damaged %"PRId64
" > %"PRId64
" + %d\n",
991 stc = &nut->
stream[*stream_id];
1009 for (i = 0; i < reserved_count; i++) {
1044 int size, stream_id, discard,
ret;
1045 int64_t
pts, last_IP_pts;
1053 stc = &nut->
stream[stream_id];
1062 last_IP_pts > pts) ||
1072 if (nut->
header[header_idx])
1083 pkt->
size -= sm_size;
1105 int i, frame_code = 0,
ret, skip;
1106 int64_t ts, back_ptr;
1119 if (frame_code ==
'N') {
1121 for (i = 1; i < 8; i++)
1122 tmp = (tmp << 8) +
avio_r8(bc);
1160 int64_t *pos_arg, int64_t pos_limit)
1164 int64_t pos,
pts, back_ptr;
1166 stream_index, *pos_arg, pos_limit);
1180 if (stream_index == -2)
1193 Syncpoint *
sp, *next_node[2] = { &nopts_sp, &nopts_sp };
1194 int64_t pos, pos2, ts;
1212 (
void **) next_node);
1214 next_node[0]->pos, next_node[1]->pos, next_node[0]->ts,
1217 next_node[1]->
pos, next_node[1]->
pos,
1218 next_node[0]->
ts, next_node[1]->
ts,
1222 dummy.
pos = pos + 16;
1223 next_node[1] = &nopts_sp;
1225 (
void **) next_node);
1227 next_node[1]->
pos, next_node[1]->
pos,
1246 if (pos2 > pos || pos2 + 15 < pos)
1280 .extensions =
"nut",
if set, side / meta data is stored in the frame header.
uint64_t ffio_read_varlen(AVIOContext *bc)
discard all frames except keyframes
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
int64_t avio_size(AVIOContext *s)
Get the filesize.
int64_t last_syncpoint_pos
int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp, int size, int distance, int flags)
Add an index entry into a sorted list.
enum AVDurationEstimationMethod duration_estimation_method
The duration field can be estimated through various ways, and this field can be used to know how the ...
#define AV_LOG_WARNING
Something somehow does not look correct.
int64_t pos
byte position in stream, -1 if unknown
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
const AVCodecTag ff_nut_audio_extra_tags[]
int event_flags
Flags for the user to detect events happening on the stream.
static int get_str(AVIOContext *bc, char *string, unsigned int maxlen)
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
AVFormatInternal * internal
An opaque field for libavformat internal usage.
int event_flags
Flags for the user to detect events happening on the file.
static void set_disposition_bits(AVFormatContext *avf, char *value, int stream_id)
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
static int decode_main_header(NUTContext *nut)
const uint8_t * header[128]
static int decode_frame_header(NUTContext *nut, int64_t *pts, int *stream_id, uint8_t *header_idx, int frame_code)
if set, reserved_count is coded in the frame header
static int64_t nut_read_timestamp(AVFormatContext *s, int stream_index, int64_t *pos_arg, int64_t pos_limit)
#define av_assert0(cond)
assert() equivalent, that is always enabled.
void * av_tree_find(const AVTreeNode *t, void *key, int(*cmp)(void *key, const void *b), void *next[2])
Opaque data information usually continuous.
static int nut_probe(AVProbeData *p)
enum AVCodecID av_codec_get_id(const struct AVCodecTag *const *tags, unsigned int tag)
Get the AVCodecID for the given codec tag tag.
const AVCodecTag ff_codec_movvideo_tags[]
unsigned int avio_rb32(AVIOContext *s)
static av_cold int end(AVCodecContext *avctx)
if set, coded_pts is in the frame header
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
AVStream ** streams
A list of all streams in the file.
If set, match_time_delta is coded in the frame header.
const AVMetadataConv ff_nut_metadata_conv[]
static double av_q2d(AVRational a)
Convert rational to double.
static int decode_frame(NUTContext *nut, AVPacket *pkt, int frame_code)
#define AVERROR_EOF
End of file.
static av_cold int read_close(AVFormatContext *ctx)
#define AV_LOG_VERBOSE
Detailed information.
const AVCodecTag ff_nut_data_tags[]
uint64_t avio_rb64(AVIOContext *s)
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
int ff_nut_sp_pos_cmp(const Syncpoint *a, const Syncpoint *b)
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
AVDictionary * metadata
Metadata that applies to the whole file.
int has_b_frames
Size of the frame reordering buffer in the decoder.
void ff_nut_free_sp(NUTContext *nut)
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
unsigned int avio_rl32(AVIOContext *s)
discard all bidirectional frames
An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:
int64_t timestamp
Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are...
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
simple assert() macros that are a bit more flexible than ISO C assert().
int64_t av_gcd(int64_t a, int64_t b)
Return the greatest common divisor of a and b.
static int nut_read_packet(AVFormatContext *s, AVPacket *pkt)
const AVCodecTag ff_nut_audio_tags[]
static int decode_stream_header(NUTContext *nut)
const AVCodecTag ff_codec_wav_tags[]
if set, frame is keyframe
int ff_nut_sp_pts_cmp(const Syncpoint *a, const Syncpoint *b)
int flags
A combination of AV_PKT_FLAG values.
int avio_r8(AVIOContext *s)
AVCodecContext * codec
Codec context associated with this stream.
static int nut_read_close(AVFormatContext *s)
int buf_size
Size of buf except extra allocated bytes.
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
void ffio_init_checksum(AVIOContext *s, unsigned long(*update_checksum)(unsigned long c, const uint8_t *p, unsigned int len), unsigned long checksum)
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
void ff_nut_reset_ts(NUTContext *nut, AVRational time_base, int64_t val)
#define AV_TIME_BASE
Internal time base represented as integer.
const AVCodecTag ff_codec_bmp_tags[]
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
int width
picture width / height.
static uint64_t find_any_startcode(AVIOContext *bc, int64_t pos)
GLsizei GLboolean const GLfloat * value
unsigned long ff_crc04C11DB7_update(unsigned long checksum, const uint8_t *buf, unsigned int len)
static int find_and_decode_index(NUTContext *nut)
int64_t ff_lsb2full(StreamContext *stream, int64_t lsb)
internal header for RIFF based (de)muxers do NOT include this in end user applications ...
if set, frame_code is invalid
static uint64_t get_fourcc(AVIOContext *bc)
static int get_packetheader(NUTContext *nut, AVIOContext *bc, int calculate_checksum, uint64_t startcode)
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
struct AVTreeNode * syncpoints
if set, data_size_msb is at frame header, otherwise data_size_msb is 0
static int nut_read_header(AVFormatContext *s)
if set, the frame header contains a checksum
static int read_header(FFV1Context *f)
static int decode_syncpoint(NUTContext *nut, int64_t *ts, int64_t *back_ptr)
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
static int read_sm_data(AVFormatContext *s, AVIOContext *bc, AVPacket *pkt, int is_meta, int64_t maxpos)
#define AV_LOG_INFO
Standard information.
enum AVMediaType codec_type
const AVCodecTag ff_nut_subtitle_tags[]
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
int sample_rate
samples per second
AVIOContext * pb
I/O context.
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
if set, coded_flags are stored in the frame header
Data found in BlockAdditional element of matroska container.
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
#define GET_V(dst, check)
BYTE int const BYTE int int int height
rational number numerator/denominator
Recommmends skipping the specified number of samples.
unsigned long ffio_get_checksum(AVIOContext *s)
int(* func)(AVBPrint *dst, const char *in, const char *arg)
static int skip_reserved(AVIOContext *bc, int64_t pos)
static int64_t find_startcode(AVIOContext *bc, uint64_t code, int64_t pos)
Find the given startcode.
This structure contains the data a format has to probe a file.
static int read_seek(AVFormatContext *s, int stream_index, int64_t pts, int flags)
void * av_calloc(size_t nmemb, size_t size)
Allocate a block of nmemb * size bytes with alignment suitable for all memory accesses (including vec...
static int64_t pts
Global timestamp for the audio frames.
static int64_t find_duration(NUTContext *nut, int64_t filesize)
const Dispositions ff_nut_dispositions[]
unsigned int avio_rl16(AVIOContext *s)
uint64_t next_startcode
stores the next startcode if it has already been parsed but the stream is not seekable ...
static int decode_info_header(NUTContext *nut)
FrameCode frame_code[256]
int disposition
AV_DISPOSITION_* bit field.
const AVCodecTag ff_nut_video_tags[]
int ff_nut_add_sp(NUTContext *nut, int64_t pos, int64_t back_ptr, int64_t ts)
#define SYNCPOINT_STARTCODE
int eof_reached
true if eof reached
If set, header_idx is coded in the frame header.
AVInputFormat ff_nut_demuxer
int channels
number of audio channels
static int64_t get_s(AVIOContext *bc)
void * priv_data
Format private data.
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
if set, stream_id is coded in the frame header
#define av_malloc_array(a, b)
int avio_feof(AVIOContext *s)
feof() equivalent for AVIOContext.
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
AVRational r_frame_rate
Real base framerate of the stream.
const AVCodecTag *const ff_nut_codec_tags[]
This structure stores compressed data.
uint64_t avio_rl64(AVIOContext *s)
unsigned int time_base_count
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
#define AV_NOPTS_VALUE
Undefined timestamp value.
unsigned int max_distance