Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * NSV demuxer | ||
3 | * Copyright (c) 2004 The FFmpeg Project | ||
4 | * | ||
5 | * first version by Francois Revol <revol@free.fr> | ||
6 | * | ||
7 | * This file is part of FFmpeg. | ||
8 | * | ||
9 | * FFmpeg is free software; you can redistribute it and/or | ||
10 | * modify it under the terms of the GNU Lesser General Public | ||
11 | * License as published by the Free Software Foundation; either | ||
12 | * version 2.1 of the License, or (at your option) any later version. | ||
13 | * | ||
14 | * FFmpeg is distributed in the hope that it will be useful, | ||
15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
17 | * Lesser General Public License for more details. | ||
18 | * | ||
19 | * You should have received a copy of the GNU Lesser General Public | ||
20 | * License along with FFmpeg; if not, write to the Free Software | ||
21 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
22 | */ | ||
23 | |||
24 | #include "libavutil/attributes.h" | ||
25 | #include "libavutil/mathematics.h" | ||
26 | #include "avformat.h" | ||
27 | #include "demux.h" | ||
28 | #include "internal.h" | ||
29 | #include "libavutil/dict.h" | ||
30 | #include "libavutil/intreadwrite.h" | ||
31 | |||
32 | /* max bytes to crawl for trying to resync | ||
33 | * stupid streaming servers don't start at chunk boundaries... | ||
34 | */ | ||
35 | #define NSV_MAX_RESYNC (500*1024) | ||
36 | #define NSV_MAX_RESYNC_TRIES 300 | ||
37 | |||
38 | /* | ||
39 | * References: | ||
40 | * (1) http://www.multimedia.cx/nsv-format.txt | ||
41 | * seems someone came to the same conclusions as me, and updated it: | ||
42 | * (2) http://www.stud.ktu.lt/~vitslav/nsv/nsv-format.txt | ||
43 | * http://www.stud.ktu.lt/~vitslav/nsv/ | ||
44 | * official docs | ||
45 | * (3) http://ultravox.aol.com/NSVFormat.rtf | ||
46 | * Sample files: | ||
47 | * (S1) http://www.nullsoft.com/nsv/samples/ | ||
48 | * http://www.nullsoft.com/nsv/samples/faster.nsv | ||
49 | * http://streamripper.sourceforge.net/openbb/read.php?TID=492&page=4 | ||
50 | */ | ||
51 | |||
52 | /* | ||
53 | * notes on the header (Francois Revol): | ||
54 | * | ||
55 | * It is followed by strings, then a table, but nothing tells | ||
56 | * where the table begins according to (1). After checking faster.nsv, | ||
57 | * I believe NVSf[16-19] gives the size of the strings data | ||
58 | * (that is the offset of the data table after the header). | ||
59 | * After checking all samples from (S1) all confirms this. | ||
60 | * | ||
61 | * Then, about NSVf[12-15], faster.nsf has 179700. When viewing it in VLC, | ||
62 | * I noticed there was about 1 NVSs chunk/s, so I ran | ||
63 | * strings faster.nsv | grep NSVs | wc -l | ||
64 | * which gave me 180. That leads me to think that NSVf[12-15] might be the | ||
65 | * file length in milliseconds. | ||
66 | * Let's try that: | ||
67 | * for f in *.nsv; do HTIME="$(od -t x4 "$f" | head -1 | sed 's/.* //')"; echo "'$f' $((0x$HTIME))s = $((0x$HTIME/1000/60)):$((0x$HTIME/1000%60))"; done | ||
68 | * except for nsvtrailer (which doesn't have an NSVf header), it reports correct time. | ||
69 | * | ||
70 | * nsvtrailer.nsv (S1) does not have any NSVf header, only NSVs chunks, | ||
71 | * so the header seems to not be mandatory. (for streaming). | ||
72 | * | ||
73 | * index slice duration check (excepts nsvtrailer.nsv): | ||
74 | * for f in [^n]*.nsv; do DUR="$(ffmpeg -i "$f" 2>/dev/null | grep 'NSVf duration' | cut -d ' ' -f 4)"; IC="$(ffmpeg -i "$f" 2>/dev/null | grep 'INDEX ENTRIES' | cut -d ' ' -f 2)"; echo "duration $DUR, slite time $(($DUR/$IC))"; done | ||
75 | */ | ||
76 | |||
77 | /* | ||
78 | * TODO: | ||
79 | * - handle timestamps !!! | ||
80 | * - use index | ||
81 | * - mime-type in probe() | ||
82 | * - seek | ||
83 | */ | ||
84 | |||
85 | #if 0 | ||
86 | struct NSVf_header { | ||
87 | uint32_t chunk_tag; /* 'NSVf' */ | ||
88 | uint32_t chunk_size; | ||
89 | uint32_t file_size; /* max 4GB ??? no one learns anything it seems :^) */ | ||
90 | uint32_t file_length; //unknown1; /* what about MSB of file_size ? */ | ||
91 | uint32_t info_strings_size; /* size of the info strings */ //unknown2; | ||
92 | uint32_t table_entries; | ||
93 | uint32_t table_entries_used; /* the left ones should be -1 */ | ||
94 | }; | ||
95 | |||
96 | struct NSVs_header { | ||
97 | uint32_t chunk_tag; /* 'NSVs' */ | ||
98 | uint32_t v4cc; /* or 'NONE' */ | ||
99 | uint32_t a4cc; /* or 'NONE' */ | ||
100 | uint16_t vwidth; /* av_assert0(vwidth%16==0) */ | ||
101 | uint16_t vheight; /* av_assert0(vheight%16==0) */ | ||
102 | uint8_t framerate; /* value = (framerate&0x80)?frtable[frameratex0x7f]:framerate */ | ||
103 | uint16_t unknown; | ||
104 | }; | ||
105 | |||
106 | struct nsv_avchunk_header { | ||
107 | uint8_t vchunk_size_lsb; | ||
108 | uint16_t vchunk_size_msb; /* value = (vchunk_size_msb << 4) | (vchunk_size_lsb >> 4) */ | ||
109 | uint16_t achunk_size; | ||
110 | }; | ||
111 | |||
112 | struct nsv_pcm_header { | ||
113 | uint8_t bits_per_sample; | ||
114 | uint8_t channel_count; | ||
115 | uint16_t sample_rate; | ||
116 | }; | ||
117 | #endif | ||
118 | |||
119 | /* variation from avi.h */ | ||
120 | /*typedef struct CodecTag { | ||
121 | int id; | ||
122 | unsigned int tag; | ||
123 | } CodecTag;*/ | ||
124 | |||
125 | /* tags */ | ||
126 | |||
127 | #define T_NSVF MKTAG('N', 'S', 'V', 'f') /* file header */ | ||
128 | #define T_NSVS MKTAG('N', 'S', 'V', 's') /* chunk header */ | ||
129 | #define T_TOC2 MKTAG('T', 'O', 'C', '2') /* extra index marker */ | ||
130 | #define T_NONE MKTAG('N', 'O', 'N', 'E') /* null a/v 4CC */ | ||
131 | #define T_SUBT MKTAG('S', 'U', 'B', 'T') /* subtitle aux data */ | ||
132 | #define T_ASYN MKTAG('A', 'S', 'Y', 'N') /* async a/v aux marker */ | ||
133 | #define T_KEYF MKTAG('K', 'E', 'Y', 'F') /* video keyframe aux marker (addition) */ | ||
134 | |||
135 | #define TB_NSVF MKBETAG('N', 'S', 'V', 'f') | ||
136 | #define TB_NSVS MKBETAG('N', 'S', 'V', 's') | ||
137 | |||
138 | /* hardcoded stream indexes */ | ||
139 | #define NSV_ST_VIDEO 0 | ||
140 | #define NSV_ST_AUDIO 1 | ||
141 | #define NSV_ST_SUBT 2 | ||
142 | |||
143 | enum NSVStatus { | ||
144 | NSV_UNSYNC, | ||
145 | NSV_FOUND_NSVF, | ||
146 | NSV_HAS_READ_NSVF, | ||
147 | NSV_FOUND_NSVS, | ||
148 | NSV_HAS_READ_NSVS, | ||
149 | NSV_FOUND_BEEF, | ||
150 | NSV_GOT_VIDEO, | ||
151 | NSV_GOT_AUDIO, | ||
152 | }; | ||
153 | |||
154 | typedef struct NSVStream { | ||
155 | int frame_offset; /* current frame (video) or byte (audio) counter | ||
156 | (used to compute the pts) */ | ||
157 | int scale; | ||
158 | int rate; | ||
159 | int sample_size; /* audio only data */ | ||
160 | int start; | ||
161 | |||
162 | int new_frame_offset; /* temporary storage (used during seek) */ | ||
163 | int cum_len; /* temporary storage (used during seek) */ | ||
164 | } NSVStream; | ||
165 | |||
166 | typedef struct NSVContext { | ||
167 | int base_offset; | ||
168 | int NSVf_end; | ||
169 | uint32_t *nsvs_file_offset; | ||
170 | int index_entries; | ||
171 | enum NSVStatus state; | ||
172 | AVPacket ahead[2]; /* [v, a] if .data is !NULL there is something */ | ||
173 | /* cached */ | ||
174 | int64_t duration; | ||
175 | uint32_t vtag, atag; | ||
176 | uint16_t vwidth, vheight; | ||
177 | int16_t avsync; | ||
178 | AVRational framerate; | ||
179 | uint32_t *nsvs_timestamps; | ||
180 | int nsvf; | ||
181 | } NSVContext; | ||
182 | |||
183 | static const AVCodecTag nsv_codec_video_tags[] = { | ||
184 | { AV_CODEC_ID_VP3, MKTAG('V', 'P', '3', ' ') }, | ||
185 | { AV_CODEC_ID_VP3, MKTAG('V', 'P', '3', '0') }, | ||
186 | { AV_CODEC_ID_VP3, MKTAG('V', 'P', '3', '1') }, | ||
187 | { AV_CODEC_ID_VP5, MKTAG('V', 'P', '5', ' ') }, | ||
188 | { AV_CODEC_ID_VP5, MKTAG('V', 'P', '5', '0') }, | ||
189 | { AV_CODEC_ID_VP6, MKTAG('V', 'P', '6', ' ') }, | ||
190 | { AV_CODEC_ID_VP6, MKTAG('V', 'P', '6', '0') }, | ||
191 | { AV_CODEC_ID_VP6, MKTAG('V', 'P', '6', '1') }, | ||
192 | { AV_CODEC_ID_VP6, MKTAG('V', 'P', '6', '2') }, | ||
193 | { AV_CODEC_ID_VP8, MKTAG('V', 'P', '8', '0') }, | ||
194 | /* | ||
195 | { AV_CODEC_ID_VP4, MKTAG('V', 'P', '4', ' ') }, | ||
196 | { AV_CODEC_ID_VP4, MKTAG('V', 'P', '4', '0') }, | ||
197 | */ | ||
198 | { AV_CODEC_ID_MPEG4, MKTAG('X', 'V', 'I', 'D') }, /* cf sample xvid decoder from nsv_codec_sdk.zip */ | ||
199 | { AV_CODEC_ID_H264, MKTAG('H', '2', '6', '4') }, | ||
200 | { AV_CODEC_ID_RAWVIDEO, MKTAG('R', 'G', 'B', '3') }, | ||
201 | { AV_CODEC_ID_NONE, 0 }, | ||
202 | }; | ||
203 | |||
204 | static const AVCodecTag nsv_codec_audio_tags[] = { | ||
205 | { AV_CODEC_ID_MP3, MKTAG('M', 'P', '3', ' ') }, | ||
206 | { AV_CODEC_ID_AAC, MKTAG('A', 'A', 'C', ' ') }, | ||
207 | { AV_CODEC_ID_AAC, MKTAG('A', 'A', 'C', 'P') }, | ||
208 | { AV_CODEC_ID_AAC, MKTAG('A', 'A', 'V', ' ') }, | ||
209 | { AV_CODEC_ID_AAC, MKTAG('V', 'L', 'B', ' ') }, | ||
210 | { AV_CODEC_ID_SPEEX, MKTAG('S', 'P', 'X', ' ') }, | ||
211 | { AV_CODEC_ID_PCM_U16LE, MKTAG('P', 'C', 'M', ' ') }, | ||
212 | { AV_CODEC_ID_NONE, 0 }, | ||
213 | }; | ||
214 | |||
215 | //static int nsv_load_index(AVFormatContext *s); | ||
216 | static int nsv_read_chunk(AVFormatContext *s, int fill_header); | ||
217 | |||
218 | /* try to find something we recognize, and set the state accordingly */ | ||
219 | 95 | static int nsv_resync(AVFormatContext *s) | |
220 | { | ||
221 | 95 | NSVContext *nsv = s->priv_data; | |
222 | 95 | AVIOContext *pb = s->pb; | |
223 | 95 | uint32_t v = 0; | |
224 | int i; | ||
225 | |||
226 |
1/2✓ Branch 0 taken 202 times.
✗ Branch 1 not taken.
|
202 | for (i = 0; i < NSV_MAX_RESYNC; i++) { |
227 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 202 times.
|
202 | if (avio_feof(pb)) { |
228 | ✗ | av_log(s, AV_LOG_TRACE, "NSV EOF\n"); | |
229 | ✗ | nsv->state = NSV_UNSYNC; | |
230 | ✗ | return -1; | |
231 | } | ||
232 | 202 | v <<= 8; | |
233 | 202 | v |= avio_r8(pb); | |
234 |
1/2✓ Branch 0 taken 202 times.
✗ Branch 1 not taken.
|
202 | if (i < 8) { |
235 | 202 | av_log(s, AV_LOG_TRACE, "NSV resync: [%d] = %02"PRIx32"\n", i, v & 0x0FF); | |
236 | } | ||
237 | |||
238 |
2/2✓ Branch 0 taken 89 times.
✓ Branch 1 taken 113 times.
|
202 | if ((v & 0x0000ffff) == 0xefbe) { /* BEEF */ |
239 | 89 | av_log(s, AV_LOG_TRACE, "NSV resynced on BEEF after %d bytes\n", i+1); | |
240 | 89 | nsv->state = NSV_FOUND_BEEF; | |
241 | 89 | return 0; | |
242 | } | ||
243 | /* we read as big-endian, thus the MK*BE* */ | ||
244 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 112 times.
|
113 | if (v == TB_NSVF) { /* NSVf */ |
245 | 1 | av_log(s, AV_LOG_TRACE, "NSV resynced on NSVf after %d bytes\n", i+1); | |
246 | 1 | nsv->state = NSV_FOUND_NSVF; | |
247 | 1 | return 0; | |
248 | } | ||
249 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 107 times.
|
112 | if (v == MKBETAG('N', 'S', 'V', 's')) { /* NSVs */ |
250 | 5 | av_log(s, AV_LOG_TRACE, "NSV resynced on NSVs after %d bytes\n", i+1); | |
251 | 5 | nsv->state = NSV_FOUND_NSVS; | |
252 | 5 | return 0; | |
253 | } | ||
254 | |||
255 | } | ||
256 | ✗ | av_log(s, AV_LOG_TRACE, "NSV sync lost\n"); | |
257 | ✗ | return -1; | |
258 | } | ||
259 | |||
260 | 1 | static int nsv_parse_NSVf_header(AVFormatContext *s) | |
261 | { | ||
262 | 1 | NSVContext *nsv = s->priv_data; | |
263 | 1 | AVIOContext *pb = s->pb; | |
264 | unsigned int av_unused file_size; | ||
265 | unsigned int size; | ||
266 | int64_t duration; | ||
267 | int strings_size; | ||
268 | int table_entries; | ||
269 | int table_entries_used; | ||
270 | |||
271 | 1 | nsv->state = NSV_UNSYNC; /* in case we fail */ | |
272 | |||
273 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (nsv->nsvf) { |
274 | ✗ | av_log(s, AV_LOG_TRACE, "Multiple NSVf\n"); | |
275 | ✗ | return 0; | |
276 | } | ||
277 | 1 | nsv->nsvf = 1; | |
278 | |||
279 | 1 | size = avio_rl32(pb); | |
280 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (size < 28) |
281 | ✗ | return -1; | |
282 | 1 | nsv->NSVf_end = size; | |
283 | |||
284 | 1 | file_size = (uint32_t)avio_rl32(pb); | |
285 | 1 | av_log(s, AV_LOG_TRACE, "NSV NSVf chunk_size %u\n", size); | |
286 | 1 | av_log(s, AV_LOG_TRACE, "NSV NSVf file_size %u\n", file_size); | |
287 | |||
288 | 1 | nsv->duration = duration = avio_rl32(pb); /* in ms */ | |
289 | 1 | av_log(s, AV_LOG_TRACE, "NSV NSVf duration %"PRId64" ms\n", duration); | |
290 | // XXX: store it in AVStreams | ||
291 | |||
292 | 1 | strings_size = avio_rl32(pb); | |
293 | 1 | table_entries = avio_rl32(pb); | |
294 | 1 | table_entries_used = avio_rl32(pb); | |
295 | 1 | av_log(s, AV_LOG_TRACE, "NSV NSVf info-strings size: %d, table entries: %d, bis %d\n", | |
296 | strings_size, table_entries, table_entries_used); | ||
297 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
|
1 | if (avio_feof(pb)) |
298 | ✗ | return -1; | |
299 | |||
300 | 1 | av_log(s, AV_LOG_TRACE, "NSV got header; filepos %"PRId64"\n", avio_tell(pb)); | |
301 | |||
302 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | if (strings_size > 0) { |
303 | char *strings; /* last byte will be '\0' to play safe with str*() */ | ||
304 | char *p, *endp; | ||
305 | char *token, *value; | ||
306 | char quote; | ||
307 | |||
308 | 1 | p = strings = av_mallocz((size_t)strings_size + 1); | |
309 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (!p) |
310 | ✗ | return AVERROR(ENOMEM); | |
311 | 1 | endp = strings + strings_size; | |
312 | 1 | avio_read(pb, strings, strings_size); | |
313 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
|
2 | while (p < endp) { |
314 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | while (*p == ' ') |
315 | ✗ | p++; /* strip out spaces */ | |
316 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (p >= endp-2) |
317 | ✗ | break; | |
318 | 1 | token = p; | |
319 | 1 | p = strchr(p, '='); | |
320 |
2/4✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
|
1 | if (!p || p >= endp-2) |
321 | break; | ||
322 | 1 | *p++ = '\0'; | |
323 | 1 | quote = *p++; | |
324 | 1 | value = p; | |
325 | 1 | p = strchr(p, quote); | |
326 |
2/4✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
|
1 | if (!p || p >= endp) |
327 | break; | ||
328 | 1 | *p++ = '\0'; | |
329 | 1 | av_log(s, AV_LOG_TRACE, "NSV NSVf INFO: %s='%s'\n", token, value); | |
330 | 1 | av_dict_set(&s->metadata, token, value, 0); | |
331 | } | ||
332 | 1 | av_free(strings); | |
333 | } | ||
334 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
|
1 | if (avio_feof(pb)) |
335 | ✗ | return -1; | |
336 | |||
337 | 1 | av_log(s, AV_LOG_TRACE, "NSV got infos; filepos %"PRId64"\n", avio_tell(pb)); | |
338 | |||
339 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | if (table_entries_used > 0) { |
340 | int i; | ||
341 | 1 | nsv->index_entries = table_entries_used; | |
342 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if((unsigned)table_entries_used >= UINT_MAX / sizeof(uint32_t)) |
343 | ✗ | return -1; | |
344 | 1 | nsv->nsvs_file_offset = av_malloc_array((unsigned)table_entries_used, sizeof(uint32_t)); | |
345 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (!nsv->nsvs_file_offset) |
346 | ✗ | return AVERROR(ENOMEM); | |
347 | |||
348 |
2/2✓ Branch 0 taken 100 times.
✓ Branch 1 taken 1 times.
|
101 | for(i=0;i<table_entries_used;i++) { |
349 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 100 times.
|
100 | if (avio_feof(pb)) |
350 | ✗ | return AVERROR_INVALIDDATA; | |
351 | 100 | nsv->nsvs_file_offset[i] = avio_rl32(pb) + size; | |
352 | } | ||
353 | |||
354 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
1 | if(table_entries > table_entries_used && |
355 | ✗ | avio_rl32(pb) == MKTAG('T','O','C','2')) { | |
356 | ✗ | nsv->nsvs_timestamps = av_malloc_array((unsigned)table_entries_used, sizeof(uint32_t)); | |
357 | ✗ | if (!nsv->nsvs_timestamps) | |
358 | ✗ | return AVERROR(ENOMEM); | |
359 | ✗ | for(i=0;i<table_entries_used;i++) { | |
360 | ✗ | nsv->nsvs_timestamps[i] = avio_rl32(pb); | |
361 | } | ||
362 | } | ||
363 | } | ||
364 | |||
365 | 1 | av_log(s, AV_LOG_TRACE, "NSV got index; filepos %"PRId64"\n", avio_tell(pb)); | |
366 | |||
367 | 1 | avio_seek(pb, nsv->base_offset + size, SEEK_SET); /* required for dumbdriving-271.nsv (2 extra bytes) */ | |
368 | |||
369 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
|
1 | if (avio_feof(pb)) |
370 | ✗ | return -1; | |
371 | 1 | nsv->state = NSV_HAS_READ_NSVF; | |
372 | 1 | return 0; | |
373 | } | ||
374 | |||
375 | 5 | static int nsv_parse_NSVs_header(AVFormatContext *s) | |
376 | { | ||
377 | 5 | NSVContext *nsv = s->priv_data; | |
378 | 5 | AVIOContext *pb = s->pb; | |
379 | uint32_t vtag, atag; | ||
380 | uint16_t vwidth, vheight; | ||
381 | AVRational framerate; | ||
382 | int i; | ||
383 | AVStream *st; | ||
384 | NSVStream *nst; | ||
385 | |||
386 | 5 | vtag = avio_rl32(pb); | |
387 | 5 | atag = avio_rl32(pb); | |
388 | 5 | vwidth = avio_rl16(pb); | |
389 | 5 | vheight = avio_rl16(pb); | |
390 | 5 | i = avio_r8(pb); | |
391 | |||
392 | 5 | av_log(s, AV_LOG_TRACE, "NSV NSVs framerate code %2x\n", i); | |
393 |
1/2✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
|
5 | if(i&0x80) { /* odd way of giving native framerates from docs */ |
394 | 5 | int t=(i & 0x7F)>>2; | |
395 |
1/2✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
|
5 | if(t<16) framerate = (AVRational){1, t+1}; |
396 | ✗ | else framerate = (AVRational){t-15, 1}; | |
397 | |||
398 |
1/2✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
|
5 | if(i&1){ |
399 | 5 | framerate.num *= 1000; | |
400 | 5 | framerate.den *= 1001; | |
401 | } | ||
402 | |||
403 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
|
5 | if((i&3)==3) framerate.num *= 24; |
404 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
|
5 | else if((i&3)==2) framerate.num *= 25; |
405 | 5 | else framerate.num *= 30; | |
406 | } | ||
407 | else | ||
408 | ✗ | framerate= (AVRational){i, 1}; | |
409 | |||
410 | 5 | nsv->avsync = avio_rl16(pb); | |
411 | 5 | nsv->framerate = framerate; | |
412 | |||
413 | 5 | av_log(s, AV_LOG_TRACE, "NSV NSVs vsize %dx%d\n", vwidth, vheight); | |
414 | |||
415 | /* XXX change to ap != NULL ? */ | ||
416 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 4 times.
|
5 | if (s->nb_streams == 0) { /* streams not yet published, let's do that */ |
417 | 1 | nsv->vtag = vtag; | |
418 | 1 | nsv->atag = atag; | |
419 | 1 | nsv->vwidth = vwidth; | |
420 | 1 | nsv->vheight = vwidth; | |
421 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | if (vtag != T_NONE) { |
422 | int i; | ||
423 | 1 | st = avformat_new_stream(s, NULL); | |
424 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (!st) |
425 | ✗ | goto fail; | |
426 | |||
427 | 1 | st->id = NSV_ST_VIDEO; | |
428 | 1 | nst = av_mallocz(sizeof(NSVStream)); | |
429 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (!nst) |
430 | ✗ | goto fail; | |
431 | 1 | st->priv_data = nst; | |
432 | 1 | st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO; | |
433 | 1 | st->codecpar->codec_tag = vtag; | |
434 | 1 | st->codecpar->codec_id = ff_codec_get_id(nsv_codec_video_tags, vtag); | |
435 | 1 | st->codecpar->width = vwidth; | |
436 | 1 | st->codecpar->height = vheight; | |
437 | 1 | st->codecpar->bits_per_coded_sample = 24; /* depth XXX */ | |
438 | |||
439 | 1 | avpriv_set_pts_info(st, 64, framerate.den, framerate.num); | |
440 | 1 | st->start_time = 0; | |
441 | 1 | st->duration = av_rescale(nsv->duration, framerate.num, 1000*framerate.den); | |
442 | |||
443 |
2/2✓ Branch 0 taken 100 times.
✓ Branch 1 taken 1 times.
|
101 | for(i=0;i<nsv->index_entries;i++) { |
444 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 100 times.
|
100 | if(nsv->nsvs_timestamps) { |
445 | ✗ | av_add_index_entry(st, nsv->nsvs_file_offset[i], nsv->nsvs_timestamps[i], | |
446 | 0, 0, AVINDEX_KEYFRAME); | ||
447 | } else { | ||
448 | 100 | int64_t ts = av_rescale(i*nsv->duration/nsv->index_entries, framerate.num, 1000*framerate.den); | |
449 | 100 | av_add_index_entry(st, nsv->nsvs_file_offset[i], ts, 0, 0, AVINDEX_KEYFRAME); | |
450 | } | ||
451 | } | ||
452 | } | ||
453 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | if (atag != T_NONE) { |
454 | 1 | st = avformat_new_stream(s, NULL); | |
455 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (!st) |
456 | ✗ | goto fail; | |
457 | |||
458 | 1 | st->id = NSV_ST_AUDIO; | |
459 | 1 | nst = av_mallocz(sizeof(NSVStream)); | |
460 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (!nst) |
461 | ✗ | goto fail; | |
462 | 1 | st->priv_data = nst; | |
463 | 1 | st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO; | |
464 | 1 | st->codecpar->codec_tag = atag; | |
465 | 1 | st->codecpar->codec_id = ff_codec_get_id(nsv_codec_audio_tags, atag); | |
466 | |||
467 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (atag == MKTAG('A', 'A', 'V', ' ')) { |
468 | static const uint8_t aav_pce[] = { | ||
469 | 0x12, 0x00, 0x05, 0x08, 0x48, 0x00, | ||
470 | 0x20, 0x00, 0xC6, 0x40, 0x04, 0x4C, | ||
471 | 0x61, 0x76, 0x63, 0x56, 0xE5, 0x00, | ||
472 | 0x00, 0x00, | ||
473 | }; | ||
474 | int ret; | ||
475 | |||
476 | ✗ | if ((ret = ff_alloc_extradata(st->codecpar, sizeof(aav_pce))) < 0) | |
477 | ✗ | return ret; | |
478 | |||
479 | ✗ | st->codecpar->sample_rate = 44100; | |
480 | ✗ | memcpy(st->codecpar->extradata, aav_pce, sizeof(aav_pce)); | |
481 | } | ||
482 | |||
483 | 1 | ffstream(st)->need_parsing = AVSTREAM_PARSE_FULL; /* for PCM we will read a chunk later and put correct info */ | |
484 | |||
485 | /* set timebase to common denominator of ms and framerate */ | ||
486 | 1 | avpriv_set_pts_info(st, 64, 1, framerate.num*1000); | |
487 | 1 | st->start_time = 0; | |
488 | 1 | st->duration = (int64_t)nsv->duration * framerate.num; | |
489 | } | ||
490 | } else { | ||
491 |
4/8✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 4 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 4 times.
|
4 | if (nsv->vtag != vtag || nsv->atag != atag || nsv->vwidth != vwidth || nsv->vheight != vwidth) { |
492 | ✗ | av_log(s, AV_LOG_TRACE, "NSV NSVs header values differ from the first one!!!\n"); | |
493 | //return -1; | ||
494 | } | ||
495 | } | ||
496 | |||
497 | 5 | nsv->state = NSV_HAS_READ_NSVS; | |
498 | 5 | return 0; | |
499 | ✗ | fail: | |
500 | /* XXX */ | ||
501 | ✗ | nsv->state = NSV_UNSYNC; | |
502 | ✗ | return -1; | |
503 | } | ||
504 | |||
505 | 1 | static int nsv_read_header(AVFormatContext *s) | |
506 | { | ||
507 | 1 | NSVContext *nsv = s->priv_data; | |
508 | int i, err; | ||
509 | |||
510 | 1 | nsv->state = NSV_UNSYNC; | |
511 | 1 | nsv->ahead[0].data = nsv->ahead[1].data = NULL; | |
512 | |||
513 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | for (i = 0; i < NSV_MAX_RESYNC_TRIES; i++) { |
514 | 2 | err = nsv_resync(s); | |
515 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (err < 0) |
516 | ✗ | return err; | |
517 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
|
2 | if (nsv->state == NSV_FOUND_NSVF) { |
518 | 1 | err = nsv_parse_NSVf_header(s); | |
519 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (err < 0) |
520 | ✗ | return err; | |
521 | } | ||
522 | /* we need the first NSVs also... */ | ||
523 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
|
2 | if (nsv->state == NSV_FOUND_NSVS) { |
524 | 1 | err = nsv_parse_NSVs_header(s); | |
525 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (err < 0) |
526 | ✗ | return err; | |
527 | 1 | break; /* we just want the first one */ | |
528 | } | ||
529 | } | ||
530 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (s->nb_streams < 1) /* no luck so far */ |
531 | ✗ | return AVERROR_INVALIDDATA; | |
532 | |||
533 | /* now read the first chunk, so we can attempt to decode more info */ | ||
534 | 1 | err = nsv_read_chunk(s, 1); | |
535 | |||
536 | 1 | av_log(s, AV_LOG_TRACE, "parsed header\n"); | |
537 | 1 | return err; | |
538 | } | ||
539 | |||
540 | 94 | static int nsv_read_chunk(AVFormatContext *s, int fill_header) | |
541 | { | ||
542 | 94 | NSVContext *nsv = s->priv_data; | |
543 | 94 | AVIOContext *pb = s->pb; | |
544 | 94 | AVStream *st[2] = {NULL, NULL}; | |
545 | NSVStream *nst; | ||
546 | AVPacket *pkt; | ||
547 | 94 | int i, err = 0; | |
548 | uint8_t auxcount; /* number of aux metadata, also 4 bits of vsize */ | ||
549 | uint32_t vsize; | ||
550 | uint16_t asize; | ||
551 | uint16_t auxsize; | ||
552 | int ret; | ||
553 | |||
554 |
2/4✓ Branch 0 taken 94 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 94 times.
✗ Branch 3 not taken.
|
94 | if (nsv->ahead[0].data || nsv->ahead[1].data) |
555 | ✗ | return 0; //-1; /* hey! eat what you've in your plate first! */ | |
556 | |||
557 | 94 | null_chunk_retry: | |
558 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 94 times.
|
94 | if (avio_feof(pb)) |
559 | ✗ | return -1; | |
560 | |||
561 |
4/6✓ Branch 0 taken 187 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 93 times.
✓ Branch 3 taken 94 times.
✓ Branch 4 taken 93 times.
✗ Branch 5 not taken.
|
187 | for (i = 0; i < NSV_MAX_RESYNC_TRIES && nsv->state < NSV_FOUND_NSVS && !err; i++) |
562 | 93 | err = nsv_resync(s); | |
563 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 94 times.
|
94 | if (err < 0) |
564 | ✗ | return err; | |
565 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 90 times.
|
94 | if (nsv->state == NSV_FOUND_NSVS) |
566 | 4 | err = nsv_parse_NSVs_header(s); | |
567 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 94 times.
|
94 | if (err < 0) |
568 | ✗ | return err; | |
569 |
3/4✓ Branch 0 taken 89 times.
✓ Branch 1 taken 5 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 89 times.
|
94 | if (nsv->state != NSV_HAS_READ_NSVS && nsv->state != NSV_FOUND_BEEF) |
570 | ✗ | return -1; | |
571 | |||
572 | 94 | auxcount = avio_r8(pb); | |
573 | 94 | vsize = avio_rl16(pb); | |
574 | 94 | asize = avio_rl16(pb); | |
575 | 94 | vsize = (vsize << 4) | (auxcount >> 4); | |
576 | 94 | auxcount &= 0x0f; | |
577 | 94 | av_log(s, AV_LOG_TRACE, "NSV CHUNK %d aux, %"PRIu32" bytes video, %d bytes audio\n", auxcount, vsize, asize); | |
578 | /* skip aux stuff */ | ||
579 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 94 times.
|
94 | for (i = 0; i < auxcount; i++) { |
580 | uint32_t av_unused auxtag; | ||
581 | ✗ | auxsize = avio_rl16(pb); | |
582 | ✗ | auxtag = avio_rl32(pb); | |
583 | ✗ | avio_skip(pb, auxsize); | |
584 | ✗ | vsize -= auxsize + sizeof(uint16_t) + sizeof(uint32_t); /* that's becoming brain-dead */ | |
585 | } | ||
586 | |||
587 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 94 times.
|
94 | if (avio_feof(pb)) |
588 | ✗ | return -1; | |
589 |
3/4✓ Branch 0 taken 33 times.
✓ Branch 1 taken 61 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 33 times.
|
94 | if (!vsize && !asize) { |
590 | ✗ | nsv->state = NSV_UNSYNC; | |
591 | ✗ | goto null_chunk_retry; | |
592 | } | ||
593 | |||
594 | /* map back streams to v,a */ | ||
595 |
1/2✓ Branch 0 taken 94 times.
✗ Branch 1 not taken.
|
94 | if (s->nb_streams > 0) |
596 | 94 | st[s->streams[0]->id] = s->streams[0]; | |
597 |
1/2✓ Branch 0 taken 94 times.
✗ Branch 1 not taken.
|
94 | if (s->nb_streams > 1) |
598 | 94 | st[s->streams[1]->id] = s->streams[1]; | |
599 | |||
600 |
3/4✓ Branch 0 taken 61 times.
✓ Branch 1 taken 33 times.
✓ Branch 2 taken 61 times.
✗ Branch 3 not taken.
|
94 | if (vsize && st[NSV_ST_VIDEO]) { |
601 | 61 | nst = st[NSV_ST_VIDEO]->priv_data; | |
602 | 61 | pkt = &nsv->ahead[NSV_ST_VIDEO]; | |
603 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 61 times.
|
61 | if ((ret = av_get_packet(pb, pkt, vsize)) < 0) |
604 | ✗ | return ret; | |
605 | 61 | pkt->stream_index = st[NSV_ST_VIDEO]->index;//NSV_ST_VIDEO; | |
606 | 61 | pkt->dts = nst->frame_offset; | |
607 | 61 | pkt->flags |= nsv->state == NSV_HAS_READ_NSVS ? AV_PKT_FLAG_KEY : 0; /* keyframe only likely on a sync frame */ | |
608 |
2/2✓ Branch 0 taken 488 times.
✓ Branch 1 taken 61 times.
|
549 | for (i = 0; i < FFMIN(8, vsize); i++) |
609 | 488 | av_log(s, AV_LOG_TRACE, "NSV video: [%d] = %02x\n", i, pkt->data[i]); | |
610 | } | ||
611 |
1/2✓ Branch 0 taken 94 times.
✗ Branch 1 not taken.
|
94 | if(st[NSV_ST_VIDEO]) |
612 | 94 | ((NSVStream*)st[NSV_ST_VIDEO]->priv_data)->frame_offset++; | |
613 | |||
614 |
3/4✓ Branch 0 taken 90 times.
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 90 times.
✗ Branch 3 not taken.
|
94 | if (asize && st[NSV_ST_AUDIO]) { |
615 | 90 | nst = st[NSV_ST_AUDIO]->priv_data; | |
616 | 90 | pkt = &nsv->ahead[NSV_ST_AUDIO]; | |
617 | /* read raw audio specific header on the first audio chunk... */ | ||
618 | /* on ALL audio chunks ?? seems so! */ | ||
619 |
2/4✓ Branch 0 taken 90 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 90 times.
|
90 | if (asize && st[NSV_ST_AUDIO]->codecpar->codec_tag == MKTAG('P', 'C', 'M', ' ')/* && fill_header*/) { |
620 | uint8_t bps; | ||
621 | uint8_t channels; | ||
622 | uint16_t samplerate; | ||
623 | ✗ | bps = avio_r8(pb); | |
624 | ✗ | channels = avio_r8(pb); | |
625 | ✗ | samplerate = avio_rl16(pb); | |
626 | ✗ | if (!channels || !samplerate) | |
627 | ✗ | return AVERROR_INVALIDDATA; | |
628 | ✗ | asize-=4; | |
629 | ✗ | av_log(s, AV_LOG_TRACE, "NSV RAWAUDIO: bps %d, nchan %d, srate %d\n", bps, channels, samplerate); | |
630 | ✗ | if (fill_header) { | |
631 | ✗ | ffstream(st[NSV_ST_AUDIO])->need_parsing = AVSTREAM_PARSE_NONE; /* we know everything */ | |
632 | ✗ | if (bps != 16) { | |
633 | ✗ | av_log(s, AV_LOG_TRACE, "NSV AUDIO bit/sample != 16 (%d)!!!\n", bps); | |
634 | } | ||
635 | ✗ | bps /= channels; // ??? | |
636 | ✗ | if (bps == 8) | |
637 | ✗ | st[NSV_ST_AUDIO]->codecpar->codec_id = AV_CODEC_ID_PCM_U8; | |
638 | ✗ | samplerate /= 4;/* UGH ??? XXX */ | |
639 | ✗ | channels = 1; | |
640 | ✗ | st[NSV_ST_AUDIO]->codecpar->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO; | |
641 | ✗ | st[NSV_ST_AUDIO]->codecpar->sample_rate = samplerate; | |
642 | ✗ | av_log(s, AV_LOG_TRACE, "NSV RAWAUDIO: bps %d, nchan %d, srate %d\n", bps, channels, samplerate); | |
643 | } | ||
644 | } | ||
645 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 90 times.
|
90 | if ((ret = av_get_packet(pb, pkt, asize)) < 0) |
646 | ✗ | return ret; | |
647 | 90 | pkt->stream_index = st[NSV_ST_AUDIO]->index;//NSV_ST_AUDIO; | |
648 | 90 | pkt->flags |= nsv->state == NSV_HAS_READ_NSVS ? AV_PKT_FLAG_KEY : 0; /* keyframe only likely on a sync frame */ | |
649 |
3/4✓ Branch 0 taken 4 times.
✓ Branch 1 taken 86 times.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
|
90 | if( nsv->state == NSV_HAS_READ_NSVS && st[NSV_ST_VIDEO] ) { |
650 | /* on a nsvs frame we have new information on a/v sync */ | ||
651 | 4 | pkt->dts = (((NSVStream*)st[NSV_ST_VIDEO]->priv_data)->frame_offset-1); | |
652 | 4 | pkt->dts *= (int64_t)1000 * nsv->framerate.den; | |
653 | 4 | pkt->dts += (int64_t)nsv->avsync * nsv->framerate.num; | |
654 | 4 | av_log(s, AV_LOG_TRACE, "NSV AUDIO: sync:%d, dts:%"PRId64, nsv->avsync, pkt->dts); | |
655 | } | ||
656 | 90 | nst->frame_offset++; | |
657 | } | ||
658 | |||
659 | 94 | nsv->state = NSV_UNSYNC; | |
660 | 94 | return 0; | |
661 | } | ||
662 | |||
663 | |||
664 | 150 | static int nsv_read_packet(AVFormatContext *s, AVPacket *pkt) | |
665 | { | ||
666 | 150 | NSVContext *nsv = s->priv_data; | |
667 | 150 | int i, err = 0; | |
668 | |||
669 | /* in case we don't already have something to eat ... */ | ||
670 |
4/4✓ Branch 0 taken 149 times.
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 93 times.
✓ Branch 3 taken 56 times.
|
150 | if (!nsv->ahead[0].data && !nsv->ahead[1].data) |
671 | 93 | err = nsv_read_chunk(s, 0); | |
672 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 150 times.
|
150 | if (err < 0) |
673 | ✗ | return err; | |
674 | |||
675 | /* now pick one of the plates */ | ||
676 |
1/2✓ Branch 0 taken 239 times.
✗ Branch 1 not taken.
|
239 | for (i = 0; i < 2; i++) { |
677 |
2/2✓ Branch 0 taken 150 times.
✓ Branch 1 taken 89 times.
|
239 | if (nsv->ahead[i].data) { |
678 | 150 | av_packet_move_ref(pkt, &nsv->ahead[i]); | |
679 | 150 | return 0; | |
680 | } | ||
681 | } | ||
682 | |||
683 | /* this restaurant is not provisioned :^] */ | ||
684 | ✗ | return -1; | |
685 | } | ||
686 | |||
687 | ✗ | static int nsv_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags) | |
688 | { | ||
689 | ✗ | NSVContext *nsv = s->priv_data; | |
690 | ✗ | AVStream *st = s->streams[stream_index]; | |
691 | ✗ | FFStream *const sti = ffstream(st); | |
692 | ✗ | NSVStream *nst = st->priv_data; | |
693 | int index; | ||
694 | |||
695 | ✗ | index = av_index_search_timestamp(st, timestamp, flags); | |
696 | ✗ | if(index < 0) | |
697 | ✗ | return -1; | |
698 | |||
699 | ✗ | if (avio_seek(s->pb, sti->index_entries[index].pos, SEEK_SET) < 0) | |
700 | ✗ | return -1; | |
701 | |||
702 | ✗ | nst->frame_offset = sti->index_entries[index].timestamp; | |
703 | ✗ | nsv->state = NSV_UNSYNC; | |
704 | ✗ | return 0; | |
705 | } | ||
706 | |||
707 | 1 | static int nsv_read_close(AVFormatContext *s) | |
708 | { | ||
709 | 1 | NSVContext *nsv = s->priv_data; | |
710 | |||
711 | 1 | av_freep(&nsv->nsvs_file_offset); | |
712 | 1 | av_freep(&nsv->nsvs_timestamps); | |
713 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (nsv->ahead[0].data) |
714 | ✗ | av_packet_unref(&nsv->ahead[0]); | |
715 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | if (nsv->ahead[1].data) |
716 | 1 | av_packet_unref(&nsv->ahead[1]); | |
717 | 1 | return 0; | |
718 | } | ||
719 | |||
720 | 7124 | static int nsv_probe(const AVProbeData *p) | |
721 | { | ||
722 | 7124 | int i, score = 0; | |
723 | |||
724 | /* check file header */ | ||
725 | /* streamed files might not have any header */ | ||
726 |
4/4✓ Branch 0 taken 3 times.
✓ Branch 1 taken 7121 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 2 times.
|
7124 | if (p->buf[0] == 'N' && p->buf[1] == 'S' && |
727 |
2/6✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
1 | p->buf[2] == 'V' && (p->buf[3] == 'f' || p->buf[3] == 's')) |
728 | 1 | return AVPROBE_SCORE_MAX; | |
729 | /* XXX: do streamed files always start at chunk boundary ?? */ | ||
730 | /* or do we need to search NSVs in the byte stream ? */ | ||
731 | /* seems the servers don't bother starting clean chunks... */ | ||
732 | /* sometimes even the first header is at 9KB or something :^) */ | ||
733 |
2/2✓ Branch 0 taken 367546335 times.
✓ Branch 1 taken 7123 times.
|
367553458 | for (i = 1; i < p->buf_size - 3; i++) { |
734 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 367546335 times.
|
367546335 | if (AV_RL32(p->buf + i) == AV_RL32("NSVs")) { |
735 | /* Get the chunk size and check if at the end we are getting 0xBEEF */ | ||
736 | ✗ | int vsize = AV_RL24(p->buf+i+19) >> 4; | |
737 | ✗ | int asize = AV_RL16(p->buf+i+22); | |
738 | ✗ | int offset = i + 23 + asize + vsize + 1; | |
739 | ✗ | if (offset <= p->buf_size - 2 && AV_RL16(p->buf + offset) == 0xBEEF) | |
740 | ✗ | return 4*AVPROBE_SCORE_MAX/5; | |
741 | ✗ | score = AVPROBE_SCORE_MAX/5; | |
742 | } | ||
743 | } | ||
744 | /* so we'll have more luck on extension... */ | ||
745 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 7123 times.
|
7123 | if (av_match_ext(p->filename, "nsv")) |
746 | ✗ | return AVPROBE_SCORE_EXTENSION; | |
747 | /* FIXME: add mime-type check */ | ||
748 | 7123 | return score; | |
749 | } | ||
750 | |||
751 | const FFInputFormat ff_nsv_demuxer = { | ||
752 | .p.name = "nsv", | ||
753 | .p.long_name = NULL_IF_CONFIG_SMALL("Nullsoft Streaming Video"), | ||
754 | .priv_data_size = sizeof(NSVContext), | ||
755 | .flags_internal = FF_INFMT_FLAG_INIT_CLEANUP, | ||
756 | .read_probe = nsv_probe, | ||
757 | .read_header = nsv_read_header, | ||
758 | .read_packet = nsv_read_packet, | ||
759 | .read_close = nsv_read_close, | ||
760 | .read_seek = nsv_read_seek, | ||
761 | }; | ||
762 |