Mercurial > libavformat.hg
annotate nut.c @ 804:6a0cd265adbb libavformat
fix assertion failure
author | michael |
---|---|
date | Wed, 29 Jun 2005 08:48:26 +0000 |
parents | b54823a20627 |
children | feca73904e67 |
rev | line source |
---|---|
219 | 1 /* |
403 | 2 * "NUT" Container Format muxer and demuxer (DRAFT-200403??) |
219 | 3 * Copyright (c) 2003 Alex Beregszaszi |
403 | 4 * Copyright (c) 2004 Michael Niedermayer |
219 | 5 * |
6 * This library is free software; you can redistribute it and/or | |
7 * modify it under the terms of the GNU Lesser General Public | |
8 * License as published by the Free Software Foundation; either | |
9 * version 2 of the License, or (at your option) any later version. | |
10 * | |
11 * This library is distributed in the hope that it will be useful, | |
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
14 * Lesser General Public License for more details. | |
15 * | |
16 * You should have received a copy of the GNU General Public | |
17 * License along with this library; if not, write to the Free Software | |
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
19 * | |
20 * | |
787 | 21 * Visit the official site at http://www.nut.hu/ |
219 | 22 * |
23 */ | |
24 | |
25 /* | |
26 * TODO: | |
27 * - index writing | |
415 | 28 * - index packet reading support |
219 | 29 */ |
30 | |
31 //#define DEBUG 1 | |
32 | |
403 | 33 #include <limits.h> |
219 | 34 #include "avformat.h" |
35 #include "mpegaudio.h" | |
228 | 36 #include "avi.h" |
219 | 37 |
403 | 38 #undef NDEBUG |
39 #include <assert.h> | |
40 | |
461 | 41 //#define TRACE |
42 | |
220 | 43 //from /dev/random |
44 | |
403 | 45 #define MAIN_STARTCODE (0x7A561F5F04ADULL + (((uint64_t)('N'<<8) + 'M')<<48)) |
46 #define STREAM_STARTCODE (0x11405BF2F9DBULL + (((uint64_t)('N'<<8) + 'S')<<48)) | |
47 #define KEYFRAME_STARTCODE (0xE4ADEECA4569ULL + (((uint64_t)('N'<<8) + 'K')<<48)) | |
48 #define INDEX_STARTCODE (0xDD672F23E64EULL + (((uint64_t)('N'<<8) + 'X')<<48)) | |
49 #define INFO_STARTCODE (0xAB68B596BA78ULL + (((uint64_t)('N'<<8) + 'I')<<48)) | |
50 | |
478 | 51 #define ID_STRING "nut/multimedia container\0" |
52 | |
456 | 53 #define MAX_DISTANCE (1024*16-1) |
54 #define MAX_SHORT_DISTANCE (1024*4-1) | |
403 | 55 |
461 | 56 #define FLAG_DATA_SIZE 1 |
57 #define FLAG_KEY_FRAME 2 | |
58 #define FLAG_INVALID 4 | |
403 | 59 |
60 typedef struct { | |
61 uint8_t flags; | |
62 uint8_t stream_id_plus1; | |
456 | 63 uint16_t size_mul; |
64 uint16_t size_lsb; | |
461 | 65 int16_t timestamp_delta; |
66 uint8_t reserved_count; | |
403 | 67 } FrameCode; |
68 | |
69 typedef struct { | |
70 int last_key_frame; | |
71 int msb_timestamp_shift; | |
72 int rate_num; | |
73 int rate_den; | |
74 int64_t last_pts; | |
426 | 75 int64_t last_sync_pos; ///<pos of last 1/2 type frame |
456 | 76 int decode_delay; |
403 | 77 } StreamContext; |
220 | 78 |
219 | 79 typedef struct { |
403 | 80 AVFormatContext *avf; |
81 int written_packet_size; | |
456 | 82 int64_t packet_start[3]; //0-> startcode less, 1-> short startcode 2-> long startcodes |
403 | 83 FrameCode frame_code[256]; |
639 | 84 unsigned int stream_count; |
421 | 85 uint64_t next_startcode; ///< stores the next startcode if it has alraedy been parsed but the stream isnt seekable |
403 | 86 StreamContext *stream; |
456 | 87 int max_distance; |
478 | 88 int max_short_distance; |
461 | 89 int rate_num; |
90 int rate_den; | |
91 int short_startcode; | |
219 | 92 } NUTContext; |
93 | |
415 | 94 static char *info_table[][2]={ |
95 {NULL , NULL }, // end | |
96 {NULL , NULL }, | |
97 {NULL , "UTF8"}, | |
98 {NULL , "v"}, | |
99 {NULL , "s"}, | |
100 {"StreamId" , "v"}, | |
101 {"SegmentId" , "v"}, | |
102 {"StartTimestamp" , "v"}, | |
103 {"EndTimestamp" , "v"}, | |
104 {"Author" , "UTF8"}, | |
416 | 105 {"Title" , "UTF8"}, |
415 | 106 {"Description" , "UTF8"}, |
107 {"Copyright" , "UTF8"}, | |
108 {"Encoder" , "UTF8"}, | |
109 {"Keyword" , "UTF8"}, | |
110 {"Cover" , "JPEG"}, | |
111 {"Cover" , "PNG"}, | |
112 }; | |
113 | |
782 | 114 void ff_parse_specific_params(AVCodecContext *stream, int *au_rate, int *au_ssize, int *au_scale); |
115 | |
403 | 116 static void update(NUTContext *nut, int stream_index, int64_t frame_start, int frame_type, int frame_code, int key_frame, int size, int64_t pts){ |
117 StreamContext *stream= &nut->stream[stream_index]; | |
118 | |
119 stream->last_key_frame= key_frame; | |
456 | 120 nut->packet_start[ frame_type ]= frame_start; |
403 | 121 stream->last_pts= pts; |
122 } | |
123 | |
461 | 124 static void reset(AVFormatContext *s, int64_t global_ts){ |
403 | 125 NUTContext *nut = s->priv_data; |
126 int i; | |
127 | |
128 for(i=0; i<s->nb_streams; i++){ | |
129 StreamContext *stream= &nut->stream[i]; | |
130 | |
131 stream->last_key_frame= 1; | |
461 | 132 |
133 stream->last_pts= av_rescale(global_ts, stream->rate_num*(int64_t)nut->rate_den, stream->rate_den*(int64_t)nut->rate_num); | |
403 | 134 } |
135 } | |
136 | |
137 static void build_frame_code(AVFormatContext *s){ | |
138 NUTContext *nut = s->priv_data; | |
461 | 139 int key_frame, index, pred, stream_id; |
403 | 140 int start=0; |
141 int end= 255; | |
142 int keyframe_0_esc= s->nb_streams > 2; | |
461 | 143 int pred_table[10]; |
403 | 144 |
145 if(keyframe_0_esc){ | |
456 | 146 /* keyframe = 0 escape */ |
147 FrameCode *ft= &nut->frame_code[start]; | |
461 | 148 ft->flags= FLAG_DATA_SIZE; |
456 | 149 ft->stream_id_plus1= 0; |
150 ft->size_mul=1; | |
461 | 151 ft->timestamp_delta=0; |
456 | 152 start++; |
403 | 153 } |
154 | |
155 for(stream_id= 0; stream_id<s->nb_streams; stream_id++){ | |
156 int start2= start + (end-start)*stream_id / s->nb_streams; | |
157 int end2 = start + (end-start)*(stream_id+1) / s->nb_streams; | |
158 AVCodecContext *codec = &s->streams[stream_id]->codec; | |
159 int is_audio= codec->codec_type == CODEC_TYPE_AUDIO; | |
160 int intra_only= /*codec->intra_only || */is_audio; | |
161 int pred_count; | |
162 | |
163 for(key_frame=0; key_frame<2; key_frame++){ | |
164 if(intra_only && keyframe_0_esc && key_frame==0) | |
165 continue; | |
166 | |
456 | 167 { |
168 FrameCode *ft= &nut->frame_code[start2]; | |
169 ft->flags= FLAG_KEY_FRAME*key_frame; | |
461 | 170 ft->flags|= FLAG_DATA_SIZE; |
456 | 171 ft->stream_id_plus1= stream_id + 1; |
172 ft->size_mul=1; | |
461 | 173 ft->timestamp_delta=0; |
456 | 174 start2++; |
403 | 175 } |
176 } | |
177 | |
178 key_frame= intra_only; | |
179 #if 1 | |
180 if(is_audio){ | |
181 int frame_bytes= codec->frame_size*(int64_t)codec->bit_rate / (8*codec->sample_rate); | |
461 | 182 int pts; |
183 for(pts=0; pts<2; pts++){ | |
456 | 184 for(pred=0; pred<2; pred++){ |
403 | 185 FrameCode *ft= &nut->frame_code[start2]; |
461 | 186 ft->flags= FLAG_KEY_FRAME*key_frame; |
403 | 187 ft->stream_id_plus1= stream_id + 1; |
456 | 188 ft->size_mul=frame_bytes + 2; |
189 ft->size_lsb=frame_bytes + pred; | |
461 | 190 ft->timestamp_delta=pts; |
403 | 191 start2++; |
192 } | |
193 } | |
194 }else{ | |
195 FrameCode *ft= &nut->frame_code[start2]; | |
196 ft->flags= FLAG_KEY_FRAME | FLAG_DATA_SIZE; | |
197 ft->stream_id_plus1= stream_id + 1; | |
198 ft->size_mul=1; | |
461 | 199 ft->timestamp_delta=1; |
403 | 200 start2++; |
201 } | |
202 #endif | |
461 | 203 |
204 if(codec->has_b_frames){ | |
205 pred_count=5; | |
206 pred_table[0]=-2; | |
207 pred_table[1]=-1; | |
208 pred_table[2]=1; | |
209 pred_table[3]=3; | |
210 pred_table[4]=4; | |
211 }else if(codec->codec_id == CODEC_ID_VORBIS){ | |
212 pred_count=3; | |
213 pred_table[0]=2; | |
214 pred_table[1]=9; | |
215 pred_table[2]=16; | |
216 }else{ | |
217 pred_count=1; | |
218 pred_table[0]=1; | |
219 } | |
220 | |
403 | 221 for(pred=0; pred<pred_count; pred++){ |
222 int start3= start2 + (end2-start2)*pred / pred_count; | |
223 int end3 = start2 + (end2-start2)*(pred+1) / pred_count; | |
224 | |
225 for(index=start3; index<end3; index++){ | |
226 FrameCode *ft= &nut->frame_code[index]; | |
461 | 227 ft->flags= FLAG_KEY_FRAME*key_frame; |
403 | 228 ft->flags|= FLAG_DATA_SIZE; |
229 ft->stream_id_plus1= stream_id + 1; | |
230 //FIXME use single byte size and pred from last | |
231 ft->size_mul= end3-start3; | |
232 ft->size_lsb= index - start3; | |
461 | 233 ft->timestamp_delta= pred_table[pred]; |
403 | 234 } |
235 } | |
236 } | |
237 memmove(&nut->frame_code['N'+1], &nut->frame_code['N'], sizeof(FrameCode)*(255-'N')); | |
461 | 238 nut->frame_code['N'].flags= FLAG_INVALID; |
403 | 239 } |
240 | |
219 | 241 static uint64_t get_v(ByteIOContext *bc) |
242 { | |
243 uint64_t val = 0; | |
244 | |
421 | 245 for(;;) |
219 | 246 { |
247 int tmp = get_byte(bc); | |
248 | |
249 if (tmp&0x80) | |
250 val= (val<<7) + tmp - 0x80; | |
456 | 251 else{ |
252 //av_log(NULL, AV_LOG_DEBUG, "get_v()= %lld\n", (val<<7) + tmp); | |
219 | 253 return (val<<7) + tmp; |
456 | 254 } |
219 | 255 } |
256 return -1; | |
257 } | |
258 | |
639 | 259 static int get_str(ByteIOContext *bc, char *string, unsigned int maxlen){ |
260 unsigned int len= get_v(bc); | |
219 | 261 |
415 | 262 if(len && maxlen) |
263 get_buffer(bc, string, FFMIN(len, maxlen)); | |
264 while(len > maxlen){ | |
265 get_byte(bc); | |
266 len--; | |
267 } | |
240 | 268 |
415 | 269 if(maxlen) |
270 string[FFMIN(len, maxlen-1)]= 0; | |
240 | 271 |
415 | 272 if(maxlen == len) |
273 return -1; | |
274 else | |
275 return 0; | |
219 | 276 } |
277 | |
461 | 278 static int64_t get_s(ByteIOContext *bc){ |
279 int64_t v = get_v(bc) + 1; | |
280 | |
281 if (v&1) return -(v>>1); | |
282 else return (v>>1); | |
283 } | |
284 | |
426 | 285 static uint64_t get_vb(ByteIOContext *bc){ |
286 uint64_t val=0; | |
639 | 287 unsigned int i= get_v(bc); |
426 | 288 |
289 if(i>8) | |
290 return UINT64_MAX; | |
291 | |
292 while(i--) | |
293 val = (val<<8) + get_byte(bc); | |
294 | |
456 | 295 //av_log(NULL, AV_LOG_DEBUG, "get_vb()= %lld\n", val); |
426 | 296 return val; |
297 } | |
298 | |
461 | 299 #ifdef TRACE |
300 static inline uint64_t get_v_trace(ByteIOContext *bc, char *file, char *func, int line){ | |
301 uint64_t v= get_v(bc); | |
302 | |
303 printf("get_v %5lld / %llX in %s %s:%d\n", v, v, file, func, line); | |
304 return v; | |
305 } | |
306 | |
307 static inline int64_t get_s_trace(ByteIOContext *bc, char *file, char *func, int line){ | |
308 int64_t v= get_s(bc); | |
309 | |
310 printf("get_s %5lld / %llX in %s %s:%d\n", v, v, file, func, line); | |
311 return v; | |
312 } | |
313 | |
314 static inline uint64_t get_vb_trace(ByteIOContext *bc, char *file, char *func, int line){ | |
315 uint64_t v= get_vb(bc); | |
316 | |
317 printf("get_vb %5lld / %llX in %s %s:%d\n", v, v, file, func, line); | |
318 return v; | |
319 } | |
320 #define get_v(bc) get_v_trace(bc, __FILE__, __PRETTY_FUNCTION__, __LINE__) | |
321 #define get_s(bc) get_s_trace(bc, __FILE__, __PRETTY_FUNCTION__, __LINE__) | |
322 #define get_vb(bc) get_vb_trace(bc, __FILE__, __PRETTY_FUNCTION__, __LINE__) | |
323 #endif | |
324 | |
325 | |
456 | 326 static int get_packetheader(NUTContext *nut, ByteIOContext *bc, int calculate_checksum) |
219 | 327 { |
456 | 328 int64_t start, size; |
329 start= url_ftell(bc) - 8; | |
403 | 330 |
421 | 331 init_checksum(bc, calculate_checksum ? update_adler32 : NULL, 0); |
403 | 332 |
333 size= get_v(bc); | |
334 | |
456 | 335 nut->packet_start[2] = start; |
403 | 336 nut->written_packet_size= size; |
337 | |
338 return size; | |
219 | 339 } |
340 | |
418
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
416
diff
changeset
|
341 static int check_checksum(ByteIOContext *bc){ |
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
416
diff
changeset
|
342 unsigned long checksum= get_checksum(bc); |
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
416
diff
changeset
|
343 return checksum != get_be32(bc); |
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
416
diff
changeset
|
344 } |
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
416
diff
changeset
|
345 |
221 | 346 /** |
347 * | |
348 */ | |
349 static int get_length(uint64_t val){ | |
350 int i; | |
219 | 351 |
426 | 352 for (i=7; val>>i; i+=7); |
219 | 353 |
426 | 354 return i; |
219 | 355 } |
356 | |
419 | 357 static uint64_t find_any_startcode(ByteIOContext *bc, int64_t pos){ |
358 uint64_t state=0; | |
359 | |
360 if(pos >= 0) | |
361 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 | |
362 | |
421 | 363 while(!url_feof(bc)){ |
419 | 364 state= (state<<8) | get_byte(bc); |
365 if((state>>56) != 'N') | |
366 continue; | |
367 switch(state){ | |
368 case MAIN_STARTCODE: | |
369 case STREAM_STARTCODE: | |
370 case KEYFRAME_STARTCODE: | |
371 case INFO_STARTCODE: | |
372 case INDEX_STARTCODE: | |
373 return state; | |
374 } | |
375 } | |
426 | 376 |
419 | 377 return 0; |
378 } | |
379 | |
426 | 380 /** |
381 * find the given startcode. | |
382 * @param code the startcode | |
383 * @param pos the start position of the search, or -1 if the current position | |
384 * @returns the position of the startcode or -1 if not found | |
385 */ | |
386 static int64_t find_startcode(ByteIOContext *bc, uint64_t code, int64_t pos){ | |
419 | 387 for(;;){ |
388 uint64_t startcode= find_any_startcode(bc, pos); | |
389 if(startcode == code) | |
426 | 390 return url_ftell(bc) - 8; |
419 | 391 else if(startcode == 0) |
392 return -1; | |
393 pos=-1; | |
394 } | |
395 } | |
396 | |
277
a313e1080322
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
272
diff
changeset
|
397 #ifdef CONFIG_ENCODERS |
461 | 398 |
426 | 399 static void put_v(ByteIOContext *bc, uint64_t val) |
219 | 400 { |
401 int i; | |
402 | |
456 | 403 //av_log(NULL, AV_LOG_DEBUG, "put_v()= %lld\n", val); |
219 | 404 val &= 0x7FFFFFFFFFFFFFFFULL; // FIXME can only encode upto 63 bits currently |
221 | 405 i= get_length(val); |
219 | 406 |
220 | 407 for (i-=7; i>0; i-=7){ |
219 | 408 put_byte(bc, 0x80 | (val>>i)); |
220 | 409 } |
219 | 410 |
411 put_byte(bc, val&0x7f); | |
412 } | |
413 | |
426 | 414 /** |
415 * stores a string as vb. | |
416 */ | |
417 static void put_str(ByteIOContext *bc, const char *string){ | |
415 | 418 int len= strlen(string); |
219 | 419 |
420 put_v(bc, len); | |
415 | 421 put_buffer(bc, string, len); |
426 | 422 } |
423 | |
699
2f5f4578a076
"put_s should store signed values. Spotted on #mplayerdev by someone I
michael
parents:
683
diff
changeset
|
424 static void put_s(ByteIOContext *bc, int64_t val){ |
461 | 425 if (val<=0) put_v(bc, -2*val ); |
426 else put_v(bc, 2*val-1); | |
427 } | |
428 | |
426 | 429 static void put_vb(ByteIOContext *bc, uint64_t val){ |
430 int i; | |
415 | 431 |
426 | 432 for (i=8; val>>i; i+=8); |
433 | |
434 put_v(bc, i>>3); | |
435 for(i-=8; i>=0; i-=8) | |
436 put_byte(bc, (val>>i)&0xFF); | |
228 | 437 } |
438 | |
461 | 439 #ifdef TRACE |
440 static inline void put_v_trace(ByteIOContext *bc, uint64_t v, char *file, char *func, int line){ | |
441 printf("get_v %5lld / %llX in %s %s:%d\n", v, v, file, func, line); | |
442 | |
443 put_v(bc, v); | |
444 } | |
445 | |
446 static inline void put_s_trace(ByteIOContext *bc, int64_t v, char *file, char *func, int line){ | |
447 printf("get_s %5lld / %llX in %s %s:%d\n", v, v, file, func, line); | |
448 | |
449 put_s(bc, v); | |
450 } | |
451 | |
452 static inline void put_vb_trace(ByteIOContext *bc, uint64_t v, char *file, char *func, int line){ | |
453 printf("get_vb %5lld / %llX in %s %s:%d\n", v, v, file, func, line); | |
454 | |
455 put_vb(bc, v); | |
456 } | |
457 #define put_v(bc, v) put_v_trace(bc, v, __FILE__, __PRETTY_FUNCTION__, __LINE__) | |
458 #define put_s(bc, v) put_s_trace(bc, v, __FILE__, __PRETTY_FUNCTION__, __LINE__) | |
459 #define put_vb(bc, v) put_vb_trace(bc, v, __FILE__, __PRETTY_FUNCTION__, __LINE__) | |
460 #endif | |
461 | |
418
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
416
diff
changeset
|
462 static int put_packetheader(NUTContext *nut, ByteIOContext *bc, int max_size, int calculate_checksum) |
219 | 463 { |
464 put_flush_packet(bc); | |
456 | 465 nut->packet_start[2]+= nut->written_packet_size; |
466 assert(url_ftell(bc) - 8 == nut->packet_start[2]); | |
403 | 467 nut->written_packet_size = max_size; |
418
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
416
diff
changeset
|
468 |
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
416
diff
changeset
|
469 if(calculate_checksum) |
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
416
diff
changeset
|
470 init_checksum(bc, update_adler32, 0); |
403 | 471 |
219 | 472 /* packet header */ |
403 | 473 put_v(bc, nut->written_packet_size); /* forward ptr */ |
219 | 474 |
475 return 0; | |
476 } | |
477 | |
418
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
416
diff
changeset
|
478 static int update_packetheader(NUTContext *nut, ByteIOContext *bc, int additional_size, int calculate_checksum){ |
456 | 479 int64_t start= nut->packet_start[2]; |
403 | 480 int64_t cur= url_ftell(bc); |
221 | 481 int size= cur - start + additional_size; |
482 | |
418
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
416
diff
changeset
|
483 if(calculate_checksum) |
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
416
diff
changeset
|
484 size += 4; |
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
416
diff
changeset
|
485 |
403 | 486 if(size != nut->written_packet_size){ |
487 int i; | |
488 | |
489 assert( size <= nut->written_packet_size ); | |
219 | 490 |
456 | 491 url_fseek(bc, start + 8, SEEK_SET); |
403 | 492 for(i=get_length(size); i < get_length(nut->written_packet_size); i+=7) |
493 put_byte(bc, 0x80); | |
494 put_v(bc, size); | |
219 | 495 |
403 | 496 url_fseek(bc, cur, SEEK_SET); |
497 nut->written_packet_size= size; //FIXME may fail if multiple updates with differing sizes, as get_length may differ | |
418
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
416
diff
changeset
|
498 |
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
416
diff
changeset
|
499 if(calculate_checksum) |
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
416
diff
changeset
|
500 put_be32(bc, get_checksum(bc)); |
403 | 501 } |
221 | 502 |
219 | 503 return 0; |
504 } | |
505 | |
506 static int nut_write_header(AVFormatContext *s) | |
507 { | |
508 NUTContext *nut = s->priv_data; | |
509 ByteIOContext *bc = &s->pb; | |
510 AVCodecContext *codec; | |
461 | 511 int i, j, tmp_time, tmp_flags,tmp_stream, tmp_mul, tmp_size, tmp_fields; |
219 | 512 |
403 | 513 nut->avf= s; |
514 | |
515 nut->stream = | |
516 av_mallocz(sizeof(StreamContext)*s->nb_streams); | |
478 | 517 |
518 | |
519 put_buffer(bc, ID_STRING, strlen(ID_STRING)); | |
520 put_byte(bc, 0); | |
521 nut->packet_start[2]= url_ftell(bc); | |
403 | 522 |
219 | 523 /* main header */ |
220 | 524 put_be64(bc, MAIN_STARTCODE); |
418
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
416
diff
changeset
|
525 put_packetheader(nut, bc, 120+5*256, 1); |
456 | 526 put_v(bc, 2); /* version */ |
219 | 527 put_v(bc, s->nb_streams); |
456 | 528 put_v(bc, MAX_DISTANCE); |
478 | 529 put_v(bc, MAX_SHORT_DISTANCE); |
403 | 530 |
461 | 531 put_v(bc, nut->rate_num=1); |
532 put_v(bc, nut->rate_den=2); | |
533 put_v(bc, nut->short_startcode=0x4EFE79); | |
534 | |
403 | 535 build_frame_code(s); |
461 | 536 assert(nut->frame_code['N'].flags == FLAG_INVALID); |
537 | |
538 tmp_time= tmp_flags= tmp_stream= tmp_mul= tmp_size= /*tmp_res=*/ INT_MAX; | |
403 | 539 for(i=0; i<256;){ |
461 | 540 tmp_fields=0; |
541 tmp_size= 0; | |
542 if(tmp_time != nut->frame_code[i].timestamp_delta) tmp_fields=1; | |
543 if(tmp_mul != nut->frame_code[i].size_mul ) tmp_fields=2; | |
544 if(tmp_stream != nut->frame_code[i].stream_id_plus1) tmp_fields=3; | |
545 if(tmp_size != nut->frame_code[i].size_lsb ) tmp_fields=4; | |
546 // if(tmp_res != nut->frame_code[i].res ) tmp_fields=5; | |
403 | 547 |
461 | 548 tmp_time = nut->frame_code[i].timestamp_delta; |
549 tmp_flags = nut->frame_code[i].flags; | |
550 tmp_stream= nut->frame_code[i].stream_id_plus1; | |
551 tmp_mul = nut->frame_code[i].size_mul; | |
552 tmp_size = nut->frame_code[i].size_lsb; | |
553 // tmp_res = nut->frame_code[i].res; | |
554 | |
403 | 555 for(j=0; i<256; j++,i++){ |
461 | 556 if(nut->frame_code[i].timestamp_delta != tmp_time ) break; |
403 | 557 if(nut->frame_code[i].flags != tmp_flags ) break; |
558 if(nut->frame_code[i].stream_id_plus1 != tmp_stream) break; | |
559 if(nut->frame_code[i].size_mul != tmp_mul ) break; | |
461 | 560 if(nut->frame_code[i].size_lsb != tmp_size+j) break; |
561 // if(nut->frame_code[i].res != tmp_res ) break; | |
403 | 562 } |
461 | 563 if(j != tmp_mul - tmp_size) tmp_fields=6; |
564 | |
565 put_v(bc, tmp_flags); | |
566 put_v(bc, tmp_fields); | |
567 if(tmp_fields>0) put_s(bc, tmp_time); | |
568 if(tmp_fields>1) put_v(bc, tmp_mul); | |
569 if(tmp_fields>2) put_v(bc, tmp_stream); | |
570 if(tmp_fields>3) put_v(bc, tmp_size); | |
571 if(tmp_fields>4) put_v(bc, 0 /*tmp_res*/); | |
572 if(tmp_fields>5) put_v(bc, j); | |
403 | 573 } |
574 | |
418
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
416
diff
changeset
|
575 update_packetheader(nut, bc, 0, 1); |
221 | 576 |
219 | 577 /* stream headers */ |
578 for (i = 0; i < s->nb_streams; i++) | |
579 { | |
782 | 580 int nom, denom, ssize; |
271 | 581 |
219 | 582 codec = &s->streams[i]->codec; |
583 | |
223 | 584 put_be64(bc, STREAM_STARTCODE); |
418
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
416
diff
changeset
|
585 put_packetheader(nut, bc, 120 + codec->extradata_size, 1); |
222 | 586 put_v(bc, i /*s->streams[i]->index*/); |
782 | 587 switch(codec->codec_type){ |
588 case CODEC_TYPE_VIDEO: put_v(bc, 0); break; | |
589 case CODEC_TYPE_AUDIO: put_v(bc, 1); break; | |
590 // case CODEC_TYPE_TEXT : put_v(bc, 2); break; | |
591 case CODEC_TYPE_DATA : put_v(bc, 3); break; | |
592 default: return -1; | |
593 } | |
219 | 594 if (codec->codec_tag) |
426 | 595 put_vb(bc, codec->codec_tag); |
219 | 596 else if (codec->codec_type == CODEC_TYPE_VIDEO) |
597 { | |
426 | 598 put_vb(bc, codec_get_bmp_tag(codec->codec_id)); |
219 | 599 } |
600 else if (codec->codec_type == CODEC_TYPE_AUDIO) | |
601 { | |
426 | 602 put_vb(bc, codec_get_wav_tag(codec->codec_id)); |
282 | 603 } |
415 | 604 else |
426 | 605 put_vb(bc, 0); |
782 | 606 |
607 ff_parse_specific_params(codec, &nom, &ssize, &denom); | |
282 | 608 |
403 | 609 nut->stream[i].rate_num= nom; |
610 nut->stream[i].rate_den= denom; | |
463
696f41bc8784
store index for seeking in the native timebase of each stream
michael
parents:
462
diff
changeset
|
611 av_set_pts_info(s->streams[i], 60, denom, nom); |
403 | 612 |
219 | 613 put_v(bc, codec->bit_rate); |
426 | 614 put_vb(bc, 0); /* no language code */ |
271 | 615 put_v(bc, nom); |
616 put_v(bc, denom); | |
403 | 617 if(nom / denom < 1000) |
618 nut->stream[i].msb_timestamp_shift = 7; | |
619 else | |
620 nut->stream[i].msb_timestamp_shift = 14; | |
621 put_v(bc, nut->stream[i].msb_timestamp_shift); | |
456 | 622 put_v(bc, codec->has_b_frames); |
219 | 623 put_byte(bc, 0); /* flags: 0x1 - fixed_fps, 0x2 - index_present */ |
624 | |
403 | 625 if(codec->extradata_size){ |
626 put_v(bc, 1); | |
627 put_v(bc, codec->extradata_size); | |
628 put_buffer(bc, codec->extradata, codec->extradata_size); | |
629 } | |
630 put_v(bc, 0); /* end of codec specific headers */ | |
219 | 631 |
632 switch(codec->codec_type) | |
633 { | |
634 case CODEC_TYPE_AUDIO: | |
456 | 635 put_v(bc, codec->sample_rate); |
636 put_v(bc, 1); | |
219 | 637 put_v(bc, codec->channels); |
638 break; | |
639 case CODEC_TYPE_VIDEO: | |
640 put_v(bc, codec->width); | |
641 put_v(bc, codec->height); | |
403 | 642 put_v(bc, codec->sample_aspect_ratio.num); |
643 put_v(bc, codec->sample_aspect_ratio.den); | |
219 | 644 put_v(bc, 0); /* csp type -- unknown */ |
645 break; | |
228 | 646 default: |
647 break; | |
219 | 648 } |
418
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
416
diff
changeset
|
649 update_packetheader(nut, bc, 0, 1); |
219 | 650 } |
651 | |
652 /* info header */ | |
223 | 653 put_be64(bc, INFO_STARTCODE); |
415 | 654 put_packetheader(nut, bc, 30+strlen(s->author)+strlen(s->title)+ |
418
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
416
diff
changeset
|
655 strlen(s->comment)+strlen(s->copyright)+strlen(LIBAVFORMAT_IDENT), 1); |
219 | 656 if (s->author[0]) |
657 { | |
415 | 658 put_v(bc, 9); /* type */ |
659 put_str(bc, s->author); | |
219 | 660 } |
661 if (s->title[0]) | |
662 { | |
415 | 663 put_v(bc, 10); /* type */ |
664 put_str(bc, s->title); | |
219 | 665 } |
666 if (s->comment[0]) | |
667 { | |
415 | 668 put_v(bc, 11); /* type */ |
669 put_str(bc, s->comment); | |
219 | 670 } |
671 if (s->copyright[0]) | |
672 { | |
415 | 673 put_v(bc, 12); /* type */ |
674 put_str(bc, s->copyright); | |
219 | 675 } |
676 /* encoder */ | |
441 | 677 if(!(s->streams[0]->codec.flags & CODEC_FLAG_BITEXACT)){ |
678 put_v(bc, 13); /* type */ | |
679 put_str(bc, LIBAVFORMAT_IDENT); | |
680 } | |
222 | 681 |
682 put_v(bc, 0); /* eof info */ | |
418
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
416
diff
changeset
|
683 update_packetheader(nut, bc, 0, 1); |
219 | 684 |
685 put_flush_packet(bc); | |
686 | |
687 return 0; | |
688 } | |
689 | |
456 | 690 static int64_t lsb2full(StreamContext *stream, int64_t lsb){ |
691 int64_t mask = (1<<stream->msb_timestamp_shift)-1; | |
692 int64_t delta= stream->last_pts - mask/2; | |
693 return ((lsb - delta)&mask) + delta; | |
694 } | |
695 | |
468 | 696 static int nut_write_packet(AVFormatContext *s, AVPacket *pkt) |
219 | 697 { |
698 NUTContext *nut = s->priv_data; | |
468 | 699 StreamContext *stream= &nut->stream[pkt->stream_index]; |
219 | 700 ByteIOContext *bc = &s->pb; |
403 | 701 int key_frame = 0, full_pts=0; |
219 | 702 AVCodecContext *enc; |
456 | 703 int64_t coded_pts; |
461 | 704 int frame_type, best_length, frame_code, flags, i, size_mul, size_lsb, time_delta; |
403 | 705 const int64_t frame_start= url_ftell(bc); |
468 | 706 int64_t pts= pkt->pts; |
707 int size= pkt->size; | |
708 int stream_index= pkt->stream_index; | |
219 | 709 |
710 enc = &s->streams[stream_index]->codec; | |
468 | 711 key_frame = !!(pkt->flags & PKT_FLAG_KEY); |
403 | 712 |
713 frame_type=0; | |
456 | 714 if(frame_start + size + 20 - FFMAX(nut->packet_start[1], nut->packet_start[2]) > MAX_DISTANCE) |
715 frame_type=2; | |
716 if(key_frame && !stream->last_key_frame) | |
717 frame_type=2; | |
718 | |
461 | 719 if(frame_type>1){ |
720 int64_t global_ts= av_rescale(pts, stream->rate_den*(int64_t)nut->rate_num, stream->rate_num*(int64_t)nut->rate_den); | |
721 reset(s, global_ts); | |
722 put_be64(bc, KEYFRAME_STARTCODE); | |
723 put_v(bc, global_ts); | |
724 } | |
725 assert(stream->last_pts != AV_NOPTS_VALUE); | |
726 coded_pts = pts & ((1<<stream->msb_timestamp_shift)-1); | |
727 if(lsb2full(stream, coded_pts) != pts) | |
456 | 728 full_pts=1; |
328 | 729 |
456 | 730 if(full_pts) |
731 coded_pts= pts + (1<<stream->msb_timestamp_shift); | |
403 | 732 |
733 best_length=INT_MAX; | |
734 frame_code= -1; | |
735 for(i=0; i<256; i++){ | |
736 int stream_id_plus1= nut->frame_code[i].stream_id_plus1; | |
429
983639863758
removing keyframe prediction and checksum threshold
michael
parents:
427
diff
changeset
|
737 int fc_key_frame; |
403 | 738 int length=0; |
739 size_mul= nut->frame_code[i].size_mul; | |
740 size_lsb= nut->frame_code[i].size_lsb; | |
461 | 741 time_delta= nut->frame_code[i].timestamp_delta; |
403 | 742 flags= nut->frame_code[i].flags; |
743 | |
456 | 744 assert(size_mul > size_lsb); |
745 | |
403 | 746 if(stream_id_plus1 == 0) length+= get_length(stream_index); |
747 else if(stream_id_plus1 - 1 != stream_index) | |
748 continue; | |
429
983639863758
removing keyframe prediction and checksum threshold
michael
parents:
427
diff
changeset
|
749 fc_key_frame= !!(flags & FLAG_KEY_FRAME); |
983639863758
removing keyframe prediction and checksum threshold
michael
parents:
427
diff
changeset
|
750 |
403 | 751 assert(key_frame==0 || key_frame==1); |
752 if(fc_key_frame != key_frame) | |
753 continue; | |
754 | |
456 | 755 if(flags & FLAG_DATA_SIZE){ |
403 | 756 if(size % size_mul != size_lsb) |
757 continue; | |
456 | 758 length += get_length(size / size_mul); |
759 }else if(size != size_lsb) | |
760 continue; | |
220 | 761 |
461 | 762 if(full_pts && time_delta) |
403 | 763 continue; |
764 | |
461 | 765 if(!time_delta){ |
456 | 766 length += get_length(coded_pts); |
403 | 767 }else{ |
461 | 768 if(time_delta != pts - stream->last_pts) |
403 | 769 continue; |
770 } | |
771 | |
772 if(length < best_length){ | |
773 best_length= length; | |
774 frame_code=i; | |
775 } | |
776 // av_log(s, AV_LOG_DEBUG, "%d %d %d %d %d %d %d %d %d %d\n", key_frame, frame_type, full_pts, size, stream_index, flags, size_mul, size_lsb, stream_id_plus1, length); | |
777 } | |
223 | 778 |
403 | 779 assert(frame_code != -1); |
780 flags= nut->frame_code[frame_code].flags; | |
781 size_mul= nut->frame_code[frame_code].size_mul; | |
782 size_lsb= nut->frame_code[frame_code].size_lsb; | |
461 | 783 time_delta= nut->frame_code[frame_code].timestamp_delta; |
784 #ifdef TRACE | |
403 | 785 best_length /= 7; |
786 best_length ++; //frame_code | |
456 | 787 if(frame_type==2){ |
788 best_length += 8; // startcode | |
403 | 789 } |
461 | 790 av_log(s, AV_LOG_DEBUG, "kf:%d ft:%d pt:%d fc:%2X len:%2d size:%d stream:%d flag:%d mul:%d lsb:%d s+1:%d pts_delta:%d pts:%lld fs:%lld\n", key_frame, frame_type, full_pts ? 1 : 0, frame_code, best_length, size, stream_index, flags, size_mul, size_lsb, nut->frame_code[frame_code].stream_id_plus1,(int)(pts - stream->last_pts), pts, frame_start); |
456 | 791 // av_log(s, AV_LOG_DEBUG, "%d %d %d\n", stream->lru_pts_delta[0], stream->lru_pts_delta[1], stream->lru_pts_delta[2]); |
403 | 792 #endif |
793 | |
456 | 794 assert(frame_type != 1); //short startcode not implemented yet |
403 | 795 put_byte(bc, frame_code); |
796 | |
797 if(nut->frame_code[frame_code].stream_id_plus1 == 0) | |
798 put_v(bc, stream_index); | |
461 | 799 if (!time_delta){ |
456 | 800 put_v(bc, coded_pts); |
403 | 801 } |
802 if(flags & FLAG_DATA_SIZE) | |
803 put_v(bc, size / size_mul); | |
461 | 804 else |
805 assert(size == size_lsb); | |
456 | 806 if(size > MAX_DISTANCE){ |
807 assert(frame_type > 1); | |
403 | 808 } |
219 | 809 |
468 | 810 put_buffer(bc, pkt->data, size); |
403 | 811 |
812 update(nut, stream_index, frame_start, frame_type, frame_code, key_frame, size, pts); | |
219 | 813 |
814 return 0; | |
815 } | |
816 | |
817 static int nut_write_trailer(AVFormatContext *s) | |
818 { | |
328 | 819 NUTContext *nut = s->priv_data; |
219 | 820 ByteIOContext *bc = &s->pb; |
403 | 821 |
219 | 822 #if 0 |
823 int i; | |
824 | |
825 /* WRITE INDEX */ | |
826 | |
827 for (i = 0; s->nb_streams; i++) | |
828 { | |
223 | 829 put_be64(bc, INDEX_STARTCODE); |
418
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
416
diff
changeset
|
830 put_packetheader(nut, bc, 64, 1); |
219 | 831 put_v(bc, s->streams[i]->id); |
832 put_v(bc, ...); | |
418
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
416
diff
changeset
|
833 update_packetheader(nut, bc, 0, 1); |
219 | 834 } |
835 #endif | |
836 | |
837 put_flush_packet(bc); | |
328 | 838 |
403 | 839 av_freep(&nut->stream); |
219 | 840 |
841 return 0; | |
842 } | |
277
a313e1080322
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
272
diff
changeset
|
843 #endif //CONFIG_ENCODERS |
219 | 844 |
845 static int nut_probe(AVProbeData *p) | |
846 { | |
220 | 847 int i; |
456 | 848 uint64_t code= 0xff; |
220 | 849 |
850 for (i = 0; i < p->buf_size; i++) { | |
456 | 851 code = (code << 8) | p->buf[i]; |
220 | 852 if (code == MAIN_STARTCODE) |
853 return AVPROBE_SCORE_MAX; | |
854 } | |
855 return 0; | |
219 | 856 } |
857 | |
419 | 858 static int decode_main_header(NUTContext *nut){ |
859 AVFormatContext *s= nut->avf; | |
219 | 860 ByteIOContext *bc = &s->pb; |
220 | 861 uint64_t tmp; |
461 | 862 int i, j, tmp_stream, tmp_mul, tmp_time, tmp_size, count, tmp_res; |
219 | 863 |
456 | 864 get_packetheader(nut, bc, 1); |
403 | 865 |
419 | 866 tmp = get_v(bc); |
456 | 867 if (tmp != 2){ |
419 | 868 av_log(s, AV_LOG_ERROR, "bad version (%Ld)\n", tmp); |
869 return -1; | |
870 } | |
219 | 871 |
419 | 872 nut->stream_count = get_v(bc); |
639 | 873 if(nut->stream_count > MAX_STREAMS){ |
874 av_log(s, AV_LOG_ERROR, "too many streams\n"); | |
875 return -1; | |
876 } | |
456 | 877 nut->max_distance = get_v(bc); |
478 | 878 nut->max_short_distance = get_v(bc); |
461 | 879 nut->rate_num= get_v(bc); |
880 nut->rate_den= get_v(bc); | |
881 nut->short_startcode= get_v(bc); | |
882 if(nut->short_startcode>>16 != 'N'){ | |
883 av_log(s, AV_LOG_ERROR, "invalid short startcode %X\n", nut->short_startcode); | |
884 return -1; | |
885 } | |
456 | 886 |
403 | 887 for(i=0; i<256;){ |
888 int tmp_flags = get_v(bc); | |
461 | 889 int tmp_fields= get_v(bc); |
890 if(tmp_fields>0) tmp_time = get_s(bc); | |
891 if(tmp_fields>1) tmp_mul = get_v(bc); | |
892 if(tmp_fields>2) tmp_stream= get_v(bc); | |
893 if(tmp_fields>3) tmp_size = get_v(bc); | |
894 else tmp_size = 0; | |
895 if(tmp_fields>4) tmp_res = get_v(bc); | |
896 else tmp_res = 0; | |
897 if(tmp_fields>5) count = get_v(bc); | |
898 else count = tmp_mul - tmp_size; | |
899 | |
900 while(tmp_fields-- > 6) | |
901 get_v(bc); | |
902 | |
403 | 903 if(count == 0 || i+count > 256){ |
904 av_log(s, AV_LOG_ERROR, "illegal count %d at %d\n", count, i); | |
905 return -1; | |
906 } | |
461 | 907 if(tmp_stream > nut->stream_count + 1){ |
908 av_log(s, AV_LOG_ERROR, "illegal stream number\n"); | |
909 return -1; | |
910 } | |
403 | 911 |
912 for(j=0; j<count; j++,i++){ | |
913 nut->frame_code[i].flags = tmp_flags ; | |
461 | 914 nut->frame_code[i].timestamp_delta = tmp_time ; |
403 | 915 nut->frame_code[i].stream_id_plus1 = tmp_stream; |
916 nut->frame_code[i].size_mul = tmp_mul ; | |
461 | 917 nut->frame_code[i].size_lsb = tmp_size+j; |
918 nut->frame_code[i].reserved_count = tmp_res ; | |
403 | 919 } |
920 } | |
461 | 921 if(nut->frame_code['N'].flags != FLAG_INVALID){ |
403 | 922 av_log(s, AV_LOG_ERROR, "illegal frame_code table\n"); |
923 return -1; | |
924 } | |
419 | 925 |
418
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
416
diff
changeset
|
926 if(check_checksum(bc)){ |
735
72f8690c3f37
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
709
diff
changeset
|
927 av_log(s, AV_LOG_ERROR, "Main header checksum mismatch\n"); |
418
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
416
diff
changeset
|
928 return -1; |
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
416
diff
changeset
|
929 } |
419 | 930 |
931 return 0; | |
932 } | |
933 | |
934 static int decode_stream_header(NUTContext *nut){ | |
935 AVFormatContext *s= nut->avf; | |
936 ByteIOContext *bc = &s->pb; | |
461 | 937 int class, nom, denom, stream_id; |
419 | 938 uint64_t tmp; |
939 AVStream *st; | |
940 | |
456 | 941 get_packetheader(nut, bc, 1); |
419 | 942 stream_id= get_v(bc); |
943 if(stream_id >= nut->stream_count || s->streams[stream_id]) | |
944 return -1; | |
945 | |
946 st = av_new_stream(s, stream_id); | |
947 if (!st) | |
948 return AVERROR_NOMEM; | |
462
b69898ffc92a
move time_base (pts_num/pts_den) from AVFormatContext -> AVStream
michael
parents:
461
diff
changeset
|
949 |
419 | 950 class = get_v(bc); |
426 | 951 tmp = get_vb(bc); |
432 | 952 st->codec.codec_tag= tmp; |
419 | 953 switch(class) |
954 { | |
955 case 0: | |
956 st->codec.codec_type = CODEC_TYPE_VIDEO; | |
957 st->codec.codec_id = codec_get_bmp_id(tmp); | |
958 if (st->codec.codec_id == CODEC_ID_NONE) | |
959 av_log(s, AV_LOG_ERROR, "Unknown codec?!\n"); | |
960 break; | |
782 | 961 case 1: |
962 case 32: //compatibility | |
419 | 963 st->codec.codec_type = CODEC_TYPE_AUDIO; |
964 st->codec.codec_id = codec_get_wav_id(tmp); | |
965 if (st->codec.codec_id == CODEC_ID_NONE) | |
966 av_log(s, AV_LOG_ERROR, "Unknown codec?!\n"); | |
967 break; | |
782 | 968 case 2: |
969 // st->codec.codec_type = CODEC_TYPE_TEXT; | |
970 // break; | |
971 case 3: | |
972 st->codec.codec_type = CODEC_TYPE_DATA; | |
973 break; | |
419 | 974 default: |
975 av_log(s, AV_LOG_ERROR, "Unknown stream class (%d)\n", class); | |
976 return -1; | |
977 } | |
978 s->bit_rate += get_v(bc); | |
426 | 979 get_vb(bc); /* language code */ |
419 | 980 nom = get_v(bc); |
981 denom = get_v(bc); | |
982 nut->stream[stream_id].msb_timestamp_shift = get_v(bc); | |
709 | 983 st->codec.has_b_frames= |
456 | 984 nut->stream[stream_id].decode_delay= get_v(bc); |
419 | 985 get_byte(bc); /* flags */ |
986 | |
987 /* codec specific data headers */ | |
988 while(get_v(bc) != 0){ | |
989 st->codec.extradata_size= get_v(bc); | |
639 | 990 if((unsigned)st->codec.extradata_size > (1<<30)) |
991 return -1; | |
587
fe24632a577b
allocate a few bytes more for extradata so the bitstream reader if its used by the codec for parsing extardata, doesnt read over the end
michael
parents:
555
diff
changeset
|
992 st->codec.extradata= av_mallocz(st->codec.extradata_size + FF_INPUT_BUFFER_PADDING_SIZE); |
419 | 993 get_buffer(bc, st->codec.extradata, st->codec.extradata_size); |
994 // url_fskip(bc, get_v(bc)); | |
995 } | |
996 | |
782 | 997 if (st->codec.codec_type == CODEC_TYPE_VIDEO) /* VIDEO */ |
419 | 998 { |
999 st->codec.width = get_v(bc); | |
1000 st->codec.height = get_v(bc); | |
1001 st->codec.sample_aspect_ratio.num= get_v(bc); | |
1002 st->codec.sample_aspect_ratio.den= get_v(bc); | |
1003 get_v(bc); /* csp type */ | |
1004 } | |
782 | 1005 if (st->codec.codec_type == CODEC_TYPE_AUDIO) /* AUDIO */ |
419 | 1006 { |
456 | 1007 st->codec.sample_rate = get_v(bc); |
1008 get_v(bc); // samplerate_den | |
419 | 1009 st->codec.channels = get_v(bc); |
1010 } | |
1011 if(check_checksum(bc)){ | |
735
72f8690c3f37
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
709
diff
changeset
|
1012 av_log(s, AV_LOG_ERROR, "Stream header %d checksum mismatch\n", stream_id); |
419 | 1013 return -1; |
1014 } | |
463
696f41bc8784
store index for seeking in the native timebase of each stream
michael
parents:
462
diff
changeset
|
1015 av_set_pts_info(s->streams[stream_id], 60, denom, nom); |
419 | 1016 nut->stream[stream_id].rate_num= nom; |
1017 nut->stream[stream_id].rate_den= denom; | |
1018 return 0; | |
1019 } | |
1020 | |
1021 static int decode_info_header(NUTContext *nut){ | |
1022 AVFormatContext *s= nut->avf; | |
1023 ByteIOContext *bc = &s->pb; | |
1024 | |
456 | 1025 get_packetheader(nut, bc, 1); |
419 | 1026 |
1027 for(;;){ | |
1028 int id= get_v(bc); | |
1029 char *name, *type, custom_name[256], custom_type[256]; | |
1030 | |
1031 if(!id) | |
1032 break; | |
1033 else if(id >= sizeof(info_table)/sizeof(info_table[0])){ | |
1034 av_log(s, AV_LOG_ERROR, "info id is too large %d %d\n", id, sizeof(info_table)/sizeof(info_table[0])); | |
1035 return -1; | |
1036 } | |
1037 | |
1038 type= info_table[id][1]; | |
1039 name= info_table[id][0]; | |
1040 //av_log(s, AV_LOG_DEBUG, "%d %s %s\n", id, type, name); | |
1041 | |
1042 if(!type){ | |
1043 get_str(bc, custom_type, sizeof(custom_type)); | |
1044 type= custom_type; | |
1045 } | |
1046 if(!name){ | |
1047 get_str(bc, custom_name, sizeof(custom_name)); | |
1048 name= custom_name; | |
1049 } | |
1050 | |
1051 if(!strcmp(type, "v")){ | |
683
095009fc2f35
kill warnings patch by (M«©ns Rullg«©rd <mru inprovide com>)
michael
parents:
682
diff
changeset
|
1052 get_v(bc); |
419 | 1053 }else{ |
1054 if(!strcmp(name, "Author")) | |
1055 get_str(bc, s->author, sizeof(s->author)); | |
1056 else if(!strcmp(name, "Title")) | |
1057 get_str(bc, s->title, sizeof(s->title)); | |
1058 else if(!strcmp(name, "Copyright")) | |
1059 get_str(bc, s->copyright, sizeof(s->copyright)); | |
1060 else if(!strcmp(name, "Description")) | |
1061 get_str(bc, s->comment, sizeof(s->comment)); | |
1062 else | |
1063 get_str(bc, NULL, 0); | |
1064 } | |
1065 } | |
1066 if(check_checksum(bc)){ | |
735
72f8690c3f37
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
709
diff
changeset
|
1067 av_log(s, AV_LOG_ERROR, "Info header checksum mismatch\n"); |
419 | 1068 return -1; |
1069 } | |
1070 return 0; | |
1071 } | |
1072 | |
1073 static int nut_read_header(AVFormatContext *s, AVFormatParameters *ap) | |
1074 { | |
1075 NUTContext *nut = s->priv_data; | |
1076 ByteIOContext *bc = &s->pb; | |
1077 int64_t pos; | |
1078 int inited_stream_count; | |
1079 | |
1080 nut->avf= s; | |
1081 | |
1082 /* main header */ | |
1083 pos=0; | |
1084 for(;;){ | |
426 | 1085 pos= find_startcode(bc, MAIN_STARTCODE, pos)+1; |
1086 if (pos<0){ | |
419 | 1087 av_log(s, AV_LOG_ERROR, "no main startcode found\n"); |
1088 return -1; | |
1089 } | |
1090 if(decode_main_header(nut) >= 0) | |
1091 break; | |
1092 } | |
1093 | |
219 | 1094 |
1095 s->bit_rate = 0; | |
328 | 1096 |
419 | 1097 nut->stream = av_malloc(sizeof(StreamContext)*nut->stream_count); |
272 | 1098 |
419 | 1099 /* stream headers */ |
1100 pos=0; | |
1101 for(inited_stream_count=0; inited_stream_count < nut->stream_count;){ | |
426 | 1102 pos= find_startcode(bc, STREAM_STARTCODE, pos)+1; |
782 | 1103 if (pos<0+1){ |
419 | 1104 av_log(s, AV_LOG_ERROR, "not all stream headers found\n"); |
418
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
416
diff
changeset
|
1105 return -1; |
41da3366d341
checksuming for nut & nice checksum API for libavformat
michael
parents:
416
diff
changeset
|
1106 } |
419 | 1107 if(decode_stream_header(nut) >= 0) |
1108 inited_stream_count++; | |
415 | 1109 } |
1110 | |
419 | 1111 /* info headers */ |
1112 pos=0; | |
1113 for(;;){ | |
1114 uint64_t startcode= find_any_startcode(bc, pos); | |
1115 pos= url_ftell(bc); | |
415 | 1116 |
419 | 1117 if(startcode==0){ |
1118 av_log(s, AV_LOG_ERROR, "EOF before video frames\n"); | |
1119 return -1; | |
1120 }else if(startcode == KEYFRAME_STARTCODE){ | |
421 | 1121 nut->next_startcode= startcode; |
419 | 1122 break; |
1123 }else if(startcode != INFO_STARTCODE){ | |
1124 continue; | |
415 | 1125 } |
419 | 1126 |
1127 decode_info_header(nut); | |
1128 } | |
1129 | |
219 | 1130 return 0; |
1131 } | |
1132 | |
461 | 1133 static int decode_frame_header(NUTContext *nut, int *key_frame_ret, int64_t *pts_ret, int *stream_id_ret, int frame_code, int frame_type, int64_t frame_start){ |
421 | 1134 AVFormatContext *s= nut->avf; |
403 | 1135 StreamContext *stream; |
219 | 1136 ByteIOContext *bc = &s->pb; |
461 | 1137 int size, flags, size_mul, size_lsb, stream_id, time_delta; |
328 | 1138 int64_t pts = 0; |
219 | 1139 |
456 | 1140 if(frame_type < 2 && frame_start - nut->packet_start[2] > nut->max_distance){ |
1141 av_log(s, AV_LOG_ERROR, "last frame must have been damaged\n"); | |
1142 return -1; | |
1143 } | |
1144 | |
1145 if(frame_type) | |
1146 nut->packet_start[ frame_type ]= frame_start; //otherwise 1 goto 1 may happen | |
1147 | |
403 | 1148 flags= nut->frame_code[frame_code].flags; |
1149 size_mul= nut->frame_code[frame_code].size_mul; | |
1150 size_lsb= nut->frame_code[frame_code].size_lsb; | |
1151 stream_id= nut->frame_code[frame_code].stream_id_plus1 - 1; | |
461 | 1152 time_delta= nut->frame_code[frame_code].timestamp_delta; |
1153 | |
403 | 1154 if(stream_id==-1) |
1155 stream_id= get_v(bc); | |
1156 if(stream_id >= s->nb_streams){ | |
1157 av_log(s, AV_LOG_ERROR, "illegal stream_id\n"); | |
1158 return -1; | |
1159 } | |
1160 stream= &nut->stream[stream_id]; | |
421 | 1161 |
1162 // av_log(s, AV_LOG_DEBUG, "ft:%d ppts:%d %d %d\n", frame_type, stream->lru_pts_delta[0], stream->lru_pts_delta[1], stream->lru_pts_delta[2]); | |
456 | 1163 |
1164 *key_frame_ret= !!(flags & FLAG_KEY_FRAME); | |
403 | 1165 |
461 | 1166 if(!time_delta){ |
456 | 1167 int64_t mask = (1<<stream->msb_timestamp_shift)-1; |
1168 pts= get_v(bc); | |
1169 if(pts > mask){ | |
1170 pts -= mask+1; | |
1171 }else{ | |
1172 if(stream->last_pts == AV_NOPTS_VALUE){ | |
1173 av_log(s, AV_LOG_ERROR, "no reference pts available\n"); | |
1174 return -1; | |
426 | 1175 } |
456 | 1176 pts= lsb2full(stream, pts); |
403 | 1177 } |
1178 }else{ | |
456 | 1179 if(stream->last_pts == AV_NOPTS_VALUE){ |
1180 av_log(s, AV_LOG_ERROR, "no reference pts available\n"); | |
1181 return -1; | |
1182 } | |
461 | 1183 pts= stream->last_pts + time_delta; |
403 | 1184 } |
456 | 1185 |
1186 if(*key_frame_ret){ | |
1187 // av_log(s, AV_LOG_DEBUG, "stream:%d start:%lld pts:%lld length:%lld\n",stream_id, frame_start, av_pts, frame_start - nut->stream[stream_id].last_sync_pos); | |
1188 av_add_index_entry( | |
1189 s->streams[stream_id], | |
1190 frame_start, | |
463
696f41bc8784
store index for seeking in the native timebase of each stream
michael
parents:
462
diff
changeset
|
1191 pts, |
456 | 1192 frame_start - nut->stream[stream_id].last_sync_pos, |
1193 AVINDEX_KEYFRAME); | |
1194 nut->stream[stream_id].last_sync_pos= frame_start; | |
1195 // assert(nut->packet_start == frame_start); | |
403 | 1196 } |
456 | 1197 |
1198 assert(size_mul > size_lsb); | |
1199 size= size_lsb; | |
1200 if(flags & FLAG_DATA_SIZE) | |
1201 size+= size_mul*get_v(bc); | |
403 | 1202 |
461 | 1203 #ifdef TRACE |
1204 av_log(s, AV_LOG_DEBUG, "fs:%lld fc:%d ft:%d kf:%d pts:%lld size:%d mul:%d lsb:%d flags:%d delta:%d\n", frame_start, frame_code, frame_type, *key_frame_ret, pts, size, size_mul, size_lsb, flags, time_delta); | |
1205 #endif | |
421 | 1206 |
456 | 1207 if(frame_type==0 && url_ftell(bc) - nut->packet_start[2] + size > nut->max_distance){ |
421 | 1208 av_log(s, AV_LOG_ERROR, "frame size too large\n"); |
1209 return -1; | |
1210 } | |
219 | 1211 |
456 | 1212 *stream_id_ret = stream_id; |
463
696f41bc8784
store index for seeking in the native timebase of each stream
michael
parents:
462
diff
changeset
|
1213 *pts_ret = pts; |
456 | 1214 |
1215 update(nut, stream_id, frame_start, frame_type, frame_code, *key_frame_ret, size, pts); | |
1216 | |
1217 return size; | |
1218 } | |
1219 | |
461 | 1220 static int decode_frame(NUTContext *nut, AVPacket *pkt, int frame_code, int frame_type, int64_t frame_start){ |
456 | 1221 AVFormatContext *s= nut->avf; |
1222 ByteIOContext *bc = &s->pb; | |
708 | 1223 int size, stream_id, key_frame, discard; |
1224 int64_t pts, last_IP_pts; | |
456 | 1225 |
461 | 1226 size= decode_frame_header(nut, &key_frame, &pts, &stream_id, frame_code, frame_type, frame_start); |
456 | 1227 if(size < 0) |
1228 return -1; | |
1229 | |
708 | 1230 discard= s->streams[ stream_id ]->discard; |
1231 last_IP_pts= s->streams[ stream_id ]->last_IP_pts; | |
1232 if( (discard >= AVDISCARD_NONKEY && !key_frame) | |
1233 ||(discard >= AVDISCARD_BIDIR && last_IP_pts != AV_NOPTS_VALUE && last_IP_pts > pts) | |
1234 || discard >= AVDISCARD_ALL){ | |
652 | 1235 url_fskip(bc, size); |
1236 return 1; | |
1237 } | |
1238 | |
775 | 1239 av_get_packet(bc, pkt, size); |
403 | 1240 pkt->stream_index = stream_id; |
219 | 1241 if (key_frame) |
1242 pkt->flags |= PKT_FLAG_KEY; | |
456 | 1243 pkt->pts = pts; |
403 | 1244 |
421 | 1245 return 0; |
1246 } | |
403 | 1247 |
421 | 1248 static int nut_read_packet(AVFormatContext *s, AVPacket *pkt) |
1249 { | |
1250 NUTContext *nut = s->priv_data; | |
1251 ByteIOContext *bc = &s->pb; | |
652 | 1252 int i, frame_code=0, ret; |
421 | 1253 |
1254 for(;;){ | |
461 | 1255 int64_t pos= url_ftell(bc); |
426 | 1256 int frame_type= 0; |
421 | 1257 uint64_t tmp= nut->next_startcode; |
1258 nut->next_startcode=0; | |
1259 | |
1260 if (url_feof(bc)) | |
1261 return -1; | |
1262 | |
461 | 1263 if(tmp){ |
1264 pos-=8; | |
1265 }else{ | |
421 | 1266 frame_code = get_byte(bc); |
1267 if(frame_code == 'N'){ | |
1268 tmp= frame_code; | |
426 | 1269 for(i=1; i<8; i++) |
1270 tmp = (tmp<<8) + get_byte(bc); | |
421 | 1271 } |
1272 } | |
1273 switch(tmp){ | |
1274 case MAIN_STARTCODE: | |
1275 case STREAM_STARTCODE: | |
1276 case INDEX_STARTCODE: | |
456 | 1277 get_packetheader(nut, bc, 0); |
461 | 1278 assert(nut->packet_start[2] == pos); |
456 | 1279 url_fseek(bc, nut->written_packet_size + nut->packet_start[2], SEEK_SET); |
421 | 1280 break; |
1281 case INFO_STARTCODE: | |
1282 if(decode_info_header(nut)<0) | |
1283 goto resync; | |
1284 break; | |
426 | 1285 case KEYFRAME_STARTCODE: |
1286 frame_type = 2; | |
461 | 1287 reset(s, get_v(bc)); |
426 | 1288 frame_code = get_byte(bc); |
421 | 1289 case 0: |
652 | 1290 ret= decode_frame(nut, pkt, frame_code, frame_type, pos); |
1291 if(ret==0) | |
421 | 1292 return 0; |
652 | 1293 else if(ret==1) //ok but discard packet |
1294 break; | |
421 | 1295 default: |
1296 resync: | |
456 | 1297 av_log(s, AV_LOG_DEBUG, "syncing from %lld\n", nut->packet_start[2]+1); |
1298 tmp= find_any_startcode(bc, nut->packet_start[2]+1); | |
421 | 1299 if(tmp==0) |
1300 return -1; | |
1301 av_log(s, AV_LOG_DEBUG, "sync\n"); | |
456 | 1302 nut->next_startcode= tmp; |
426 | 1303 } |
1304 } | |
1305 } | |
1306 | |
437
50bae308f71e
moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents:
432
diff
changeset
|
1307 static int64_t nut_read_timestamp(AVFormatContext *s, int stream_index, int64_t *pos_arg, int64_t pos_limit){ |
426 | 1308 NUTContext *nut = s->priv_data; |
437
50bae308f71e
moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents:
432
diff
changeset
|
1309 StreamContext *stream; |
426 | 1310 ByteIOContext *bc = &s->pb; |
1311 int64_t pos, pts; | |
1312 uint64_t code; | |
456 | 1313 int frame_code,step, stream_id, i,size, key_frame; |
426 | 1314 av_log(s, AV_LOG_DEBUG, "read_timestamp(X,%d,%lld,%lld)\n", stream_index, *pos_arg, pos_limit); |
1315 | |
1316 if(*pos_arg < 0) | |
1317 return AV_NOPTS_VALUE; | |
1318 | |
1319 pos= *pos_arg; | |
1320 step= FFMIN(16*1024, pos); | |
1321 do{ | |
1322 pos-= step; | |
1323 code= find_any_startcode(bc, pos); | |
1324 | |
456 | 1325 if(code && url_ftell(bc) - 8 <= *pos_arg) |
426 | 1326 break; |
1327 step= FFMIN(2*step, pos); | |
1328 }while(step); | |
1329 | |
1330 if(!code) //nothing found, not even after pos_arg | |
1331 return AV_NOPTS_VALUE; | |
1332 | |
1333 url_fseek(bc, -8, SEEK_CUR); | |
1334 for(i=0; i<s->nb_streams; i++) | |
1335 nut->stream[i].last_sync_pos= url_ftell(bc); | |
1336 | |
1337 for(;;){ | |
456 | 1338 int frame_type=0; |
426 | 1339 int64_t pos= url_ftell(bc); |
1340 uint64_t tmp=0; | |
1341 | |
456 | 1342 if(pos > pos_limit || url_feof(bc)) |
426 | 1343 return AV_NOPTS_VALUE; |
1344 | |
1345 frame_code = get_byte(bc); | |
1346 if(frame_code == 'N'){ | |
1347 tmp= frame_code; | |
1348 for(i=1; i<8; i++) | |
1349 tmp = (tmp<<8) + get_byte(bc); | |
1350 } | |
1351 //av_log(s, AV_LOG_DEBUG, "before switch %llX at=%lld\n", tmp, pos); | |
1352 | |
1353 switch(tmp){ | |
1354 case MAIN_STARTCODE: | |
1355 case STREAM_STARTCODE: | |
1356 case INDEX_STARTCODE: | |
1357 case INFO_STARTCODE: | |
456 | 1358 get_packetheader(nut, bc, 0); |
1359 assert(nut->packet_start[2]==pos); | |
1360 url_fseek(bc, nut->written_packet_size + pos, SEEK_SET); | |
426 | 1361 break; |
1362 case KEYFRAME_STARTCODE: | |
456 | 1363 frame_type=2; |
461 | 1364 reset(s, get_v(bc)); |
426 | 1365 frame_code = get_byte(bc); |
1366 case 0: | |
461 | 1367 size= decode_frame_header(nut, &key_frame, &pts, &stream_id, frame_code, frame_type, pos); |
456 | 1368 if(size < 0) |
426 | 1369 goto resync; |
1370 | |
437
50bae308f71e
moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents:
432
diff
changeset
|
1371 stream= &nut->stream[stream_id]; |
456 | 1372 if(stream_id != stream_index || !key_frame || pos < *pos_arg){ |
1373 url_fseek(bc, size, SEEK_CUR); | |
426 | 1374 break; |
1375 } | |
1376 | |
456 | 1377 *pos_arg= pos; |
426 | 1378 return pts; |
1379 default: | |
1380 resync: | |
456 | 1381 av_log(s, AV_LOG_DEBUG, "syncing from %lld\n", nut->packet_start[2]+1); |
1382 if(!find_any_startcode(bc, nut->packet_start[2]+1)) | |
426 | 1383 return AV_NOPTS_VALUE; |
1384 | |
1385 url_fseek(bc, -8, SEEK_CUR); | |
421 | 1386 } |
1387 } | |
426 | 1388 return AV_NOPTS_VALUE; |
1389 } | |
1390 | |
555 | 1391 static int nut_read_seek(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){ |
456 | 1392 // NUTContext *nut = s->priv_data; |
437
50bae308f71e
moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents:
432
diff
changeset
|
1393 int64_t pos; |
426 | 1394 |
555 | 1395 if(av_seek_frame_binary(s, stream_index, target_ts, flags) < 0) |
437
50bae308f71e
moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents:
432
diff
changeset
|
1396 return -1; |
426 | 1397 |
437
50bae308f71e
moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents:
432
diff
changeset
|
1398 pos= url_ftell(&s->pb); |
456 | 1399 nut_read_timestamp(s, stream_index, &pos, pos-1); |
426 | 1400 |
1401 return 0; | |
403 | 1402 } |
1403 | |
1404 static int nut_read_close(AVFormatContext *s) | |
1405 { | |
1406 NUTContext *nut = s->priv_data; | |
1407 int i; | |
1408 | |
1409 for(i=0;i<s->nb_streams;i++) { | |
1410 av_freep(&s->streams[i]->codec.extradata); | |
1411 } | |
1412 av_freep(&nut->stream); | |
219 | 1413 |
1414 return 0; | |
1415 } | |
1416 | |
1417 static AVInputFormat nut_iformat = { | |
1418 "nut", | |
1419 "nut format", | |
1420 sizeof(NUTContext), | |
1421 nut_probe, | |
1422 nut_read_header, | |
1423 nut_read_packet, | |
403 | 1424 nut_read_close, |
426 | 1425 nut_read_seek, |
437
50bae308f71e
moving nearly identical binary search code from nut/mpeg/asf to utils.c
michael
parents:
432
diff
changeset
|
1426 nut_read_timestamp, |
219 | 1427 .extensions = "nut", |
1428 }; | |
1429 | |
277
a313e1080322
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
272
diff
changeset
|
1430 #ifdef CONFIG_ENCODERS |
219 | 1431 static AVOutputFormat nut_oformat = { |
1432 "nut", | |
1433 "nut format", | |
1434 "video/x-nut", | |
1435 "nut", | |
1436 sizeof(NUTContext), | |
682 | 1437 #ifdef CONFIG_LIBVORBIS |
219 | 1438 CODEC_ID_VORBIS, |
1439 #elif defined(CONFIG_MP3LAME) | |
232 | 1440 CODEC_ID_MP3, |
219 | 1441 #else |
223 | 1442 CODEC_ID_MP2, /* AC3 needs liba52 decoder */ |
219 | 1443 #endif |
1444 CODEC_ID_MPEG4, | |
1445 nut_write_header, | |
1446 nut_write_packet, | |
1447 nut_write_trailer, | |
798 | 1448 .flags = AVFMT_GLOBALHEADER, |
219 | 1449 }; |
277
a313e1080322
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
272
diff
changeset
|
1450 #endif //CONFIG_ENCODERS |
219 | 1451 |
1452 int nut_init(void) | |
1453 { | |
1454 av_register_input_format(&nut_iformat); | |
277
a313e1080322
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
272
diff
changeset
|
1455 #ifdef CONFIG_ENCODERS |
219 | 1456 av_register_output_format(&nut_oformat); |
277
a313e1080322
disable encoders where appropriate (patch courtesy of BERO
melanson
parents:
272
diff
changeset
|
1457 #endif //CONFIG_ENCODERS |
219 | 1458 return 0; |
1459 } |