10l (bytes_left() -> url_feof())
[ffmpeg.git] / libavformat / nut.c
1 /*
2  * "NUT" Container Format muxer and demuxer (DRAFT-200403??)
3  * Copyright (c) 2003 Alex Beregszaszi
4  * Copyright (c) 2004 Michael Niedermayer
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  * NUT DRAFT can be found in MPlayer CVS at DOCS/tech/mpcf.txt
21  *
22  * AND http://people.fsn.hu/~alex/nut/ (TeX, pdf, ps, dvi, ..)
23  *
24  */
25
26 /*
27  * TODO:
28  * - seeking
29  * - index writing
30  * - index packet reading support
31 */
32
33 //#define DEBUG 1
34
35 #include <limits.h>
36 #include "avformat.h"
37 #include "mpegaudio.h"
38 #include "avi.h"
39
40 #undef NDEBUG
41 #include <assert.h>
42
43 //from /dev/random
44
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
51 #define MAX_TYPE1_DISTANCE (1024*16-1)
52 #define MAX_TYPE2_DISTANCE (1024*64-1)
53
54 #define MAX_SIZE_LRU 2
55 #define MAX_PTS_LRU 3
56
57 #define FLAG_FRAME_TYPE      1
58 #define FLAG_DATA_SIZE       2
59 #define FLAG_PTS            16
60 #define FLAG_FULL_PTS        4
61 #define FLAG_KEY_FRAME      32
62 #define FLAG_PRED_KEY_FRAME 64
63
64 typedef struct {
65     uint8_t flags;
66     uint8_t stream_id_plus1;
67     uint8_t size_mul;
68     uint8_t size_lsb;
69 } FrameCode;
70
71 typedef struct {
72     int last_key_frame;
73     int msb_timestamp_shift;
74     int rate_num;
75     int rate_den;
76     int64_t last_pts;
77     int64_t last_full_pts;
78     int lru_pts_delta[MAX_PTS_LRU];
79     int lru_size[MAX_SIZE_LRU];
80     int initial_pts_predictor[MAX_PTS_LRU];
81     int initial_size_predictor[MAX_SIZE_LRU];
82 } StreamContext;
83
84 typedef struct {
85     AVFormatContext *avf;
86     int64_t packet_start;
87     int64_t last_packet_start;
88     int written_packet_size;
89     int64_t packet_size_pos;
90     int64_t last_frame_start[3];
91     FrameCode frame_code[256];
92     int stream_count;
93     uint64_t next_startcode;     ///< stores the next startcode if it has alraedy been parsed but the stream isnt seekable
94     StreamContext *stream;
95 } NUTContext;
96
97 static char *info_table[][2]={
98         {NULL                   ,  NULL }, // end
99         {NULL                   ,  NULL },
100         {NULL                   , "UTF8"},
101         {NULL                   , "v"},
102         {NULL                   , "s"},
103         {"StreamId"             , "v"},
104         {"SegmentId"            , "v"},
105         {"StartTimestamp"       , "v"},
106         {"EndTimestamp"         , "v"},
107         {"Author"               , "UTF8"},
108         {"Title"                , "UTF8"},
109         {"Description"          , "UTF8"},
110         {"Copyright"            , "UTF8"},
111         {"Encoder"              , "UTF8"},
112         {"Keyword"              , "UTF8"},
113         {"Cover"                , "JPEG"},
114         {"Cover"                , "PNG"},
115 };
116
117 static void update_lru(int *lru, int current, int count){
118     int i;
119
120     for(i=0; i<count-1; i++){
121         if(lru[i] == current)
122             break;
123     }
124
125     for(; i; i--){
126         lru[i]= lru[i-1];
127     }
128
129     lru[0]= current;
130 }
131
132 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){
133     StreamContext *stream= &nut->stream[stream_index];
134     const int flags=nut->frame_code[frame_code].flags; 
135     
136     stream->last_key_frame= key_frame;
137     nut->last_frame_start[ frame_type ]= frame_start;
138     if(frame_type == 0)
139         update_lru(stream->lru_pts_delta, pts - stream->last_pts, 3);
140     update_lru(stream->lru_size, size, 2);
141     stream->last_pts= pts;
142     if((flags & FLAG_PTS) && (flags & FLAG_FULL_PTS))
143         stream->last_full_pts= pts;
144 }
145
146 static void reset(AVFormatContext *s/*, int frame_type*/){
147     NUTContext *nut = s->priv_data;
148     int i;
149     
150     for(i=0; i<s->nb_streams; i++){
151         StreamContext *stream= &nut->stream[i];
152     
153         stream->last_key_frame= 1;
154         memcpy(stream->lru_pts_delta, stream->initial_pts_predictor, sizeof(int)*MAX_PTS_LRU);
155         memcpy(stream->lru_size, stream->initial_size_predictor, sizeof(int)*MAX_SIZE_LRU);
156     }
157 }
158
159 static void build_frame_code(AVFormatContext *s){
160     NUTContext *nut = s->priv_data;
161     int key_frame, frame_type, full_pts, index, pred, stream_id;
162     int start=0;
163     int end= 255;
164     int keyframe_0_esc= s->nb_streams > 2;
165
166     if(keyframe_0_esc){
167         /* keyframe = 0 escapes, 3 codes */
168         for(frame_type=0; frame_type<2; frame_type++){
169             for(full_pts=frame_type; full_pts<2; full_pts++){
170                 FrameCode *ft= &nut->frame_code[start];
171                 ft->flags= FLAG_FRAME_TYPE*frame_type + FLAG_FULL_PTS*full_pts;
172                 ft->flags|= FLAG_DATA_SIZE | FLAG_PTS; 
173                 ft->stream_id_plus1= 0;
174                 ft->size_mul=1;
175                 start++;
176             }
177         }
178     }
179
180     for(stream_id= 0; stream_id<s->nb_streams; stream_id++){
181         int start2= start + (end-start)*stream_id / s->nb_streams;
182         int end2  = start + (end-start)*(stream_id+1) / s->nb_streams;
183         AVCodecContext *codec = &s->streams[stream_id]->codec;
184         int is_audio= codec->codec_type == CODEC_TYPE_AUDIO;
185         int intra_only= /*codec->intra_only || */is_audio;
186         int pred_count;
187
188         for(key_frame=0; key_frame<2; key_frame++){
189             if(intra_only && keyframe_0_esc && key_frame==0)
190                 continue;
191             
192             for(frame_type=0; frame_type<2; frame_type++){
193                 for(full_pts=frame_type; full_pts<2; full_pts++){
194                     FrameCode *ft= &nut->frame_code[start2];
195                     ft->flags= FLAG_FRAME_TYPE*frame_type + FLAG_FULL_PTS*full_pts + FLAG_KEY_FRAME*key_frame;
196                     ft->flags|= FLAG_DATA_SIZE | FLAG_PTS;
197                     ft->stream_id_plus1= stream_id + 1;
198                     ft->size_mul=1;
199                     start2++;
200                 }
201             }
202         }
203
204         key_frame= intra_only;
205 #if 1
206         if(is_audio){
207             int frame_bytes= codec->frame_size*(int64_t)codec->bit_rate / (8*codec->sample_rate);
208             for(pred=0; pred<MAX_SIZE_LRU; pred++){
209                 for(frame_type=0; frame_type<1; frame_type++){
210                     FrameCode *ft= &nut->frame_code[start2];
211                     ft->flags= FLAG_KEY_FRAME*key_frame + (FLAG_FULL_PTS+FLAG_PTS+FLAG_FRAME_TYPE)*frame_type;
212                     ft->stream_id_plus1= stream_id + 1;
213                     ft->size_mul=1;
214                     ft->size_lsb=1 + pred;
215                     start2++;
216                 }
217                 nut->stream[stream_id].initial_size_predictor[pred]= frame_bytes + pred;
218             }
219         }else{
220             FrameCode *ft= &nut->frame_code[start2];
221             ft->flags= FLAG_KEY_FRAME | FLAG_DATA_SIZE;
222             ft->stream_id_plus1= stream_id + 1;
223             ft->size_mul=1;
224             start2++;
225         }
226 #endif
227         pred_count= 2 + codec->has_b_frames + (codec->codec_id == CODEC_ID_VORBIS);
228         for(pred=0; pred<pred_count; pred++){
229             int start3= start2 + (end2-start2)*pred / pred_count;
230             int end3  = start2 + (end2-start2)*(pred+1) / pred_count;
231
232             for(index=start3; index<end3; index++){
233                 FrameCode *ft= &nut->frame_code[index];
234                 ft->flags= FLAG_KEY_FRAME*key_frame + pred*4;
235                 ft->flags|= FLAG_DATA_SIZE;
236                 ft->stream_id_plus1= stream_id + 1;
237 //FIXME use single byte size and pred from last
238                 ft->size_mul= end3-start3;
239                 ft->size_lsb= index - start3;
240             }
241             nut->stream[stream_id].initial_pts_predictor[pred]= pred+1;
242         }
243     }
244     memmove(&nut->frame_code['N'+1], &nut->frame_code['N'], sizeof(FrameCode)*(255-'N'));
245     nut->frame_code['N'].flags= 1;
246 }
247
248 static uint64_t get_v(ByteIOContext *bc)
249 {
250     uint64_t val = 0;
251
252     for(;;)
253     {
254         int tmp = get_byte(bc);
255
256         if (tmp&0x80)
257             val= (val<<7) + tmp - 0x80;
258         else
259             return (val<<7) + tmp;
260     }
261     return -1;
262 }
263
264 static int get_str(ByteIOContext *bc, char *string, int maxlen){
265     int len= get_v(bc);
266     
267     if(len && maxlen)
268         get_buffer(bc, string, FFMIN(len, maxlen));
269     while(len > maxlen){
270         get_byte(bc);
271         len--;
272     }
273
274     if(maxlen)
275         string[FFMIN(len, maxlen-1)]= 0;
276     
277     if(maxlen == len)
278         return -1;
279     else
280         return 0;
281 }
282
283 static int get_packetheader(NUTContext *nut, ByteIOContext *bc, int prefix_length, int calculate_checksum)
284 {
285     int64_t start, size, last_size;
286     start= url_ftell(bc) - prefix_length;
287
288     if(start != nut->packet_start + nut->written_packet_size){
289         av_log(nut->avf, AV_LOG_ERROR, "get_packetheader called at weird position\n");
290         if(prefix_length<8)
291             return -1;
292     }
293     
294     init_checksum(bc, calculate_checksum ? update_adler32 : NULL, 0);
295
296     size= get_v(bc);
297     last_size= get_v(bc);
298     if(nut->written_packet_size != last_size){
299         av_log(nut->avf, AV_LOG_ERROR, "packet size missmatch %d != %lld at %lld\n", nut->written_packet_size, last_size, start);
300         if(prefix_length<8)
301             return -1;
302     }
303
304     nut->last_packet_start = nut->packet_start;
305     nut->packet_start = start;
306     nut->written_packet_size= size;
307
308     return size;
309 }
310
311 static int check_checksum(ByteIOContext *bc){
312     unsigned long checksum= get_checksum(bc);
313     return checksum != get_be32(bc);
314 }
315
316 /**
317  * 
318  */
319 static int get_length(uint64_t val){
320     int i;
321
322     for (i=7; ; i+=7)
323         if ((val>>i) == 0)
324             return i;
325
326     return 7; //not reached
327 }
328
329 static uint64_t find_any_startcode(ByteIOContext *bc, int64_t pos){
330     uint64_t state=0;
331     
332     if(pos >= 0)
333         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
334
335     while(!url_feof(bc)){
336         state= (state<<8) | get_byte(bc);
337         if((state>>56) != 'N')
338             continue;
339         switch(state){
340         case MAIN_STARTCODE:
341         case STREAM_STARTCODE:
342         case KEYFRAME_STARTCODE:
343         case INFO_STARTCODE:
344         case INDEX_STARTCODE:
345             return state;
346         }
347     }
348     av_log(NULL, AV_LOG_DEBUG, "searched until %lld\n", url_ftell(bc));
349     return 0;
350 }
351
352 static int find_startcode(ByteIOContext *bc, uint64_t code, int64_t pos){
353     for(;;){
354         uint64_t startcode= find_any_startcode(bc, pos);
355         if(startcode == code)
356             return 0;
357         else if(startcode == 0)
358             return -1;
359         pos=-1;
360     }
361 }
362
363 #ifdef CONFIG_ENCODERS
364 static int put_v(ByteIOContext *bc, uint64_t val)
365 {
366     int i;
367
368     val &= 0x7FFFFFFFFFFFFFFFULL; // FIXME can only encode upto 63 bits currently
369     i= get_length(val);
370
371     for (i-=7; i>0; i-=7){
372         put_byte(bc, 0x80 | (val>>i));
373     }
374
375     put_byte(bc, val&0x7f);
376
377     return 0;
378 }
379
380 static int put_str(ByteIOContext *bc, const char *string){
381     int len= strlen(string);
382     
383     put_v(bc, len);
384     put_buffer(bc, string, len);
385     
386     return 0;
387 }
388
389 static int put_packetheader(NUTContext *nut, ByteIOContext *bc, int max_size, int calculate_checksum)
390 {
391     put_flush_packet(bc);
392     nut->last_packet_start= nut->packet_start;
393     nut->packet_start+= nut->written_packet_size;
394     nut->packet_size_pos = url_ftell(bc);
395     nut->written_packet_size = max_size;
396     
397     if(calculate_checksum)
398         init_checksum(bc, update_adler32, 0);
399
400     /* packet header */
401     put_v(bc, nut->written_packet_size); /* forward ptr */
402     put_v(bc, nut->packet_start - nut->last_packet_start); /* backward ptr */
403
404     return 0;
405 }
406
407 static int update_packetheader(NUTContext *nut, ByteIOContext *bc, int additional_size, int calculate_checksum){
408     int64_t start= nut->packet_start;
409     int64_t cur= url_ftell(bc);
410     int size= cur - start + additional_size;
411     
412     if(calculate_checksum)
413         size += 4;
414     
415     if(size != nut->written_packet_size){
416         int i;
417
418         assert( size <= nut->written_packet_size );
419     
420         url_fseek(bc, nut->packet_size_pos, SEEK_SET);
421         for(i=get_length(size); i < get_length(nut->written_packet_size); i+=7)
422             put_byte(bc, 0x80);
423         put_v(bc, size);
424
425         url_fseek(bc, cur, SEEK_SET);
426         nut->written_packet_size= size; //FIXME may fail if multiple updates with differing sizes, as get_length may differ
427         
428         if(calculate_checksum)
429             put_be32(bc, get_checksum(bc));
430     }
431     
432     return 0;
433 }
434
435 static int nut_write_header(AVFormatContext *s)
436 {
437     NUTContext *nut = s->priv_data;
438     ByteIOContext *bc = &s->pb;
439     AVCodecContext *codec;
440     int i, j;
441
442     nut->avf= s;
443     
444     nut->stream =       
445         av_mallocz(sizeof(StreamContext)*s->nb_streams);
446     
447     av_set_pts_info(s, 60, 1, AV_TIME_BASE);
448     
449     /* main header */
450     put_be64(bc, MAIN_STARTCODE);
451     put_packetheader(nut, bc, 120+5*256, 1);
452     put_v(bc, 1); /* version */
453     put_v(bc, s->nb_streams);
454     put_v(bc, 3);
455     
456     build_frame_code(s);
457     assert(nut->frame_code['N'].flags == 1);
458     for(i=0; i<256;){
459         int tmp_flags = nut->frame_code[i].flags;
460         int tmp_stream= nut->frame_code[i].stream_id_plus1;
461         int tmp_mul   = nut->frame_code[i].size_mul;
462         int tmp_size  = nut->frame_code[i].size_lsb;
463         put_v(bc, tmp_flags);
464         put_v(bc, tmp_stream);
465         put_v(bc, tmp_mul);
466         put_v(bc, tmp_size);
467
468         for(j=0; i<256; j++,i++){
469             if(nut->frame_code[i].flags           != tmp_flags ) break;
470             if(nut->frame_code[i].stream_id_plus1 != tmp_stream) break;
471             if(nut->frame_code[i].size_mul        != tmp_mul   ) break;
472             if(nut->frame_code[i].size_lsb        != tmp_size  ) break;
473             if(++tmp_size >= tmp_mul){
474                 tmp_size=0;
475                 tmp_stream++;
476             }
477         }
478         put_v(bc, j);
479     }
480
481     update_packetheader(nut, bc, 0, 1);
482     
483     /* stream headers */
484     for (i = 0; i < s->nb_streams; i++)
485     {
486         int nom, denom, gcd;
487
488         codec = &s->streams[i]->codec;
489         
490         put_be64(bc, STREAM_STARTCODE);
491         put_packetheader(nut, bc, 120 + codec->extradata_size, 1);
492         put_v(bc, i /*s->streams[i]->index*/);
493         put_v(bc, (codec->codec_type == CODEC_TYPE_AUDIO) ? 32 : 0);
494         if (codec->codec_tag)
495             put_v(bc, codec->codec_tag);
496         else if (codec->codec_type == CODEC_TYPE_VIDEO)
497         {
498             put_v(bc, codec_get_bmp_tag(codec->codec_id));
499         }
500         else if (codec->codec_type == CODEC_TYPE_AUDIO)
501         {
502             put_v(bc, codec_get_wav_tag(codec->codec_id));
503         }
504         else
505             put_v(bc, 0);
506
507         if (codec->codec_type == CODEC_TYPE_VIDEO)
508         {
509             nom = codec->frame_rate;
510             denom = codec->frame_rate_base;
511         }
512         else
513         {
514             nom = codec->sample_rate;
515             if(codec->frame_size>0)
516                 denom= codec->frame_size;
517             else
518                 denom= 1; //unlucky
519         }
520         gcd= ff_gcd(nom, denom);
521         nom   /= gcd;
522         denom /= gcd;
523         nut->stream[i].rate_num= nom;
524         nut->stream[i].rate_den= denom;
525
526         put_v(bc, codec->bit_rate);
527         put_v(bc, 0); /* no language code */
528         put_v(bc, nom);
529         put_v(bc, denom);
530         if(nom / denom < 1000)
531             nut->stream[i].msb_timestamp_shift = 7;
532         else
533             nut->stream[i].msb_timestamp_shift = 14;
534         put_v(bc, nut->stream[i].msb_timestamp_shift);
535         for(j=0; j<3; j++)
536                 put_v(bc, nut->stream[i].initial_pts_predictor[j]);
537         for(j=0; j<2; j++)
538                 put_v(bc, nut->stream[i].initial_size_predictor[j]);
539         put_byte(bc, 0); /* flags: 0x1 - fixed_fps, 0x2 - index_present */
540         
541         if(codec->extradata_size){
542             put_v(bc, 1);
543             put_v(bc, codec->extradata_size);
544             put_buffer(bc, codec->extradata, codec->extradata_size);            
545         }
546         put_v(bc, 0); /* end of codec specific headers */
547         
548         switch(codec->codec_type)
549         {
550             case CODEC_TYPE_AUDIO:
551                 put_v(bc, (codec->sample_rate * denom) / nom);
552                 put_v(bc, codec->channels);
553                 break;
554             case CODEC_TYPE_VIDEO:
555                 put_v(bc, codec->width);
556                 put_v(bc, codec->height);
557                 put_v(bc, codec->sample_aspect_ratio.num);
558                 put_v(bc, codec->sample_aspect_ratio.den);
559                 put_v(bc, 0); /* csp type -- unknown */
560                 break;
561             default:
562                 break;
563         }
564         update_packetheader(nut, bc, 0, 1);
565     }
566
567     /* info header */
568     put_be64(bc, INFO_STARTCODE);
569     put_packetheader(nut, bc, 30+strlen(s->author)+strlen(s->title)+
570         strlen(s->comment)+strlen(s->copyright)+strlen(LIBAVFORMAT_IDENT), 1); 
571     if (s->author[0])
572     {
573         put_v(bc, 9); /* type */
574         put_str(bc, s->author);
575     }
576     if (s->title[0])
577     {
578         put_v(bc, 10); /* type */
579         put_str(bc, s->title);
580     }
581     if (s->comment[0])
582     {
583         put_v(bc, 11); /* type */
584         put_str(bc, s->comment);
585     }
586     if (s->copyright[0])
587     {
588         put_v(bc, 12); /* type */
589         put_str(bc, s->copyright);
590     }
591     /* encoder */
592     put_v(bc, 13); /* type */
593     put_str(bc, LIBAVFORMAT_IDENT);
594     
595     put_v(bc, 0); /* eof info */
596     update_packetheader(nut, bc, 0, 1);
597         
598     put_flush_packet(bc);
599     
600     return 0;
601 }
602
603 static int nut_write_packet(AVFormatContext *s, int stream_index, 
604                             const uint8_t *buf, int size, int64_t pts)
605 {
606     NUTContext *nut = s->priv_data;
607     StreamContext *stream= &nut->stream[stream_index];
608     ByteIOContext *bc = &s->pb;
609     int key_frame = 0, full_pts=0;
610     AVCodecContext *enc;
611     int64_t lsb_pts, delta_pts;
612     int frame_type, best_length, frame_code, flags, i, size_mul, size_lsb;
613     const int64_t frame_start= url_ftell(bc);
614
615     if (stream_index > s->nb_streams)
616         return 1;
617         
618     pts= (av_rescale(pts, stream->rate_num, stream->rate_den) + AV_TIME_BASE/2) / AV_TIME_BASE;
619
620     enc = &s->streams[stream_index]->codec;
621     key_frame = enc->coded_frame->key_frame;
622     delta_pts= pts - stream->last_pts;
623     
624     frame_type=0;
625     if(frame_start + size + 20 - FFMAX(nut->last_frame_start[1], nut->last_frame_start[2]) > MAX_TYPE1_DISTANCE)
626         frame_type=1;
627     if(key_frame){
628         if(frame_type==1 && frame_start + size - nut->last_frame_start[2] > MAX_TYPE2_DISTANCE)
629             frame_type=2;
630         if(!stream->last_key_frame)
631             frame_type=2;
632     }
633
634     if(frame_type>0){
635         update_packetheader(nut, bc, 0, 0);
636         reset(s);
637         full_pts=1;
638     }
639     //FIXME ensure that the timestamp can be represented by either delta or lsb or full_pts=1
640
641     lsb_pts = pts & ((1 << stream->msb_timestamp_shift)-1);
642
643     best_length=INT_MAX;
644     frame_code= -1;
645     for(i=0; i<256; i++){
646         int stream_id_plus1= nut->frame_code[i].stream_id_plus1;
647         int fc_key_frame= stream->last_key_frame;
648         int length=0;
649         size_mul= nut->frame_code[i].size_mul;
650         size_lsb= nut->frame_code[i].size_lsb;
651         flags= nut->frame_code[i].flags;
652
653         if(stream_id_plus1 == 0) length+= get_length(stream_index);
654         else if(stream_id_plus1 - 1 != stream_index)
655             continue;
656         if(flags & FLAG_PRED_KEY_FRAME){
657             if(flags & FLAG_KEY_FRAME)
658                 fc_key_frame= !fc_key_frame;
659         }else{
660             fc_key_frame= !!(flags & FLAG_KEY_FRAME);
661         }
662         assert(key_frame==0 || key_frame==1);
663         if(fc_key_frame != key_frame)
664             continue;
665
666         if((!!(flags & FLAG_FRAME_TYPE)) != (frame_type > 0))
667             continue;
668         
669         if(size_mul <= size_lsb){
670             int p= stream->lru_size[size_lsb - size_mul];
671             if(p != size)
672                 continue;
673         }else{
674             if(size % size_mul != size_lsb)
675                 continue;
676             if(flags & FLAG_DATA_SIZE)
677                 length += get_length(size / size_mul);
678             else if(size/size_mul)
679                 continue;
680         }
681
682         if(full_pts != ((flags & FLAG_PTS) && (flags & FLAG_FULL_PTS)))
683             continue;
684             
685         if(flags&FLAG_PTS){
686             if(flags&FLAG_FULL_PTS){
687                 length += get_length(pts);
688             }else{
689                 length += get_length(lsb_pts);
690             }
691         }else{
692             int delta= stream->lru_pts_delta[(flags & 12)>>2];
693             if(delta != pts - stream->last_pts)
694                 continue;
695             assert(frame_type == 0);
696         }
697
698         if(length < best_length){
699             best_length= length;
700             frame_code=i;
701         }
702 //    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);
703     }
704
705     assert(frame_code != -1);
706     flags= nut->frame_code[frame_code].flags;
707     size_mul= nut->frame_code[frame_code].size_mul;
708     size_lsb= nut->frame_code[frame_code].size_lsb;
709 #if 0
710     best_length /= 7;
711     best_length ++; //frame_code
712     if(frame_type>0){
713         best_length += 4; //packet header
714         if(frame_type>1)
715             best_length += 8; // startcode
716     }
717     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\n", key_frame, frame_type, full_pts ? 2 : ((flags & FLAG_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));
718 #endif
719
720     if (frame_type==2)
721         put_be64(bc, KEYFRAME_STARTCODE);
722     put_byte(bc, frame_code);
723
724     if(frame_type>0)
725         put_packetheader(nut, bc, FFMAX(size+20, MAX_TYPE1_DISTANCE), 0);
726     if(nut->frame_code[frame_code].stream_id_plus1 == 0)
727         put_v(bc, stream_index);
728     if (flags & FLAG_PTS){
729         if (flags & FLAG_FULL_PTS)
730             put_v(bc, pts);
731         else
732             put_v(bc, lsb_pts);
733     }
734     if(flags & FLAG_DATA_SIZE)
735         put_v(bc, size / size_mul);
736     if(size > MAX_TYPE1_DISTANCE){
737         assert(frame_type > 0);
738         update_packetheader(nut, bc, size, 0);
739     }
740     
741     put_buffer(bc, buf, size);
742
743     update(nut, stream_index, frame_start, frame_type, frame_code, key_frame, size, pts);
744     
745     return 0;
746 }
747
748 static int nut_write_trailer(AVFormatContext *s)
749 {
750     NUTContext *nut = s->priv_data;
751     ByteIOContext *bc = &s->pb;
752
753     update_packetheader(nut, bc, 0, 0);
754
755 #if 0
756     int i;
757
758     /* WRITE INDEX */
759
760     for (i = 0; s->nb_streams; i++)
761     {
762         put_be64(bc, INDEX_STARTCODE);
763         put_packetheader(nut, bc, 64, 1);
764         put_v(bc, s->streams[i]->id);
765         put_v(bc, ...);
766         update_packetheader(nut, bc, 0, 1);
767     }
768 #endif
769
770     put_flush_packet(bc);
771     
772     av_freep(&nut->stream);
773
774     return 0;
775 }
776 #endif //CONFIG_ENCODERS
777
778 static int nut_probe(AVProbeData *p)
779 {
780     int i;
781     uint64_t code;
782
783     code = 0xff;
784     for (i = 0; i < p->buf_size; i++) {
785         int c = p->buf[i];
786         code = (code << 8) | c;
787         if (code == MAIN_STARTCODE)
788             return AVPROBE_SCORE_MAX;
789     }
790     return 0;
791 }
792
793 static int decode_main_header(NUTContext *nut){
794     AVFormatContext *s= nut->avf;
795     ByteIOContext *bc = &s->pb;
796     uint64_t tmp;
797     int i, j;
798     
799     get_packetheader(nut, bc, 8, 1);
800
801     tmp = get_v(bc);
802     if (tmp != 1){
803         av_log(s, AV_LOG_ERROR, "bad version (%Ld)\n", tmp);
804         return -1;
805     }
806     
807     nut->stream_count = get_v(bc);
808     get_v(bc); //checksum threshold
809
810     for(i=0; i<256;){
811         int tmp_flags = get_v(bc);
812         int tmp_stream= get_v(bc);
813         int tmp_mul   = get_v(bc);
814         int tmp_size  = get_v(bc);
815         int count     = get_v(bc);
816
817         if(count == 0 || i+count > 256){
818             av_log(s, AV_LOG_ERROR, "illegal count %d at %d\n", count, i);
819             return -1;
820         }
821
822         if((tmp_flags & FLAG_FRAME_TYPE) && tmp_flags != 1){
823             if(tmp_flags & FLAG_PRED_KEY_FRAME){
824                 av_log(s, AV_LOG_ERROR, "keyframe prediction in non 0 frame type\n");
825                 return -1;
826             }
827             if(!(tmp_flags & FLAG_PTS) || !(tmp_flags & FLAG_FULL_PTS) ){
828                 av_log(s, AV_LOG_ERROR, "no full pts in non 0 frame type\n");
829                 return -1;
830             }
831         }
832
833         for(j=0; j<count; j++,i++){
834             if(tmp_stream > nut->stream_count + 1){
835                 av_log(s, AV_LOG_ERROR, "illegal stream number\n");
836                 return -1;
837             }
838
839             nut->frame_code[i].flags           = tmp_flags ;
840             nut->frame_code[i].stream_id_plus1 = tmp_stream;
841             nut->frame_code[i].size_mul        = tmp_mul   ;
842             nut->frame_code[i].size_lsb        = tmp_size  ;
843             if(++tmp_size >= tmp_mul){
844                 tmp_size=0;
845                 tmp_stream++;
846             }
847         }
848     }
849     if(nut->frame_code['N'].flags != 1){
850         av_log(s, AV_LOG_ERROR, "illegal frame_code table\n");
851         return -1;
852     }
853
854     if(check_checksum(bc)){
855         av_log(s, AV_LOG_ERROR, "Main header checksum missmatch\n");
856         return -1;
857     }
858
859     return 0;
860 }
861
862 static int decode_stream_header(NUTContext *nut){
863     AVFormatContext *s= nut->avf;
864     ByteIOContext *bc = &s->pb;
865     int class, nom, denom, stream_id, i;
866     uint64_t tmp;
867     AVStream *st;
868     
869     get_packetheader(nut, bc, 8, 1);
870     stream_id= get_v(bc);
871     if(stream_id >= nut->stream_count || s->streams[stream_id])
872         return -1;
873     
874     st = av_new_stream(s, stream_id);
875     if (!st)
876         return AVERROR_NOMEM;
877     class = get_v(bc);
878     tmp = get_v(bc);
879     switch(class)
880     {
881         case 0:
882             st->codec.codec_type = CODEC_TYPE_VIDEO;
883             st->codec.codec_id = codec_get_bmp_id(tmp);
884             if (st->codec.codec_id == CODEC_ID_NONE)
885                 av_log(s, AV_LOG_ERROR, "Unknown codec?!\n");
886             break;
887         case 32:
888             st->codec.codec_type = CODEC_TYPE_AUDIO;
889             st->codec.codec_id = codec_get_wav_id(tmp);
890             if (st->codec.codec_id == CODEC_ID_NONE)
891                 av_log(s, AV_LOG_ERROR, "Unknown codec?!\n");
892             break;
893         default:
894             av_log(s, AV_LOG_ERROR, "Unknown stream class (%d)\n", class);
895             return -1;
896     }
897     s->bit_rate += get_v(bc);
898     get_v(bc); /* language code */
899     nom = get_v(bc);
900     denom = get_v(bc);
901     nut->stream[stream_id].msb_timestamp_shift = get_v(bc);
902     for(i=0; i<3; i++)
903             nut->stream[stream_id].initial_pts_predictor[i]= get_v(bc);
904     for(i=0; i<2; i++)
905             nut->stream[stream_id].initial_size_predictor[i]= get_v(bc);
906     get_byte(bc); /* flags */
907
908     /* codec specific data headers */
909     while(get_v(bc) != 0){
910         st->codec.extradata_size= get_v(bc);
911         st->codec.extradata= av_mallocz(st->codec.extradata_size);
912         get_buffer(bc, st->codec.extradata, st->codec.extradata_size);            
913 //          url_fskip(bc, get_v(bc));
914     }
915     
916     if (class == 0) /* VIDEO */
917     {
918         st->codec.width = get_v(bc);
919         st->codec.height = get_v(bc);
920         st->codec.sample_aspect_ratio.num= get_v(bc);
921         st->codec.sample_aspect_ratio.den= get_v(bc);
922         get_v(bc); /* csp type */
923
924         st->codec.frame_rate = nom;
925         st->codec.frame_rate_base = denom;
926     }
927     if (class == 32) /* AUDIO */
928     {
929         st->codec.sample_rate = (get_v(bc) * nom) / denom;
930         st->codec.channels = get_v(bc);
931     }
932     if(check_checksum(bc)){
933         av_log(s, AV_LOG_ERROR, "Stream header %d checksum missmatch\n", stream_id);
934         return -1;
935     }
936     nut->stream[stream_id].rate_num= nom;
937     nut->stream[stream_id].rate_den= denom;
938     return 0;
939 }
940
941 static int decode_info_header(NUTContext *nut){
942     AVFormatContext *s= nut->avf;
943     ByteIOContext *bc = &s->pb;
944     
945     get_packetheader(nut, bc, 8, 1);
946
947     for(;;){
948         int id= get_v(bc);
949         char *name, *type, custom_name[256], custom_type[256];
950
951         if(!id)
952             break;
953         else if(id >= sizeof(info_table)/sizeof(info_table[0])){
954             av_log(s, AV_LOG_ERROR, "info id is too large %d %d\n", id, sizeof(info_table)/sizeof(info_table[0]));
955             return -1;
956         }
957
958         type= info_table[id][1];
959         name= info_table[id][0];
960 //av_log(s, AV_LOG_DEBUG, "%d %s %s\n", id, type, name);
961
962         if(!type){
963             get_str(bc, custom_type, sizeof(custom_type));
964             type= custom_type;
965         }
966         if(!name){
967             get_str(bc, custom_name, sizeof(custom_name));
968             name= custom_name;
969         }
970         
971         if(!strcmp(type, "v")){
972             int value= get_v(bc);
973         }else{
974             if(!strcmp(name, "Author"))
975                 get_str(bc, s->author, sizeof(s->author));
976             else if(!strcmp(name, "Title"))
977                 get_str(bc, s->title, sizeof(s->title));
978             else if(!strcmp(name, "Copyright"))
979                 get_str(bc, s->copyright, sizeof(s->copyright));
980             else if(!strcmp(name, "Description"))
981                 get_str(bc, s->comment, sizeof(s->comment));
982             else
983                 get_str(bc, NULL, 0);
984         }
985     }
986     if(check_checksum(bc)){
987         av_log(s, AV_LOG_ERROR, "Info header checksum missmatch\n");
988         return -1;
989     }
990     return 0;
991 }
992
993 static int nut_read_header(AVFormatContext *s, AVFormatParameters *ap)
994 {
995     NUTContext *nut = s->priv_data;
996     ByteIOContext *bc = &s->pb;
997     int64_t pos;
998     int inited_stream_count;
999
1000     nut->avf= s;
1001     
1002     av_set_pts_info(s, 60, 1, AV_TIME_BASE);
1003
1004     /* main header */
1005     pos=0;
1006     for(;;){
1007         if (find_startcode(bc, MAIN_STARTCODE, pos)<0){
1008             av_log(s, AV_LOG_ERROR, "no main startcode found\n");
1009             return -1;
1010         }
1011         pos= url_ftell(bc);
1012         if(decode_main_header(nut) >= 0)
1013             break;
1014     }
1015     
1016     
1017     s->bit_rate = 0;
1018
1019     nut->stream = av_malloc(sizeof(StreamContext)*nut->stream_count);
1020
1021     /* stream headers */
1022     pos=0;
1023     for(inited_stream_count=0; inited_stream_count < nut->stream_count;){
1024         if (find_startcode(bc, STREAM_STARTCODE, pos)<0){
1025             av_log(s, AV_LOG_ERROR, "not all stream headers found\n");
1026             return -1;
1027         }
1028         pos= url_ftell(bc);
1029         if(decode_stream_header(nut) >= 0)
1030             inited_stream_count++;
1031     }
1032
1033     /* info headers */
1034     pos=0;
1035     for(;;){
1036         uint64_t startcode= find_any_startcode(bc, pos);
1037         pos= url_ftell(bc);
1038
1039         if(startcode==0){
1040             av_log(s, AV_LOG_ERROR, "EOF before video frames\n");
1041             return -1;
1042         }else if(startcode == KEYFRAME_STARTCODE){
1043             nut->next_startcode= startcode;
1044             break;
1045         }else if(startcode != INFO_STARTCODE){
1046             continue;
1047         }
1048
1049         decode_info_header(nut);
1050     }
1051
1052     return 0;
1053 }
1054
1055 static int decode_frame(NUTContext *nut, AVPacket *pkt, int frame_code, int frame_type){
1056     AVFormatContext *s= nut->avf;
1057     StreamContext *stream;
1058     ByteIOContext *bc = &s->pb;
1059     int size, flags, size_mul, size_lsb, stream_id;
1060     int key_frame = 0;
1061     int64_t pts = 0;
1062     const int prefix_len= frame_type == 2 ? 8+1 : 1;
1063     const int64_t frame_start= url_ftell(bc) + prefix_len;
1064
1065     flags= nut->frame_code[frame_code].flags;
1066     size_mul= nut->frame_code[frame_code].size_mul;
1067     size_lsb= nut->frame_code[frame_code].size_lsb;
1068     stream_id= nut->frame_code[frame_code].stream_id_plus1 - 1;
1069
1070     if(flags & FLAG_FRAME_TYPE){
1071         reset(s);
1072         if(get_packetheader(nut, bc, prefix_len, 0) < 0)
1073             return -1;
1074         if(frame_type!=2)
1075             frame_type= 1;
1076     }
1077
1078     if(stream_id==-1)
1079         stream_id= get_v(bc);
1080     if(stream_id >= s->nb_streams){
1081         av_log(s, AV_LOG_ERROR, "illegal stream_id\n");
1082         return -1;
1083     }
1084     stream= &nut->stream[stream_id];
1085
1086 //    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]);
1087     
1088     if(flags & FLAG_PRED_KEY_FRAME){
1089         if(flags & FLAG_KEY_FRAME)
1090             key_frame= !stream->last_key_frame;
1091         else
1092             key_frame= stream->last_key_frame;
1093     }else{
1094         key_frame= !!(flags & FLAG_KEY_FRAME);
1095     }
1096
1097     if(flags & FLAG_PTS){
1098         if(flags & FLAG_FULL_PTS){
1099             pts= get_v(bc);
1100         }else{
1101             int64_t mask = (1<<stream->msb_timestamp_shift)-1;
1102             int64_t delta= stream->last_pts - mask/2;
1103             pts= ((get_v(bc) - delta)&mask) + delta;
1104         }
1105     }else{
1106         pts= stream->last_pts + stream->lru_pts_delta[(flags&12)>>2];
1107     }
1108   
1109     if(size_mul <= size_lsb){
1110         size= stream->lru_size[size_lsb - size_mul];
1111     }else{
1112         if(flags & FLAG_DATA_SIZE)
1113             size= size_mul*get_v(bc) + size_lsb;
1114         else
1115             size= size_lsb;
1116     }
1117       
1118 //av_log(s, AV_LOG_DEBUG, "fs:%lld fc:%d ft:%d kf:%d pts:%lld size:%d\n", frame_start, frame_code, frame_type, key_frame, pts, size);
1119
1120     if(url_ftell(bc) - nut->packet_start + size > nut->written_packet_size){
1121         av_log(s, AV_LOG_ERROR, "frame size too large\n");
1122         return -1;
1123     }
1124     
1125     av_new_packet(pkt, size);
1126     get_buffer(bc, pkt->data, size);
1127     pkt->stream_index = stream_id;
1128     if (key_frame)
1129         pkt->flags |= PKT_FLAG_KEY;
1130     pkt->pts = pts * AV_TIME_BASE * stream->rate_den / stream->rate_num;
1131
1132     update(nut, stream_id, frame_start, frame_type, frame_code, key_frame, size, pts);
1133     
1134     return 0;
1135 }
1136
1137 static int nut_read_packet(AVFormatContext *s, AVPacket *pkt)
1138 {
1139     NUTContext *nut = s->priv_data;
1140     ByteIOContext *bc = &s->pb;
1141     int size, frame_code=0;
1142     int frame_type= 0;
1143     int64_t pos;
1144
1145     for(;;){
1146         uint64_t tmp= nut->next_startcode;
1147         nut->next_startcode=0;
1148
1149         if (url_feof(bc))
1150             return -1;
1151
1152         if(!tmp){
1153             frame_code = get_byte(bc);
1154             if(frame_code == 'N'){
1155                 tmp= frame_code;
1156                 tmp<<=8 ; tmp |= get_byte(bc);
1157                 tmp<<=16; tmp |= get_be16(bc);
1158                 tmp<<=32; tmp |= get_be32(bc);
1159             }
1160         }
1161         switch(tmp){
1162         case KEYFRAME_STARTCODE:
1163             frame_type = 2;
1164             break;
1165         case MAIN_STARTCODE:
1166         case STREAM_STARTCODE:
1167         case INDEX_STARTCODE:
1168             get_packetheader(nut, bc, 8, 0);
1169             url_fseek(bc, nut->written_packet_size + nut->packet_start, SEEK_SET);
1170             break;
1171         case INFO_STARTCODE:
1172             if(decode_info_header(nut)<0)
1173                 goto resync;
1174             break;
1175         case 0:
1176             if(decode_frame(nut, pkt, frame_code, frame_type)>=0)
1177                 return 0;
1178         default:
1179 resync:
1180             frame_type = 0;
1181 av_log(s, AV_LOG_DEBUG, "syncing from %lld\n", nut->packet_start+1);
1182             tmp= find_any_startcode(bc, nut->packet_start+1);
1183             if(tmp==0)
1184                 return -1;
1185 av_log(s, AV_LOG_DEBUG, "sync\n");
1186             if(url_is_streamed(bc)){
1187                 nut->next_startcode= tmp;
1188                 break;
1189             }
1190
1191             pos= url_ftell(bc) - 8;
1192 av_log(s, AV_LOG_DEBUG, "at %lld code=%llX\n", pos, tmp);
1193             if(tmp==KEYFRAME_STARTCODE){
1194                 get_byte(bc);
1195             }
1196             get_v(bc);
1197             size= get_v(bc);
1198             
1199             while(size > 2 && size < 100000 && nut->packet_start < pos - size){
1200                 url_fseek(bc, pos - size, SEEK_SET);
1201                 frame_code= get_byte(bc);
1202                 if(!(nut->frame_code[ frame_code ].flags & FLAG_FRAME_TYPE))
1203                     break;
1204                 if(get_v(bc) != size)
1205                     break;
1206                 pos -= size;
1207                 size= get_v(bc);
1208 av_log(s, AV_LOG_DEBUG, "steping back to %lld next %d\n", pos, size);
1209             }
1210             url_fseek(bc, pos, SEEK_SET);
1211             
1212             nut->written_packet_size= size;
1213             nut->packet_start= pos - size;
1214         }
1215     }
1216 }
1217
1218 static int nut_read_close(AVFormatContext *s)
1219 {
1220     NUTContext *nut = s->priv_data;
1221     int i;
1222
1223     for(i=0;i<s->nb_streams;i++) {
1224         av_freep(&s->streams[i]->codec.extradata);
1225     }
1226     av_freep(&nut->stream);
1227
1228     return 0;
1229 }
1230
1231 static AVInputFormat nut_iformat = {
1232     "nut",
1233     "nut format",
1234     sizeof(NUTContext),
1235     nut_probe,
1236     nut_read_header,
1237     nut_read_packet,
1238     nut_read_close,
1239 //    nut_read_seek,
1240     .extensions = "nut",
1241 };
1242
1243 #ifdef CONFIG_ENCODERS
1244 static AVOutputFormat nut_oformat = {
1245     "nut",
1246     "nut format",
1247     "video/x-nut",
1248     "nut",
1249     sizeof(NUTContext),
1250 #ifdef CONFIG_VORBIS
1251     CODEC_ID_VORBIS,
1252 #elif defined(CONFIG_MP3LAME)
1253     CODEC_ID_MP3,
1254 #else
1255     CODEC_ID_MP2, /* AC3 needs liba52 decoder */
1256 #endif
1257     CODEC_ID_MPEG4,
1258     nut_write_header,
1259     nut_write_packet,
1260     nut_write_trailer,
1261 };
1262 #endif //CONFIG_ENCODERS
1263
1264 int nut_init(void)
1265 {
1266     av_register_input_format(&nut_iformat);
1267 #ifdef CONFIG_ENCODERS
1268     av_register_output_format(&nut_oformat);
1269 #endif //CONFIG_ENCODERS
1270     return 0;
1271 }