09475946f3c1c0c53f7c17384bfcc6ecc1a6cefe
[ffmpeg.git] / libavformat / nut.c
1 /*
2  * "NUT" Container Format muxer and demuxer (DRAFT-20031003)
3  * Copyright (c) 2003 Alex Beregszaszi
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18  *
19  * NUT DRAFT can be found in MPlayer CVS at DOCS/tech/mpcf.txt
20  *
21  * AND http://people.fsn.hu/~alex/nut/ (TeX, pdf, ps, dvi, ..)
22  *
23  */
24
25 /*
26  * TODO:
27  * - checksumming
28  * - optimal timestamp handling
29  * - index writing
30  * - info and index packet reading support
31  * - startcode searching for broken streams
32  * - subpacket support
33 */
34
35 //#define DEBUG 1
36
37 #include "avformat.h"
38 #include "mpegaudio.h"
39 #include "avi.h"
40
41 //from /dev/random
42
43 #define     MAIN_STARTCODE (0xF9526A6200000000ULL + ('N'<<24) + ('U'<<16) + ('T'<<8) + 'M')
44 #define   STREAM_STARTCODE (0xD667773F00000000ULL + ('N'<<24) + ('U'<<16) + ('T'<<8) + 'S')
45 #define KEYFRAME_STARTCODE (0xCB86308700000000ULL + ('N'<<24) + ('U'<<16) + ('T'<<8) + 'K')
46 #define    INDEX_STARTCODE (0xEBFCDE0E00000000ULL + ('N'<<24) + ('U'<<16) + ('T'<<8) + 'X')
47 #define     INFO_STARTCODE (0xA37B643500000000ULL + ('N'<<24) + ('U'<<16) + ('T'<<8) + 'I')
48
49 typedef struct {
50     int curr_frame_start;
51     int last_frame_size;
52     int curr_frame_size;
53     int *msb_timestamp_shift;
54     int64_t *last_msb_timestamp;
55 } NUTContext;
56
57 static int bytes_left(ByteIOContext *bc)
58 {
59     return bc->buf_end - bc->buf_ptr;
60 }
61
62 static uint64_t get_v(ByteIOContext *bc)
63 {
64     uint64_t val = 0;
65
66     for(; bytes_left(bc) > 0; )
67     {
68         int tmp = get_byte(bc);
69
70         if (tmp&0x80)
71             val= (val<<7) + tmp - 0x80;
72         else
73             return (val<<7) + tmp;
74     }
75     return -1;
76 }
77
78 static int64_t get_s(ByteIOContext *bc)
79 {
80     int64_t v = get_v(bc) + 1;
81
82     if (v&1)
83         return -(v>>1);
84     else
85         return (v>>1);
86 }
87
88 static int get_b(ByteIOContext *bc, char *data, int maxlen)
89 {
90     int i, len;
91     
92     len = get_v(bc);
93     for (i = 0; i < len && i < maxlen; i++)
94         data[i] = get_byte(bc);
95     /* skip remaining bytes */
96     url_fskip(bc, len-i);
97
98     return 0;
99 }
100
101 static int get_bi(ByteIOContext *bc)
102 {
103    int i, len, val = 0;
104     
105     len = get_v(bc);
106     for (i = 0; i < len && i <= 4; i++)
107         val |= get_byte(bc) << (i * 8);
108     /* skip remaining bytes */
109     url_fskip(bc, len-i);
110
111     return val;
112 }
113
114 static int get_packetheader(NUTContext *nut, ByteIOContext *bc)
115 {
116     nut->curr_frame_start = url_ftell(bc);
117     nut->curr_frame_size = get_v(bc);
118     nut->last_frame_size = get_v(bc);
119     dprintf("Packet: fwd: %d bwd: %d\n",
120         nut->curr_frame_size, nut->last_frame_size);
121     
122     return 0;
123 }
124
125 /**
126  * 
127  */
128 static int get_length(uint64_t val){
129     int i;
130
131     for (i=7; ; i+=7)
132         if ((val>>i) == 0)
133             return i;
134
135     return 7; //not reached
136 }
137
138 #ifdef CONFIG_ENCODERS
139 static int put_v(ByteIOContext *bc, uint64_t val)
140 {
141     int i;
142
143 //    if (bytes_left(s)*8 < 9)
144 //      return -1;
145
146     if (bytes_left(bc) < 1)
147         return -1;
148
149     val &= 0x7FFFFFFFFFFFFFFFULL; // FIXME can only encode upto 63 bits currently
150     i= get_length(val);
151
152     for (i-=7; i>0; i-=7){
153         put_byte(bc, 0x80 | (val>>i));
154     }
155
156     put_byte(bc, val&0x7f);
157
158     return 0;
159 }
160
161 static int put_s(ByteIOContext *bc, uint64_t val)
162 {
163     if (val<=0)
164         return put_v(bc, -2*val);
165     else
166         return put_v(bc, 2*val-1);
167 }
168
169 static int put_b(ByteIOContext *bc, char *data, int len)
170 {
171     int i;
172     
173     put_v(bc, len);
174     for (i = 0; i < len; i++)
175         put_byte(bc, data[i]);
176
177     return 0;
178 }
179
180 static int put_bi(ByteIOContext *bc, int val)
181 {
182     put_v(bc, 4);
183     put_le32(bc, val);
184     return 0;
185 }
186
187 static int put_packetheader(NUTContext *nut, ByteIOContext *bc, int max_size)
188 {
189     put_flush_packet(bc);
190     nut->curr_frame_start = url_ftell(bc);
191     nut->curr_frame_size = max_size;
192     
193     /* packet header */
194     put_v(bc, nut->curr_frame_size); /* forward ptr */
195     put_v(bc, nut->last_frame_size); /* backward ptr */
196     dprintf("Packet: fwd: %d, bwd: %d\n",
197         nut->curr_frame_size, nut->last_frame_size);
198
199     nut->last_frame_size = nut->curr_frame_size;
200     
201     return 0;
202 }
203
204 static int update_packetheader(NUTContext *nut, ByteIOContext *bc, int additional_size){
205     offset_t start= nut->curr_frame_start;
206     offset_t cur= url_ftell(bc);
207     int size= cur - start + additional_size;
208     
209     assert( size <= nut->curr_frame_size );
210     
211     url_fseek(bc, start, SEEK_SET);
212     put_v(bc, size);
213     if(get_length(size) < get_length(nut->curr_frame_size))
214         put_byte(bc, 0x80);
215     nut->curr_frame_size= size;
216     dprintf("Packet update: size: %d\n", size);
217
218     url_fseek(bc, cur, SEEK_SET);    
219     
220     return 0;
221 }
222
223 static int nut_write_header(AVFormatContext *s)
224 {
225     NUTContext *nut = s->priv_data;
226     ByteIOContext *bc = &s->pb;
227     AVCodecContext *codec;
228     int i;
229
230     /* main header */
231     put_be64(bc, MAIN_STARTCODE);
232     put_packetheader(nut, bc, 120);
233     put_v(bc, 0); /* version */
234     put_v(bc, s->nb_streams);
235     put_be32(bc, 0); /* FIXME: checksum */
236     
237     update_packetheader(nut, bc, 0);
238     
239     nut->msb_timestamp_shift =  
240         av_mallocz(sizeof(nut->msb_timestamp_shift)*s->nb_streams);
241     nut->last_msb_timestamp =
242         av_mallocz(sizeof(nut->last_msb_timestamp)*s->nb_streams);
243     
244     /* stream headers */
245     for (i = 0; i < s->nb_streams; i++)
246     {
247         int nom, denom;
248
249         codec = &s->streams[i]->codec;
250         
251         put_be64(bc, STREAM_STARTCODE);
252         put_packetheader(nut, bc, 120);
253         put_v(bc, i /*s->streams[i]->index*/);
254         put_v(bc, (codec->codec_type == CODEC_TYPE_AUDIO) ? 32 : 0);
255         if (codec->codec_tag)
256             put_bi(bc, codec->codec_tag);
257         else if (codec->codec_type == CODEC_TYPE_VIDEO)
258         {
259             int tmp = codec_get_bmp_tag(codec->codec_id);
260             put_bi(bc, tmp);
261         }
262         else if (codec->codec_type == CODEC_TYPE_AUDIO)
263         {
264             int tmp = codec_get_wav_tag(codec->codec_id);
265             put_bi(bc, tmp);
266         }
267
268         if (codec->codec_type == CODEC_TYPE_VIDEO)
269         {
270             nom = codec->frame_rate;
271             denom = codec->frame_rate_base;
272         }
273         else
274         {
275             nom = codec->sample_rate/8;
276             denom = 8;
277         }
278         put_v(bc, codec->bit_rate);
279         put_v(bc, 0); /* no language code */
280         put_v(bc, nom);
281         put_v(bc, denom);
282         nut->msb_timestamp_shift[i] = 0;
283         put_v(bc, nut->msb_timestamp_shift[i]);
284         put_v(bc, 0); /* shuffle type */
285         put_byte(bc, 0); /* flags: 0x1 - fixed_fps, 0x2 - index_present */
286         
287         put_v(bc, 0); /* no codec specific headers */
288         
289         switch(codec->codec_type)
290         {
291             case CODEC_TYPE_AUDIO:
292                 put_v(bc, (codec->sample_rate * denom) / nom);
293                 put_v(bc, codec->channels);
294                 put_be32(bc, 0); /* FIXME: checksum */
295                 break;
296             case CODEC_TYPE_VIDEO:
297                 put_v(bc, codec->width);
298                 put_v(bc, codec->height);
299                 put_v(bc, 0); /* aspected w */
300                 put_v(bc, 0); /* aspected h */
301                 put_v(bc, 0); /* csp type -- unknown */
302                 put_be32(bc, 0); /* FIXME: checksum */
303                 break;
304             default:
305                 break;
306         }
307         update_packetheader(nut, bc, 0);
308     }
309
310 #if 0
311     /* info header */
312     put_be64(bc, INFO_STARTCODE);
313     put_packetheader(nut, bc, 16+strlen(s->author)+strlen(s->title)+
314         strlen(s->comment)+strlen(s->copyright)); 
315     if (s->author[0])
316     {
317         put_v(bc, 5); /* type */
318         put_b(bc, s->author, strlen(s->author));
319     }
320     if (s->title[0])
321     {
322         put_v(bc, 6); /* type */
323         put_b(bc, s->title, strlen(s->title));
324     }
325     if (s->comment[0])
326     {
327         put_v(bc, 7); /* type */
328         put_b(bc, s->comment, strlen(s->comment));
329     }
330     if (s->copyright[0])
331     {
332         put_v(bc, 8); /* type */
333         put_b(bc, s->copyright, strlen(s->copyright));
334     }
335     /* encoder */
336     put_v(bc, 9); /* type */
337     put_b(bc, LIBAVFORMAT_IDENT "\0", strlen(LIBAVFORMAT_IDENT));
338     
339     put_v(bc, 0); /* eof info */
340
341     put_be32(bc, 0); /* FIXME: checksum */
342     update_packetheader(nut, bc, 0);
343 #endif
344         
345     put_flush_packet(bc);
346     
347     return 0;
348 }
349
350 static int nut_write_packet(AVFormatContext *s, int stream_index, 
351                             const uint8_t *buf, int size, int64_t pts)
352 {
353     NUTContext *nut = s->priv_data;
354     ByteIOContext *bc = &s->pb;
355     int key_frame = 0, flags, msb_pts = 0;
356     AVCodecContext *enc;
357     int64_t lsb_pts;
358
359     if (stream_index > s->nb_streams)
360         return 1;
361
362     enc = &s->streams[stream_index]->codec;
363     // FIXME, lavc reports always keyframes for audio, which will make
364     // _huge_ overhead
365     if (enc->codec_type == CODEC_TYPE_VIDEO)
366         key_frame = enc->coded_frame->key_frame;
367
368     if (key_frame /*||
369         ((pts - (nut->last_msb_timestamp[stream_index] <<
370         nut->msb_timestamp_shift[stream_index])) > 1024)*/)
371     {
372         msb_pts = 1;
373         nut->last_msb_timestamp[stream_index] = pts >> nut->msb_timestamp_shift[stream_index];
374     }
375
376     lsb_pts = pts - (nut->last_msb_timestamp[stream_index] << nut->msb_timestamp_shift[stream_index]);
377     
378     flags=0;
379     flags<<=2; flags|=1; //priority
380     flags<<=1; flags|=0; //checksum
381     flags<<=1; flags|=msb_pts; //msb_timestamp_flag
382     flags<<=2; flags|=1; //subpacket_type
383     flags<<=1; flags|=0; //reserved
384
385     if (key_frame)
386         put_be64(bc, KEYFRAME_STARTCODE);
387     put_byte(bc, flags);
388
389     put_packetheader(nut, bc, size+20);
390     put_v(bc, stream_index);
391     if (msb_pts)
392         put_v(bc, nut->last_msb_timestamp[stream_index]);
393     put_v(bc, lsb_pts); /* lsb_timestamp */
394     update_packetheader(nut, bc, size);
395     
396     put_buffer(bc, buf, size);
397     
398     put_flush_packet(bc);
399
400     return 0;
401 }
402
403 static int nut_write_trailer(AVFormatContext *s)
404 {
405     NUTContext *nut = s->priv_data;
406     ByteIOContext *bc = &s->pb;
407 #if 0
408     int i;
409
410     /* WRITE INDEX */
411
412     for (i = 0; s->nb_streams; i++)
413     {
414         put_be64(bc, INDEX_STARTCODE);
415         put_packetheader(nut, bc, 64);
416         put_v(bc, s->streams[i]->id);
417         put_v(bc, ...);
418         put_be32(bc, 0); /* FIXME: checksum */
419         update_packetheader(nut, bc, 0);
420     }
421 #endif
422
423     put_flush_packet(bc);
424     
425     if (nut->last_msb_timestamp)
426         av_free(nut->last_msb_timestamp);
427     if (nut->msb_timestamp_shift)
428         av_free(nut->msb_timestamp_shift);
429
430     return 0;
431 }
432 #endif //CONFIG_ENCODERS
433
434 static int nut_probe(AVProbeData *p)
435 {
436     int i;
437     uint64_t code;
438
439     code = 0xff;
440     for (i = 0; i < p->buf_size; i++) {
441         int c = p->buf[i];
442         code = (code << 8) | c;
443         if (code == MAIN_STARTCODE)
444             return AVPROBE_SCORE_MAX;
445     }
446     return 0;
447 }
448
449 static int nut_read_header(AVFormatContext *s, AVFormatParameters *ap)
450 {
451     NUTContext *nut = s->priv_data;
452     ByteIOContext *bc = &s->pb;
453     uint64_t tmp;
454     int cur_stream, nb_streams;
455     
456     /* main header */
457     tmp = get_be64(bc);
458     if (tmp != MAIN_STARTCODE)
459         fprintf(stderr, "damaged? startcode!=1 (%Ld)\n", tmp);
460     get_packetheader(nut, bc);
461     
462     tmp = get_v(bc);
463     if (tmp != 0)
464         fprintf(stderr, "bad version (%Ld)\n", tmp);
465     
466     nb_streams = get_v(bc);
467     get_be32(bc); /* checkusm */
468     
469     s->bit_rate = 0;
470
471     nut->msb_timestamp_shift =  
472         av_malloc(sizeof(nut->msb_timestamp_shift)*s->nb_streams);
473     nut->last_msb_timestamp =
474         av_malloc(sizeof(nut->last_msb_timestamp)*s->nb_streams);
475     
476     /* stream header */
477     for (cur_stream = 0; cur_stream < nb_streams; cur_stream++)
478     {
479         int class, nom, denom;
480         AVStream *st;
481         
482         tmp = get_be64(bc);
483         if (tmp != STREAM_STARTCODE)
484             fprintf(stderr, "damaged? startcode!=1 (%Ld)\n", tmp);
485         get_packetheader(nut, bc);
486         st = av_new_stream(s, get_v(bc));
487         if (!st)
488             return AVERROR_NOMEM;
489         class = get_v(bc);
490         tmp = get_bi(bc);
491         switch(class)
492         {
493             case 0:
494                 st->codec.codec_type = CODEC_TYPE_VIDEO;
495                 st->codec.codec_id = codec_get_bmp_id(tmp);
496                 if (st->codec.codec_id == CODEC_ID_NONE)
497                     fprintf(stderr, "Unknown codec?!\n");
498                 break;
499             case 32:
500                 st->codec.codec_type = CODEC_TYPE_AUDIO;
501                 st->codec.codec_id = codec_get_wav_id(tmp);
502                 if (st->codec.codec_id == CODEC_ID_NONE)
503                     fprintf(stderr, "Unknown codec?!\n");
504                 break;
505             default:
506                 fprintf(stderr, "Unknown stream class (%d)\n", class);
507                 return -1;
508         }
509         s->bit_rate += get_v(bc);
510         get_b(bc, NULL, 0); /* language code */
511         nom = get_v(bc);
512         denom = get_v(bc);
513         nut->msb_timestamp_shift[cur_stream] = get_v(bc);
514         get_v(bc); /* shuffle type */
515         get_byte(bc); /* flags */
516
517         /* codec specific data headers */
518         while(get_v(bc) != 0)
519             url_fskip(bc, get_v(bc));
520         
521         if (class == 0) /* VIDEO */
522         {
523             st->codec.width = get_v(bc);
524             st->codec.height = get_v(bc);
525             get_v(bc); /* aspected w */
526             get_v(bc); /* aspected h */
527             get_v(bc); /* csp type */
528             get_be32(bc); /* checksum */
529
530             st->codec.frame_rate = nom;
531             st->codec.frame_rate_base = denom;
532         }
533         if (class == 32) /* AUDIO */
534         {
535             st->codec.sample_rate = (get_v(bc) * nom) / denom;
536             st->codec.channels = get_v(bc);
537             get_be32(bc); /* checksum */
538         }
539     }    
540     
541     return 0;
542 }
543
544 static int nut_read_packet(AVFormatContext *s, AVPacket *pkt)
545 {
546     NUTContext *nut = s->priv_data;
547     ByteIOContext *bc = &s->pb;
548     int id, size;
549     int key_frame = 0;
550     uint64_t tmp;
551     int64_t pts = 0;
552
553     if (url_feof(bc))
554         return -1;
555     
556     tmp = get_byte(bc);
557     if (tmp & 0x80) /* zero bit set? */
558     {
559         tmp<<=8 ; tmp |= get_byte(bc);
560         tmp<<=16; tmp |= get_be16(bc);
561         tmp<<=32; tmp |= get_be32(bc);
562         if (tmp == KEYFRAME_STARTCODE)
563         {
564             key_frame = 1;
565             tmp = get_byte(bc); /* flags */
566         }
567         else
568             fprintf(stderr, "error in zero bit / startcode %LX\n", tmp);
569     }
570     get_packetheader(nut, bc);
571 #if 0
572     if (((tmp & 0x60)>>5) > 3) /* priority <= 3 */
573         fprintf(stderr, "sanity check failed!\n");
574 #endif
575     id = get_v(bc);
576     if ((tmp & 0x8) >> 3)
577         pts = get_v(bc) << nut->msb_timestamp_shift[id];
578     pts += get_v(bc);
579     
580     size = (nut->curr_frame_size - (url_ftell(bc)-nut->curr_frame_start));
581     dprintf("flags: 0x%llx, timestamp: %llx, packet size: %d\n", tmp, pts, size);
582     
583     if (size < 0)
584         return -1;
585
586     av_new_packet(pkt, size);
587     get_buffer(bc, pkt->data, size);
588     pkt->stream_index = id;
589     if (key_frame)
590         pkt->flags |= PKT_FLAG_KEY;
591     pkt->pts = pts;
592
593     return 0;
594 }
595
596 static AVInputFormat nut_iformat = {
597     "nut",
598     "nut format",
599     sizeof(NUTContext),
600     nut_probe,
601     nut_read_header,
602     nut_read_packet,
603 //    nut_read_close,
604 //    nut_read_seek,
605     .extensions = "nut",
606 };
607
608 #ifdef CONFIG_ENCODERS
609 static AVOutputFormat nut_oformat = {
610     "nut",
611     "nut format",
612     "video/x-nut",
613     "nut",
614     sizeof(NUTContext),
615 #ifdef CONFIG_VORBIS
616     CODEC_ID_VORBIS,
617 #elif defined(CONFIG_MP3LAME)
618     CODEC_ID_MP3,
619 #else
620     CODEC_ID_MP2, /* AC3 needs liba52 decoder */
621 #endif
622     CODEC_ID_MPEG4,
623     nut_write_header,
624     nut_write_packet,
625     nut_write_trailer,
626 };
627 #endif //CONFIG_ENCODERS
628
629 int nut_init(void)
630 {
631     av_register_input_format(&nut_iformat);
632 #ifdef CONFIG_ENCODERS
633     av_register_output_format(&nut_oformat);
634 #endif //CONFIG_ENCODERS
635     return 0;
636 }