Mercurial > libavformat.hg
annotate nutdec.c @ 1480:2355202d4c4c libavformat
simplify
author | michael |
---|---|
date | Sat, 11 Nov 2006 19:47:58 +0000 |
parents | 6a33963be49a |
children | 20438d25cf8c |
rev | line source |
---|---|
1477 | 1 /* |
2 * "NUT" Container Format demuxer | |
3 * Copyright (c) 2004-2006 Michael Niedermayer | |
4 * Copyright (c) 2003 Alex Beregszaszi | |
5 * | |
6 * This file is part of FFmpeg. | |
7 * | |
8 * FFmpeg is free software; you can redistribute it and/or | |
9 * modify it under the terms of the GNU Lesser General Public | |
10 * License as published by the Free Software Foundation; either | |
11 * version 2.1 of the License, or (at your option) any later version. | |
12 * | |
13 * FFmpeg is distributed in the hope that it will be useful, | |
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
16 * Lesser General Public License for more details. | |
17 * | |
18 * You should have received a copy of the GNU Lesser General Public | |
19 * License along with FFmpeg; if not, write to the Free Software | |
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
21 * | |
22 */ | |
23 | |
24 #include "nut.h" | |
25 | |
26 #undef NDEBUG | |
27 #include <assert.h> | |
28 | |
29 static uint64_t get_v(ByteIOContext *bc/*, maxstuffing*/){ | |
30 uint64_t val = 0; | |
31 | |
32 for(;;) | |
33 { | |
34 int tmp = get_byte(bc); | |
35 | |
36 // if(tmp=0x80){ | |
37 // if(!maxstuffing-- || val) | |
38 // return -1; | |
39 // } | |
40 | |
41 if (tmp&0x80) | |
42 val= (val<<7) + tmp - 0x80; | |
43 else{ | |
44 return (val<<7) + tmp; | |
45 } | |
46 } | |
47 return -1; | |
48 } | |
49 | |
50 static int get_str(ByteIOContext *bc, char *string, unsigned int maxlen){ | |
51 unsigned int len= get_v(bc); | |
52 | |
53 if(len && maxlen) | |
54 get_buffer(bc, string, FFMIN(len, maxlen)); | |
55 while(len > maxlen){ | |
56 get_byte(bc); | |
57 len--; | |
58 } | |
59 | |
60 if(maxlen) | |
61 string[FFMIN(len, maxlen-1)]= 0; | |
62 | |
63 if(maxlen == len) | |
64 return -1; | |
65 else | |
66 return 0; | |
67 } | |
68 | |
69 static int64_t get_s(ByteIOContext *bc){ | |
70 int64_t v = get_v(bc) + 1; | |
71 | |
72 if (v&1) return -(v>>1); | |
73 else return (v>>1); | |
74 } | |
75 | |
76 static uint64_t get_fourcc(ByteIOContext *bc){ | |
77 unsigned int len= get_v(bc); | |
78 | |
79 if (len==2) return get_le16(bc); | |
80 else if(len==4) return get_le32(bc); | |
81 else return -1; | |
82 } | |
83 | |
84 #ifdef TRACE | |
85 static inline uint64_t get_v_trace(ByteIOContext *bc, char *file, char *func, int line){ | |
86 uint64_t v= get_v(bc); | |
87 | |
88 printf("get_v %5"PRId64" / %"PRIX64" in %s %s:%d\n", v, v, file, func, line); | |
89 return v; | |
90 } | |
91 | |
92 static inline int64_t get_s_trace(ByteIOContext *bc, char *file, char *func, int line){ | |
93 int64_t v= get_s(bc); | |
94 | |
95 printf("get_s %5"PRId64" / %"PRIX64" in %s %s:%d\n", v, v, file, func, line); | |
96 return v; | |
97 } | |
98 | |
99 static inline uint64_t get_vb_trace(ByteIOContext *bc, char *file, char *func, int line){ | |
100 uint64_t v= get_vb(bc); | |
101 | |
102 printf("get_vb %5"PRId64" / %"PRIX64" in %s %s:%d\n", v, v, file, func, line); | |
103 return v; | |
104 } | |
105 #define get_v(bc) get_v_trace(bc, __FILE__, __PRETTY_FUNCTION__, __LINE__) | |
106 #define get_s(bc) get_s_trace(bc, __FILE__, __PRETTY_FUNCTION__, __LINE__) | |
107 #define get_vb(bc) get_vb_trace(bc, __FILE__, __PRETTY_FUNCTION__, __LINE__) | |
108 #endif | |
109 | |
110 static int get_packetheader(NUTContext *nut, ByteIOContext *bc, int calculate_checksum) | |
111 { | |
112 int64_t start, size; | |
113 // start= url_ftell(bc) - 8; | |
114 | |
115 size= get_v(bc); | |
116 | |
117 init_checksum(bc, calculate_checksum ? av_crc04C11DB7_update : NULL, 1); | |
118 | |
119 // nut->packet_start[2] = start; | |
120 // nut->written_packet_size= size; | |
121 | |
122 return size; | |
123 } | |
124 | |
125 static int check_checksum(ByteIOContext *bc){ | |
126 unsigned long checksum= get_checksum(bc); | |
127 // return checksum != get_be32(bc); | |
128 | |
129 av_log(NULL, AV_LOG_ERROR, "%08X %08X\n", checksum, (int)get_be32(bc)); | |
130 | |
131 return 0; | |
132 } | |
133 | |
134 static uint64_t find_any_startcode(ByteIOContext *bc, int64_t pos){ | |
135 uint64_t state=0; | |
136 | |
137 if(pos >= 0) | |
138 url_fseek(bc, pos, SEEK_SET); //note, this may fail if the stream isnt seekable, but that shouldnt matter, as in this case we simply start where we are currently | |
139 | |
140 while(!url_feof(bc)){ | |
141 state= (state<<8) | get_byte(bc); | |
142 if((state>>56) != 'N') | |
143 continue; | |
144 switch(state){ | |
145 case MAIN_STARTCODE: | |
146 case STREAM_STARTCODE: | |
147 case SYNCPOINT_STARTCODE: | |
148 case INFO_STARTCODE: | |
149 case INDEX_STARTCODE: | |
150 return state; | |
151 } | |
152 } | |
153 | |
154 return 0; | |
155 } | |
156 | |
157 /** | |
158 * find the given startcode. | |
159 * @param code the startcode | |
160 * @param pos the start position of the search, or -1 if the current position | |
161 * @returns the position of the startcode or -1 if not found | |
162 */ | |
163 static int64_t find_startcode(ByteIOContext *bc, uint64_t code, int64_t pos){ | |
164 for(;;){ | |
165 uint64_t startcode= find_any_startcode(bc, pos); | |
166 if(startcode == code) | |
167 return url_ftell(bc) - 8; | |
168 else if(startcode == 0) | |
169 return -1; | |
170 pos=-1; | |
171 } | |
172 } | |
173 | |
174 static int64_t lsb2full(StreamContext *stream, int64_t lsb){ | |
175 int64_t mask = (1<<stream->msb_pts_shift)-1; | |
176 int64_t delta= stream->last_pts - mask/2; | |
177 return ((lsb - delta)&mask) + delta; | |
178 } | |
179 | |
180 static int nut_probe(AVProbeData *p){ | |
181 int i; | |
182 uint64_t code= 0; | |
183 | |
184 for (i = 0; i < p->buf_size; i++) { | |
185 code = (code << 8) | p->buf[i]; | |
186 if (code == MAIN_STARTCODE) | |
187 return AVPROBE_SCORE_MAX; | |
188 } | |
189 return 0; | |
190 } | |
191 | |
192 #define GET_V(dst, check) \ | |
193 tmp= get_v(bc);\ | |
194 if(!(check)){\ | |
195 av_log(s, AV_LOG_ERROR, "Error " #dst " is (%"PRId64")\n", tmp);\ | |
196 return -1;\ | |
197 }\ | |
198 dst= tmp; | |
199 | |
200 static int skip_reserved(ByteIOContext *bc, int64_t pos){ | |
201 pos -= url_ftell(bc); | |
202 | |
203 if(pos<0){ | |
204 url_fseek(bc, pos, SEEK_CUR); | |
205 return -1; | |
206 }else{ | |
207 while(pos--) | |
208 get_byte(bc); | |
209 return 0; | |
210 } | |
211 } | |
212 | |
213 static int decode_main_header(NUTContext *nut){ | |
214 AVFormatContext *s= nut->avf; | |
215 ByteIOContext *bc = &s->pb; | |
216 uint64_t tmp, end; | |
217 unsigned int stream_count; | |
218 int i, j, tmp_stream, tmp_mul, tmp_pts, tmp_size, count, tmp_res; | |
219 | |
220 end= get_packetheader(nut, bc, 1); | |
221 end += url_ftell(bc) - 4; | |
222 | |
223 GET_V(tmp , tmp >=2 && tmp <= 3) | |
224 GET_V(stream_count , tmp > 0 && tmp <=MAX_STREAMS) | |
225 | |
226 nut->max_distance = get_v(bc); | |
227 if(nut->max_distance > 65536){ | |
228 av_log(s, AV_LOG_DEBUG, "max_distance %d\n", nut->max_distance); | |
229 nut->max_distance= 65536; | |
230 } | |
231 | |
232 GET_V(nut->time_base_count, tmp>0 && tmp<INT_MAX / sizeof(AVRational)) | |
233 nut->time_base= av_malloc(nut->time_base_count * sizeof(AVRational)); | |
234 | |
235 for(i=0; i<nut->time_base_count; i++){ | |
236 GET_V(nut->time_base[i].num, tmp>0 && tmp<(1ULL<<31)) | |
237 GET_V(nut->time_base[i].den, tmp>0 && tmp<(1ULL<<31)) | |
238 if(ff_gcd(nut->time_base[i].num, nut->time_base[i].den) != 1){ | |
239 av_log(s, AV_LOG_ERROR, "time base invalid\n"); | |
240 return -1; | |
241 } | |
242 } | |
243 tmp_pts=0; | |
244 tmp_mul=1; | |
245 tmp_stream=0; | |
246 for(i=0; i<256;){ | |
247 int tmp_flags = get_v(bc); | |
248 int tmp_fields= get_v(bc); | |
249 if(tmp_fields>0) tmp_pts = get_s(bc); | |
250 if(tmp_fields>1) tmp_mul = get_v(bc); | |
251 if(tmp_fields>2) tmp_stream= get_v(bc); | |
252 if(tmp_fields>3) tmp_size = get_v(bc); | |
253 else tmp_size = 0; | |
254 if(tmp_fields>4) tmp_res = get_v(bc); | |
255 else tmp_res = 0; | |
256 if(tmp_fields>5) count = get_v(bc); | |
257 else count = tmp_mul - tmp_size; | |
258 | |
259 while(tmp_fields-- > 6) | |
260 get_v(bc); | |
261 | |
262 if(count == 0 || i+count > 256){ | |
263 av_log(s, AV_LOG_ERROR, "illegal count %d at %d\n", count, i); | |
264 return -1; | |
265 } | |
266 if(tmp_stream >= stream_count){ | |
267 av_log(s, AV_LOG_ERROR, "illegal stream number\n"); | |
268 return -1; | |
269 } | |
270 | |
271 for(j=0; j<count; j++,i++){ | |
272 if (i == 'N') { | |
273 nut->frame_code[i].flags= FLAG_INVALID; | |
274 j--; | |
275 continue; | |
276 } | |
277 nut->frame_code[i].flags = tmp_flags ; | |
278 nut->frame_code[i].pts_delta = tmp_pts ; | |
279 nut->frame_code[i].stream_id = tmp_stream; | |
280 nut->frame_code[i].size_mul = tmp_mul ; | |
281 nut->frame_code[i].size_lsb = tmp_size+j; | |
282 nut->frame_code[i].reserved_count = tmp_res ; | |
283 } | |
284 } | |
285 assert(nut->frame_code['N'].flags == FLAG_INVALID); | |
286 | |
287 if(skip_reserved(bc, end) || check_checksum(bc)){ | |
288 av_log(s, AV_LOG_ERROR, "Main header checksum mismatch\n"); | |
289 return -1; | |
290 } | |
291 | |
292 nut->stream = av_mallocz(sizeof(StreamContext)*stream_count); | |
293 for(i=0; i<stream_count; i++){ | |
294 av_new_stream(s, i); | |
295 } | |
296 | |
297 return 0; | |
298 } | |
299 | |
300 static int decode_stream_header(NUTContext *nut){ | |
301 AVFormatContext *s= nut->avf; | |
302 ByteIOContext *bc = &s->pb; | |
303 StreamContext *stc; | |
304 int class, nom, denom, stream_id; | |
305 uint64_t tmp, end; | |
306 AVStream *st; | |
307 | |
308 end= get_packetheader(nut, bc, 1); | |
309 end += url_ftell(bc) - 4; | |
310 | |
311 GET_V(stream_id, tmp < s->nb_streams && !nut->stream[tmp].time_base.num); | |
312 stc= &nut->stream[stream_id]; | |
313 | |
314 st = s->streams[stream_id]; | |
315 if (!st) | |
316 return AVERROR_NOMEM; | |
317 | |
318 class = get_v(bc); | |
319 tmp = get_fourcc(bc); | |
320 st->codec->codec_tag= tmp; | |
321 switch(class) | |
322 { | |
323 case 0: | |
324 st->codec->codec_type = CODEC_TYPE_VIDEO; | |
325 st->codec->codec_id = codec_get_bmp_id(tmp); | |
326 if (st->codec->codec_id == CODEC_ID_NONE) | |
327 av_log(s, AV_LOG_ERROR, "Unknown codec?!\n"); | |
328 break; | |
329 case 1: | |
330 st->codec->codec_type = CODEC_TYPE_AUDIO; | |
331 st->codec->codec_id = codec_get_wav_id(tmp); | |
332 if (st->codec->codec_id == CODEC_ID_NONE) | |
333 av_log(s, AV_LOG_ERROR, "Unknown codec?!\n"); | |
334 break; | |
335 case 2: | |
336 // st->codec->codec_type = CODEC_TYPE_TEXT; | |
337 // break; | |
338 case 3: | |
339 st->codec->codec_type = CODEC_TYPE_DATA; | |
340 break; | |
341 default: | |
342 av_log(s, AV_LOG_ERROR, "Unknown stream class (%d)\n", class); | |
343 return -1; | |
344 } | |
345 GET_V(stc->time_base_id , tmp < nut->time_base_count); | |
346 GET_V(stc->msb_pts_shift , tmp < 16); | |
347 stc->max_pts_distance= get_v(bc); | |
348 GET_V(stc->decode_delay , tmp < 1000); //sanity limit, raise this if moors law is true | |
349 st->codec->has_b_frames= stc->decode_delay; | |
350 get_v(bc); //stream flags | |
351 | |
352 GET_V(st->codec->extradata_size, tmp < (1<<30)); | |
353 if(st->codec->extradata_size){ | |
354 st->codec->extradata= av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE); | |
355 get_buffer(bc, st->codec->extradata, st->codec->extradata_size); | |
356 } | |
357 | |
358 if (st->codec->codec_type == CODEC_TYPE_VIDEO){ | |
359 GET_V(st->codec->width , tmp > 0) | |
360 GET_V(st->codec->height, tmp > 0) | |
361 st->codec->sample_aspect_ratio.num= get_v(bc); | |
362 st->codec->sample_aspect_ratio.den= get_v(bc); | |
363 if((!st->codec->sample_aspect_ratio.num) != (!st->codec->sample_aspect_ratio.den)){ | |
364 av_log(s, AV_LOG_ERROR, "invalid aspect ratio\n"); | |
365 return -1; | |
366 } | |
367 get_v(bc); /* csp type */ | |
368 }else if (st->codec->codec_type == CODEC_TYPE_AUDIO){ | |
369 GET_V(st->codec->sample_rate , tmp > 0) | |
370 tmp= get_v(bc); // samplerate_den | |
371 if(tmp > st->codec->sample_rate){ | |
372 av_log(s, AV_LOG_ERROR, "bleh, libnut muxed this ;)\n"); | |
373 st->codec->sample_rate= tmp; | |
374 } | |
375 GET_V(st->codec->channels, tmp > 0) | |
376 } | |
377 if(skip_reserved(bc, end) || check_checksum(bc)){ | |
378 av_log(s, AV_LOG_ERROR, "Stream header %d checksum mismatch\n", stream_id); | |
379 return -1; | |
380 } | |
381 stc->time_base= nut->time_base[stc->time_base_id]; | |
382 av_set_pts_info(s->streams[stream_id], 63, stc->time_base.num, stc->time_base.den); | |
383 return 0; | |
384 } | |
385 | |
386 static int decode_info_header(NUTContext *nut){ | |
387 AVFormatContext *s= nut->avf; | |
388 ByteIOContext *bc = &s->pb; | |
389 uint64_t tmp; | |
390 unsigned int stream_id_plus1, chapter_start, chapter_len, count; | |
391 int chapter_id, i; | |
392 int64_t value, end; | |
393 char name[256], str_value[1024], type_str[256], *type= type_str; | |
394 | |
395 end= get_packetheader(nut, bc, 1); | |
396 end += url_ftell(bc) - 4; | |
397 | |
398 GET_V(stream_id_plus1, tmp <= s->nb_streams) | |
399 chapter_id = get_s(bc); | |
400 chapter_start= get_v(bc); | |
401 chapter_len = get_v(bc); | |
402 count = get_v(bc); | |
403 for(i=0; i<count; i++){ | |
404 get_str(bc, name, sizeof(name)); | |
405 value= get_s(bc); | |
406 if(value == -1){ | |
407 type= "UTF-8"; | |
408 get_str(bc, str_value, sizeof(str_value)); | |
409 }else if(value == -2){ | |
410 get_str(bc, type, sizeof(type)); | |
411 get_str(bc, str_value, sizeof(str_value)); | |
412 }else if(value == -3){ | |
413 type= "s"; | |
414 value= get_s(bc); | |
415 }else if(value == -4){ | |
416 type= "t"; | |
417 value= get_v(bc); | |
418 }else if(value < -4){ | |
419 type= "r"; | |
420 get_s(bc); | |
421 }else{ | |
422 type= "v"; | |
423 } | |
424 | |
425 if(chapter_id==0 && !strcmp(type, "UTF-8")){ | |
426 if (!strcmp(name, "Author")) | |
427 pstrcpy(s->author , sizeof(s->author) , str_value); | |
428 else if(!strcmp(name, "Title")) | |
429 pstrcpy(s->title , sizeof(s->title) , str_value); | |
430 else if(!strcmp(name, "Copyright")) | |
431 pstrcpy(s->copyright, sizeof(s->copyright), str_value); | |
432 else if(!strcmp(name, "Description")) | |
433 pstrcpy(s->comment , sizeof(s->comment) , str_value); | |
434 } | |
435 } | |
436 | |
437 if(skip_reserved(bc, end) || check_checksum(bc)){ | |
438 av_log(s, AV_LOG_ERROR, "Info header checksum mismatch\n"); | |
439 return -1; | |
440 } | |
441 return 0; | |
442 } | |
443 | |
444 static int decode_syncpoint(NUTContext *nut){ | |
445 AVFormatContext *s= nut->avf; | |
446 ByteIOContext *bc = &s->pb; | |
447 int64_t end; | |
448 uint64_t tmp; | |
449 int i; | |
450 AVRational time_base; | |
451 | |
1478 | 452 nut->last_syncpoint_pos= url_ftell(bc)-8; |
1477 | 453 |
454 end= get_packetheader(nut, bc, 1); | |
455 end += url_ftell(bc) - 4; | |
456 | |
457 tmp= get_v(bc); | |
458 get_v(bc); //back_ptr_div16 | |
459 | |
460 time_base= nut->time_base[tmp % nut->time_base_count]; | |
461 for(i=0; i<s->nb_streams; i++){ | |
462 nut->stream[i].last_pts= av_rescale_q(tmp / nut->time_base_count, time_base, nut->stream[i].time_base); //FIXME rounding and co | |
463 //last_key_frame ? | |
464 } | |
465 //FIXME put this in a reset func maybe | |
466 | |
467 if(skip_reserved(bc, end) || check_checksum(bc)){ | |
1478 | 468 av_log(s, AV_LOG_ERROR, "sync point checksum mismatch\n"); |
1477 | 469 return -1; |
470 } | |
471 return 0; | |
472 } | |
473 | |
474 static int nut_read_header(AVFormatContext *s, AVFormatParameters *ap) | |
475 { | |
476 NUTContext *nut = s->priv_data; | |
477 ByteIOContext *bc = &s->pb; | |
478 int64_t pos; | |
479 int inited_stream_count; | |
480 | |
481 nut->avf= s; | |
482 | |
483 /* main header */ | |
484 pos=0; | |
1480 | 485 do{ |
1477 | 486 pos= find_startcode(bc, MAIN_STARTCODE, pos)+1; |
487 if (pos<0+1){ | |
488 av_log(s, AV_LOG_ERROR, "no main startcode found\n"); | |
489 return -1; | |
490 } | |
1480 | 491 }while(decode_main_header(nut) < 0); |
1477 | 492 |
493 /* stream headers */ | |
494 pos=0; | |
495 for(inited_stream_count=0; inited_stream_count < s->nb_streams;){ | |
496 pos= find_startcode(bc, STREAM_STARTCODE, pos)+1; | |
497 if (pos<0+1){ | |
498 av_log(s, AV_LOG_ERROR, "not all stream headers found\n"); | |
499 return -1; | |
500 } | |
501 if(decode_stream_header(nut) >= 0) | |
502 inited_stream_count++; | |
503 } | |
504 | |
505 /* info headers */ | |
506 pos=0; | |
507 for(;;){ | |
508 uint64_t startcode= find_any_startcode(bc, pos); | |
509 pos= url_ftell(bc); | |
510 | |
511 if(startcode==0){ | |
512 av_log(s, AV_LOG_ERROR, "EOF before video frames\n"); | |
513 return -1; | |
514 }else if(startcode == SYNCPOINT_STARTCODE){ | |
515 nut->next_startcode= startcode; | |
516 break; | |
517 }else if(startcode != INFO_STARTCODE){ | |
518 continue; | |
519 } | |
520 | |
521 decode_info_header(nut); | |
522 } | |
523 | |
1478 | 524 s->data_offset= pos-8; |
525 | |
1477 | 526 return 0; |
527 } | |
528 | |
529 static int decode_frame_header(NUTContext *nut, int *flags_ret, int64_t *pts, int *stream_id, int frame_code){ | |
530 AVFormatContext *s= nut->avf; | |
531 ByteIOContext *bc = &s->pb; | |
532 StreamContext *stc; | |
533 int size, flags, size_mul, pts_delta, i, reserved_count; | |
534 uint64_t tmp; | |
535 | |
536 if(url_ftell(bc) > nut->last_syncpoint_pos + nut->max_distance){ | |
1478 | 537 av_log(s, AV_LOG_ERROR, "last frame must have been damaged %Ld > %Ld + %d\n", url_ftell(bc), nut->last_syncpoint_pos, nut->max_distance); |
1477 | 538 return -1; |
539 } | |
540 | |
541 flags = nut->frame_code[frame_code].flags; | |
542 size_mul = nut->frame_code[frame_code].size_mul; | |
543 size = nut->frame_code[frame_code].size_lsb; | |
544 *stream_id = nut->frame_code[frame_code].stream_id; | |
545 pts_delta = nut->frame_code[frame_code].pts_delta; | |
546 reserved_count = nut->frame_code[frame_code].reserved_count; | |
547 | |
548 if(flags & FLAG_INVALID) | |
549 return -1; | |
550 if(flags & FLAG_CODED) | |
551 flags ^= get_v(bc); | |
552 if(flags & FLAG_STREAM_ID){ | |
553 GET_V(*stream_id, tmp < s->nb_streams) | |
554 } | |
555 stc= &nut->stream[*stream_id]; | |
556 if(flags&FLAG_CODED_PTS){ | |
557 int coded_pts= get_v(bc); | |
558 //FIXME check last_pts validity? | |
559 if(coded_pts < (1<<stc->msb_pts_shift)){ | |
560 *pts=lsb2full(stc, coded_pts); | |
561 }else | |
562 *pts=coded_pts - (1<<stc->msb_pts_shift); | |
563 }else | |
564 *pts= stc->last_pts + pts_delta; | |
565 if(flags&FLAG_SIZE_MSB){ | |
566 size += size_mul*get_v(bc); | |
567 } | |
568 if(flags&FLAG_RESERVED) | |
569 reserved_count= get_v(bc); | |
570 for(i=0; i<reserved_count; i++) | |
571 get_v(bc); | |
572 if(flags&FLAG_CHECKSUM){ | |
573 get_be32(bc); //FIXME check this | |
574 } | |
575 *flags_ret= flags; | |
576 | |
577 stc->last_pts= *pts; | |
578 stc->last_key_frame= flags&FLAG_KEY; //FIXME change to last flags | |
579 | |
1478 | 580 if(flags&FLAG_KEY){ |
581 av_add_index_entry( | |
582 s->streams[*stream_id], | |
583 nut->last_syncpoint_pos, | |
584 *pts, | |
585 0, | |
586 0, | |
587 AVINDEX_KEYFRAME); | |
588 } | |
589 | |
1477 | 590 return size; |
591 } | |
592 | |
593 static int decode_frame(NUTContext *nut, AVPacket *pkt, int frame_code){ | |
594 AVFormatContext *s= nut->avf; | |
595 ByteIOContext *bc = &s->pb; | |
596 int size, stream_id, flags, discard; | |
597 int64_t pts, last_IP_pts; | |
598 | |
599 size= decode_frame_header(nut, &flags, &pts, &stream_id, frame_code); | |
600 if(size < 0) | |
601 return -1; | |
602 | |
603 discard= s->streams[ stream_id ]->discard; | |
604 last_IP_pts= s->streams[ stream_id ]->last_IP_pts; | |
605 if( (discard >= AVDISCARD_NONKEY && !(flags & FLAG_KEY)) | |
606 ||(discard >= AVDISCARD_BIDIR && last_IP_pts != AV_NOPTS_VALUE && last_IP_pts > pts) | |
607 || discard >= AVDISCARD_ALL){ | |
608 url_fskip(bc, size); | |
609 return 1; | |
610 } | |
611 | |
612 av_get_packet(bc, pkt, size); | |
613 pkt->stream_index = stream_id; | |
614 if (flags & FLAG_KEY) | |
615 pkt->flags |= PKT_FLAG_KEY; | |
616 pkt->pts = pts; | |
617 | |
618 return 0; | |
619 } | |
620 | |
621 static int nut_read_packet(AVFormatContext *s, AVPacket *pkt) | |
622 { | |
623 NUTContext *nut = s->priv_data; | |
624 ByteIOContext *bc = &s->pb; | |
625 int i, frame_code=0, ret, skip; | |
626 | |
627 for(;;){ | |
628 int64_t pos= url_ftell(bc); | |
629 uint64_t tmp= nut->next_startcode; | |
630 nut->next_startcode=0; | |
631 | |
632 if (url_feof(bc)) | |
633 return -1; | |
634 | |
635 if(tmp){ | |
636 pos-=8; | |
637 }else{ | |
638 frame_code = get_byte(bc); | |
639 if(frame_code == 'N'){ | |
640 tmp= frame_code; | |
641 for(i=1; i<8; i++) | |
642 tmp = (tmp<<8) + get_byte(bc); | |
643 } | |
644 } | |
645 switch(tmp){ | |
646 case MAIN_STARTCODE: | |
647 case STREAM_STARTCODE: | |
648 case INDEX_STARTCODE: | |
649 skip= get_packetheader(nut, bc, 0); | |
650 url_fseek(bc, skip, SEEK_CUR); | |
651 break; | |
652 case INFO_STARTCODE: | |
653 if(decode_info_header(nut)<0) | |
654 goto resync; | |
655 break; | |
656 case SYNCPOINT_STARTCODE: | |
657 if(decode_syncpoint(nut)<0) | |
658 goto resync; | |
659 frame_code = get_byte(bc); | |
660 case 0: | |
661 ret= decode_frame(nut, pkt, frame_code); | |
662 if(ret==0) | |
663 return 0; | |
664 else if(ret==1) //ok but discard packet | |
665 break; | |
666 default: | |
667 resync: | |
668 av_log(s, AV_LOG_DEBUG, "syncing from %"PRId64"\n", pos); | |
669 tmp= find_any_startcode(bc, pos+1); | |
670 if(tmp==0) | |
671 return -1; | |
672 av_log(s, AV_LOG_DEBUG, "sync\n"); | |
673 nut->next_startcode= tmp; | |
674 } | |
675 } | |
676 } | |
677 | |
1478 | 678 static int64_t nut_read_timestamp(AVFormatContext *s, int stream_index, int64_t *pos_arg, int64_t pos_limit){ |
679 NUTContext *nut = s->priv_data; | |
680 ByteIOContext *bc = &s->pb; | |
681 int64_t pos, pts; | |
682 int frame_code, stream_id,size, flags; | |
683 av_log(s, AV_LOG_DEBUG, "read_timestamp(X,%d,%"PRId64",%"PRId64")\n", stream_index, *pos_arg, pos_limit); | |
684 | |
685 pos= *pos_arg; | |
686 resync: | |
687 do{ | |
688 pos= find_startcode(bc, SYNCPOINT_STARTCODE, pos)+1; | |
689 if(pos < 1){ | |
690 assert(nut->next_startcode == 0); | |
691 av_log(s, AV_LOG_ERROR, "read_timestamp failed\n"); | |
692 return AV_NOPTS_VALUE; | |
693 } | |
694 }while(decode_syncpoint(nut) < 0); | |
695 *pos_arg = pos-1; | |
696 assert(nut->last_syncpoint_pos == *pos_arg); | |
697 | |
698 do{ | |
699 frame_code= get_byte(bc); | |
1479
6a33963be49a
dont do startcode search from last syncpoint if there are no errors
michael
parents:
1478
diff
changeset
|
700 if(frame_code == 'N'){ |
6a33963be49a
dont do startcode search from last syncpoint if there are no errors
michael
parents:
1478
diff
changeset
|
701 pos= url_ftell(bc)-1; |
1478 | 702 goto resync; |
1479
6a33963be49a
dont do startcode search from last syncpoint if there are no errors
michael
parents:
1478
diff
changeset
|
703 } |
1478 | 704 //FIXME consider pos_limit and eof |
705 size= decode_frame_header(nut, &flags, &pts, &stream_id, frame_code); | |
706 | |
707 if(size < 0) | |
708 goto resync; | |
709 | |
710 url_fseek(bc, size, SEEK_CUR); | |
711 }while(stream_id != stream_index || !(flags & FLAG_KEY)); | |
712 assert(nut->next_startcode == 0); | |
713 av_log(s, AV_LOG_DEBUG, "read_timestamp success\n"); | |
714 | |
715 return pts; | |
716 } | |
717 | |
1477 | 718 static int nut_read_close(AVFormatContext *s) |
719 { | |
720 NUTContext *nut = s->priv_data; | |
721 | |
722 av_freep(&nut->time_base); | |
723 av_freep(&nut->stream); | |
724 | |
725 return 0; | |
726 } | |
727 | |
728 #ifdef CONFIG_NUT_DEMUXER | |
729 AVInputFormat nut_demuxer = { | |
730 "nut", | |
731 "nut format", | |
732 sizeof(NUTContext), | |
733 nut_probe, | |
734 nut_read_header, | |
735 nut_read_packet, | |
736 nut_read_close, | |
737 NULL, | |
1478 | 738 nut_read_timestamp, |
1477 | 739 .extensions = "nut", |
740 }; | |
741 #endif |