fixed endianness dependancies (untested)
[ffmpeg.git] / libavformat / nut.c
1 /*
2  * NUT (de)muxer based on initial draft
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  * Compatible with draft version 20030906
22  *
23  */
24
25 /*
26  * TODO:
27  * - checksumming
28  * - correct rate denom/nom and sample_mul
29  * - correct timestamp handling
30  * - index writing
31  * - info and index packet reading support
32  * - startcode searching for broken streams
33  * - subpacket support
34  * - handling of codec specific headers
35 */
36
37 //#define DEBUG 1
38
39 #include "avformat.h"
40 #include "mpegaudio.h"
41 #include "avi.h"
42
43 //from /dev/random
44
45 #define     MAIN_STARTCODE (0xF9526A6200000000ULL + ('N'<<24) + ('U'<<16) + ('T'<<8) + 'M')
46 #define   STREAM_STARTCODE (0xD667773F00000000ULL + ('N'<<24) + ('U'<<16) + ('T'<<8) + 'S')
47 #define KEYFRAME_STARTCODE (0xCB86308700000000ULL + ('N'<<24) + ('U'<<16) + ('T'<<8) + 'K')
48 #define    INDEX_STARTCODE (0xEBFCDE0E00000000ULL + ('N'<<24) + ('U'<<16) + ('T'<<8) + 'X')
49 #define     INFO_STARTCODE (0xA37B643500000000ULL + ('N'<<24) + ('U'<<16) + ('T'<<8) + 'I')
50
51 typedef struct {
52     int curr_frame_start;
53     int last_frame_size;
54     int curr_frame_size;
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(s)*8 > 0; )
67     for(; bytes_left(bc) > 0; )
68     {
69         int tmp = get_byte(bc);
70
71         if (tmp&0x80)
72             val= (val<<7) + tmp - 0x80;
73         else
74             return (val<<7) + tmp;
75     }
76     return -1;
77 }
78
79 static int64_t get_s(ByteIOContext *bc)
80 {
81     int64_t v = get_v(bc) + 1;
82
83     if (v&1)
84         return -(v>>1);
85     else
86         return (v>>1);
87 }
88
89 static int get_b(ByteIOContext *bc)
90 {
91     int i, len, val;
92     
93     len = get_v(bc);
94     val = 0;
95     for (i = 0; i < len; i++) {
96         if (i < 4)
97             val |= get_byte(bc) << (i * 8);
98     }
99     return val;
100 }
101
102 static int get_packetheader(NUTContext *nut, ByteIOContext *bc)
103 {
104     nut->curr_frame_start = url_ftell(bc);
105     nut->curr_frame_size = get_v(bc);
106     nut->last_frame_size = get_v(bc);
107     dprintf("Packet: fwd: %d bwd: %d\n",
108         nut->curr_frame_size, nut->last_frame_size);
109     
110     return 0;
111 }
112
113 /**
114  * 
115  */
116 static int get_length(uint64_t val){
117     int i;
118
119     for (i=7; ; i+=7)
120         if ((val>>i) == 0)
121             return i;
122
123     return 7; //not reached
124 }
125
126 static int put_v(ByteIOContext *bc, uint64_t val)
127 {
128     int i;
129
130 //    if (bytes_left(s)*8 < 9)
131 //      return -1;
132
133     if (bytes_left(bc) < 1)
134         return -1;
135
136     val &= 0x7FFFFFFFFFFFFFFFULL; // FIXME can only encode upto 63 bits currently
137     i= get_length(val);
138
139     for (i-=7; i>0; i-=7){
140         put_byte(bc, 0x80 | (val>>i));
141     }
142
143     put_byte(bc, val&0x7f);
144
145     return 0;
146 }
147
148 static int put_s(ByteIOContext *bc, uint64_t val)
149 {
150     if (val<=0)
151         return put_v(bc, -2*val);
152     else
153         return put_v(bc, 2*val-1);
154 }
155
156 static int put_b(ByteIOContext *bc, char *data, int len)
157 {
158     int i;
159     
160     put_v(bc, len);
161     for (i = 0; i < len; i++)
162         put_byte(bc, data[i]);
163
164     return 0;
165 }
166
167 static int put_bi(ByteIOContext *bc, int val)
168 {
169     put_v(bc, 4);
170     put_le32(bc, val);
171     return 0;
172 }
173
174 static int put_packetheader(NUTContext *nut, ByteIOContext *bc, int max_size)
175 {
176     put_flush_packet(bc);
177     nut->curr_frame_start = url_ftell(bc);
178     nut->curr_frame_size = max_size;
179     
180     /* packet header */
181     put_v(bc, nut->curr_frame_size); /* forward ptr */
182     put_v(bc, nut->last_frame_size); /* backward ptr */
183     dprintf("Packet: fwd: %d, bwd: %d\n",
184         nut->curr_frame_size, nut->last_frame_size);
185
186     nut->last_frame_size = nut->curr_frame_size;
187     
188     return 0;
189 }
190
191 static int update_packetheader(NUTContext *nut, ByteIOContext *bc, int additional_size){
192     offset_t start= nut->curr_frame_start;
193     offset_t cur= url_ftell(bc);
194     int size= cur - start + additional_size;
195     
196     assert( size <= nut->curr_frame_size );
197     
198     url_fseek(bc, start, SEEK_SET);
199     put_v(bc, size);
200     if(get_length(size) < get_length(nut->curr_frame_size))
201         put_byte(bc, 0x80);
202     nut->curr_frame_size= size;
203     dprintf("Packet update: size: %d\n", size);
204
205     url_fseek(bc, cur, SEEK_SET);    
206     
207     return 0;
208 }
209
210 static int nut_write_header(AVFormatContext *s)
211 {
212     NUTContext *nut = s->priv_data;
213     ByteIOContext *bc = &s->pb;
214     AVCodecContext *codec;
215     int i;
216     int stream_length = 0;
217
218     for (i = 0; i < s->nb_streams; i++)
219     {
220         if (stream_length < (s->streams[i]->duration * (AV_TIME_BASE / 1000)))
221             stream_length = s->streams[i]->duration * (AV_TIME_BASE / 1000);
222     }
223
224     /* main header */
225     put_be64(bc, MAIN_STARTCODE);
226     put_packetheader(nut, bc, 120);
227     put_v(bc, 0); /* version */
228     put_v(bc, s->nb_streams);
229     put_v(bc, 0); /* file size */
230     put_v(bc, stream_length); /* len in msec */
231     put_be32(bc, 0); /* FIXME: checksum */
232     
233     update_packetheader(nut, bc, 0);
234     
235     /* stream headers */
236     for (i = 0; i < s->nb_streams; i++)
237     {
238         codec = &s->streams[i]->codec;
239         
240         put_be64(bc, STREAM_STARTCODE);
241         put_packetheader(nut, bc, 120);
242         put_v(bc, i /*s->streams[i]->index*/);
243         put_v(bc, (codec->codec_type == CODEC_TYPE_AUDIO) ? 32 : 0);
244         if (codec->codec_tag)
245             put_bi(bc, codec->codec_tag);
246         else if (codec->codec_type == CODEC_TYPE_VIDEO)
247         {
248             int tmp = codec_get_bmp_tag(codec->codec_id);
249             put_bi(bc, tmp);
250         }
251         else if (codec->codec_type == CODEC_TYPE_AUDIO)
252         {
253             int tmp = codec_get_wav_tag(codec->codec_id);
254             put_bi(bc, tmp);
255         }
256         put_v(bc, codec->bit_rate);
257         put_v(bc, 0); /* no language code */
258         put_v(bc, codec->frame_rate_base);
259         put_v(bc, codec->frame_rate);
260         put_v(bc, 0); /* timestamp_shift */
261         put_v(bc, 0); /* shuffle type */
262         put_byte(bc, 0); /* flags: 0x1 - fixed_fps, 0x2 - index_present */
263         
264         put_v(bc, 0); /* no codec specific headers */
265         
266         switch(codec->codec_type)
267         {
268             case CODEC_TYPE_AUDIO:
269                 put_v(bc, codec->sample_rate / (double)(codec->frame_rate_base / codec->frame_rate));
270                 put_v(bc, codec->channels);
271                 put_be32(bc, 0); /* FIXME: checksum */
272                 break;
273             case CODEC_TYPE_VIDEO:
274                 put_v(bc, codec->width);
275                 put_v(bc, codec->height);
276                 put_v(bc, 0); /* aspected w */
277                 put_v(bc, 0); /* aspected h */
278                 put_v(bc, 0); /* csp type -- unknown */
279                 put_be32(bc, 0); /* FIXME: checksum */
280                 break;
281             default:
282                 break;
283         }
284         update_packetheader(nut, bc, 0);
285     }
286
287 #if 0
288     /* info header */
289     put_be64(bc, INFO_STARTCODE);
290     put_packetheader(nut, bc, 16+strlen(s->author)+strlen(s->title)+
291         strlen(s->comment)+strlen(s->copyright)); 
292     if (s->author[0])
293     {
294         put_v(bc, 5); /* type */
295         put_b(bc, s->author, strlen(s->author));
296     }
297     if (s->title[0])
298     {
299         put_v(bc, 6); /* type */
300         put_b(bc, s->title, strlen(s->title));
301     }
302     if (s->comment[0])
303     {
304         put_v(bc, 7); /* type */
305         put_b(bc, s->comment, strlen(s->comment));
306     }
307     if (s->copyright[0])
308     {
309         put_v(bc, 8); /* type */
310         put_b(bc, s->copyright, strlen(s->copyright));
311     }
312     /* encoder */
313     put_v(bc, 9); /* type */
314     put_b(bc, LIBAVFORMAT_IDENT "\0", strlen(LIBAVFORMAT_IDENT));
315     
316     put_v(bc, 0); /* eof info */
317
318     put_be32(bc, 0); /* FIXME: checksum */
319     update_packetheader(nut, bc, 0);
320 #endif
321         
322     put_flush_packet(bc);
323     
324     return 0;
325 }
326
327 static int nut_write_packet(AVFormatContext *s, int stream_index, 
328                             uint8_t *buf, int size, int force_pts)
329 {
330     NUTContext *nut = s->priv_data;
331     ByteIOContext *bc = &s->pb;
332     int key_frame = 0;
333     int flags;
334     AVCodecContext *enc;
335
336     if (stream_index > s->nb_streams)
337         return 1;
338
339     enc = &s->streams[stream_index]->codec;
340     if (enc->codec_type == CODEC_TYPE_VIDEO)
341         key_frame = enc->coded_frame->key_frame;
342
343     if (key_frame)
344         put_be64(bc, KEYFRAME_STARTCODE);
345     
346     flags=0;
347     flags<<=2; flags|=1; //priority
348     flags<<=1; flags|=0; //checksum
349     flags<<=1; flags|=0; //msb_timestamp_flag
350     flags<<=2; flags|=1; //subpacket_type
351     flags<<=1; flags|=0; //reserved
352
353     put_byte(bc, flags);
354
355     put_packetheader(nut, bc, size+20);
356     put_v(bc, stream_index);
357     put_s(bc, force_pts); /* lsb_timestamp */
358     update_packetheader(nut, bc, size);
359     
360     put_buffer(bc, buf, size);
361     
362     put_flush_packet(bc);
363
364     return 0;
365 }
366
367 static int nut_write_trailer(AVFormatContext *s)
368 {
369     ByteIOContext *bc = &s->pb;
370 #if 0
371     int i;
372
373     /* WRITE INDEX */
374
375     for (i = 0; s->nb_streams; i++)
376     {
377         put_be64(bc, INDEX_STARTCODE);
378         put_packetheader(nut, bc, 64);
379         put_v(bc, s->streams[i]->id);
380         put_v(bc, ...);
381         put_be32(bc, 0); /* FIXME: checksum */
382         update_packetheader(nut, bc, 0);
383     }
384 #endif
385
386     put_flush_packet(bc);
387
388     return 0;
389 }
390
391 static int nut_probe(AVProbeData *p)
392 {
393     int i;
394     uint64_t code;
395
396     code = 0xff;
397     for (i = 0; i < p->buf_size; i++) {
398         int c = p->buf[i];
399         code = (code << 8) | c;
400         code &= 0xFFFFFFFFFFFFFFFFULL;
401         if (code == MAIN_STARTCODE)
402             return AVPROBE_SCORE_MAX;
403     }
404     return 0;
405 }
406
407 static int nut_read_header(AVFormatContext *s, AVFormatParameters *ap)
408 {
409     NUTContext *nut = s->priv_data;
410     ByteIOContext *bc = &s->pb;
411     uint64_t tmp;
412     int cur_stream, nb_streams;
413     
414     /* main header */
415     tmp = get_be64(bc);
416     if (tmp != MAIN_STARTCODE)
417         fprintf(stderr, "damaged? startcode!=1 (%Ld)\n", tmp);
418     get_packetheader(nut, bc);
419     
420     tmp = get_v(bc);
421     if (tmp != 0)
422         fprintf(stderr, "bad version (%Ld)\n", tmp);
423     
424     nb_streams = get_v(bc);
425     
426     s->file_size = get_v(bc);
427     s->duration = get_v(bc) / (AV_TIME_BASE / 1000);
428
429     get_be32(bc); /* checkusm */
430     
431     s->bit_rate = 0;
432     
433     /* stream header */
434     for (cur_stream = 0; cur_stream < nb_streams; cur_stream++)
435     {
436         int class;
437         AVStream *st;
438         
439         tmp = get_be64(bc);
440         if (tmp != STREAM_STARTCODE)
441             fprintf(stderr, "damaged? startcode!=1 (%Ld)\n", tmp);
442         get_packetheader(nut, bc);
443         st = av_new_stream(s, get_v(bc));
444         if (!st)
445             return AVERROR_NOMEM;
446         class = get_v(bc);
447         switch(class)
448         {
449             case 0:
450                 st->codec.codec_type = CODEC_TYPE_VIDEO;
451                 tmp = get_b(bc);
452                 st->codec.codec_id = codec_get_bmp_id(tmp);
453                 if (st->codec.codec_id == CODEC_ID_NONE)
454                     fprintf(stderr, "Unknown codec?!\n");
455                 break;
456             case 32:
457                 st->codec.codec_type = CODEC_TYPE_AUDIO;
458                 tmp = get_b(bc);
459                 st->codec.codec_id = codec_get_wav_id(tmp);
460                 if (st->codec.codec_id == CODEC_ID_NONE)
461                     fprintf(stderr, "Unknown codec?!\n");
462                 break;
463             default:
464                 fprintf(stderr, "Unknown stream class (%d)\n", class);
465                 return -1;
466         }
467         s->bit_rate += get_v(bc);
468         tmp = get_v(bc); /* language code */
469         while(tmp--)
470             get_byte(bc);
471         st->codec.frame_rate_base = get_v(bc);
472         st->codec.frame_rate = get_v(bc);
473         get_v(bc); /* FIXME: msb timestamp base */
474         get_v(bc); /* shuffle type */
475         get_byte(bc); /* flags */
476         
477         get_v(bc); /* FIXME: codec specific data headers */
478         
479         if (class == 0) /* VIDEO */
480         {
481             st->codec.width = get_v(bc);
482             st->codec.height = get_v(bc);
483             get_v(bc); /* aspected w */
484             get_v(bc); /* aspected h */
485             get_v(bc); /* csp type */
486             get_le32(bc); /* checksum */
487         }
488         if (class == 32) /* AUDIO */
489         {
490             st->codec.sample_rate = get_v(bc) * (double)(st->codec.frame_rate_base / st->codec.frame_rate);
491             st->codec.channels = get_v(bc);
492             get_le32(bc); /* checksum */
493         }
494     }    
495     
496     return 0;
497 }
498
499 static int nut_read_packet(AVFormatContext *s, AVPacket *pkt)
500 {
501     NUTContext *nut = s->priv_data;
502     ByteIOContext *bc = &s->pb;
503     int id, timestamp, size;
504     int key_frame = 0;
505     uint64_t tmp;
506
507
508     if (url_feof(bc))
509         return -1;
510     
511     tmp = get_byte(bc);
512     if (tmp & 0x80) /* zero bit set? */
513     {
514         tmp<<=8 ; tmp |= get_byte(bc);
515         tmp<<=16; tmp |= get_be16(bc);
516         tmp<<=32; tmp |= get_be32(bc);
517         if (tmp == KEYFRAME_STARTCODE)
518         {
519             key_frame = 1;
520             tmp = get_byte(bc); /* flags */
521         }
522         else
523             fprintf(stderr, "error in zero bit / startcode %LX\n", tmp);
524     }
525     get_packetheader(nut, bc);
526 #if 0
527     if (((tmp & 0x60)>>5) > 3) /* priority <= 3 */
528         fprintf(stderr, "sanity check failed!\n");
529 #endif
530     id = get_v(bc);
531     timestamp = get_s(bc);
532     
533     size = (nut->curr_frame_size - (url_ftell(bc)-nut->curr_frame_start));
534     dprintf("flags: 0x%Lx, timestamp: %d, packet size: %d\n", tmp, timestamp, size);
535     
536     if (size < 0)
537         return -1;
538
539     av_new_packet(pkt, size);
540     get_buffer(bc, pkt->data, size);
541     pkt->stream_index = id;
542     if (key_frame)
543         pkt->flags |= PKT_FLAG_KEY;
544     pkt->pts = timestamp;
545
546     return 0;
547 }
548
549 static AVInputFormat nut_iformat = {
550     "nut",
551     "nut format",
552     sizeof(NUTContext),
553     nut_probe,
554     nut_read_header,
555     nut_read_packet,
556 //    nut_read_close,
557 //    nut_read_seek,
558     .extensions = "nut",
559 };
560
561 static AVOutputFormat nut_oformat = {
562     "nut",
563     "nut format",
564     "video/x-nut",
565     "nut",
566     sizeof(NUTContext),
567 #ifdef CONFIG_VORBIS
568     CODEC_ID_VORBIS,
569 #elif defined(CONFIG_MP3LAME)
570     CODEC_ID_MP3LAME,
571 #else
572     CODEC_ID_MP2, /* AC3 needs liba52 decoder */
573 #endif
574     CODEC_ID_MPEG4,
575     nut_write_header,
576     nut_write_packet,
577     nut_write_trailer,
578 };
579
580 int nut_init(void)
581 {
582     av_register_input_format(&nut_iformat);
583     av_register_output_format(&nut_oformat);
584     return 0;
585 }