annotate nutdec.c @ 6345:60df621e6237 libavformat

Remove is_playing variable. Patch by Zhentan Feng <spyfeng gmail com>.
author rbultje
date Wed, 04 Aug 2010 22:33:38 +0000
parents e630da0f5861
children 4f920c9dd895
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
1 /*
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
2 * "NUT" Container Format demuxer
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
3 * Copyright (c) 2004-2006 Michael Niedermayer
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
4 * Copyright (c) 2003 Alex Beregszaszi
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
5 *
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
6 * This file is part of FFmpeg.
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
7 *
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
8 * FFmpeg is free software; you can redistribute it and/or
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
9 * modify it under the terms of the GNU Lesser General Public
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
10 * License as published by the Free Software Foundation; either
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
11 * version 2.1 of the License, or (at your option) any later version.
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
12 *
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
13 * FFmpeg is distributed in the hope that it will be useful,
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
16 * Lesser General Public License for more details.
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
17 *
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
18 * You should have received a copy of the GNU Lesser General Public
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
19 * License along with FFmpeg; if not, write to the Free Software
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
21 */
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
22
4605
4fe4d790c020 use new metadata API in nut demuxer
aurel
parents: 4242
diff changeset
23 #include <strings.h>
3286
6f61c3b36632 Use full path for #includes from another directory.
diego
parents: 3275
diff changeset
24 #include "libavutil/avstring.h"
4201
7d2f3f1b68d8 Fix build: Add intreadwrite.h and bswap.h #includes where necessary.
diego
parents: 4076
diff changeset
25 #include "libavutil/bswap.h"
3286
6f61c3b36632 Use full path for #includes from another directory.
diego
parents: 3275
diff changeset
26 #include "libavutil/tree.h"
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
27 #include "nut.h"
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
28
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
29 #undef NDEBUG
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
30 #include <assert.h>
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
31
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
32 static int get_str(ByteIOContext *bc, char *string, unsigned int maxlen){
2700
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
33 unsigned int len= ff_get_v(bc);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
34
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
35 if(len && maxlen)
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
36 get_buffer(bc, string, FFMIN(len, maxlen));
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
37 while(len > maxlen){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
38 get_byte(bc);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
39 len--;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
40 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
41
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
42 if(maxlen)
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
43 string[FFMIN(len, maxlen-1)]= 0;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
44
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
45 if(maxlen == len)
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
46 return -1;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
47 else
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
48 return 0;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
49 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
50
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
51 static int64_t get_s(ByteIOContext *bc){
2700
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
52 int64_t v = ff_get_v(bc) + 1;
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
53
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
54 if (v&1) return -(v>>1);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
55 else return (v>>1);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
56 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
57
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
58 static uint64_t get_fourcc(ByteIOContext *bc){
2700
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
59 unsigned int len= ff_get_v(bc);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
60
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
61 if (len==2) return get_le16(bc);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
62 else if(len==4) return get_le32(bc);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
63 else return -1;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
64 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
65
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
66 #ifdef TRACE
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
67 static inline uint64_t get_v_trace(ByteIOContext *bc, char *file, char *func, int line){
2700
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
68 uint64_t v= ff_get_v(bc);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
69
2344
a7fd892b1a57 get rid of printf
michael
parents: 2338
diff changeset
70 av_log(NULL, AV_LOG_DEBUG, "get_v %5"PRId64" / %"PRIX64" in %s %s:%d\n", v, v, file, func, line);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
71 return v;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
72 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
73
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
74 static inline int64_t get_s_trace(ByteIOContext *bc, char *file, char *func, int line){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
75 int64_t v= get_s(bc);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
76
2344
a7fd892b1a57 get rid of printf
michael
parents: 2338
diff changeset
77 av_log(NULL, AV_LOG_DEBUG, "get_s %5"PRId64" / %"PRIX64" in %s %s:%d\n", v, v, file, func, line);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
78 return v;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
79 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
80
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
81 static inline uint64_t get_vb_trace(ByteIOContext *bc, char *file, char *func, int line){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
82 uint64_t v= get_vb(bc);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
83
2344
a7fd892b1a57 get rid of printf
michael
parents: 2338
diff changeset
84 av_log(NULL, AV_LOG_DEBUG, "get_vb %5"PRId64" / %"PRIX64" in %s %s:%d\n", v, v, file, func, line);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
85 return v;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
86 }
2700
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
87 #define ff_get_v(bc) get_v_trace(bc, __FILE__, __PRETTY_FUNCTION__, __LINE__)
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
88 #define get_s(bc) get_s_trace(bc, __FILE__, __PRETTY_FUNCTION__, __LINE__)
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
89 #define get_vb(bc) get_vb_trace(bc, __FILE__, __PRETTY_FUNCTION__, __LINE__)
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
90 #endif
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
91
2348
b995891375b2 fix forw_ptr crc check
michael
parents: 2344
diff changeset
92 static int get_packetheader(NUTContext *nut, ByteIOContext *bc, int calculate_checksum, uint64_t startcode)
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
93 {
2035
43de2eae6c69 Remove unused code + variable, fixes a warning.
diego
parents: 2005
diff changeset
94 int64_t size;
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
95 // start= url_ftell(bc) - 8;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
96
6248
e630da0f5861 Add av_ prefix to bswap macros
mru
parents: 6247
diff changeset
97 startcode= av_be2ne64(startcode);
6229
3b049f067bdd Fix warning "passing argument from incompatible pointer type".
cehoyos
parents: 6039
diff changeset
98 startcode= ff_crc04C11DB7_update(0, (uint8_t*)&startcode, 8);
2348
b995891375b2 fix forw_ptr crc check
michael
parents: 2344
diff changeset
99
2683
153d6efc05b8 rename av_crc04C11DB7_update to ff_crc04C11DB7_update and move it to aviobuf.c so it can be reused by other (de)muxers
bcoudurier
parents: 2553
diff changeset
100 init_checksum(bc, ff_crc04C11DB7_update, startcode);
2700
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
101 size= ff_get_v(bc);
1820
ec025d5fbbe2 get_packetheader() forgot to read the header_checksum in big packets
lu_zero
parents: 1682
diff changeset
102 if(size > 4096)
2333
892b9d82e812 check forw_ptr CRC
michael
parents: 2327
diff changeset
103 get_be32(bc);
892b9d82e812 check forw_ptr CRC
michael
parents: 2327
diff changeset
104 if(get_checksum(bc) && size > 4096)
892b9d82e812 check forw_ptr CRC
michael
parents: 2327
diff changeset
105 return -1;
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
106
2683
153d6efc05b8 rename av_crc04C11DB7_update to ff_crc04C11DB7_update and move it to aviobuf.c so it can be reused by other (de)muxers
bcoudurier
parents: 2553
diff changeset
107 init_checksum(bc, calculate_checksum ? ff_crc04C11DB7_update : NULL, 0);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
108
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
109 return size;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
110 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
111
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
112 static uint64_t find_any_startcode(ByteIOContext *bc, int64_t pos){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
113 uint64_t state=0;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
114
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
115 if(pos >= 0)
3142
8891d470ada3 typo fixes
diego
parents: 3139
diff changeset
116 url_fseek(bc, pos, SEEK_SET); //note, this may fail if the stream is not seekable, but that should not matter, as in this case we simply start where we currently are
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
117
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
118 while(!url_feof(bc)){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
119 state= (state<<8) | get_byte(bc);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
120 if((state>>56) != 'N')
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
121 continue;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
122 switch(state){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
123 case MAIN_STARTCODE:
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
124 case STREAM_STARTCODE:
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
125 case SYNCPOINT_STARTCODE:
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
126 case INFO_STARTCODE:
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
127 case INDEX_STARTCODE:
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
128 return state;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
129 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
130 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
131
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
132 return 0;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
133 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
134
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
135 /**
2393
fc685315d568 spelling/wording cosmetics
diego
parents: 2349
diff changeset
136 * Find the given startcode.
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
137 * @param code the startcode
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
138 * @param pos the start position of the search, or -1 if the current position
5909
b8041f85c327 Replace @returns by @return.
benoit
parents: 5902
diff changeset
139 * @return the position of the startcode or -1 if not found
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
140 */
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
141 static int64_t find_startcode(ByteIOContext *bc, uint64_t code, int64_t pos){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
142 for(;;){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
143 uint64_t startcode= find_any_startcode(bc, pos);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
144 if(startcode == code)
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
145 return url_ftell(bc) - 8;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
146 else if(startcode == 0)
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
147 return -1;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
148 pos=-1;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
149 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
150 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
151
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
152 static int nut_probe(AVProbeData *p){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
153 int i;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
154 uint64_t code= 0;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
155
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
156 for (i = 0; i < p->buf_size; i++) {
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
157 code = (code << 8) | p->buf[i];
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
158 if (code == MAIN_STARTCODE)
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
159 return AVPROBE_SCORE_MAX;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
160 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
161 return 0;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
162 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
163
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
164 #define GET_V(dst, check) \
2700
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
165 tmp= ff_get_v(bc);\
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
166 if(!(check)){\
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
167 av_log(s, AV_LOG_ERROR, "Error " #dst " is (%"PRId64")\n", tmp);\
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
168 return -1;\
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
169 }\
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
170 dst= tmp;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
171
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
172 static int skip_reserved(ByteIOContext *bc, int64_t pos){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
173 pos -= url_ftell(bc);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
174 if(pos<0){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
175 url_fseek(bc, pos, SEEK_CUR);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
176 return -1;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
177 }else{
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
178 while(pos--)
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
179 get_byte(bc);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
180 return 0;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
181 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
182 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
183
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
184 static int decode_main_header(NUTContext *nut){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
185 AVFormatContext *s= nut->avf;
2771
d52c718e83f9 Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents: 2700
diff changeset
186 ByteIOContext *bc = s->pb;
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
187 uint64_t tmp, end;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
188 unsigned int stream_count;
3045
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
189 int i, j, tmp_stream, tmp_mul, tmp_pts, tmp_size, count, tmp_res, tmp_head_idx;
3043
d6f8dd8d17e5 Read match_time_delta in the framecode table.
michael
parents: 3035
diff changeset
190 int64_t tmp_match;
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
191
2348
b995891375b2 fix forw_ptr crc check
michael
parents: 2344
diff changeset
192 end= get_packetheader(nut, bc, 1, MAIN_STARTCODE);
1485
9000f9cdac49 fix checksum check (was my bug not libnut)
michael
parents: 1484
diff changeset
193 end += url_ftell(bc);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
194
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
195 GET_V(tmp , tmp >=2 && tmp <= 3)
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
196 GET_V(stream_count , tmp > 0 && tmp <=MAX_STREAMS)
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
197
2700
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
198 nut->max_distance = ff_get_v(bc);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
199 if(nut->max_distance > 65536){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
200 av_log(s, AV_LOG_DEBUG, "max_distance %d\n", nut->max_distance);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
201 nut->max_distance= 65536;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
202 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
203
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
204 GET_V(nut->time_base_count, tmp>0 && tmp<INT_MAX / sizeof(AVRational))
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
205 nut->time_base= av_malloc(nut->time_base_count * sizeof(AVRational));
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
206
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
207 for(i=0; i<nut->time_base_count; i++){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
208 GET_V(nut->time_base[i].num, tmp>0 && tmp<(1ULL<<31))
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
209 GET_V(nut->time_base[i].den, tmp>0 && tmp<(1ULL<<31))
4242
44f4dca12784 export gcd function as av_gcd()
aurel
parents: 4206
diff changeset
210 if(av_gcd(nut->time_base[i].num, nut->time_base[i].den) != 1){
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
211 av_log(s, AV_LOG_ERROR, "time base invalid\n");
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
212 return -1;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
213 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
214 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
215 tmp_pts=0;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
216 tmp_mul=1;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
217 tmp_stream=0;
3043
d6f8dd8d17e5 Read match_time_delta in the framecode table.
michael
parents: 3035
diff changeset
218 tmp_match= 1-(1LL<<62);
3045
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
219 tmp_head_idx= 0;
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
220 for(i=0; i<256;){
2700
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
221 int tmp_flags = ff_get_v(bc);
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
222 int tmp_fields= ff_get_v(bc);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
223 if(tmp_fields>0) tmp_pts = get_s(bc);
2700
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
224 if(tmp_fields>1) tmp_mul = ff_get_v(bc);
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
225 if(tmp_fields>2) tmp_stream= ff_get_v(bc);
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
226 if(tmp_fields>3) tmp_size = ff_get_v(bc);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
227 else tmp_size = 0;
2700
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
228 if(tmp_fields>4) tmp_res = ff_get_v(bc);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
229 else tmp_res = 0;
2700
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
230 if(tmp_fields>5) count = ff_get_v(bc);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
231 else count = tmp_mul - tmp_size;
3043
d6f8dd8d17e5 Read match_time_delta in the framecode table.
michael
parents: 3035
diff changeset
232 if(tmp_fields>6) tmp_match = get_s(bc);
3045
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
233 if(tmp_fields>7) tmp_head_idx= ff_get_v(bc);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
234
3045
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
235 while(tmp_fields-- > 8)
2700
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
236 ff_get_v(bc);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
237
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
238 if(count == 0 || i+count > 256){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
239 av_log(s, AV_LOG_ERROR, "illegal count %d at %d\n", count, i);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
240 return -1;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
241 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
242 if(tmp_stream >= stream_count){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
243 av_log(s, AV_LOG_ERROR, "illegal stream number\n");
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
244 return -1;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
245 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
246
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
247 for(j=0; j<count; j++,i++){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
248 if (i == 'N') {
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
249 nut->frame_code[i].flags= FLAG_INVALID;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
250 j--;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
251 continue;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
252 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
253 nut->frame_code[i].flags = tmp_flags ;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
254 nut->frame_code[i].pts_delta = tmp_pts ;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
255 nut->frame_code[i].stream_id = tmp_stream;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
256 nut->frame_code[i].size_mul = tmp_mul ;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
257 nut->frame_code[i].size_lsb = tmp_size+j;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
258 nut->frame_code[i].reserved_count = tmp_res ;
3045
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
259 nut->frame_code[i].header_idx = tmp_head_idx;
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
260 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
261 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
262 assert(nut->frame_code['N'].flags == FLAG_INVALID);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
263
3045
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
264 if(end > url_ftell(bc) + 4){
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
265 int rem= 1024;
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
266 GET_V(nut->header_count, tmp<128U)
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
267 nut->header_count++;
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
268 for(i=1; i<nut->header_count; i++){
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
269 GET_V(nut->header_len[i], tmp>0 && tmp<256);
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
270 rem -= nut->header_len[i];
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
271 if(rem < 0){
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
272 av_log(s, AV_LOG_ERROR, "invalid elision header\n");
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
273 return -1;
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
274 }
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
275 nut->header[i]= av_malloc(nut->header_len[i]);
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
276 get_buffer(bc, nut->header[i], nut->header_len[i]);
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
277 }
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
278 assert(nut->header_len[0]==0);
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
279 }
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
280
1485
9000f9cdac49 fix checksum check (was my bug not libnut)
michael
parents: 1484
diff changeset
281 if(skip_reserved(bc, end) || get_checksum(bc)){
2393
fc685315d568 spelling/wording cosmetics
diego
parents: 2349
diff changeset
282 av_log(s, AV_LOG_ERROR, "main header checksum mismatch\n");
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
283 return -1;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
284 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
285
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
286 nut->stream = av_mallocz(sizeof(StreamContext)*stream_count);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
287 for(i=0; i<stream_count; i++){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
288 av_new_stream(s, i);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
289 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
290
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
291 return 0;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
292 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
293
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
294 static int decode_stream_header(NUTContext *nut){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
295 AVFormatContext *s= nut->avf;
2771
d52c718e83f9 Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents: 2700
diff changeset
296 ByteIOContext *bc = s->pb;
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
297 StreamContext *stc;
1516
21dcee17917a remove unused variables
michael
parents: 1515
diff changeset
298 int class, stream_id;
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
299 uint64_t tmp, end;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
300 AVStream *st;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
301
2348
b995891375b2 fix forw_ptr crc check
michael
parents: 2344
diff changeset
302 end= get_packetheader(nut, bc, 1, STREAM_STARTCODE);
1485
9000f9cdac49 fix checksum check (was my bug not libnut)
michael
parents: 1484
diff changeset
303 end += url_ftell(bc);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
304
2327
768d27bac3c1 make StreamContext.time_base a pointer
michael
parents: 2273
diff changeset
305 GET_V(stream_id, tmp < s->nb_streams && !nut->stream[tmp].time_base);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
306 stc= &nut->stream[stream_id];
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
307
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
308 st = s->streams[stream_id];
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
309 if (!st)
2273
7eb456c4ed8a Replace all occurrences of AVERROR_NOMEM with AVERROR(ENOMEM).
takis
parents: 2228
diff changeset
310 return AVERROR(ENOMEM);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
311
2700
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
312 class = ff_get_v(bc);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
313 tmp = get_fourcc(bc);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
314 st->codec->codec_tag= tmp;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
315 switch(class)
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
316 {
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
317 case 0:
5910
536e5527c1e0 Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents: 5909
diff changeset
318 st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
6039
eeb6e3c4c32b Make the nut decoder read the ff_nut_video_tags to detect codec id of
stefano
parents: 6038
diff changeset
319 st->codec->codec_id = av_codec_get_id(
eeb6e3c4c32b Make the nut decoder read the ff_nut_video_tags to detect codec id of
stefano
parents: 6038
diff changeset
320 (const AVCodecTag * const []) { ff_codec_bmp_tags, ff_nut_video_tags, 0 },
eeb6e3c4c32b Make the nut decoder read the ff_nut_video_tags to detect codec id of
stefano
parents: 6038
diff changeset
321 tmp);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
322 break;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
323 case 1:
5910
536e5527c1e0 Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents: 5909
diff changeset
324 st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
5058
33a244b7ca65 Add ff_ prefixes to exported symbols in libavformat/riff.h.
diego
parents: 4605
diff changeset
325 st->codec->codec_id = ff_codec_get_id(ff_codec_wav_tags, tmp);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
326 break;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
327 case 2:
5910
536e5527c1e0 Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents: 5909
diff changeset
328 st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
5058
33a244b7ca65 Add ff_ prefixes to exported symbols in libavformat/riff.h.
diego
parents: 4605
diff changeset
329 st->codec->codec_id = ff_codec_get_id(ff_nut_subtitle_tags, tmp);
3101
83537aac00f1 subtitles (codec tag tables still missing ...)
michael
parents: 3045
diff changeset
330 break;
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
331 case 3:
5910
536e5527c1e0 Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents: 5909
diff changeset
332 st->codec->codec_type = AVMEDIA_TYPE_DATA;
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
333 break;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
334 default:
2393
fc685315d568 spelling/wording cosmetics
diego
parents: 2349
diff changeset
335 av_log(s, AV_LOG_ERROR, "unknown stream class (%d)\n", class);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
336 return -1;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
337 }
3102
fca018d1bbce factorize
michael
parents: 3101
diff changeset
338 if(class<3 && st->codec->codec_id == CODEC_ID_NONE)
5997
06f15a7a9bb8 Make the nut demuxer issue a more meaningful error message if it
stefano
parents: 5982
diff changeset
339 av_log(s, AV_LOG_ERROR, "Unknown codec tag '0x%04x' for stream number %d\n",
06f15a7a9bb8 Make the nut demuxer issue a more meaningful error message if it
stefano
parents: 5982
diff changeset
340 (unsigned int)tmp, stream_id);
3102
fca018d1bbce factorize
michael
parents: 3101
diff changeset
341
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
342 GET_V(stc->time_base_id , tmp < nut->time_base_count);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
343 GET_V(stc->msb_pts_shift , tmp < 16);
2700
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
344 stc->max_pts_distance= ff_get_v(bc);
2393
fc685315d568 spelling/wording cosmetics
diego
parents: 2349
diff changeset
345 GET_V(stc->decode_delay , tmp < 1000); //sanity limit, raise this if Moore's law is true
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
346 st->codec->has_b_frames= stc->decode_delay;
2700
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
347 ff_get_v(bc); //stream flags
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
348
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
349 GET_V(st->codec->extradata_size, tmp < (1<<30));
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
350 if(st->codec->extradata_size){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
351 st->codec->extradata= av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
352 get_buffer(bc, st->codec->extradata, st->codec->extradata_size);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
353 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
354
5910
536e5527c1e0 Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents: 5909
diff changeset
355 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
356 GET_V(st->codec->width , tmp > 0)
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
357 GET_V(st->codec->height, tmp > 0)
3759
27537074f2a9 convert every muxer/demuxer to write/read sample_aspect_ratio from/to
aurel
parents: 3424
diff changeset
358 st->sample_aspect_ratio.num= ff_get_v(bc);
27537074f2a9 convert every muxer/demuxer to write/read sample_aspect_ratio from/to
aurel
parents: 3424
diff changeset
359 st->sample_aspect_ratio.den= ff_get_v(bc);
27537074f2a9 convert every muxer/demuxer to write/read sample_aspect_ratio from/to
aurel
parents: 3424
diff changeset
360 if((!st->sample_aspect_ratio.num) != (!st->sample_aspect_ratio.den)){
27537074f2a9 convert every muxer/demuxer to write/read sample_aspect_ratio from/to
aurel
parents: 3424
diff changeset
361 av_log(s, AV_LOG_ERROR, "invalid aspect ratio %d/%d\n", st->sample_aspect_ratio.num, st->sample_aspect_ratio.den);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
362 return -1;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
363 }
2700
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
364 ff_get_v(bc); /* csp type */
5910
536e5527c1e0 Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents: 5909
diff changeset
365 }else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO){
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
366 GET_V(st->codec->sample_rate , tmp > 0)
3013
2478b7222c56 Remove old workaround in nutdec.c for libnut bug
ods15
parents: 3012
diff changeset
367 ff_get_v(bc); // samplerate_den
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
368 GET_V(st->codec->channels, tmp > 0)
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
369 }
1485
9000f9cdac49 fix checksum check (was my bug not libnut)
michael
parents: 1484
diff changeset
370 if(skip_reserved(bc, end) || get_checksum(bc)){
2393
fc685315d568 spelling/wording cosmetics
diego
parents: 2349
diff changeset
371 av_log(s, AV_LOG_ERROR, "stream header %d checksum mismatch\n", stream_id);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
372 return -1;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
373 }
2327
768d27bac3c1 make StreamContext.time_base a pointer
michael
parents: 2273
diff changeset
374 stc->time_base= &nut->time_base[stc->time_base_id];
768d27bac3c1 make StreamContext.time_base a pointer
michael
parents: 2273
diff changeset
375 av_set_pts_info(s->streams[stream_id], 63, stc->time_base->num, stc->time_base->den);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
376 return 0;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
377 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
378
3120
ea5623a8efde Add 'disposition' bitfield to AVStream and use it for both muxing and demuxing
eugeni
parents: 3112
diff changeset
379 static void set_disposition_bits(AVFormatContext* avf, char* value, int stream_id){
ea5623a8efde Add 'disposition' bitfield to AVStream and use it for both muxing and demuxing
eugeni
parents: 3112
diff changeset
380 int flag = 0, i;
ea5623a8efde Add 'disposition' bitfield to AVStream and use it for both muxing and demuxing
eugeni
parents: 3112
diff changeset
381 for (i=0; ff_nut_dispositions[i].flag; ++i) {
ea5623a8efde Add 'disposition' bitfield to AVStream and use it for both muxing and demuxing
eugeni
parents: 3112
diff changeset
382 if (!strcmp(ff_nut_dispositions[i].str, value))
ea5623a8efde Add 'disposition' bitfield to AVStream and use it for both muxing and demuxing
eugeni
parents: 3112
diff changeset
383 flag = ff_nut_dispositions[i].flag;
ea5623a8efde Add 'disposition' bitfield to AVStream and use it for both muxing and demuxing
eugeni
parents: 3112
diff changeset
384 }
ea5623a8efde Add 'disposition' bitfield to AVStream and use it for both muxing and demuxing
eugeni
parents: 3112
diff changeset
385 if (!flag)
ea5623a8efde Add 'disposition' bitfield to AVStream and use it for both muxing and demuxing
eugeni
parents: 3112
diff changeset
386 av_log(avf, AV_LOG_INFO, "unknown disposition type '%s'\n", value);
ea5623a8efde Add 'disposition' bitfield to AVStream and use it for both muxing and demuxing
eugeni
parents: 3112
diff changeset
387 for (i = 0; i < avf->nb_streams; ++i)
ea5623a8efde Add 'disposition' bitfield to AVStream and use it for both muxing and demuxing
eugeni
parents: 3112
diff changeset
388 if (stream_id == i || stream_id == -1)
ea5623a8efde Add 'disposition' bitfield to AVStream and use it for both muxing and demuxing
eugeni
parents: 3112
diff changeset
389 avf->streams[i]->disposition |= flag;
ea5623a8efde Add 'disposition' bitfield to AVStream and use it for both muxing and demuxing
eugeni
parents: 3112
diff changeset
390 }
ea5623a8efde Add 'disposition' bitfield to AVStream and use it for both muxing and demuxing
eugeni
parents: 3112
diff changeset
391
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
392 static int decode_info_header(NUTContext *nut){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
393 AVFormatContext *s= nut->avf;
2771
d52c718e83f9 Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents: 2700
diff changeset
394 ByteIOContext *bc = s->pb;
5732
12baf46105f4 nutdec: make chapter start and length uint64_t to prevent overflows.
benoit
parents: 5729
diff changeset
395 uint64_t tmp, chapter_start, chapter_len;
12baf46105f4 nutdec: make chapter start and length uint64_t to prevent overflows.
benoit
parents: 5729
diff changeset
396 unsigned int stream_id_plus1, count;
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
397 int chapter_id, i;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
398 int64_t value, end;
3005
d1a8a747d85f -Wwrite-strings nitpicking fix
michael
parents: 2874
diff changeset
399 char name[256], str_value[1024], type_str[256];
3006
fa2fb523fd6b Fix info packet type, found by oded as well as the new pedantic const
michael
parents: 3005
diff changeset
400 const char *type;
3331
f89173ea4c5e Chapter demuxing support. (untested as I have no nuts with chapters)
michael
parents: 3286
diff changeset
401 AVChapter *chapter= NULL;
4605
4fe4d790c020 use new metadata API in nut demuxer
aurel
parents: 4242
diff changeset
402 AVStream *st= NULL;
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
403
2348
b995891375b2 fix forw_ptr crc check
michael
parents: 2344
diff changeset
404 end= get_packetheader(nut, bc, 1, INFO_STARTCODE);
1485
9000f9cdac49 fix checksum check (was my bug not libnut)
michael
parents: 1484
diff changeset
405 end += url_ftell(bc);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
406
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
407 GET_V(stream_id_plus1, tmp <= s->nb_streams)
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
408 chapter_id = get_s(bc);
2700
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
409 chapter_start= ff_get_v(bc);
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
410 chapter_len = ff_get_v(bc);
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
411 count = ff_get_v(bc);
3331
f89173ea4c5e Chapter demuxing support. (untested as I have no nuts with chapters)
michael
parents: 3286
diff changeset
412
f89173ea4c5e Chapter demuxing support. (untested as I have no nuts with chapters)
michael
parents: 3286
diff changeset
413 if(chapter_id && !stream_id_plus1){
f89173ea4c5e Chapter demuxing support. (untested as I have no nuts with chapters)
michael
parents: 3286
diff changeset
414 int64_t start= chapter_start / nut->time_base_count;
3334
7a823a401282 Pass time_base as argument to new_chapter() as well.
michael
parents: 3331
diff changeset
415 chapter= ff_new_chapter(s, chapter_id,
7a823a401282 Pass time_base as argument to new_chapter() as well.
michael
parents: 3331
diff changeset
416 nut->time_base[chapter_start % nut->time_base_count],
7a823a401282 Pass time_base as argument to new_chapter() as well.
michael
parents: 3331
diff changeset
417 start, start + chapter_len, NULL);
4605
4fe4d790c020 use new metadata API in nut demuxer
aurel
parents: 4242
diff changeset
418 } else if(stream_id_plus1)
4fe4d790c020 use new metadata API in nut demuxer
aurel
parents: 4242
diff changeset
419 st= s->streams[stream_id_plus1 - 1];
3331
f89173ea4c5e Chapter demuxing support. (untested as I have no nuts with chapters)
michael
parents: 3286
diff changeset
420
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
421 for(i=0; i<count; i++){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
422 get_str(bc, name, sizeof(name));
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
423 value= get_s(bc);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
424 if(value == -1){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
425 type= "UTF-8";
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
426 get_str(bc, str_value, sizeof(str_value));
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
427 }else if(value == -2){
3006
fa2fb523fd6b Fix info packet type, found by oded as well as the new pedantic const
michael
parents: 3005
diff changeset
428 get_str(bc, type_str, sizeof(type_str));
fa2fb523fd6b Fix info packet type, found by oded as well as the new pedantic const
michael
parents: 3005
diff changeset
429 type= type_str;
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
430 get_str(bc, str_value, sizeof(str_value));
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
431 }else if(value == -3){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
432 type= "s";
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
433 value= get_s(bc);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
434 }else if(value == -4){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
435 type= "t";
2700
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
436 value= ff_get_v(bc);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
437 }else if(value < -4){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
438 type= "r";
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
439 get_s(bc);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
440 }else{
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
441 type= "v";
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
442 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
443
3275
1c55ed1a5044 Fix 'comparison always false' warning.
diego
parents: 3142
diff changeset
444 if (stream_id_plus1 > s->nb_streams) {
3120
ea5623a8efde Add 'disposition' bitfield to AVStream and use it for both muxing and demuxing
eugeni
parents: 3112
diff changeset
445 av_log(s, AV_LOG_ERROR, "invalid stream id for info packet\n");
ea5623a8efde Add 'disposition' bitfield to AVStream and use it for both muxing and demuxing
eugeni
parents: 3112
diff changeset
446 continue;
ea5623a8efde Add 'disposition' bitfield to AVStream and use it for both muxing and demuxing
eugeni
parents: 3112
diff changeset
447 }
ea5623a8efde Add 'disposition' bitfield to AVStream and use it for both muxing and demuxing
eugeni
parents: 3112
diff changeset
448
4605
4fe4d790c020 use new metadata API in nut demuxer
aurel
parents: 4242
diff changeset
449 if(!strcmp(type, "UTF-8")){
4fe4d790c020 use new metadata API in nut demuxer
aurel
parents: 4242
diff changeset
450 AVMetadata **metadata = NULL;
4fe4d790c020 use new metadata API in nut demuxer
aurel
parents: 4242
diff changeset
451 if(chapter_id==0 && !strcmp(name, "Disposition"))
3120
ea5623a8efde Add 'disposition' bitfield to AVStream and use it for both muxing and demuxing
eugeni
parents: 3112
diff changeset
452 set_disposition_bits(s, str_value, stream_id_plus1 - 1);
4605
4fe4d790c020 use new metadata API in nut demuxer
aurel
parents: 4242
diff changeset
453 else if(chapter) metadata= &chapter->metadata;
4fe4d790c020 use new metadata API in nut demuxer
aurel
parents: 4242
diff changeset
454 else if(stream_id_plus1) metadata= &st->metadata;
4fe4d790c020 use new metadata API in nut demuxer
aurel
parents: 4242
diff changeset
455 else metadata= &s->metadata;
4fe4d790c020 use new metadata API in nut demuxer
aurel
parents: 4242
diff changeset
456 if(metadata && strcasecmp(name,"Uses")
4fe4d790c020 use new metadata API in nut demuxer
aurel
parents: 4242
diff changeset
457 && strcasecmp(name,"Depends") && strcasecmp(name,"Replaces"))
5982
f74198942337 Mark av_metadata_set() as deprecated, and use av_metadata_set2()
stefano
parents: 5913
diff changeset
458 av_metadata_set2(metadata, name, str_value, 0);
3331
f89173ea4c5e Chapter demuxing support. (untested as I have no nuts with chapters)
michael
parents: 3286
diff changeset
459 }
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
460 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
461
1485
9000f9cdac49 fix checksum check (was my bug not libnut)
michael
parents: 1484
diff changeset
462 if(skip_reserved(bc, end) || get_checksum(bc)){
2393
fc685315d568 spelling/wording cosmetics
diego
parents: 2349
diff changeset
463 av_log(s, AV_LOG_ERROR, "info header checksum mismatch\n");
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
464 return -1;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
465 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
466 return 0;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
467 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
468
1500
2ac9e4f39a67 index less seeking in O(log n) time
michael
parents: 1485
diff changeset
469 static int decode_syncpoint(NUTContext *nut, int64_t *ts, int64_t *back_ptr){
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
470 AVFormatContext *s= nut->avf;
2771
d52c718e83f9 Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents: 2700
diff changeset
471 ByteIOContext *bc = s->pb;
1500
2ac9e4f39a67 index less seeking in O(log n) time
michael
parents: 1485
diff changeset
472 int64_t end, tmp;
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
473
1478
5e1b279a26d2 nut simple seeking first try
michael
parents: 1477
diff changeset
474 nut->last_syncpoint_pos= url_ftell(bc)-8;
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
475
2348
b995891375b2 fix forw_ptr crc check
michael
parents: 2344
diff changeset
476 end= get_packetheader(nut, bc, 1, SYNCPOINT_STARTCODE);
1485
9000f9cdac49 fix checksum check (was my bug not libnut)
michael
parents: 1484
diff changeset
477 end += url_ftell(bc);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
478
2700
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
479 tmp= ff_get_v(bc);
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
480 *back_ptr= nut->last_syncpoint_pos - 16*ff_get_v(bc);
1500
2ac9e4f39a67 index less seeking in O(log n) time
michael
parents: 1485
diff changeset
481 if(*back_ptr < 0)
2ac9e4f39a67 index less seeking in O(log n) time
michael
parents: 1485
diff changeset
482 return -1;
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
483
3011
0439b354e005 ff_nut_reset_ts() expected to get 'ts*time_base_count', but muxer only
ods15
parents: 3006
diff changeset
484 ff_nut_reset_ts(nut, nut->time_base[tmp % nut->time_base_count], tmp / nut->time_base_count);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
485
1485
9000f9cdac49 fix checksum check (was my bug not libnut)
michael
parents: 1484
diff changeset
486 if(skip_reserved(bc, end) || get_checksum(bc)){
1478
5e1b279a26d2 nut simple seeking first try
michael
parents: 1477
diff changeset
487 av_log(s, AV_LOG_ERROR, "sync point checksum mismatch\n");
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
488 return -1;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
489 }
1500
2ac9e4f39a67 index less seeking in O(log n) time
michael
parents: 1485
diff changeset
490
2ac9e4f39a67 index less seeking in O(log n) time
michael
parents: 1485
diff changeset
491 *ts= tmp / s->nb_streams * av_q2d(nut->time_base[tmp % s->nb_streams])*AV_TIME_BASE;
2349
a9dc7596498a move syncpoint cache related stuff to common file
michael
parents: 2348
diff changeset
492 ff_nut_add_sp(nut, nut->last_syncpoint_pos, *back_ptr, *ts);
1500
2ac9e4f39a67 index less seeking in O(log n) time
michael
parents: 1485
diff changeset
493
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
494 return 0;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
495 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
496
1484
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
497 static int find_and_decode_index(NUTContext *nut){
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
498 AVFormatContext *s= nut->avf;
2771
d52c718e83f9 Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents: 2700
diff changeset
499 ByteIOContext *bc = s->pb;
1484
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
500 uint64_t tmp, end;
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
501 int i, j, syncpoint_count;
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
502 int64_t filesize= url_fsize(bc);
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
503 int64_t *syncpoints;
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
504 int8_t *has_keyframe;
3377
7b34cd9dfe85 Fix memleak, fixed CID123.
michael
parents: 3334
diff changeset
505 int ret= -1;
1484
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
506
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
507 url_fseek(bc, filesize-12, SEEK_SET);
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
508 url_fseek(bc, filesize-get_be64(bc), SEEK_SET);
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
509 if(get_be64(bc) != INDEX_STARTCODE){
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
510 av_log(s, AV_LOG_ERROR, "no index at the end\n");
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
511 return -1;
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
512 }
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
513
2348
b995891375b2 fix forw_ptr crc check
michael
parents: 2344
diff changeset
514 end= get_packetheader(nut, bc, 1, INDEX_STARTCODE);
1485
9000f9cdac49 fix checksum check (was my bug not libnut)
michael
parents: 1484
diff changeset
515 end += url_ftell(bc);
1484
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
516
2700
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
517 ff_get_v(bc); //max_pts
1484
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
518 GET_V(syncpoint_count, tmp < INT_MAX/8 && tmp > 0)
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
519 syncpoints= av_malloc(sizeof(int64_t)*syncpoint_count);
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
520 has_keyframe= av_malloc(sizeof(int8_t)*(syncpoint_count+1));
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
521 for(i=0; i<syncpoint_count; i++){
3377
7b34cd9dfe85 Fix memleak, fixed CID123.
michael
parents: 3334
diff changeset
522 syncpoints[i] = ff_get_v(bc);
7b34cd9dfe85 Fix memleak, fixed CID123.
michael
parents: 3334
diff changeset
523 if(syncpoints[i] <= 0)
7b34cd9dfe85 Fix memleak, fixed CID123.
michael
parents: 3334
diff changeset
524 goto fail;
1484
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
525 if(i)
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
526 syncpoints[i] += syncpoints[i-1];
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
527 }
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
528
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
529 for(i=0; i<s->nb_streams; i++){
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
530 int64_t last_pts= -1;
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
531 for(j=0; j<syncpoint_count;){
2700
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
532 uint64_t x= ff_get_v(bc);
1484
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
533 int type= x&1;
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
534 int n= j;
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
535 x>>=1;
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
536 if(type){
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
537 int flag= x&1;
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
538 x>>=1;
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
539 if(n+x >= syncpoint_count + 1){
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
540 av_log(s, AV_LOG_ERROR, "index overflow A\n");
3377
7b34cd9dfe85 Fix memleak, fixed CID123.
michael
parents: 3334
diff changeset
541 goto fail;
1484
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
542 }
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
543 while(x--)
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
544 has_keyframe[n++]= flag;
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
545 has_keyframe[n++]= !flag;
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
546 }else{
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
547 while(x != 1){
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
548 if(n>=syncpoint_count + 1){
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
549 av_log(s, AV_LOG_ERROR, "index overflow B\n");
3377
7b34cd9dfe85 Fix memleak, fixed CID123.
michael
parents: 3334
diff changeset
550 goto fail;
1484
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
551 }
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
552 has_keyframe[n++]= x&1;
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
553 x>>=1;
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
554 }
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
555 }
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
556 if(has_keyframe[0]){
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
557 av_log(s, AV_LOG_ERROR, "keyframe before first syncpoint in index\n");
3377
7b34cd9dfe85 Fix memleak, fixed CID123.
michael
parents: 3334
diff changeset
558 goto fail;
1484
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
559 }
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
560 assert(n<=syncpoint_count+1);
3012
2214e8b1cb4d missing " && j<syncpoint_count" protection in the index parsing, as the
ods15
parents: 3011
diff changeset
561 for(; j<n && j<syncpoint_count; j++){
1484
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
562 if(has_keyframe[j]){
2700
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
563 uint64_t B, A= ff_get_v(bc);
1484
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
564 if(!A){
2700
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
565 A= ff_get_v(bc);
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
566 B= ff_get_v(bc);
1484
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
567 //eor_pts[j][i] = last_pts + A + B
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
568 }else
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
569 B= 0;
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
570 av_add_index_entry(
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
571 s->streams[i],
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
572 16*syncpoints[j-1],
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
573 last_pts + A,
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
574 0,
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
575 0,
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
576 AVINDEX_KEYFRAME);
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
577 last_pts += A + B;
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
578 }
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
579 }
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
580 }
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
581 }
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
582
1485
9000f9cdac49 fix checksum check (was my bug not libnut)
michael
parents: 1484
diff changeset
583 if(skip_reserved(bc, end) || get_checksum(bc)){
2393
fc685315d568 spelling/wording cosmetics
diego
parents: 2349
diff changeset
584 av_log(s, AV_LOG_ERROR, "index checksum mismatch\n");
3377
7b34cd9dfe85 Fix memleak, fixed CID123.
michael
parents: 3334
diff changeset
585 goto fail;
1484
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
586 }
3377
7b34cd9dfe85 Fix memleak, fixed CID123.
michael
parents: 3334
diff changeset
587 ret= 0;
7b34cd9dfe85 Fix memleak, fixed CID123.
michael
parents: 3334
diff changeset
588 fail:
7b34cd9dfe85 Fix memleak, fixed CID123.
michael
parents: 3334
diff changeset
589 av_free(syncpoints);
7b34cd9dfe85 Fix memleak, fixed CID123.
michael
parents: 3334
diff changeset
590 av_free(has_keyframe);
7b34cd9dfe85 Fix memleak, fixed CID123.
michael
parents: 3334
diff changeset
591 return ret;
1484
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
592 }
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
593
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
594 static int nut_read_header(AVFormatContext *s, AVFormatParameters *ap)
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
595 {
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
596 NUTContext *nut = s->priv_data;
2771
d52c718e83f9 Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents: 2700
diff changeset
597 ByteIOContext *bc = s->pb;
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
598 int64_t pos;
3035
f5de7bad2bb9 typo fix: inited --> initialized
diego
parents: 3013
diff changeset
599 int initialized_stream_count;
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
600
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
601 nut->avf= s;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
602
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
603 /* main header */
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
604 pos=0;
1480
2355202d4c4c simplify
michael
parents: 1479
diff changeset
605 do{
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
606 pos= find_startcode(bc, MAIN_STARTCODE, pos)+1;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
607 if (pos<0+1){
2393
fc685315d568 spelling/wording cosmetics
diego
parents: 2349
diff changeset
608 av_log(s, AV_LOG_ERROR, "No main startcode found.\n");
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
609 return -1;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
610 }
1480
2355202d4c4c simplify
michael
parents: 1479
diff changeset
611 }while(decode_main_header(nut) < 0);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
612
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
613 /* stream headers */
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
614 pos=0;
3035
f5de7bad2bb9 typo fix: inited --> initialized
diego
parents: 3013
diff changeset
615 for(initialized_stream_count=0; initialized_stream_count < s->nb_streams;){
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
616 pos= find_startcode(bc, STREAM_STARTCODE, pos)+1;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
617 if (pos<0+1){
2393
fc685315d568 spelling/wording cosmetics
diego
parents: 2349
diff changeset
618 av_log(s, AV_LOG_ERROR, "Not all stream headers found.\n");
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
619 return -1;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
620 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
621 if(decode_stream_header(nut) >= 0)
3035
f5de7bad2bb9 typo fix: inited --> initialized
diego
parents: 3013
diff changeset
622 initialized_stream_count++;
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
623 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
624
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
625 /* info headers */
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
626 pos=0;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
627 for(;;){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
628 uint64_t startcode= find_any_startcode(bc, pos);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
629 pos= url_ftell(bc);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
630
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
631 if(startcode==0){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
632 av_log(s, AV_LOG_ERROR, "EOF before video frames\n");
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
633 return -1;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
634 }else if(startcode == SYNCPOINT_STARTCODE){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
635 nut->next_startcode= startcode;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
636 break;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
637 }else if(startcode != INFO_STARTCODE){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
638 continue;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
639 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
640
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
641 decode_info_header(nut);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
642 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
643
1478
5e1b279a26d2 nut simple seeking first try
michael
parents: 1477
diff changeset
644 s->data_offset= pos-8;
5e1b279a26d2 nut simple seeking first try
michael
parents: 1477
diff changeset
645
1501
1d17ea4b6e94 seeking with index
michael
parents: 1500
diff changeset
646 if(!url_is_streamed(bc)){
1484
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
647 int64_t orig_pos= url_ftell(bc);
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
648 find_and_decode_index(nut);
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
649 url_fseek(bc, orig_pos, SEEK_SET);
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
650 }
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
651 assert(nut->next_startcode == SYNCPOINT_STARTCODE);
20438d25cf8c fix timestamp rounding in syncpoints
michael
parents: 1480
diff changeset
652
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
653 return 0;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
654 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
655
3045
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
656 static int decode_frame_header(NUTContext *nut, int64_t *pts, int *stream_id, uint8_t *header_idx, int frame_code){
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
657 AVFormatContext *s= nut->avf;
2771
d52c718e83f9 Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents: 2700
diff changeset
658 ByteIOContext *bc = s->pb;
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
659 StreamContext *stc;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
660 int size, flags, size_mul, pts_delta, i, reserved_count;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
661 uint64_t tmp;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
662
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
663 if(url_ftell(bc) > nut->last_syncpoint_pos + nut->max_distance){
2393
fc685315d568 spelling/wording cosmetics
diego
parents: 2349
diff changeset
664 av_log(s, AV_LOG_ERROR, "Last frame must have been damaged %"PRId64" > %"PRId64" + %d\n", url_ftell(bc), nut->last_syncpoint_pos, nut->max_distance);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
665 return -1;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
666 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
667
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
668 flags = nut->frame_code[frame_code].flags;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
669 size_mul = nut->frame_code[frame_code].size_mul;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
670 size = nut->frame_code[frame_code].size_lsb;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
671 *stream_id = nut->frame_code[frame_code].stream_id;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
672 pts_delta = nut->frame_code[frame_code].pts_delta;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
673 reserved_count = nut->frame_code[frame_code].reserved_count;
3045
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
674 *header_idx = nut->frame_code[frame_code].header_idx;
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
675
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
676 if(flags & FLAG_INVALID)
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
677 return -1;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
678 if(flags & FLAG_CODED)
2700
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
679 flags ^= ff_get_v(bc);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
680 if(flags & FLAG_STREAM_ID){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
681 GET_V(*stream_id, tmp < s->nb_streams)
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
682 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
683 stc= &nut->stream[*stream_id];
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
684 if(flags&FLAG_CODED_PTS){
2700
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
685 int coded_pts= ff_get_v(bc);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
686 //FIXME check last_pts validity?
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
687 if(coded_pts < (1<<stc->msb_pts_shift)){
2338
4a06a51ceb70 move lsb2full to common file
michael
parents: 2335
diff changeset
688 *pts=ff_lsb2full(stc, coded_pts);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
689 }else
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
690 *pts=coded_pts - (1<<stc->msb_pts_shift);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
691 }else
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
692 *pts= stc->last_pts + pts_delta;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
693 if(flags&FLAG_SIZE_MSB){
2700
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
694 size += size_mul*ff_get_v(bc);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
695 }
3044
410abc272c3b Read match time delta in the frame header.
michael
parents: 3043
diff changeset
696 if(flags&FLAG_MATCH_TIME)
410abc272c3b Read match time delta in the frame header.
michael
parents: 3043
diff changeset
697 get_s(bc);
3045
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
698 if(flags&FLAG_HEADER_IDX)
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
699 *header_idx= ff_get_v(bc);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
700 if(flags&FLAG_RESERVED)
2700
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
701 reserved_count= ff_get_v(bc);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
702 for(i=0; i<reserved_count; i++)
2700
dfcac0102c34 Add ff_ prefix to get_v()
kostya
parents: 2699
diff changeset
703 ff_get_v(bc);
3045
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
704
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
705 if(*header_idx >= (unsigned)nut->header_count){
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
706 av_log(s, AV_LOG_ERROR, "header_idx invalid\n");
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
707 return -1;
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
708 }
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
709 if(size > 4096)
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
710 *header_idx=0;
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
711 size -= nut->header_len[*header_idx];
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
712
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
713 if(flags&FLAG_CHECKSUM){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
714 get_be32(bc); //FIXME check this
1518
10be48ec6b57 check max_pts_distance
michael
parents: 1517
diff changeset
715 }else if(size > 2*nut->max_distance || FFABS(stc->last_pts - *pts) > stc->max_pts_distance){
1509
edc979a1ecb5 check for frames with 2*size > max_dist and no crc
michael
parents: 1508
diff changeset
716 av_log(s, AV_LOG_ERROR, "frame size > 2max_distance and no checksum\n");
edc979a1ecb5 check for frames with 2*size > max_dist and no crc
michael
parents: 1508
diff changeset
717 return -1;
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
718 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
719
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
720 stc->last_pts= *pts;
1518
10be48ec6b57 check max_pts_distance
michael
parents: 1517
diff changeset
721 stc->last_flags= flags;
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
722
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
723 return size;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
724 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
725
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
726 static int decode_frame(NUTContext *nut, AVPacket *pkt, int frame_code){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
727 AVFormatContext *s= nut->avf;
2771
d52c718e83f9 Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents: 2700
diff changeset
728 ByteIOContext *bc = s->pb;
1518
10be48ec6b57 check max_pts_distance
michael
parents: 1517
diff changeset
729 int size, stream_id, discard;
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
730 int64_t pts, last_IP_pts;
1518
10be48ec6b57 check max_pts_distance
michael
parents: 1517
diff changeset
731 StreamContext *stc;
3045
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
732 uint8_t header_idx;
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
733
3045
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
734 size= decode_frame_header(nut, &pts, &stream_id, &header_idx, frame_code);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
735 if(size < 0)
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
736 return -1;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
737
1518
10be48ec6b57 check max_pts_distance
michael
parents: 1517
diff changeset
738 stc= &nut->stream[stream_id];
10be48ec6b57 check max_pts_distance
michael
parents: 1517
diff changeset
739
10be48ec6b57 check max_pts_distance
michael
parents: 1517
diff changeset
740 if (stc->last_flags & FLAG_KEY)
10be48ec6b57 check max_pts_distance
michael
parents: 1517
diff changeset
741 stc->skip_until_key_frame=0;
1517
51b29c17bd1f skip non keyframes after seeking between syncpoint and the first keyframe
michael
parents: 1516
diff changeset
742
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
743 discard= s->streams[ stream_id ]->discard;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
744 last_IP_pts= s->streams[ stream_id ]->last_IP_pts;
1518
10be48ec6b57 check max_pts_distance
michael
parents: 1517
diff changeset
745 if( (discard >= AVDISCARD_NONKEY && !(stc->last_flags & FLAG_KEY))
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
746 ||(discard >= AVDISCARD_BIDIR && last_IP_pts != AV_NOPTS_VALUE && last_IP_pts > pts)
1517
51b29c17bd1f skip non keyframes after seeking between syncpoint and the first keyframe
michael
parents: 1516
diff changeset
747 || discard >= AVDISCARD_ALL
1518
10be48ec6b57 check max_pts_distance
michael
parents: 1517
diff changeset
748 || stc->skip_until_key_frame){
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
749 url_fskip(bc, size);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
750 return 1;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
751 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
752
3045
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
753 av_new_packet(pkt, size + nut->header_len[header_idx]);
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
754 memcpy(pkt->data, nut->header[header_idx], nut->header_len[header_idx]);
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
755 pkt->pos= url_ftell(bc); //FIXME
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
756 get_buffer(bc, pkt->data + nut->header_len[header_idx], size);
f4c7d2d8acbb Elision header demuxing support.
michael
parents: 3044
diff changeset
757
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
758 pkt->stream_index = stream_id;
1518
10be48ec6b57 check max_pts_distance
michael
parents: 1517
diff changeset
759 if (stc->last_flags & FLAG_KEY)
5913
11bb10c37225 Replace all occurences of PKT_FLAG_KEY with AV_PKT_FLAG_KEY.
cehoyos
parents: 5910
diff changeset
760 pkt->flags |= AV_PKT_FLAG_KEY;
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
761 pkt->pts = pts;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
762
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
763 return 0;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
764 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
765
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
766 static int nut_read_packet(AVFormatContext *s, AVPacket *pkt)
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
767 {
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
768 NUTContext *nut = s->priv_data;
2771
d52c718e83f9 Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents: 2700
diff changeset
769 ByteIOContext *bc = s->pb;
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
770 int i, frame_code=0, ret, skip;
1500
2ac9e4f39a67 index less seeking in O(log n) time
michael
parents: 1485
diff changeset
771 int64_t ts, back_ptr;
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
772
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
773 for(;;){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
774 int64_t pos= url_ftell(bc);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
775 uint64_t tmp= nut->next_startcode;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
776 nut->next_startcode=0;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
777
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
778 if(tmp){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
779 pos-=8;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
780 }else{
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
781 frame_code = get_byte(bc);
1933
eb9eeef16bdb fix end-of-file detection
gpoirier
parents: 1820
diff changeset
782 if(url_feof(bc))
eb9eeef16bdb fix end-of-file detection
gpoirier
parents: 1820
diff changeset
783 return -1;
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
784 if(frame_code == 'N'){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
785 tmp= frame_code;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
786 for(i=1; i<8; i++)
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
787 tmp = (tmp<<8) + get_byte(bc);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
788 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
789 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
790 switch(tmp){
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
791 case MAIN_STARTCODE:
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
792 case STREAM_STARTCODE:
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
793 case INDEX_STARTCODE:
2348
b995891375b2 fix forw_ptr crc check
michael
parents: 2344
diff changeset
794 skip= get_packetheader(nut, bc, 0, tmp);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
795 url_fseek(bc, skip, SEEK_CUR);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
796 break;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
797 case INFO_STARTCODE:
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
798 if(decode_info_header(nut)<0)
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
799 goto resync;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
800 break;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
801 case SYNCPOINT_STARTCODE:
1500
2ac9e4f39a67 index less seeking in O(log n) time
michael
parents: 1485
diff changeset
802 if(decode_syncpoint(nut, &ts, &back_ptr)<0)
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
803 goto resync;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
804 frame_code = get_byte(bc);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
805 case 0:
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
806 ret= decode_frame(nut, pkt, frame_code);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
807 if(ret==0)
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
808 return 0;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
809 else if(ret==1) //ok but discard packet
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
810 break;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
811 default:
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
812 resync:
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
813 av_log(s, AV_LOG_DEBUG, "syncing from %"PRId64"\n", pos);
1508
105e0c574359 resync from last syncpoint
michael
parents: 1507
diff changeset
814 tmp= find_any_startcode(bc, nut->last_syncpoint_pos+1);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
815 if(tmp==0)
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
816 return -1;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
817 av_log(s, AV_LOG_DEBUG, "sync\n");
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
818 nut->next_startcode= tmp;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
819 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
820 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
821 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
822
1478
5e1b279a26d2 nut simple seeking first try
michael
parents: 1477
diff changeset
823 static int64_t nut_read_timestamp(AVFormatContext *s, int stream_index, int64_t *pos_arg, int64_t pos_limit){
5e1b279a26d2 nut simple seeking first try
michael
parents: 1477
diff changeset
824 NUTContext *nut = s->priv_data;
2771
d52c718e83f9 Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents: 2700
diff changeset
825 ByteIOContext *bc = s->pb;
1500
2ac9e4f39a67 index less seeking in O(log n) time
michael
parents: 1485
diff changeset
826 int64_t pos, pts, back_ptr;
1478
5e1b279a26d2 nut simple seeking first try
michael
parents: 1477
diff changeset
827 av_log(s, AV_LOG_DEBUG, "read_timestamp(X,%d,%"PRId64",%"PRId64")\n", stream_index, *pos_arg, pos_limit);
5e1b279a26d2 nut simple seeking first try
michael
parents: 1477
diff changeset
828
5e1b279a26d2 nut simple seeking first try
michael
parents: 1477
diff changeset
829 pos= *pos_arg;
5e1b279a26d2 nut simple seeking first try
michael
parents: 1477
diff changeset
830 do{
5e1b279a26d2 nut simple seeking first try
michael
parents: 1477
diff changeset
831 pos= find_startcode(bc, SYNCPOINT_STARTCODE, pos)+1;
5e1b279a26d2 nut simple seeking first try
michael
parents: 1477
diff changeset
832 if(pos < 1){
5e1b279a26d2 nut simple seeking first try
michael
parents: 1477
diff changeset
833 assert(nut->next_startcode == 0);
2393
fc685315d568 spelling/wording cosmetics
diego
parents: 2349
diff changeset
834 av_log(s, AV_LOG_ERROR, "read_timestamp failed.\n");
1478
5e1b279a26d2 nut simple seeking first try
michael
parents: 1477
diff changeset
835 return AV_NOPTS_VALUE;
5e1b279a26d2 nut simple seeking first try
michael
parents: 1477
diff changeset
836 }
1500
2ac9e4f39a67 index less seeking in O(log n) time
michael
parents: 1485
diff changeset
837 }while(decode_syncpoint(nut, &pts, &back_ptr) < 0);
1478
5e1b279a26d2 nut simple seeking first try
michael
parents: 1477
diff changeset
838 *pos_arg = pos-1;
5e1b279a26d2 nut simple seeking first try
michael
parents: 1477
diff changeset
839 assert(nut->last_syncpoint_pos == *pos_arg);
5e1b279a26d2 nut simple seeking first try
michael
parents: 1477
diff changeset
840
2170
4452d75a9298 fix some printf format specifiers
mru
parents: 2164
diff changeset
841 av_log(s, AV_LOG_DEBUG, "return %"PRId64" %"PRId64"\n", pts,back_ptr );
1500
2ac9e4f39a67 index less seeking in O(log n) time
michael
parents: 1485
diff changeset
842 if (stream_index == -1) return pts;
2ac9e4f39a67 index less seeking in O(log n) time
michael
parents: 1485
diff changeset
843 else if(stream_index == -2) return back_ptr;
2ac9e4f39a67 index less seeking in O(log n) time
michael
parents: 1485
diff changeset
844
2ac9e4f39a67 index less seeking in O(log n) time
michael
parents: 1485
diff changeset
845 assert(0);
1478
5e1b279a26d2 nut simple seeking first try
michael
parents: 1477
diff changeset
846 }
5e1b279a26d2 nut simple seeking first try
michael
parents: 1477
diff changeset
847
1500
2ac9e4f39a67 index less seeking in O(log n) time
michael
parents: 1485
diff changeset
848 static int read_seek(AVFormatContext *s, int stream_index, int64_t pts, int flags){
2ac9e4f39a67 index less seeking in O(log n) time
michael
parents: 1485
diff changeset
849 NUTContext *nut = s->priv_data;
2ac9e4f39a67 index less seeking in O(log n) time
michael
parents: 1485
diff changeset
850 AVStream *st= s->streams[stream_index];
4076
a5c615b9d8ec remove _t for POSIX compatibility.
michael
parents: 3759
diff changeset
851 Syncpoint dummy={.ts= pts*av_q2d(st->time_base)*AV_TIME_BASE};
a5c615b9d8ec remove _t for POSIX compatibility.
michael
parents: 3759
diff changeset
852 Syncpoint nopts_sp= {.ts= AV_NOPTS_VALUE, .back_ptr= AV_NOPTS_VALUE};
a5c615b9d8ec remove _t for POSIX compatibility.
michael
parents: 3759
diff changeset
853 Syncpoint *sp, *next_node[2]= {&nopts_sp, &nopts_sp};
1500
2ac9e4f39a67 index less seeking in O(log n) time
michael
parents: 1485
diff changeset
854 int64_t pos, pos2, ts;
1517
51b29c17bd1f skip non keyframes after seeking between syncpoint and the first keyframe
michael
parents: 1516
diff changeset
855 int i;
1500
2ac9e4f39a67 index less seeking in O(log n) time
michael
parents: 1485
diff changeset
856
1501
1d17ea4b6e94 seeking with index
michael
parents: 1500
diff changeset
857 if(st->index_entries){
1d17ea4b6e94 seeking with index
michael
parents: 1500
diff changeset
858 int index= av_index_search_timestamp(st, pts, flags);
1d17ea4b6e94 seeking with index
michael
parents: 1500
diff changeset
859 if(index<0)
1d17ea4b6e94 seeking with index
michael
parents: 1500
diff changeset
860 return -1;
1d17ea4b6e94 seeking with index
michael
parents: 1500
diff changeset
861
1d17ea4b6e94 seeking with index
michael
parents: 1500
diff changeset
862 pos2= st->index_entries[index].pos;
1d17ea4b6e94 seeking with index
michael
parents: 1500
diff changeset
863 ts = st->index_entries[index].timestamp;
1d17ea4b6e94 seeking with index
michael
parents: 1500
diff changeset
864 }else{
5902
dbbcecb1a0dd Fix NUT (de)muxer warnings:
vitor
parents: 5881
diff changeset
865 av_tree_find(nut->syncpoints, &dummy, (void *) ff_nut_sp_pts_cmp,
dbbcecb1a0dd Fix NUT (de)muxer warnings:
vitor
parents: 5881
diff changeset
866 (void **) next_node);
2170
4452d75a9298 fix some printf format specifiers
mru
parents: 2164
diff changeset
867 av_log(s, AV_LOG_DEBUG, "%"PRIu64"-%"PRIu64" %"PRId64"-%"PRId64"\n", next_node[0]->pos, next_node[1]->pos,
1502
eae8cc31215e indention
michael
parents: 1501
diff changeset
868 next_node[0]->ts , next_node[1]->ts);
eae8cc31215e indention
michael
parents: 1501
diff changeset
869 pos= av_gen_search(s, -1, dummy.ts, next_node[0]->pos, next_node[1]->pos, next_node[1]->pos,
eae8cc31215e indention
michael
parents: 1501
diff changeset
870 next_node[0]->ts , next_node[1]->ts, AVSEEK_FLAG_BACKWARD, &ts, nut_read_timestamp);
1500
2ac9e4f39a67 index less seeking in O(log n) time
michael
parents: 1485
diff changeset
871
1502
eae8cc31215e indention
michael
parents: 1501
diff changeset
872 if(!(flags & AVSEEK_FLAG_BACKWARD)){
eae8cc31215e indention
michael
parents: 1501
diff changeset
873 dummy.pos= pos+16;
eae8cc31215e indention
michael
parents: 1501
diff changeset
874 next_node[1]= &nopts_sp;
5902
dbbcecb1a0dd Fix NUT (de)muxer warnings:
vitor
parents: 5881
diff changeset
875 av_tree_find(nut->syncpoints, &dummy, (void *) ff_nut_sp_pos_cmp,
dbbcecb1a0dd Fix NUT (de)muxer warnings:
vitor
parents: 5881
diff changeset
876 (void **) next_node);
1502
eae8cc31215e indention
michael
parents: 1501
diff changeset
877 pos2= av_gen_search(s, -2, dummy.pos, next_node[0]->pos , next_node[1]->pos, next_node[1]->pos,
eae8cc31215e indention
michael
parents: 1501
diff changeset
878 next_node[0]->back_ptr, next_node[1]->back_ptr, flags, &ts, nut_read_timestamp);
eae8cc31215e indention
michael
parents: 1501
diff changeset
879 if(pos2>=0)
eae8cc31215e indention
michael
parents: 1501
diff changeset
880 pos= pos2;
3139
4e6f5edefa76 typo fixes
diego
parents: 3120
diff changeset
881 //FIXME dir but I think it does not matter
1502
eae8cc31215e indention
michael
parents: 1501
diff changeset
882 }
eae8cc31215e indention
michael
parents: 1501
diff changeset
883 dummy.pos= pos;
5902
dbbcecb1a0dd Fix NUT (de)muxer warnings:
vitor
parents: 5881
diff changeset
884 sp= av_tree_find(nut->syncpoints, &dummy, (void *) ff_nut_sp_pos_cmp,
dbbcecb1a0dd Fix NUT (de)muxer warnings:
vitor
parents: 5881
diff changeset
885 NULL);
1500
2ac9e4f39a67 index less seeking in O(log n) time
michael
parents: 1485
diff changeset
886
1502
eae8cc31215e indention
michael
parents: 1501
diff changeset
887 assert(sp);
eae8cc31215e indention
michael
parents: 1501
diff changeset
888 pos2= sp->back_ptr - 15;
1501
1d17ea4b6e94 seeking with index
michael
parents: 1500
diff changeset
889 }
1d17ea4b6e94 seeking with index
michael
parents: 1500
diff changeset
890 av_log(NULL, AV_LOG_DEBUG, "SEEKTO: %"PRId64"\n", pos2);
2771
d52c718e83f9 Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents: 2700
diff changeset
891 pos= find_startcode(s->pb, SYNCPOINT_STARTCODE, pos2);
d52c718e83f9 Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents: 2700
diff changeset
892 url_fseek(s->pb, pos, SEEK_SET);
1500
2ac9e4f39a67 index less seeking in O(log n) time
michael
parents: 1485
diff changeset
893 av_log(NULL, AV_LOG_DEBUG, "SP: %"PRId64"\n", pos);
1501
1d17ea4b6e94 seeking with index
michael
parents: 1500
diff changeset
894 if(pos2 > pos || pos2 + 15 < pos){
1500
2ac9e4f39a67 index less seeking in O(log n) time
michael
parents: 1485
diff changeset
895 av_log(NULL, AV_LOG_ERROR, "no syncpoint at backptr pos\n");
2ac9e4f39a67 index less seeking in O(log n) time
michael
parents: 1485
diff changeset
896 }
1517
51b29c17bd1f skip non keyframes after seeking between syncpoint and the first keyframe
michael
parents: 1516
diff changeset
897 for(i=0; i<s->nb_streams; i++)
51b29c17bd1f skip non keyframes after seeking between syncpoint and the first keyframe
michael
parents: 1516
diff changeset
898 nut->stream[i].skip_until_key_frame=1;
51b29c17bd1f skip non keyframes after seeking between syncpoint and the first keyframe
michael
parents: 1516
diff changeset
899
1500
2ac9e4f39a67 index less seeking in O(log n) time
michael
parents: 1485
diff changeset
900 return 0;
2ac9e4f39a67 index less seeking in O(log n) time
michael
parents: 1485
diff changeset
901 }
2ac9e4f39a67 index less seeking in O(log n) time
michael
parents: 1485
diff changeset
902
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
903 static int nut_read_close(AVFormatContext *s)
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
904 {
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
905 NUTContext *nut = s->priv_data;
5729
aef0883e3445 Plug some memory leaks in NUT muxer and demuxer
vitor
parents: 5704
diff changeset
906 int i;
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
907
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
908 av_freep(&nut->time_base);
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
909 av_freep(&nut->stream);
5738
7152149eb03f Plug memory leak in NUT muxer and demuxer
vitor
parents: 5733
diff changeset
910 ff_nut_free_sp(nut);
5729
aef0883e3445 Plug some memory leaks in NUT muxer and demuxer
vitor
parents: 5704
diff changeset
911 for(i = 1; i < nut->header_count; i++)
aef0883e3445 Plug some memory leaks in NUT muxer and demuxer
vitor
parents: 5704
diff changeset
912 av_freep(&nut->header[i]);
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
913
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
914 return 0;
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
915 }
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
916
4206
c3102b189cb6 Change semantic of CONFIG_*, HAVE_* and ARCH_*.
aurel
parents: 4201
diff changeset
917 #if CONFIG_NUT_DEMUXER
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
918 AVInputFormat nut_demuxer = {
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
919 "nut",
3424
7a0230981402 Make long_names in lavf/lavdev optional depending on CONFIG_SMALL.
diego
parents: 3377
diff changeset
920 NULL_IF_CONFIG_SMALL("NUT format"),
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
921 sizeof(NUTContext),
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
922 nut_probe,
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
923 nut_read_header,
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
924 nut_read_packet,
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
925 nut_read_close,
1500
2ac9e4f39a67 index less seeking in O(log n) time
michael
parents: 1485
diff changeset
926 read_seek,
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
927 .extensions = "nut",
5704
6b9c2a6d8fa4 Introduce metadata conversion table for NUT muxer and demuxer.
kostya
parents: 5058
diff changeset
928 .metadata_conv = ff_nut_metadata_conv,
6038
d0ea87d82842 Define ff_nut_video_tags and make Nut muxer and demuxer set it in
stefano
parents: 5997
diff changeset
929 .codec_tag = (const AVCodecTag * const []) { ff_codec_bmp_tags, ff_nut_video_tags, ff_codec_wav_tags, ff_nut_subtitle_tags, 0 },
1477
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
930 };
56fe078ffc27 updating nut demuxer to latest spec
michael
parents:
diff changeset
931 #endif