* DV demuxer is now capable of decoding auxilary audio stream. So,
[ffmpeg.git] / libavformat / avidec.c
1 /*
2  * AVI decoder.
3  * Copyright (c) 2001 Fabrice Bellard.
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 Lesser 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 #include "avformat.h"
20 #include "avi.h"
21 #include "dv.h"
22
23 //#define DEBUG
24
25 typedef struct AVIIndex {
26     unsigned char tag[4];
27     unsigned int flags, pos, len;
28     struct AVIIndex *next;
29 } AVIIndex;
30
31 typedef struct {
32     int64_t  riff_end;
33     int64_t  movi_end;
34     offset_t movi_list;
35     AVIIndex *first, *last;
36     DVDemuxContext* dv_demux;
37 } AVIContext;
38
39 #ifdef DEBUG
40 static void print_tag(const char *str, unsigned int tag, int size)
41 {
42     printf("%s: tag=%c%c%c%c size=0x%x\n",
43            str, tag & 0xff,
44            (tag >> 8) & 0xff,
45            (tag >> 16) & 0xff,
46            (tag >> 24) & 0xff,
47            size);
48 }
49 #endif
50
51 static int get_riff(AVIContext *avi, ByteIOContext *pb)
52 {
53     uint32_t tag; 
54     /* check RIFF header */
55     tag = get_le32(pb);
56
57     if (tag != MKTAG('R', 'I', 'F', 'F'))
58         return -1;
59     avi->riff_end = get_le32(pb);   /* RIFF chunk size */
60     avi->riff_end += url_ftell(pb); /* RIFF chunk end */
61     tag = get_le32(pb);
62     if (tag != MKTAG('A', 'V', 'I', ' ') && tag != MKTAG('A', 'V', 'I', 'X'))
63         return -1;
64     
65     return 0;
66 }
67
68 static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)
69 {
70     AVIContext *avi = s->priv_data;
71     ByteIOContext *pb = &s->pb;
72     uint32_t tag, tag1, handler;
73     int codec_type, stream_index, frame_period, bit_rate, scale, rate;
74     unsigned int size, nb_frames;
75     int i, n;
76     AVStream *st;
77     int xan_video = 0;  /* hack to support Xan A/V */
78
79     if (get_riff(avi, pb) < 0)
80         return -1;
81
82     /* first list tag */
83     stream_index = -1;
84     codec_type = -1;
85     frame_period = 0;
86     for(;;) {
87         if (url_feof(pb))
88             goto fail;
89         tag = get_le32(pb);
90         size = get_le32(pb);
91 #ifdef DEBUG
92         print_tag("tag", tag, size);
93 #endif
94
95         switch(tag) {
96         case MKTAG('L', 'I', 'S', 'T'):
97             /* ignored, except when start of video packets */
98             tag1 = get_le32(pb);
99 #ifdef DEBUG
100             print_tag("list", tag1, 0);
101 #endif
102             if (tag1 == MKTAG('m', 'o', 'v', 'i')) {
103                 avi->movi_end = url_ftell(pb) + size - 4;
104 #ifdef DEBUG
105                 printf("movi end=%Lx\n", avi->movi_end);
106 #endif
107                 goto end_of_header;
108             }
109             break;
110         case MKTAG('a', 'v', 'i', 'h'):
111             /* avi header */
112             /* using frame_period is bad idea */
113             frame_period = get_le32(pb);
114             bit_rate = get_le32(pb) * 8;
115             url_fskip(pb, 4 * 4);
116             n = get_le32(pb);
117             for(i=0;i<n;i++) {
118                 st = av_new_stream(s, i);
119                 if (!st)
120                     goto fail;
121             }
122             url_fskip(pb, size - 7 * 4);
123             break;
124         case MKTAG('s', 't', 'r', 'h'):
125             /* stream header */
126             stream_index++;
127             tag1 = get_le32(pb);
128             handler = get_le32(pb); /* codec tag */
129             switch(tag1) {
130             case MKTAG('i', 'a', 'v', 's'):
131             case MKTAG('i', 'v', 'a', 's'):
132                 /* 
133                  * After some consideration -- I don't think we 
134                  * have to support anything but DV in a type1 AVIs.
135                  */
136                 if (s->nb_streams != 1)
137                     goto fail;
138                 
139                 if (handler != MKTAG('d', 'v', 's', 'd') &&
140                     handler != MKTAG('d', 'v', 'h', 'd') &&
141                     handler != MKTAG('d', 'v', 's', 'l'))
142                    goto fail;
143                 
144                 av_freep(&s->streams[0]->codec.extradata);
145                 av_freep(&s->streams[0]);
146                 s->nb_streams = 0;
147                 avi->dv_demux = dv_init_demux(s);
148                 if (!avi->dv_demux)
149                     goto fail;
150                 stream_index = s->nb_streams - 1;
151                 url_fskip(pb, size - 8);
152                 break;
153             case MKTAG('v', 'i', 'd', 's'):
154                 codec_type = CODEC_TYPE_VIDEO;
155
156                 if (stream_index >= s->nb_streams) {
157                     url_fskip(pb, size - 8);
158                     break;
159                 } 
160
161                 st = s->streams[stream_index];
162
163                 get_le32(pb); /* flags */
164                 get_le16(pb); /* priority */
165                 get_le16(pb); /* language */
166                 get_le32(pb); /* XXX: initial frame ? */
167                 scale = get_le32(pb); /* scale */
168                 rate = get_le32(pb); /* rate */
169
170                 if(scale && rate){
171                     st->codec.frame_rate = rate;
172                     st->codec.frame_rate_base = scale;
173                 }else if(frame_period){
174                     st->codec.frame_rate = 1000000;
175                     st->codec.frame_rate_base = frame_period;
176                 }else{
177                     st->codec.frame_rate = 25;
178                     st->codec.frame_rate_base = 1;
179                 }
180                 get_le32(pb); /* start */
181                 nb_frames = get_le32(pb);
182                 st->start_time = 0;
183                 st->duration = (double)nb_frames * 
184                     st->codec.frame_rate_base * AV_TIME_BASE / 
185                     st->codec.frame_rate;
186                 
187                 url_fskip(pb, size - 9 * 4);
188                 break;
189             case MKTAG('a', 'u', 'd', 's'):
190                 {
191                     unsigned int length, rate;
192
193                     codec_type = CODEC_TYPE_AUDIO;
194
195                     if (stream_index >= s->nb_streams) {
196                         url_fskip(pb, size - 8);
197                         break;
198                     } 
199                     st = s->streams[stream_index];
200
201                     get_le32(pb); /* flags */
202                     get_le16(pb); /* priority */
203                     get_le16(pb); /* language */
204                     get_le32(pb); /* initial frame */
205                     get_le32(pb); /* scale */
206                     rate = get_le32(pb);
207                     get_le32(pb); /* start */
208                     length = get_le32(pb); /* length, in samples or bytes */
209                     st->start_time = 0;
210                     if (rate != 0)
211                         st->duration = (int64_t)length * AV_TIME_BASE / rate;
212                     url_fskip(pb, size - 9 * 4);
213                 }
214                 break;
215             default:
216                 goto fail;
217             }
218             break;
219         case MKTAG('s', 't', 'r', 'f'):
220             /* stream header */
221             if (stream_index >= s->nb_streams || avi->dv_demux) {
222                 url_fskip(pb, size);
223             } else {
224                 st = s->streams[stream_index];
225                 switch(codec_type) {
226                 case CODEC_TYPE_VIDEO:
227                     get_le32(pb); /* size */
228                     st->codec.width = get_le32(pb);
229                     st->codec.height = get_le32(pb);
230                     get_le16(pb); /* panes */
231                     st->codec.bits_per_sample= get_le16(pb); /* depth */
232                     tag1 = get_le32(pb);
233                     get_le32(pb); /* ImageSize */
234                     get_le32(pb); /* XPelsPerMeter */
235                     get_le32(pb); /* YPelsPerMeter */
236                     get_le32(pb); /* ClrUsed */
237                     get_le32(pb); /* ClrImportant */
238
239                     st->codec.extradata_size= size - 10*4;
240                     st->codec.extradata= av_malloc(st->codec.extradata_size);
241                     get_buffer(pb, st->codec.extradata, st->codec.extradata_size);
242                     
243                     if(st->codec.extradata_size & 1) //FIXME check if the encoder really did this correctly
244                         get_byte(pb);
245
246 #ifdef DEBUG
247                     print_tag("video", tag1, 0);
248 #endif
249                     st->codec.codec_type = CODEC_TYPE_VIDEO;
250                     st->codec.codec_tag = tag1;
251                     st->codec.codec_id = codec_get_id(codec_bmp_tags, tag1);
252                     if (st->codec.codec_id == CODEC_ID_XAN_WC4)
253                         xan_video = 1;
254 //                    url_fskip(pb, size - 5 * 4);
255                     break;
256                 case CODEC_TYPE_AUDIO:
257                     get_wav_header(pb, &st->codec, size);
258                     if (size%2) /* 2-aligned (fix for Stargate SG-1 - 3x18 - Shades of Grey.avi) */
259                         url_fskip(pb, 1);
260                     /* special case time: To support Xan DPCM, hardcode
261                      * the format if Xxan is the video codec */
262                     if (xan_video)
263                         st->codec.codec_id = CODEC_ID_XAN_DPCM;
264                     break;
265                 default:
266                     url_fskip(pb, size);
267                     break;
268                 }
269             }
270             break;
271         default:
272             /* skip tag */
273             size += (size & 1);
274             url_fskip(pb, size);
275             break;
276         }
277     }
278  end_of_header:
279     /* check stream number */
280     if (stream_index != s->nb_streams - 1) {
281     fail:
282         for(i=0;i<s->nb_streams;i++) {
283             av_freep(&s->streams[i]->codec.extradata);
284             av_freep(&s->streams[i]);
285         }
286         return -1;
287     }
288
289     return 0;
290 }
291
292 static int avi_read_packet(AVFormatContext *s, AVPacket *pkt)
293 {
294     AVIContext *avi = s->priv_data;
295     ByteIOContext *pb = &s->pb;
296     int n, d[8], size, i;
297     void* dstr;
298
299     memset(d, -1, sizeof(int)*8);
300    
301     if (avi->dv_demux) {
302         size = dv_get_packet(avi->dv_demux, pkt);
303         if (size >= 0)
304             return size;
305     }
306         
307     for(i=url_ftell(pb); !url_feof(pb); i++) {
308         int j;
309
310         if (i >= avi->movi_end) { /* Let's see if it's an OpenDML AVI */
311             uint32_t tag, size, tag2;
312             url_fskip(pb, avi->riff_end - url_ftell(pb));
313             if (get_riff(avi, pb) < 0)
314                 return -1;
315             
316             tag = get_le32(pb);
317             size = get_le32(pb);
318             tag2 = get_le32(pb);
319             if (tag == MKTAG('L','I','S','T') && tag2 == MKTAG('m','o','v','i'))
320                 avi->movi_end = url_ftell(pb) + size - 4; 
321             else
322                 return -1;
323         }
324
325         for(j=0; j<7; j++)
326             d[j]= d[j+1];
327         d[7]= get_byte(pb);
328         
329         size= d[4] + (d[5]<<8) + (d[6]<<16) + (d[7]<<24);
330         
331         //parse ix##
332         n= (d[2] - '0') * 10 + (d[3] - '0');
333         if(    d[2] >= '0' && d[2] <= '9'
334             && d[3] >= '0' && d[3] <= '9'
335             && d[0] == 'i' && d[1] == 'x'
336             && n < s->nb_streams
337             && i + size <= avi->movi_end){
338             
339             url_fskip(pb, size);
340         }
341         
342         //parse ##dc/##wb
343         n= (d[0] - '0') * 10 + (d[1] - '0');
344         if(    d[0] >= '0' && d[0] <= '9'
345             && d[1] >= '0' && d[1] <= '9'
346             && ((d[2] == 'd' && d[3] == 'c') || 
347                 (d[2] == 'w' && d[3] == 'b') || 
348                 (d[2] == 'd' && d[3] == 'b') ||
349                 (d[2] == '_' && d[3] == '_'))
350             && n < s->nb_streams
351             && i + size <= avi->movi_end) {
352         
353             av_new_packet(pkt, size);
354             get_buffer(pb, pkt->data, size);
355             if (size & 1) {
356                 get_byte(pb);
357                 size++;
358             }
359         
360             if (avi->dv_demux) {
361                 dstr = pkt->destruct;
362                 size = dv_produce_packet(avi->dv_demux, pkt,
363                                          pkt->data, pkt->size);
364                 pkt->destruct = dstr;
365             } else {
366                 pkt->stream_index = n;
367                 pkt->flags |= PKT_FLAG_KEY; // FIXME: We really should read 
368                                             //        index for that
369             }
370             return size;
371         }
372     }
373     return -1;
374 }
375
376 static int avi_read_close(AVFormatContext *s)
377 {
378     int i;
379     AVIContext *avi = s->priv_data;
380
381     for(i=0;i<s->nb_streams;i++) {
382         AVStream *st = s->streams[i];
383 //        av_free(st->priv_data);
384         av_free(st->codec.extradata);
385     }
386
387     if (avi->dv_demux)
388         av_free(avi->dv_demux);
389
390     return 0;
391 }
392
393 static int avi_probe(AVProbeData *p)
394 {
395     /* check file header */
396     if (p->buf_size <= 32)
397         return 0;
398     if (p->buf[0] == 'R' && p->buf[1] == 'I' &&
399         p->buf[2] == 'F' && p->buf[3] == 'F' &&
400         p->buf[8] == 'A' && p->buf[9] == 'V' &&
401         p->buf[10] == 'I' && p->buf[11] == ' ')
402         return AVPROBE_SCORE_MAX;
403     else
404         return 0;
405 }
406
407 static AVInputFormat avi_iformat = {
408     "avi",
409     "avi format",
410     sizeof(AVIContext),
411     avi_probe,
412     avi_read_header,
413     avi_read_packet,
414     avi_read_close,
415 };
416
417 int avidec_init(void)
418 {
419     av_register_input_format(&avi_iformat);
420     return 0;
421 }