* avi: use stream_*, some clean and reordering.
[vlc.git] / modules / demux / avi / libavi.c
1 /*****************************************************************************
2  * libavi.c :
3  *****************************************************************************
4  * Copyright (C) 2001 VideoLAN
5  * $Id: libavi.c,v 1.23 2003/08/22 20:31:47 fenrir Exp $
6  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
21  *****************************************************************************/
22
23 #include <stdlib.h>                                      /* malloc(), free() */
24
25 #include <vlc/vlc.h>
26 #include <vlc/input.h>
27 #include "ninput.h"
28 #include "codecs.h"                                      /* BITMAPINFOHEADER */
29
30 #include "libavi.h"
31
32 #define AVI_DEBUG 1
33
34 #define FREE( p ) \
35     if( p ) {free( p ); p = NULL; }
36
37 #define __EVEN( x ) ( (x)&0x01 ? (x)+1 : (x) )
38
39 static vlc_fourcc_t GetFOURCC( byte_t *p_buff )
40 {
41     return VLC_FOURCC( p_buff[0], p_buff[1], p_buff[2], p_buff[3] );
42 }
43
44 #define AVI_ChunkFree( a, b ) _AVI_ChunkFree( (a), (avi_chunk_t*)(b) )
45 void    _AVI_ChunkFree( stream_t *, avi_chunk_t *p_chk );
46
47
48
49 /****************************************************************************
50  *
51  * Basics functions to manipulates chunks
52  *
53  ****************************************************************************/
54 static int AVI_ChunkReadCommon( stream_t *s, avi_chunk_t *p_chk )
55 {
56     uint8_t  *p_peek;
57     int i_peek;
58
59     memset( p_chk, 0, sizeof( avi_chunk_t ) );
60
61     if( ( i_peek = stream_Peek( s, &p_peek, 8 ) ) < 8 )
62     {
63         return VLC_EGENERIC;
64     }
65
66     p_chk->common.i_chunk_fourcc = GetFOURCC( p_peek );
67     p_chk->common.i_chunk_size   = GetDWLE( p_peek + 4 );
68     p_chk->common.i_chunk_pos    = stream_Tell( s );
69
70     p_chk->common.p_father = NULL;
71     p_chk->common.p_next = NULL;
72     p_chk->common.p_first = NULL;
73     p_chk->common.p_next = NULL;
74
75 #ifdef AVI_DEBUG
76     msg_Dbg( (vlc_object_t*)s,
77              "Found Chunk fourcc:%8.8x (%4.4s) size:"I64Fd" pos:"I64Fd,
78              p_chk->common.i_chunk_fourcc,
79              (char*)&p_chk->common.i_chunk_fourcc,
80              p_chk->common.i_chunk_size,
81              p_chk->common.i_chunk_pos );
82 #endif
83     return VLC_SUCCESS;
84 }
85
86 static int AVI_NextChunk( stream_t *s, avi_chunk_t *p_chk )
87 {
88     avi_chunk_t chk;
89
90     if( !p_chk )
91     {
92         if( AVI_ChunkReadCommon( s, &chk ) )
93         {
94             return VLC_EGENERIC;
95         }
96         p_chk = &chk;
97     }
98
99     if( p_chk->common.p_father )
100     {
101         if( p_chk->common.p_father->common.i_chunk_pos +
102                 __EVEN( p_chk->common.p_father->common.i_chunk_size ) + 8 <
103             p_chk->common.i_chunk_pos +
104                 __EVEN( p_chk->common.i_chunk_size ) + 8 )
105         {
106             return VLC_EGENERIC;
107         }
108     }
109     return stream_Seek( s, p_chk->common.i_chunk_pos +
110                                  __EVEN( p_chk->common.i_chunk_size ) + 8 );
111 }
112
113 /****************************************************************************
114  *
115  * Functions to read chunks
116  *
117  ****************************************************************************/
118 static int AVI_ChunkRead_list( stream_t *s, avi_chunk_t *p_container )
119 {
120     avi_chunk_t *p_chk;
121     uint8_t *p_peek;
122     vlc_bool_t b_seekable;
123
124     if( p_container->common.i_chunk_size < 8 )
125     {
126         /* empty box */
127         msg_Warn( (vlc_object_t*)s, "empty list chunk" );
128         return VLC_EGENERIC;
129     }
130     if( stream_Peek( s, &p_peek, 12 ) < 12 )
131     {
132         msg_Warn( (vlc_object_t*)s, "cannot peek while reading list chunk" );
133         return VLC_EGENERIC;
134     }
135
136     stream_Control( s, STREAM_CAN_FASTSEEK, &b_seekable );
137
138     p_container->list.i_type = GetFOURCC( p_peek + 8 );
139
140     if( p_container->common.i_chunk_fourcc == AVIFOURCC_LIST &&
141         p_container->list.i_type == AVIFOURCC_movi )
142     {
143         msg_Dbg( (vlc_object_t*)s, "Skipping movi chunk" );
144         if( b_seekable )
145         {
146             return AVI_NextChunk( s, p_container );
147         }
148         return VLC_SUCCESS; // point at begining of LIST-movi
149     }
150
151     if( stream_Read( s, NULL, 12 ) != 12 )
152     {
153         msg_Warn( (vlc_object_t*)s, "cannot enter chunk" );
154         return VLC_EGENERIC;
155     }
156
157 #ifdef AVI_DEBUG
158     msg_Dbg( (vlc_object_t*)s,
159              "found LIST chunk: \'%4.4s\'",
160              (char*)&p_container->list.i_type );
161 #endif
162     msg_Dbg( (vlc_object_t*)s, "<list \'%4.4s\'>", (char*)&p_container->list.i_type );
163     for( ; ; )
164     {
165         p_chk = malloc( sizeof( avi_chunk_t ) );
166         memset( p_chk, 0, sizeof( avi_chunk_t ) );
167         if( !p_container->common.p_first )
168         {
169             p_container->common.p_first = p_chk;
170         }
171         else
172         {
173             p_container->common.p_last->common.p_next = p_chk;
174         }
175         p_container->common.p_last = p_chk;
176
177         if( AVI_ChunkRead( s, p_chk, p_container ) ||
178            ( stream_Tell( s ) >=
179               (off_t)p_chk->common.p_father->common.i_chunk_pos +
180                (off_t)__EVEN( p_chk->common.p_father->common.i_chunk_size ) ) )
181         {
182             break;
183         }
184         /* If we can't seek then stop when we 've found LIST-movi */
185         if( p_chk->common.i_chunk_fourcc == AVIFOURCC_LIST &&
186             p_chk->list.i_type == AVIFOURCC_movi && !b_seekable )
187         {
188             break;
189         }
190
191     }
192     msg_Dbg( (vlc_object_t*)s, "</list \'%4.4s\'>", (char*)&p_container->list.i_type );
193
194     return VLC_SUCCESS;
195 }
196
197 #define AVI_READCHUNK_ENTER \
198     int64_t i_read = __EVEN(p_chk->common.i_chunk_size ) + 8; \
199     uint8_t  *p_read, *p_buff;    \
200     if( !( p_read = p_buff = malloc(i_read ) ) ) \
201     { \
202         return 0; \
203     } \
204     i_read = stream_Read( s, p_read, i_read ); \
205     p_read += 8; \
206     i_read -= 8
207
208 #define AVI_READCHUNK_EXIT( code ) \
209     free( p_buff ); \
210     if( i_read < 0 ) \
211     { \
212         msg_Warn( (vlc_object_t*)s, "not enough data" ); \
213     } \
214     return code
215
216 #define AVI_READ1BYTE( i_byte ) \
217     i_byte = *p_read; \
218     p_read++; \
219     i_read--
220
221 #define AVI_READ2BYTES( i_word ) \
222     i_word = GetWLE( p_read ); \
223     p_read += 2; \
224     i_read -= 2
225
226 #define AVI_READ4BYTES( i_dword ) \
227     i_dword = GetDWLE( p_read ); \
228     p_read += 4; \
229     i_read -= 4
230
231 #define AVI_READ8BYTES( i_dword ) \
232     i_dword = GetQWLE( p_read ); \
233     p_read += 8; \
234     i_read -= 8
235
236 #define AVI_READFOURCC( i_dword ) \
237     i_dword = GetFOURCC( p_read ); \
238     p_read += 4; \
239     i_read -= 4
240
241 static int AVI_ChunkRead_avih( stream_t *s, avi_chunk_t *p_chk )
242 {
243     AVI_READCHUNK_ENTER;
244
245     AVI_READ4BYTES( p_chk->avih.i_microsecperframe);
246     AVI_READ4BYTES( p_chk->avih.i_maxbytespersec );
247     AVI_READ4BYTES( p_chk->avih.i_reserved1 );
248     AVI_READ4BYTES( p_chk->avih.i_flags );
249     AVI_READ4BYTES( p_chk->avih.i_totalframes );
250     AVI_READ4BYTES( p_chk->avih.i_initialframes );
251     AVI_READ4BYTES( p_chk->avih.i_streams );
252     AVI_READ4BYTES( p_chk->avih.i_suggestedbuffersize );
253     AVI_READ4BYTES( p_chk->avih.i_width );
254     AVI_READ4BYTES( p_chk->avih.i_height );
255     AVI_READ4BYTES( p_chk->avih.i_scale );
256     AVI_READ4BYTES( p_chk->avih.i_rate );
257     AVI_READ4BYTES( p_chk->avih.i_start );
258     AVI_READ4BYTES( p_chk->avih.i_length );
259 #ifdef AVI_DEBUG
260     msg_Dbg( (vlc_object_t*)s,
261              "avih: streams:%d flags:%s%s%s%s %dx%d",
262              p_chk->avih.i_streams,
263              p_chk->avih.i_flags&AVIF_HASINDEX?" HAS_INDEX":"",
264              p_chk->avih.i_flags&AVIF_MUSTUSEINDEX?" MUST_USE_INDEX":"",
265              p_chk->avih.i_flags&AVIF_ISINTERLEAVED?" IS_INTERLEAVED":"",
266              p_chk->avih.i_flags&AVIF_TRUSTCKTYPE?" TRUST_CKTYPE":"",
267              p_chk->avih.i_width, p_chk->avih.i_height );
268 #endif
269     AVI_READCHUNK_EXIT( VLC_SUCCESS );
270 }
271
272 static int AVI_ChunkRead_strh( stream_t *s, avi_chunk_t *p_chk )
273 {
274     AVI_READCHUNK_ENTER;
275
276     AVI_READFOURCC( p_chk->strh.i_type );
277     AVI_READFOURCC( p_chk->strh.i_handler );
278     AVI_READ4BYTES( p_chk->strh.i_flags );
279     AVI_READ4BYTES( p_chk->strh.i_reserved1 );
280     AVI_READ4BYTES( p_chk->strh.i_initialframes );
281     AVI_READ4BYTES( p_chk->strh.i_scale );
282     AVI_READ4BYTES( p_chk->strh.i_rate );
283     AVI_READ4BYTES( p_chk->strh.i_start );
284     AVI_READ4BYTES( p_chk->strh.i_length );
285     AVI_READ4BYTES( p_chk->strh.i_suggestedbuffersize );
286     AVI_READ4BYTES( p_chk->strh.i_quality );
287     AVI_READ4BYTES( p_chk->strh.i_samplesize );
288 #ifdef AVI_DEBUG
289     msg_Dbg( (vlc_object_t*)s,
290              "strh: type:%4.4s handler:0x%8.8x samplesize:%d %.2ffps",
291              (char*)&p_chk->strh.i_type,
292              p_chk->strh.i_handler,
293              p_chk->strh.i_samplesize,
294              ( p_chk->strh.i_scale ?
295                 (float)p_chk->strh.i_rate / (float)p_chk->strh.i_scale : -1) );
296 #endif
297
298     AVI_READCHUNK_EXIT( VLC_SUCCESS );
299 }
300
301 static int AVI_ChunkRead_strf( stream_t *s, avi_chunk_t *p_chk )
302 {
303     avi_chunk_t *p_strh;
304
305     AVI_READCHUNK_ENTER;
306     if( p_chk->common.p_father == NULL )
307     {
308         msg_Err( (vlc_object_t*)s, "malformed avi file" );
309         AVI_READCHUNK_EXIT( VLC_EGENERIC );
310     }
311     if( !( p_strh = AVI_ChunkFind( p_chk->common.p_father, AVIFOURCC_strh, 0 ) ) )
312     {
313         msg_Err( (vlc_object_t*)s, "malformed avi file" );
314         AVI_READCHUNK_EXIT( VLC_EGENERIC );
315     }
316
317     switch( p_strh->strh.i_type )
318     {
319         case( AVIFOURCC_auds ):
320             p_chk->strf.auds.i_cat = AUDIO_ES;
321             p_chk->strf.auds.p_wf = malloc( __MAX( p_chk->common.i_chunk_size, sizeof( WAVEFORMATEX ) ) );
322             AVI_READ2BYTES( p_chk->strf.auds.p_wf->wFormatTag );
323             AVI_READ2BYTES( p_chk->strf.auds.p_wf->nChannels );
324             AVI_READ4BYTES( p_chk->strf.auds.p_wf->nSamplesPerSec );
325             AVI_READ4BYTES( p_chk->strf.auds.p_wf->nAvgBytesPerSec );
326             AVI_READ2BYTES( p_chk->strf.auds.p_wf->nBlockAlign );
327             AVI_READ2BYTES( p_chk->strf.auds.p_wf->wBitsPerSample );
328             if( p_chk->strf.auds.p_wf->wFormatTag != WAVE_FORMAT_PCM
329                  && p_chk->common.i_chunk_size > sizeof( WAVEFORMATEX ) )
330             {
331                 AVI_READ2BYTES( p_chk->strf.auds.p_wf->cbSize );
332                 /* prevent segfault */
333                 if( p_chk->strf.auds.p_wf->cbSize >
334                         p_chk->common.i_chunk_size - sizeof( WAVEFORMATEX ) )
335                 {
336                     p_chk->strf.auds.p_wf->cbSize =
337                         p_chk->common.i_chunk_size - sizeof( WAVEFORMATEX );
338                 }
339             }
340             else
341             {
342                 p_chk->strf.auds.p_wf->cbSize = 0;
343             }
344             if( p_chk->strf.auds.p_wf->cbSize > 0 )
345             {
346                 memcpy( &p_chk->strf.auds.p_wf[1] ,
347                         p_buff + 8 + sizeof( WAVEFORMATEX ),    // 8=fourrc+size
348                         p_chk->strf.auds.p_wf->cbSize );
349             }
350 #ifdef AVI_DEBUG
351             msg_Dbg( (vlc_object_t*)s,
352                      "strf: audio:0x%4.4x channels:%d %dHz %dbits/sample %dkb/s",
353                      p_chk->strf.auds.p_wf->wFormatTag,
354                      p_chk->strf.auds.p_wf->nChannels,
355                      p_chk->strf.auds.p_wf->nSamplesPerSec,
356                      p_chk->strf.auds.p_wf->wBitsPerSample,
357                      p_chk->strf.auds.p_wf->nAvgBytesPerSec * 8 / 1024 );
358 #endif
359             break;
360         case( AVIFOURCC_vids ):
361             p_strh->strh.i_samplesize = 0; // XXX for ffmpeg avi file
362             p_chk->strf.vids.i_cat = VIDEO_ES;
363             p_chk->strf.vids.p_bih = malloc( p_chk->common.i_chunk_size );
364             AVI_READ4BYTES( p_chk->strf.vids.p_bih->biSize );
365             AVI_READ4BYTES( p_chk->strf.vids.p_bih->biWidth );
366             AVI_READ4BYTES( p_chk->strf.vids.p_bih->biHeight );
367             AVI_READ2BYTES( p_chk->strf.vids.p_bih->biPlanes );
368             AVI_READ2BYTES( p_chk->strf.vids.p_bih->biBitCount );
369             AVI_READFOURCC( p_chk->strf.vids.p_bih->biCompression );
370             AVI_READ4BYTES( p_chk->strf.vids.p_bih->biSizeImage );
371             AVI_READ4BYTES( p_chk->strf.vids.p_bih->biXPelsPerMeter );
372             AVI_READ4BYTES( p_chk->strf.vids.p_bih->biYPelsPerMeter );
373             AVI_READ4BYTES( p_chk->strf.vids.p_bih->biClrUsed );
374             AVI_READ4BYTES( p_chk->strf.vids.p_bih->biClrImportant );
375             if( p_chk->strf.vids.p_bih->biSize >
376                         p_chk->common.i_chunk_size )
377             {
378                 p_chk->strf.vids.p_bih->biSize = p_chk->common.i_chunk_size;
379             }
380             if( p_chk->strf.vids.p_bih->biSize - sizeof(BITMAPINFOHEADER) > 0 )
381             {
382                 memcpy( &p_chk->strf.vids.p_bih[1],
383                         p_buff + 8 + sizeof(BITMAPINFOHEADER), // 8=fourrc+size
384                         p_chk->strf.vids.p_bih->biSize -
385                                                     sizeof(BITMAPINFOHEADER) );
386             }
387 #ifdef AVI_DEBUG
388             msg_Dbg( (vlc_object_t*)s,
389                      "strf: video:%4.4s %dx%d planes:%d %dbpp",
390                      (char*)&p_chk->strf.vids.p_bih->biCompression,
391                      p_chk->strf.vids.p_bih->biWidth,
392                      p_chk->strf.vids.p_bih->biHeight,
393                      p_chk->strf.vids.p_bih->biPlanes,
394                      p_chk->strf.vids.p_bih->biBitCount );
395 #endif
396             break;
397         default:
398             msg_Warn( (vlc_object_t*)s, "unknown stream type" );
399             p_chk->strf.common.i_cat = UNKNOWN_ES;
400             break;
401     }
402     AVI_READCHUNK_EXIT( VLC_SUCCESS );
403 }
404 static void AVI_ChunkFree_strf( avi_chunk_t *p_chk )
405 {
406     avi_chunk_strf_t *p_strf = (avi_chunk_strf_t*)p_chk;
407     if( p_strf->common.i_cat == AUDIO_ES )
408     {
409         FREE( p_strf->auds.p_wf );
410     }
411     else if( p_strf->common.i_cat == VIDEO_ES )
412     {
413         FREE( p_strf->vids.p_bih );
414     }
415 }
416
417 static int AVI_ChunkRead_strd( stream_t *s, avi_chunk_t *p_chk )
418 {
419     AVI_READCHUNK_ENTER;
420     p_chk->strd.p_data = malloc( p_chk->common.i_chunk_size );
421     memcpy( p_chk->strd.p_data,
422             p_buff + 8,
423             p_chk->common.i_chunk_size );
424     AVI_READCHUNK_EXIT( VLC_SUCCESS );
425 }
426
427 static int AVI_ChunkRead_idx1( stream_t *s, avi_chunk_t *p_chk )
428 {
429     unsigned int i_count, i_index;
430
431     AVI_READCHUNK_ENTER;
432
433     i_count = __MIN( (int64_t)p_chk->common.i_chunk_size, i_read ) / 16;
434
435     p_chk->idx1.i_entry_count = i_count;
436     p_chk->idx1.i_entry_max   = i_count;
437     if( i_count > 0 )
438     {
439         p_chk->idx1.entry = calloc( i_count, sizeof( idx1_entry_t ) );
440
441         for( i_index = 0; i_index < i_count ; i_index++ )
442         {
443             AVI_READFOURCC( p_chk->idx1.entry[i_index].i_fourcc );
444             AVI_READ4BYTES( p_chk->idx1.entry[i_index].i_flags );
445             AVI_READ4BYTES( p_chk->idx1.entry[i_index].i_pos );
446             AVI_READ4BYTES( p_chk->idx1.entry[i_index].i_length );
447         }
448     }
449     else
450     {
451         p_chk->idx1.entry = NULL;
452     }
453 #ifdef AVI_DEBUG
454     msg_Dbg( (vlc_object_t*)s, "idx1: index entry:%d", i_count );
455 #endif
456     AVI_READCHUNK_EXIT( VLC_SUCCESS );
457 }
458
459 static void AVI_ChunkFree_idx1( avi_chunk_t *p_chk )
460 {
461     p_chk->idx1.i_entry_count = 0;
462     p_chk->idx1.i_entry_max   = 0;
463     FREE( p_chk->idx1.entry )
464 }
465
466
467
468 static int AVI_ChunkRead_indx( stream_t *s, avi_chunk_t *p_chk )
469 {
470     unsigned int i_count, i;
471     int32_t      i_dummy;
472     avi_chunk_indx_t *p_indx = (avi_chunk_indx_t*)p_chk;
473
474     AVI_READCHUNK_ENTER;
475
476     AVI_READ2BYTES( p_indx->i_longsperentry );
477     AVI_READ1BYTE ( p_indx->i_indexsubtype );
478     AVI_READ1BYTE ( p_indx->i_indextype );
479     AVI_READ4BYTES( p_indx->i_entriesinuse );
480
481     AVI_READ4BYTES( p_indx->i_id );
482     p_indx->idx.std     = NULL;
483     p_indx->idx.field   = NULL;
484     p_indx->idx.super   = NULL;
485
486     if( p_indx->i_indextype == AVI_INDEX_OF_CHUNKS && p_indx->i_indexsubtype == 0 )
487     {
488         AVI_READ8BYTES( p_indx->i_baseoffset );
489         AVI_READ4BYTES( i_dummy );
490
491         i_count = __MIN( p_indx->i_entriesinuse, i_read / 8 );
492         p_indx->i_entriesinuse = i_count;
493         p_indx->idx.std = calloc( sizeof( indx_std_entry_t ), i_count );
494
495         for( i = 0; i < i_count; i++ )
496         {
497             AVI_READ4BYTES( p_indx->idx.std[i].i_offset );
498             AVI_READ4BYTES( p_indx->idx.std[i].i_size );
499         }
500     }
501     else if( p_indx->i_indextype == AVI_INDEX_OF_CHUNKS && p_indx->i_indexsubtype == AVI_INDEX_2FIELD )
502     {
503         AVI_READ8BYTES( p_indx->i_baseoffset );
504         AVI_READ4BYTES( i_dummy );
505
506         i_count = __MIN( p_indx->i_entriesinuse, i_read / 12 );
507         p_indx->i_entriesinuse = i_count;
508         p_indx->idx.field = calloc( sizeof( indx_field_entry_t ), i_count );
509         for( i = 0; i < i_count; i++ )
510         {
511             AVI_READ4BYTES( p_indx->idx.field[i].i_offset );
512             AVI_READ4BYTES( p_indx->idx.field[i].i_size );
513             AVI_READ4BYTES( p_indx->idx.field[i].i_offsetfield2 );
514         }
515     }
516     else if( p_indx->i_indextype == AVI_INDEX_OF_INDEXES )
517     {
518         p_indx->i_baseoffset = 0;
519         AVI_READ4BYTES( i_dummy );
520         AVI_READ4BYTES( i_dummy );
521         AVI_READ4BYTES( i_dummy );
522
523         i_count = __MIN( p_indx->i_entriesinuse, i_read / 16 );
524         p_indx->i_entriesinuse = i_count;
525         p_indx->idx.super = calloc( sizeof( indx_super_entry_t ), i_count );
526
527         for( i = 0; i < i_count; i++ )
528         {
529             AVI_READ8BYTES( p_indx->idx.super[i].i_offset );
530             AVI_READ4BYTES( p_indx->idx.super[i].i_size );
531             AVI_READ4BYTES( p_indx->idx.super[i].i_duration );
532         }
533     }
534     else
535     {
536         msg_Warn( (vlc_object_t*)s, "unknow type/subtype index" );
537     }
538
539 #ifdef AVI_DEBUG
540     msg_Dbg( (vlc_object_t*)s, "indx: type=%d subtype=%d entry=%d", p_indx->i_indextype, p_indx->i_indexsubtype, p_indx->i_entriesinuse );
541 #endif
542     AVI_READCHUNK_EXIT( VLC_SUCCESS );
543 }
544 static void AVI_ChunkFree_indx( avi_chunk_t *p_chk )
545 {
546     avi_chunk_indx_t *p_indx = (avi_chunk_indx_t*)p_chk;
547
548     FREE( p_indx->idx.std );
549     FREE( p_indx->idx.field );
550     FREE( p_indx->idx.super );
551 }
552
553
554
555 static struct
556 {
557     vlc_fourcc_t i_fourcc;
558     char *psz_type;
559 } AVI_strz_type[] =
560 {
561     { AVIFOURCC_IARL, "archive location" },
562     { AVIFOURCC_IART, "artist" },
563     { AVIFOURCC_ICMS, "commisioned" },
564     { AVIFOURCC_ICMT, "comments" },
565     { AVIFOURCC_ICOP, "copyright" },
566     { AVIFOURCC_ICRD, "creation date" },
567     { AVIFOURCC_ICRP, "cropped" },
568     { AVIFOURCC_IDIM, "dimensions" },
569     { AVIFOURCC_IDPI, "dots per inch" },
570     { AVIFOURCC_IENG, "enginner" },
571     { AVIFOURCC_IGNR, "genre" },
572     { AVIFOURCC_IKEY, "keywords" },
573     { AVIFOURCC_ILGT, "lightness" },
574     { AVIFOURCC_IMED, "medium" },
575     { AVIFOURCC_INAM, "name" },
576     { AVIFOURCC_IPLT, "palette setting" },
577     { AVIFOURCC_IPRD, "product" },
578     { AVIFOURCC_ISBJ, "subject" },
579     { AVIFOURCC_ISFT, "software" },
580     { AVIFOURCC_ISHP, "sharpness" },
581     { AVIFOURCC_ISRC, "source" },
582     { AVIFOURCC_ISRF, "source form" },
583     { AVIFOURCC_ITCH, "technician" },
584     { AVIFOURCC_ISMP, "time code" },
585     { AVIFOURCC_IDIT, "digitalization time" },
586     { AVIFOURCC_strn, "stream name" },
587     { 0,              "???" }
588 };
589 static int AVI_ChunkRead_strz( stream_t *s, avi_chunk_t *p_chk )
590 {
591     int i_index;
592     avi_chunk_STRING_t *p_strz = (avi_chunk_STRING_t*)p_chk;
593     AVI_READCHUNK_ENTER;
594
595     for( i_index = 0;; i_index++)
596     {
597         if( !AVI_strz_type[i_index].i_fourcc ||
598             AVI_strz_type[i_index].i_fourcc == p_strz->i_chunk_fourcc )
599         {
600             break;
601         }
602     }
603     p_strz->p_type = strdup( AVI_strz_type[i_index].psz_type );
604     p_strz->p_str = malloc( i_read + 1);
605
606     if( p_strz->i_chunk_size )
607     {
608         memcpy( p_strz->p_str, p_read, i_read );
609     }
610     p_strz->p_str[i_read] = 0;
611
612 #ifdef AVI_DEBUG
613     msg_Dbg( (vlc_object_t*)s, "%4.4s: %s : %s",
614              (char*)&p_strz->i_chunk_fourcc, p_strz->p_type, p_strz->p_str);
615 #endif
616     AVI_READCHUNK_EXIT( VLC_SUCCESS );
617 }
618 static void AVI_ChunkFree_strz( avi_chunk_t *p_chk )
619 {
620     avi_chunk_STRING_t *p_strz = (avi_chunk_STRING_t*)p_chk;
621     FREE( p_strz->p_type );
622     FREE( p_strz->p_str );
623 }
624
625 static int AVI_ChunkRead_nothing( stream_t *s, avi_chunk_t *p_chk )
626 {
627     return AVI_NextChunk( s, p_chk );
628 }
629 static void AVI_ChunkFree_nothing( avi_chunk_t *p_chk )
630 {
631
632 }
633
634 static struct
635 {
636     vlc_fourcc_t i_fourcc;
637     int   (*AVI_ChunkRead_function)( stream_t *s, avi_chunk_t *p_chk );
638     void  (*AVI_ChunkFree_function)( avi_chunk_t *p_chk );
639 } AVI_Chunk_Function [] =
640 {
641     { AVIFOURCC_RIFF, AVI_ChunkRead_list, AVI_ChunkFree_nothing },
642     { AVIFOURCC_LIST, AVI_ChunkRead_list, AVI_ChunkFree_nothing },
643     { AVIFOURCC_avih, AVI_ChunkRead_avih, AVI_ChunkFree_nothing },
644     { AVIFOURCC_strh, AVI_ChunkRead_strh, AVI_ChunkFree_nothing },
645     { AVIFOURCC_strf, AVI_ChunkRead_strf, AVI_ChunkFree_strf },
646     { AVIFOURCC_strd, AVI_ChunkRead_strd, AVI_ChunkFree_nothing },
647     { AVIFOURCC_idx1, AVI_ChunkRead_idx1, AVI_ChunkFree_idx1 },
648     { AVIFOURCC_indx, AVI_ChunkRead_indx, AVI_ChunkFree_indx },
649     { AVIFOURCC_JUNK, AVI_ChunkRead_nothing, AVI_ChunkFree_nothing },
650
651     { AVIFOURCC_IARL, AVI_ChunkRead_strz, AVI_ChunkFree_strz },
652     { AVIFOURCC_IARL, AVI_ChunkRead_strz, AVI_ChunkFree_strz },
653     { AVIFOURCC_IART, AVI_ChunkRead_strz, AVI_ChunkFree_strz },
654     { AVIFOURCC_ICMS, AVI_ChunkRead_strz, AVI_ChunkFree_strz },
655     { AVIFOURCC_ICMT, AVI_ChunkRead_strz, AVI_ChunkFree_strz },
656     { AVIFOURCC_ICOP, AVI_ChunkRead_strz, AVI_ChunkFree_strz },
657     { AVIFOURCC_ICRD, AVI_ChunkRead_strz, AVI_ChunkFree_strz },
658     { AVIFOURCC_ICRP, AVI_ChunkRead_strz, AVI_ChunkFree_strz },
659     { AVIFOURCC_IDIM, AVI_ChunkRead_strz, AVI_ChunkFree_strz },
660     { AVIFOURCC_IDPI, AVI_ChunkRead_strz, AVI_ChunkFree_strz },
661     { AVIFOURCC_IENG, AVI_ChunkRead_strz, AVI_ChunkFree_strz },
662     { AVIFOURCC_IGNR, AVI_ChunkRead_strz, AVI_ChunkFree_strz },
663     { AVIFOURCC_IKEY, AVI_ChunkRead_strz, AVI_ChunkFree_strz },
664     { AVIFOURCC_ILGT, AVI_ChunkRead_strz, AVI_ChunkFree_strz },
665     { AVIFOURCC_IMED, AVI_ChunkRead_strz, AVI_ChunkFree_strz },
666     { AVIFOURCC_INAM, AVI_ChunkRead_strz, AVI_ChunkFree_strz },
667     { AVIFOURCC_IPLT, AVI_ChunkRead_strz, AVI_ChunkFree_strz },
668     { AVIFOURCC_IPRD, AVI_ChunkRead_strz, AVI_ChunkFree_strz },
669     { AVIFOURCC_ISBJ, AVI_ChunkRead_strz, AVI_ChunkFree_strz },
670     { AVIFOURCC_ISFT, AVI_ChunkRead_strz, AVI_ChunkFree_strz },
671     { AVIFOURCC_ISHP, AVI_ChunkRead_strz, AVI_ChunkFree_strz },
672     { AVIFOURCC_ISRC, AVI_ChunkRead_strz, AVI_ChunkFree_strz },
673     { AVIFOURCC_ISRF, AVI_ChunkRead_strz, AVI_ChunkFree_strz },
674     { AVIFOURCC_ITCH, AVI_ChunkRead_strz, AVI_ChunkFree_strz },
675     { AVIFOURCC_ISMP, AVI_ChunkRead_strz, AVI_ChunkFree_strz },
676     { AVIFOURCC_IDIT, AVI_ChunkRead_strz, AVI_ChunkFree_strz },
677     { AVIFOURCC_strn, AVI_ChunkRead_strz, AVI_ChunkFree_strz },
678     { 0,           NULL,               NULL }
679 };
680
681 static int AVI_ChunkFunctionFind( vlc_fourcc_t i_fourcc )
682 {
683     unsigned int i_index;
684     for( i_index = 0; ; i_index++ )
685     {
686         if( ( AVI_Chunk_Function[i_index].i_fourcc == i_fourcc )||
687             ( AVI_Chunk_Function[i_index].i_fourcc == 0 ) )
688         {
689             return i_index;
690         }
691     }
692 }
693
694 int  _AVI_ChunkRead( stream_t *s, avi_chunk_t *p_chk, avi_chunk_t *p_father )
695 {
696     int i_index;
697
698     if( !p_chk )
699     {
700         return VLC_EGENERIC;
701     }
702
703     if( AVI_ChunkReadCommon( s, p_chk ) )
704     {
705         msg_Warn( (vlc_object_t*)s, "cannot read one chunk" );
706         return VLC_EGENERIC;
707     }
708     if( p_chk->common.i_chunk_fourcc == VLC_FOURCC( 0, 0, 0, 0 ) )
709     {
710         msg_Warn( (vlc_object_t*)s, "found null fourcc chunk (corrupted file?)" );
711         return VLC_EGENERIC;
712     }
713     p_chk->common.p_father = p_father;
714
715     i_index = AVI_ChunkFunctionFind( p_chk->common.i_chunk_fourcc );
716     if( AVI_Chunk_Function[i_index].AVI_ChunkRead_function )
717     {
718         return AVI_Chunk_Function[i_index].AVI_ChunkRead_function( s, p_chk );
719     }
720     else if( ((char*)&p_chk->common.i_chunk_fourcc)[0] == 'i' &&
721              ((char*)&p_chk->common.i_chunk_fourcc)[1] == 'x' )
722     {
723         p_chk->common.i_chunk_fourcc = AVIFOURCC_indx;
724         return AVI_ChunkRead_indx( s, p_chk );
725     }
726     msg_Warn( (vlc_object_t*)s, "unknown chunk (not loaded)" );
727     return AVI_NextChunk( s, p_chk );
728 }
729
730 void _AVI_ChunkFree( stream_t *s,
731                      avi_chunk_t *p_chk )
732 {
733     int i_index;
734     avi_chunk_t *p_child, *p_next;
735
736     if( !p_chk )
737     {
738         return;
739     }
740
741     /* Free all child chunk */
742     p_child = p_chk->common.p_first;
743     while( p_child )
744     {
745         p_next = p_child->common.p_next;
746         AVI_ChunkFree( s, p_child );
747         free( p_child );
748         p_child = p_next;
749     }
750
751     i_index = AVI_ChunkFunctionFind( p_chk->common.i_chunk_fourcc );
752     if( AVI_Chunk_Function[i_index].AVI_ChunkFree_function )
753     {
754 #ifdef AVI_DEBUG
755         msg_Dbg( (vlc_object_t*)s, "free chunk %4.4s",
756                  (char*)&p_chk->common.i_chunk_fourcc );
757 #endif
758         AVI_Chunk_Function[i_index].AVI_ChunkFree_function( p_chk);
759     }
760     else
761     {
762         msg_Warn( (vlc_object_t*)s, "unknown chunk (not unloaded)" );
763     }
764     p_chk->common.p_first = NULL;
765     p_chk->common.p_last  = NULL;
766
767     return;
768 }
769
770 static void AVI_ChunkDumpDebug( stream_t *, avi_chunk_t  *);
771
772 int AVI_ChunkReadRoot( stream_t *s, avi_chunk_t *p_root )
773 {
774     avi_chunk_list_t *p_list = (avi_chunk_list_t*)p_root;
775     avi_chunk_t      *p_chk;
776     vlc_bool_t b_seekable;
777
778     stream_Control( s, STREAM_CAN_FASTSEEK, &b_seekable );
779
780     p_list->i_chunk_pos  = 0;
781     p_list->i_chunk_size = stream_Size( s );
782     p_list->i_chunk_fourcc = AVIFOURCC_LIST;
783     p_list->p_father = NULL;
784     p_list->p_next  = NULL;
785     p_list->p_first = NULL;
786     p_list->p_last  = NULL;
787
788     p_list->i_type = VLC_FOURCC( 'r', 'o', 'o', 't' );
789
790     for( ; ; )
791     {
792         p_chk = malloc( sizeof( avi_chunk_t ) );
793         memset( p_chk, 0, sizeof( avi_chunk_t ) );
794         if( !p_root->common.p_first )
795         {
796             p_root->common.p_first = p_chk;
797         }
798         else
799         {
800             p_root->common.p_last->common.p_next = p_chk;
801         }
802         p_root->common.p_last = p_chk;
803
804         if( AVI_ChunkRead( s, p_chk, p_root ) ||
805            ( stream_Tell( s ) >=
806               (off_t)p_chk->common.p_father->common.i_chunk_pos +
807                (off_t)__EVEN( p_chk->common.p_father->common.i_chunk_size ) ) )
808         {
809             break;
810         }
811         /* If we can't seek then stop when we 've found first RIFF-AVI */
812         if( p_chk->common.i_chunk_fourcc == AVIFOURCC_RIFF &&
813             p_chk->list.i_type == AVIFOURCC_AVI && !b_seekable )
814         {
815             break;
816         }
817     }
818
819     AVI_ChunkDumpDebug( s, p_root );
820     return VLC_SUCCESS;
821 }
822
823 void AVI_ChunkFreeRoot( stream_t *s,
824                         avi_chunk_t  *p_chk )
825 {
826     AVI_ChunkFree( s, p_chk );
827 }
828
829
830 int  _AVI_ChunkCount( avi_chunk_t *p_chk, vlc_fourcc_t i_fourcc )
831 {
832     int i_count;
833     avi_chunk_t *p_child;
834
835     if( !p_chk )
836     {
837         return 0;
838     }
839
840     i_count = 0;
841     p_child = p_chk->common.p_first;
842     while( p_child )
843     {
844         if( p_child->common.i_chunk_fourcc == i_fourcc ||
845             ( p_child->common.i_chunk_fourcc == AVIFOURCC_LIST &&
846               p_child->list.i_type == i_fourcc ) )
847         {
848             i_count++;
849         }
850         p_child = p_child->common.p_next;
851     }
852     return i_count;
853 }
854
855 void *_AVI_ChunkFind( avi_chunk_t *p_chk,
856                       vlc_fourcc_t i_fourcc, int i_number )
857 {
858     avi_chunk_t *p_child;
859     if( !p_chk )
860     {
861         return NULL;
862     }
863     p_child = p_chk->common.p_first;
864
865     while( p_child )
866     {
867         if( p_child->common.i_chunk_fourcc == i_fourcc ||
868             ( p_child->common.i_chunk_fourcc == AVIFOURCC_LIST &&
869               p_child->list.i_type == i_fourcc ) )
870         {
871             if( i_number == 0 )
872             {
873                 /* We found it */
874                 return p_child;
875             }
876
877             i_number--;
878         }
879         p_child = p_child->common.p_next;
880     }
881     return NULL;
882 }
883
884 static void AVI_ChunkDumpDebug_level( vlc_object_t *p_obj,
885                                       avi_chunk_t  *p_chk, int i_level )
886 {
887     char str[1024];
888     int i;
889     avi_chunk_t *p_child;
890
891     memset( str, ' ', sizeof( str ) );
892     for( i = 1; i < i_level; i++ )
893     {
894         str[i * 5] = '|';
895     }
896     if( p_chk->common.i_chunk_fourcc == AVIFOURCC_RIFF||
897         p_chk->common.i_chunk_fourcc == AVIFOURCC_LIST )
898     {
899         sprintf( str + i_level * 5,
900                  "%c %4.4s-%4.4s size:"I64Fu" pos:"I64Fu,
901                  i_level ? '+' : '*',
902                  (char*)&p_chk->common.i_chunk_fourcc,
903                  (char*)&p_chk->list.i_type,
904                  p_chk->common.i_chunk_size,
905                  p_chk->common.i_chunk_pos );
906     }
907     else
908     {
909         sprintf( str + i_level * 5,
910                  "+ %4.4s size:"I64Fu" pos:"I64Fu,
911                  (char*)&p_chk->common.i_chunk_fourcc,
912                  p_chk->common.i_chunk_size,
913                  p_chk->common.i_chunk_pos );
914     }
915     msg_Dbg( p_obj, "%s", str );
916
917     p_child = p_chk->common.p_first;
918     while( p_child )
919     {
920         AVI_ChunkDumpDebug_level( p_obj, p_child, i_level + 1 );
921         p_child = p_child->common.p_next;
922     }
923 }
924
925 static void AVI_ChunkDumpDebug( stream_t *s, avi_chunk_t  *p_chk )
926 {
927     AVI_ChunkDumpDebug_level( (vlc_object_t*)s, p_chk, 0 );
928 }
929
930