35 #define NUT_MAX_STREAMS 256
43 while (len > maxlen) {
49 string[
FFMIN(len, maxlen - 1)] = 0;
80 static inline uint64_t get_v_trace(
AVIOContext *bc,
const char *file,
81 const char *func,
int line)
86 v, v, file, func, line);
90 static inline int64_t get_s_trace(
AVIOContext *bc,
const char *file,
91 const char *func,
int line)
93 int64_t v =
get_s(bc);
96 v, v, file, func, line);
100 #define ffio_read_varlen(bc) get_v_trace(bc, __FILE__, __PRETTY_FUNCTION__, __LINE__)
101 #define get_s(bc) get_s_trace(bc, __FILE__, __PRETTY_FUNCTION__, __LINE__)
105 int calculate_checksum, uint64_t startcode)
134 state = (state << 8) |
avio_r8(bc);
135 if ((state >> 56) !=
'N')
160 if (startcode == code)
162 else if (startcode == 0)
174 code = (code << 8) | p->
buf[i];
181 #define GET_V(dst, check) \
183 tmp = ffio_read_varlen(bc); \
185 av_log(s, AV_LOG_ERROR, "Error " #dst " is (%"PRId64")\n", tmp); \
209 unsigned int stream_count;
211 int tmp_stream, tmp_mul, tmp_pts, tmp_size, tmp_res, tmp_head_idx;
216 GET_V(tmp, tmp >= 2 && tmp <= 3);
240 for (i = 0; i < 256;) {
261 count = tmp_mul - tmp_size;
267 while (tmp_fields-- > 8)
270 if (count == 0 || i + count > 256) {
274 if (tmp_stream >= stream_count) {
279 for (j = 0; j < count; j++, i++) {
323 for (i = 0; i < stream_count; i++)
334 int class, stream_id;
342 stc = &nut->
stream[stream_id];
347 class = ffio_read_varlen(bc);
383 "Unknown codec tag '0x%04x' for stream number %d\n",
384 (
unsigned int) tmp, stream_id);
418 "stream header %d checksum mismatch\n", stream_id);
438 if (stream_id == i || stream_id == -1)
446 uint64_t tmp, chapter_start, chapter_len;
447 unsigned int stream_id_plus1, count;
450 char name[256], str_value[1024], type_str[256];
459 GET_V(stream_id_plus1, tmp <= s->nb_streams);
460 chapter_id =
get_s(bc);
465 if (chapter_id && !stream_id_plus1) {
470 start, start + chapter_len,
NULL);
472 }
else if (stream_id_plus1) {
473 st = s->
streams[stream_id_plus1 - 1];
478 for (i = 0; i < count; i++) {
479 get_str(bc, name,
sizeof(name));
483 get_str(bc, str_value,
sizeof(str_value));
484 }
else if (value == -2) {
485 get_str(bc, type_str,
sizeof(type_str));
487 get_str(bc, str_value,
sizeof(str_value));
488 }
else if (value == -3) {
491 }
else if (value == -4) {
494 }
else if (value < -4) {
506 if (!strcmp(type,
"UTF-8")) {
507 if (chapter_id == 0 && !strcmp(name,
"Disposition")) {
563 int i, j, syncpoint_count;
566 int8_t *has_keyframe;
580 GET_V(syncpoint_count, tmp < INT_MAX / 8 && tmp > 0);
581 syncpoints =
av_malloc(
sizeof(int64_t) * syncpoint_count);
582 has_keyframe =
av_malloc(
sizeof(int8_t) * (syncpoint_count + 1));
583 for (i = 0; i < syncpoint_count; i++) {
585 if (syncpoints[i] <= 0)
588 syncpoints[i] += syncpoints[i - 1];
592 int64_t last_pts = -1;
593 for (j = 0; j < syncpoint_count;) {
601 if (n + x >= syncpoint_count + 1) {
606 has_keyframe[n++] = flag;
607 has_keyframe[n++] = !flag;
610 if (n >= syncpoint_count + 1) {
614 has_keyframe[n++] = x & 1;
618 if (has_keyframe[0]) {
622 assert(n <= syncpoint_count + 1);
623 for (; j < n && j < syncpoint_count; j++) {
624 if (has_keyframe[j]) {
657 int initialized_stream_count;
673 for (initialized_stream_count = 0; initialized_stream_count < s->
nb_streams;) {
680 initialized_stream_count++;
689 if (startcode == 0) {
717 uint8_t *header_idx,
int frame_code)
722 int size,
flags, size_mul, pts_delta, i, reserved_count;
727 "Last frame must have been damaged %"PRId64
" > %"PRId64
" + %d\n",
745 GET_V(*stream_id, tmp < s->nb_streams);
747 stc = &nut->
stream[*stream_id];
765 for (i = 0; i < reserved_count; i++)
794 int size, stream_id, discard;
795 int64_t pts, last_IP_pts;
803 stc = &nut->
stream[stream_id];
812 last_IP_pts > pts) ||
836 int i, frame_code = 0, ret, skip;
837 int64_t ts, back_ptr;
850 if (frame_code ==
'N') {
852 for (i = 1; i < 8; i++)
853 tmp = (tmp << 8) +
avio_r8(bc);
890 int64_t *pos_arg, int64_t pos_limit)
894 int64_t pos, pts, back_ptr;
896 stream_index, *pos_arg, pos_limit);
911 if (stream_index == -1)
913 else if (stream_index == -2)
920 int64_t pts,
int flags)
926 Syncpoint *
sp, *next_node[2] = { &nopts_sp, &nopts_sp };
927 int64_t pos, pos2, ts;
939 (
void **) next_node);
941 next_node[0]->pos, next_node[1]->pos, next_node[0]->ts,
944 next_node[1]->
pos, next_node[1]->
pos,
945 next_node[0]->
ts, next_node[1]->
ts,
949 dummy.
pos = pos + 16;
950 next_node[1] = &nopts_sp;
952 (
void **) next_node);
954 next_node[1]->
pos, next_node[1]->
pos,
972 if (pos2 > pos || pos2 + 15 < pos)
1003 .extensions =
"nut",
uint64_t ffio_read_varlen(AVIOContext *bc)
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
discard all frames except keyframes
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.
int64_t pos
byte position in stream, -1 if unknown
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.
static void set_disposition_bits(AVFormatContext *avf, char *value, int stream_id)
int64_t data_offset
offset of the first packet
static int decode_main_header(NUTContext *nut)
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
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)
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.
unsigned int avio_rb32(AVIOContext *s)
if set, coded_pts is in the frame header
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
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)
static av_cold int read_close(AVFormatContext *ctx)
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.
struct NUTContext NUTContext
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
int has_b_frames
Size of the frame reordering buffer in the decoder.
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
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
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
int64_t av_gcd(int64_t a, int64_t b)
Return the greatest common divisor of a and b.
void av_log(void *avcl, int level, const char *fmt,...)
AVStream * avformat_new_stream(AVFormatContext *s, AVCodec *c)
Add a new stream to a media file.
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
A list of all streams in the file.
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)
const AVCodecTag ff_codec_bmp_tags[]
int av_strcasecmp(const char *a, const char *b)
int width
picture width / height.
static uint64_t find_any_startcode(AVIOContext *bc, int64_t pos)
unsigned long ff_crc04C11DB7_update(unsigned long checksum, const uint8_t *buf, unsigned int len)
static int find_and_decode_index(NUTContext *nut)
static av_always_inline int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
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)
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)
#define AVSEEK_FLAG_BACKWARD
enum AVMediaType codec_type
const AVCodecTag ff_nut_subtitle_tags[]
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
static int read_packet(AVFormatContext *ctx, AVPacket *pkt)
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)
rational number numerator/denominator
#define FF_INPUT_BUFFER_PADDING_SIZE
unsigned long ffio_get_checksum(AVIOContext *s)
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)
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]
#define AVERROR_INVALIDDATA
int disposition
AV_DISPOSITION_* bit field.
#define AVPROBE_SCORE_MAX
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.
if set, stream_id is coded in the frame header
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.
const AVCodecTag *const ff_nut_codec_tags[]
This structure stores compressed data.
unsigned int time_base_count
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
unsigned int max_distance
if(!(ptr_align%ac->ptr_align)&&samples_align >=aligned_len)