7edb0ace14534ad889e8e038ddbe80a6f4f75646
[vlc.git] / modules / demux / mp4 / libmp4.c
1 /*****************************************************************************
2  * libmp4.c : LibMP4 library for mp4 module for vlc
3  *****************************************************************************
4  * Copyright (C) 2001 VideoLAN
5  * $Id: libmp4.c,v 1.11 2002/12/18 14:17:10 sam 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 #include <stdlib.h>                                      /* malloc(), free() */
23 #include <stdarg.h>
24 #include <string.h>                                              /* strdup() */
25 #include <errno.h>
26 #include <sys/types.h>
27
28 #include <vlc/vlc.h>
29 #include <vlc/input.h>
30
31 #ifdef HAVE_ZLIB_H
32 #   include <zlib.h>                                     /* for compressed moov */
33 #endif
34
35 #include "libmp4.h"
36
37 /*****************************************************************************
38  * Here are defined some macro to make life simpler but before using it 
39  *  *look* at the code. 
40  *
41  *  XXX: All macro are written in capital letters
42  *
43  *****************************************************************************/
44 #define MP4_BOX_HEADERSIZE( p_box ) \
45   ( 8 + ( p_box->i_shortsize == 1 ? 8 : 0 ) \
46       + ( p_box->i_type == FOURCC_uuid ? 16 : 0 ) )
47     
48 #define MP4_BOX_DESCEND( p_box ) \
49     MP4_SeekStream( p_stream, p_box->i_pos + MP4_BOX_HEADERSIZE( p_box ) )
50
51 #define MP4_GET1BYTE( dst ) \
52     dst = *p_peek; p_peek++; i_read--
53
54 #define MP4_GET2BYTES( dst ) \
55     dst = GetWBE( p_peek ); p_peek += 2; i_read -= 2
56
57 #define MP4_GET3BYTES( dst ) \
58     dst = Get24bBE( p_peek ); p_peek += 3; i_read -= 3
59
60 #define MP4_GET4BYTES( dst ) \
61     dst = GetDWBE( p_peek ); p_peek += 4; i_read -= 4
62     
63 #define MP4_GETFOURCC( dst ) \
64     dst = VLC_FOURCC( p_peek[0], p_peek[1], p_peek[2], p_peek[3] ); \
65     p_peek += 4; i_read -= 4
66
67 #define MP4_GET8BYTES( dst ) \
68     dst = GetQWBE( p_peek ); p_peek += 8; i_read -= 8
69         
70 #define MP4_GETVERSIONFLAGS( p_void ) \
71     MP4_GET1BYTE( p_void->i_version ); \
72     MP4_GET3BYTES( p_void->i_flags )
73     
74 #define MP4_GETSTRINGZ( p_str ) \
75     if( ( i_read > 0 )&&(p_peek[0] ) ) \
76     { \
77         p_str = calloc( sizeof( char ), __MIN( strlen( p_peek ), i_read )+1);\
78         memcpy( p_str, p_peek, __MIN( strlen( p_peek ), i_read ) ); \
79         p_str[__MIN( strlen( p_peek ), i_read )] = 0; \
80         p_peek += strlen( p_str ) + 1; \
81         i_read -= strlen( p_str ) + 1; \
82     } \
83     else \
84     { \
85         p_str = NULL; \
86     }
87     
88
89 #define MP4_READBOX_ENTER( MP4_Box_data_TYPE_t ) \
90     int64_t  i_read = p_box->i_size; \
91     uint8_t *p_peek, *p_buff; \
92     i_read = p_box->i_size; \
93     if( !( p_peek = p_buff = malloc( i_read ) ) ) \
94     { \
95         return( 0 ); \
96     } \
97     if( !MP4_ReadStream( p_stream, p_peek, i_read ) )\
98     { \
99         free( p_buff ); \
100         return( 0 ); \
101     } \
102     p_peek += MP4_BOX_HEADERSIZE( p_box ); \
103     i_read -= MP4_BOX_HEADERSIZE( p_box ); \
104     if( !( p_box->data.p_data = malloc( sizeof( MP4_Box_data_TYPE_t ) ) ) ) \
105     { \
106       free( p_buff ); \
107       return( 0 ); \
108     } 
109                 
110 #define MP4_READBOX_EXIT( i_code ) \
111     free( p_buff ); \
112     if( i_read < 0 ) \
113     { \
114         msg_Warn( p_stream->p_input, "Not enougth data" ); \
115     } \
116     return( i_code )
117
118 #define FREE( p ) \
119     if( p ) {free( p ); p = NULL; }
120    
121
122     
123 /* Some assumptions:
124         * The input method HAVE to be seekable 
125  
126 */
127
128 /* Some functions to manipulate memory */
129 static uint16_t GetWLE( uint8_t *p_buff )
130 {
131     return( (p_buff[0]) + ( p_buff[1] <<8 ) );
132 }
133
134 static uint32_t GetDWLE( uint8_t *p_buff )
135 {
136     return( p_buff[0] + ( p_buff[1] <<8 ) +
137             ( p_buff[2] <<16 ) + ( p_buff[3] <<24 ) );
138 }
139
140 static uint16_t GetWBE( uint8_t *p_buff )
141 {
142     return( (p_buff[0]<<8) + p_buff[1] );
143 }
144
145 static uint32_t Get24bBE( uint8_t *p_buff )
146 {
147     return( ( p_buff[0] <<16 ) + ( p_buff[1] <<8 ) + p_buff[2] );
148 }
149
150
151 static uint32_t GetDWBE( uint8_t *p_buff )
152 {
153     return( (p_buff[0] << 24) + ( p_buff[1] <<16 ) +
154             ( p_buff[2] <<8 ) + p_buff[3] );
155 }
156
157 static uint64_t GetQWBE( uint8_t *p_buff )
158 {
159     return( ( (uint64_t)GetDWBE( p_buff ) << 32 )|( (uint64_t)GetDWBE( p_buff + 4 ) ) );
160 }
161
162
163 static void GetUUID( UUID_t *p_uuid, uint8_t *p_buff )
164 {
165     memcpy( p_uuid, 
166             p_buff,
167             16 );
168 }
169
170 static void CreateUUID( UUID_t *p_uuid, uint32_t i_fourcc )
171 {
172     /* made by 0xXXXXXXXX-0011-0010-8000-00aa00389b71 
173             where XXXXXXXX is the fourcc */
174     /* FIXME implement this */
175 }
176
177 /* some functions for mp4 encoding of variables */
178
179 void MP4_ConvertDate2Str( char *psz, uint64_t i_date )
180 {
181     int i_day;
182     int i_hour;
183     int i_min;
184     int i_sec;
185
186     i_day = i_date / ( 60*60*24);
187     i_hour = ( i_date /( 60*60 ) ) % 60;
188     i_min  = ( i_date / 60 ) % 60;
189     i_sec =  i_date % 60;
190     /* FIXME do it correctly, date begin at 1 jan 1904 */ 
191     sprintf( psz, "%dd-%2.2dh:%2.2dm:%2.2ds",
192                    i_day, i_hour, i_min, i_sec );
193 }
194
195
196
197 /*****************************************************************************
198  * Some basic functions to manipulate stream more easily in vlc
199  *
200  * MP4_TellAbsolute get file position
201  * 
202  * MP4_SeekAbsolute seek in the file
203  *
204  * MP4_ReadData read data from the file in a buffer
205  *
206  *****************************************************************************/
207 off_t MP4_TellAbsolute( input_thread_t *p_input )
208 {
209     off_t i_pos;
210     
211     vlc_mutex_lock( &p_input->stream.stream_lock );
212     
213     i_pos= p_input->stream.p_selected_area->i_tell;
214 //            ( p_input->p_last_data - p_input->p_current_data  );
215
216     vlc_mutex_unlock( &p_input->stream.stream_lock );
217
218     return( i_pos );
219 }
220  
221 int MP4_SeekAbsolute( input_thread_t *p_input,
222                        off_t i_pos)
223 {
224     off_t i_filepos;
225
226     if( i_pos >= p_input->stream.p_selected_area->i_size )
227     {
228         return( 0 );
229     }
230             
231     i_filepos = MP4_TellAbsolute( p_input );
232     if( i_pos != i_filepos )
233     {
234         p_input->pf_seek( p_input, i_pos );
235         input_AccessReinit( p_input );
236     }
237     return( 1 );
238 }
239
240 /* return 1 if success, 0 if fail */
241 int MP4_ReadData( input_thread_t *p_input, uint8_t *p_buff, int i_size )
242 {
243     data_packet_t *p_data;
244
245     int i_read;
246
247                 
248     if( !i_size )
249     {
250         return( 1 );
251     }
252
253     do
254     {
255         i_read = input_SplitBuffer(p_input, &p_data, __MIN( i_size, 1024 ) );
256         if( i_read <= 0 )
257         {
258             return( 0 );
259         }
260         memcpy( p_buff, p_data->p_payload_start, i_read );
261         input_DeletePacket( p_input->p_method_data, p_data );
262         
263         p_buff += i_read;
264         i_size -= i_read;
265                 
266     } while( i_size );
267     
268     return( 1 );
269 }
270
271 /*****************************************************************************
272  * Some basic functions to manipulate MP4_Stream_t, an abstraction o p_input
273  *  in the way that you can read from a memory buffer or from an input
274  *
275  *****************************************************************************/
276
277 /****  ------- First some function to make abstract from input --------  */
278
279 /****************************************************************************
280  * MP4_InputStream create an stram with an input
281  *
282  ****************************************************************************/
283 MP4_Stream_t *MP4_InputStream( input_thread_t *p_input )
284 {
285     MP4_Stream_t *p_stream;
286
287     if( !( p_stream = malloc( sizeof( MP4_Stream_t ) ) ) )
288     {
289         return( NULL );
290     }
291     p_stream->b_memory = 0;
292     p_stream->p_input = p_input;
293     p_stream->i_start = 0;
294     p_stream->i_stop = 0;
295     p_stream->p_buffer = NULL;
296     return( p_stream );
297 }
298
299
300 /****************************************************************************
301  * MP4_MemoryStream create a memory stream
302  * if p_buffer == NULL, will allocate a buffer of i_size, else 
303  *     it uses p_buffer XXX you have to unallocate it yourself !
304  *
305  ****************************************************************************/
306 MP4_Stream_t *MP4_MemoryStream( input_thread_t *p_input,
307                                 int i_size, uint8_t *p_buffer )
308 {
309     MP4_Stream_t *p_stream;
310
311     if( !( p_stream = malloc( sizeof( MP4_Stream_t ) ) ) )
312     {
313         return( NULL );
314     }
315     p_stream->b_memory = 1;
316     p_stream->p_input = p_input;
317     p_stream->i_start = 0;
318     p_stream->i_stop = i_size;
319     if( !p_stream->p_buffer )
320     {
321         if( !( p_stream->p_buffer = malloc( i_size ) ) )
322         {
323             free( p_stream );
324             return( NULL );
325         }
326     }
327     else
328     {
329         p_stream->p_buffer = p_buffer;
330     }
331
332     return( p_stream );
333 }
334 /****************************************************************************
335  * MP4_ReadStream read from a MP4_Stream_t
336  *
337  ****************************************************************************/
338 int MP4_ReadStream( MP4_Stream_t *p_stream, uint8_t *p_buff, int i_size )
339 {
340     if( p_stream->b_memory )
341     {
342         if( i_size > p_stream->i_stop - p_stream->i_start )
343         {
344             return( 0 );
345         }
346         memcpy( p_buff, 
347                 p_stream->p_buffer + p_stream->i_start,
348                 i_size );
349         p_stream->i_start += i_size;
350         return( 1 );
351     }
352     else
353     {
354         return( MP4_ReadData( p_stream->p_input, p_buff, i_size ) );
355     }
356 }
357
358 /****************************************************************************
359  * MP4_PeekStream peek from a MP4_Stream_t
360  *
361  ****************************************************************************/
362 int MP4_PeekStream( MP4_Stream_t *p_stream, uint8_t **pp_peek, int i_size )
363 {
364     if( p_stream->b_memory )
365     {
366         *pp_peek = p_stream->p_buffer + p_stream->i_start;
367
368         return( __MIN(i_size,p_stream->i_stop - p_stream->i_start ));
369     }
370     else
371     {
372         return( input_Peek( p_stream->p_input, pp_peek, i_size ) );
373     }
374 }
375
376 /****************************************************************************
377  * MP4_TellStream give absolute position in the stream
378  * XXX for a memory stream give position from begining of the buffer
379  ****************************************************************************/
380 off_t MP4_TellStream( MP4_Stream_t *p_stream )
381 {
382     if( p_stream->b_memory )
383     {
384         return( p_stream->i_start );
385     }
386     else
387     {
388         return( MP4_TellAbsolute( p_stream->p_input ) );
389     }
390 }
391
392 /****************************************************************************
393  * MP4_SeekStream seek in a MP4_Stream_t
394  *
395  ****************************************************************************/
396 int MP4_SeekStream( MP4_Stream_t *p_stream, off_t i_pos)
397 {
398     if( p_stream->b_memory )
399     {
400         if( i_pos < p_stream->i_stop )
401         {
402             p_stream->i_start = i_pos;
403             return( 1 );
404         }
405         else
406         {
407             return( 0 );
408         }
409     }
410     else
411     {
412         return( MP4_SeekAbsolute( p_stream->p_input, i_pos ) );
413     }
414 }
415
416
417
418 /*****************************************************************************
419  * MP4_ReadBoxCommon : Load only common parameters for all boxes 
420  *****************************************************************************
421  * p_box need to be an already allocated MP4_Box_t, and all data 
422  *  will only be peek not read
423  *
424  * RETURN : 0 if it fail, 1 otherwise
425  *****************************************************************************/
426 int MP4_ReadBoxCommon( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
427 {
428     int i_read;
429     uint8_t  *p_peek;
430     
431     if( ( ( i_read = MP4_PeekStream( p_stream, &p_peek, 32 ) ) < 8 ) )
432     {
433         return( 0 );
434     }
435     p_box->i_pos = MP4_TellStream( p_stream );
436
437     p_box->data.p_data = NULL;
438     p_box->p_father = NULL;
439     p_box->p_first  = NULL;
440     p_box->p_last  = NULL;
441     p_box->p_next   = NULL;
442     
443     MP4_GET4BYTES( p_box->i_shortsize );
444     MP4_GETFOURCC( p_box->i_type );
445
446     /* Now special case */
447
448     if( p_box->i_shortsize == 1 )
449     {
450         /* get the true size on 64 bits */
451         MP4_GET8BYTES( p_box->i_size );
452     }
453     else
454     {
455         p_box->i_size = p_box->i_shortsize;
456         /* XXX size of 0 means that the box extends to end of file */
457     }
458     
459     if( p_box->i_type == FOURCC_uuid )
460     {
461         /* get extented type on 16 bytes */
462         GetUUID( &p_box->i_uuid, p_peek );
463         p_peek += 16; i_read -= 16;
464     }
465     else
466     {
467         CreateUUID( &p_box->i_uuid, p_box->i_type );
468     }
469 #ifdef MP4_VERBOSE
470     /* FIXME how to write uint64_t ??? */
471     if( p_box->i_size )
472     {
473         msg_Dbg( p_stream->p_input, "Found Box: %c%c%c%c size %d",
474                  (p_box->i_type)&0xff, (p_box->i_type>>8)&0xff, 
475                      (p_box->i_type>>16)&0xff, (p_box->i_type>>24)&0xff,
476                  (uint32_t)p_box->i_size );
477     }
478 #endif
479
480     return( 1 ); 
481 }
482
483
484 /*****************************************************************************
485  * MP4_MP4_NextBox : Go to the next box 
486  *****************************************************************************
487  * if p_box == NULL, go to the next box in witch we are( at the begining ).
488  *****************************************************************************/
489 int MP4_NextBox( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
490 {
491     MP4_Box_t box;
492
493     if( !p_box )
494     {
495         MP4_ReadBoxCommon( p_stream, &box );
496         p_box = &box;
497     }
498
499     if( !p_box->i_size )
500     {
501         return( 2 ); /* Box with infinite size */
502     }
503
504     if( p_box->p_father )
505     {
506         /* check if it's within p-father */
507         if( p_box->i_size + p_box->i_pos >= 
508                     p_box->p_father->i_size + p_box->p_father->i_pos )
509         {
510             return( 0 ); /* out of bound */
511         }
512     }
513     return( MP4_SeekStream( p_stream, p_box->i_size + p_box->i_pos ) );
514 }
515 /*****************************************************************************
516  * MP4_MP4_GotoBox : Go to this particular box 
517  *****************************************************************************
518  * RETURN : 0 if it fail, 1 otherwise
519  *****************************************************************************/
520 int MP4_GotoBox( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
521 {
522     return( MP4_SeekStream( p_stream, p_box->i_pos ) );
523 }
524
525
526 /*****************************************************************************
527  * For all known box a loader is given, 
528  *  XXX: all common struct have to be already read by MP4_ReadBoxCommon
529  *       after called one of theses functions, file position is unknown
530  *       you need to call MP4_GotoBox to go where you want 
531  *****************************************************************************/
532 int MP4_ReadBoxContainerRaw( MP4_Stream_t *p_stream, MP4_Box_t *p_container )
533 {
534     MP4_Box_t *p_box;
535     
536     if( MP4_TellStream( p_stream ) + 8 > 
537                  (off_t)(p_container->i_pos + p_container->i_size) )
538     {
539         /* there is no box to load */
540         return( 0 );
541     }
542     
543     do
544     {
545         p_box = malloc( sizeof( MP4_Box_t ) );
546
547         if( MP4_ReadBox( p_stream, p_box , p_container ) )
548         {
549             /* chain this box with the father and the other at same level */
550             if( !p_container->p_first )
551             {
552                 p_container->p_first = p_box;
553             }
554             else
555             {
556                 p_container->p_last->p_next = p_box;
557             }
558             p_container->p_last = p_box;
559         }
560         else
561         {
562             /* free memory */
563             free( p_box );
564             break;
565         }
566         
567     }while( MP4_NextBox( p_stream, p_box ) == 1 );
568     
569     return( 1 );
570 }
571
572
573 int MP4_ReadBoxContainer( MP4_Stream_t *p_stream, MP4_Box_t *p_container )
574 {
575     
576     if( p_container->i_size <= (size_t)MP4_BOX_HEADERSIZE(p_container ) + 8 )
577     {
578         /* container is empty, 8 stand for the first header in this box */
579         return( 1 );
580     }
581     
582     /* enter box */
583     MP4_BOX_DESCEND( p_container );
584
585     return( MP4_ReadBoxContainerRaw( p_stream, p_container ) );
586 }
587
588 void MP4_FreeBox_Common( input_thread_t *p_input, MP4_Box_t *p_box )
589 {
590     /* Up to now do nothing */
591 }
592
593 int MP4_ReadBoxSkip( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
594 {
595     /* Nothing to do */
596 #ifdef MP4_VERBOSE
597     msg_Dbg( p_stream->p_input, "Skip box: \"%c%c%c%c\"", 
598             (p_box->i_type)&0xff, 
599             (p_box->i_type>>8)&0xff,
600             (p_box->i_type>>16)&0xff, 
601             (p_box->i_type>>24)&0xff );
602 #endif
603     return( 1 );
604 }
605
606 int MP4_ReadBox_ftyp( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
607 {
608     MP4_READBOX_ENTER( MP4_Box_data_ftyp_t );
609     
610     MP4_GETFOURCC( p_box->data.p_ftyp->i_major_brand );
611     MP4_GET4BYTES( p_box->data.p_ftyp->i_minor_version );
612     
613     if( ( p_box->data.p_ftyp->i_compatible_brands_count = i_read / 4 ) )
614     {
615         unsigned int i;
616         p_box->data.p_ftyp->i_compatible_brands = 
617             calloc( p_box->data.p_ftyp->i_compatible_brands_count, sizeof(uint32_t));
618
619         for( i =0; i < p_box->data.p_ftyp->i_compatible_brands_count; i++ )
620         {
621             MP4_GETFOURCC( p_box->data.p_ftyp->i_compatible_brands[i] );
622         }
623     }
624     else
625     {
626         p_box->data.p_ftyp->i_compatible_brands = NULL;
627     }
628
629     MP4_READBOX_EXIT( 1 );
630 }
631
632 void MP4_FreeBox_ftyp( input_thread_t *p_input, MP4_Box_t *p_box )
633 {
634     FREE( p_box->data.p_ftyp->i_compatible_brands );
635 }
636
637
638 int MP4_ReadBox_mvhd(  MP4_Stream_t *p_stream, MP4_Box_t *p_box )
639 {
640     unsigned int i;
641 #ifdef MP4_VERBOSE
642     char s_creation_time[128];
643     char s_modification_time[128];
644     char s_duration[128];
645 #endif
646     MP4_READBOX_ENTER( MP4_Box_data_mvhd_t );
647
648     MP4_GETVERSIONFLAGS( p_box->data.p_mvhd );
649
650     if( p_box->data.p_mvhd->i_version )
651     {
652         MP4_GET8BYTES( p_box->data.p_mvhd->i_creation_time );
653         MP4_GET8BYTES( p_box->data.p_mvhd->i_modification_time );
654         MP4_GET4BYTES( p_box->data.p_mvhd->i_timescale );
655         MP4_GET8BYTES( p_box->data.p_mvhd->i_duration );
656     }
657     else
658     {
659         MP4_GET4BYTES( p_box->data.p_mvhd->i_creation_time );
660         MP4_GET4BYTES( p_box->data.p_mvhd->i_modification_time );
661         MP4_GET4BYTES( p_box->data.p_mvhd->i_timescale );
662         MP4_GET4BYTES( p_box->data.p_mvhd->i_duration );
663     }
664     MP4_GET4BYTES( p_box->data.p_mvhd->i_rate ); 
665     MP4_GET2BYTES( p_box->data.p_mvhd->i_volume ); 
666     MP4_GET2BYTES( p_box->data.p_mvhd->i_reserved1 );
667
668   
669     for( i = 0; i < 2; i++ )
670     {
671         MP4_GET4BYTES( p_box->data.p_mvhd->i_reserved2[i] );
672     }
673     for( i = 0; i < 9; i++ )
674     {
675         MP4_GET4BYTES( p_box->data.p_mvhd->i_matrix[i] );
676     }
677     for( i = 0; i < 6; i++ )
678     {
679         MP4_GET4BYTES( p_box->data.p_mvhd->i_predefined[i] );
680     }
681     
682     MP4_GET4BYTES( p_box->data.p_mvhd->i_next_track_id );
683     
684             
685 #ifdef MP4_VERBOSE
686     MP4_ConvertDate2Str( s_creation_time, p_box->data.p_mvhd->i_creation_time );
687     MP4_ConvertDate2Str( s_modification_time, 
688                          p_box->data.p_mvhd->i_modification_time );
689     if( p_box->data.p_mvhd->i_rate )
690     {
691         MP4_ConvertDate2Str( s_duration, 
692                  p_box->data.p_mvhd->i_duration / p_box->data.p_mvhd->i_rate );
693     }
694     else
695     {
696         s_duration[0] = 0;
697     }    
698     msg_Dbg( p_stream->p_input, "Read Box: \"mvhd\" creation %s modification %s time scale %d duration %s rate %f volume %f next track id %d",
699                   s_creation_time,
700                   s_modification_time,
701                   (uint32_t)p_box->data.p_mvhd->i_timescale,
702                   s_duration,
703                   (float)p_box->data.p_mvhd->i_rate / (1<<16 ),
704                   (float)p_box->data.p_mvhd->i_volume / 256 ,
705                   (uint32_t)p_box->data.p_mvhd->i_next_track_id );
706 #endif
707     MP4_READBOX_EXIT( 1 );
708 }
709
710 int MP4_ReadBox_tkhd(  MP4_Stream_t *p_stream, MP4_Box_t *p_box )
711 {
712     unsigned int i;
713 #ifdef MP4_VERBOSE
714     char s_creation_time[128];
715     char s_modification_time[128];
716     char s_duration[128];
717 #endif
718     MP4_READBOX_ENTER( MP4_Box_data_tkhd_t );
719     
720     MP4_GETVERSIONFLAGS( p_box->data.p_tkhd );
721
722     if( p_box->data.p_tkhd->i_version )
723     {
724         MP4_GET8BYTES( p_box->data.p_tkhd->i_creation_time );
725         MP4_GET8BYTES( p_box->data.p_tkhd->i_modification_time );
726         MP4_GET4BYTES( p_box->data.p_tkhd->i_track_ID );
727         MP4_GET4BYTES( p_box->data.p_tkhd->i_reserved );
728         MP4_GET8BYTES( p_box->data.p_tkhd->i_duration );
729     }
730     else
731     {
732         MP4_GET4BYTES( p_box->data.p_tkhd->i_creation_time );
733         MP4_GET4BYTES( p_box->data.p_tkhd->i_modification_time );
734         MP4_GET4BYTES( p_box->data.p_tkhd->i_track_ID );
735         MP4_GET4BYTES( p_box->data.p_tkhd->i_reserved );
736         MP4_GET4BYTES( p_box->data.p_tkhd->i_duration );
737     }
738     
739     for( i = 0; i < 2; i++ )
740     {
741         MP4_GET4BYTES( p_box->data.p_tkhd->i_reserved2[i] );
742     }
743     MP4_GET2BYTES( p_box->data.p_tkhd->i_layer );
744     MP4_GET2BYTES( p_box->data.p_tkhd->i_predefined );
745     MP4_GET2BYTES( p_box->data.p_tkhd->i_volume );
746     MP4_GET2BYTES( p_box->data.p_tkhd->i_reserved3 );
747
748     for( i = 0; i < 9; i++ )
749     {
750         MP4_GET4BYTES( p_box->data.p_tkhd->i_matrix[i] );
751     }
752     MP4_GET4BYTES( p_box->data.p_tkhd->i_width );
753     MP4_GET4BYTES( p_box->data.p_tkhd->i_height );
754             
755 #ifdef MP4_VERBOSE
756     MP4_ConvertDate2Str( s_creation_time, p_box->data.p_mvhd->i_creation_time );
757     MP4_ConvertDate2Str( s_modification_time, p_box->data.p_mvhd->i_modification_time );
758     MP4_ConvertDate2Str( s_duration, p_box->data.p_mvhd->i_duration );
759     
760     msg_Dbg( p_stream->p_input, "Read Box: \"tkhd\" creation %s modification %s duration %s track ID %d layer %d volume %f width %f height %f",
761                   s_creation_time,
762                   s_modification_time,
763                   s_duration,
764                   p_box->data.p_tkhd->i_track_ID,
765                   p_box->data.p_tkhd->i_layer,
766                   (float)p_box->data.p_tkhd->i_volume / 256 ,
767                   (float)p_box->data.p_tkhd->i_width / 65536,
768                   (float)p_box->data.p_tkhd->i_height / 65536 );
769 #endif
770     MP4_READBOX_EXIT( 1 );
771 }
772
773 int MP4_ReadBox_tref( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
774 {
775
776     if( p_box->i_size < (size_t)MP4_BOX_HEADERSIZE(p_box ) + 8 )
777     {
778         /* container is empty, 8 stand for the first header in this box */
779         return( 1 );
780     }
781    
782     if( !MP4_SeekStream( p_stream, p_box->i_pos + MP4_BOX_HEADERSIZE( p_box ) ) )
783     {
784         return( 0 );
785     }
786
787     MP4_ReadBoxContainerRaw( p_stream, p_box );
788
789 #ifdef MP4_VERBOSE
790     msg_Dbg( p_stream->p_input, "Read Box: \"tref\" " );
791
792 #endif
793     return( 1 );
794 }
795
796
797
798 int MP4_ReadBox_mdhd( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
799 {
800     unsigned int i;
801     uint16_t i_language;
802 #ifdef MP4_VERBOSE
803     char s_creation_time[128];
804     char s_modification_time[128];
805     char s_duration[128];
806 #endif
807     MP4_READBOX_ENTER( MP4_Box_data_mdhd_t );
808
809     MP4_GETVERSIONFLAGS( p_box->data.p_mdhd );
810
811     if( p_box->data.p_mdhd->i_version )
812     {
813         MP4_GET8BYTES( p_box->data.p_mdhd->i_creation_time );
814         MP4_GET8BYTES( p_box->data.p_mdhd->i_modification_time );
815         MP4_GET4BYTES( p_box->data.p_mdhd->i_timescale );
816         MP4_GET8BYTES( p_box->data.p_mdhd->i_duration );
817     }
818     else
819     {
820         MP4_GET4BYTES( p_box->data.p_mdhd->i_creation_time );
821         MP4_GET4BYTES( p_box->data.p_mdhd->i_modification_time );
822         MP4_GET4BYTES( p_box->data.p_mdhd->i_timescale );
823         MP4_GET4BYTES( p_box->data.p_mdhd->i_duration );
824     }
825     i_language = GetWBE( p_peek ); 
826     for( i = 0; i < 3; i++ )
827     {
828         p_box->data.p_mdhd->i_language[i] = 
829                     ( ( i_language >> ( (2-i)*5 ) )&0x1f ) + 0x60;
830     }
831
832     MP4_GET2BYTES( p_box->data.p_mdhd->i_predefined );
833   
834 #ifdef MP4_VERBOSE
835     MP4_ConvertDate2Str( s_creation_time, p_box->data.p_mdhd->i_creation_time );
836     MP4_ConvertDate2Str( s_modification_time, p_box->data.p_mdhd->i_modification_time );
837     MP4_ConvertDate2Str( s_duration, p_box->data.p_mdhd->i_duration );
838     msg_Dbg( p_stream->p_input, "Read Box: \"mdhd\" creation %s modification %s time scale %d duration %s language %c%c%c",
839                   s_creation_time,
840                   s_modification_time,
841                   (uint32_t)p_box->data.p_mdhd->i_timescale,
842                   s_duration,
843                   p_box->data.p_mdhd->i_language[0],
844                   p_box->data.p_mdhd->i_language[1],
845                   p_box->data.p_mdhd->i_language[2] );
846 #endif
847     MP4_READBOX_EXIT( 1 );
848 }
849
850
851 int MP4_ReadBox_hdlr( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
852 {
853     MP4_READBOX_ENTER( MP4_Box_data_hdlr_t ); 
854
855     MP4_GETVERSIONFLAGS( p_box->data.p_hdlr );
856  
857     MP4_GET4BYTES( p_box->data.p_hdlr->i_predefined );
858     MP4_GETFOURCC( p_box->data.p_hdlr->i_handler_type );
859
860     p_box->data.p_hdlr->psz_name = calloc( sizeof( char ), i_read + 1 );
861     memcpy( p_box->data.p_hdlr->psz_name, p_peek, i_read );
862
863 #ifdef MP4_VERBOSE
864     msg_Dbg( p_stream->p_input, "Read Box: \"hdlr\" hanler type %c%c%c%c name %s",
865                        ( p_box->data.p_hdlr->i_handler_type )&0xff,
866                        ( p_box->data.p_hdlr->i_handler_type >>  8 )&0xff,
867                        ( p_box->data.p_hdlr->i_handler_type >> 16 )&0xff,
868                        ( p_box->data.p_hdlr->i_handler_type >> 24 )&0xff,
869                        p_box->data.p_hdlr->psz_name );
870
871 #endif
872     MP4_READBOX_EXIT( 1 );
873 }
874
875 void MP4_FreeBox_hdlr( input_thread_t *p_input, MP4_Box_t *p_box )
876 {
877     FREE( p_box->data.p_hdlr->psz_name );
878 }
879
880 int MP4_ReadBox_vmhd( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
881 {
882     unsigned int i;
883    
884     MP4_READBOX_ENTER( MP4_Box_data_vmhd_t ); 
885
886     MP4_GETVERSIONFLAGS( p_box->data.p_vmhd );
887     
888     MP4_GET2BYTES( p_box->data.p_vmhd->i_graphics_mode );
889     for( i = 0; i < 3; i++ )
890     {
891         MP4_GET2BYTES( p_box->data.p_vmhd->i_opcolor[i] );
892     }
893     
894 #ifdef MP4_VERBOSE
895     msg_Dbg( p_stream->p_input, "Read Box: \"vmhd\" graphics-mode %d opcolor (%d, %d, %d)",
896                       p_box->data.p_vmhd->i_graphics_mode,
897                       p_box->data.p_vmhd->i_opcolor[0],
898                       p_box->data.p_vmhd->i_opcolor[1],
899                       p_box->data.p_vmhd->i_opcolor[2] );
900                       
901 #endif
902     MP4_READBOX_EXIT( 1 );
903 }
904
905 int MP4_ReadBox_smhd( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
906 {
907     MP4_READBOX_ENTER( MP4_Box_data_smhd_t ); 
908
909     MP4_GETVERSIONFLAGS( p_box->data.p_smhd );
910
911
912
913     MP4_GET2BYTES( p_box->data.p_smhd->i_balance );
914
915     MP4_GET2BYTES( p_box->data.p_smhd->i_reserved );
916     
917 #ifdef MP4_VERBOSE
918     msg_Dbg( p_stream->p_input, "Read Box: \"smhd\" balance %f",
919                       (float)p_box->data.p_smhd->i_balance / 256 );
920                       
921 #endif
922     MP4_READBOX_EXIT( 1 );
923 }
924
925
926 int MP4_ReadBox_hmhd( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
927 {
928     MP4_READBOX_ENTER( MP4_Box_data_hmhd_t ); 
929
930     MP4_GETVERSIONFLAGS( p_box->data.p_hmhd );
931
932     MP4_GET2BYTES( p_box->data.p_hmhd->i_max_PDU_size );
933     MP4_GET2BYTES( p_box->data.p_hmhd->i_avg_PDU_size );
934
935     MP4_GET4BYTES( p_box->data.p_hmhd->i_max_bitrate );
936     MP4_GET4BYTES( p_box->data.p_hmhd->i_avg_bitrate );
937
938     MP4_GET4BYTES( p_box->data.p_hmhd->i_reserved );
939
940 #ifdef MP4_VERBOSE
941     msg_Dbg( p_stream->p_input, "Read Box: \"hmhd\" maxPDU-size %d avgPDU-size %d max-bitrate %d avg-bitrate %d",
942                       p_box->data.p_hmhd->i_max_PDU_size,
943                       p_box->data.p_hmhd->i_avg_PDU_size,
944                       p_box->data.p_hmhd->i_max_bitrate,
945                       p_box->data.p_hmhd->i_avg_bitrate );
946                       
947 #endif
948     MP4_READBOX_EXIT( 1 );
949 }
950
951 int MP4_ReadBox_url( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
952 {
953     MP4_READBOX_ENTER( MP4_Box_data_url_t ); 
954
955     MP4_GETVERSIONFLAGS( p_box->data.p_url );
956     MP4_GETSTRINGZ( p_box->data.p_url->psz_location );
957
958 #ifdef MP4_VERBOSE
959     msg_Dbg( p_stream->p_input, "Read Box: \"url\" url: %s",
960                        p_box->data.p_url->psz_location );
961
962 #endif
963     MP4_READBOX_EXIT( 1 );
964 }
965
966
967 void MP4_FreeBox_url( input_thread_t *p_input, MP4_Box_t *p_box )
968 {
969     FREE( p_box->data.p_url->psz_location )
970 }
971
972 int MP4_ReadBox_urn( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
973 {
974     MP4_READBOX_ENTER( MP4_Box_data_urn_t );
975
976     MP4_GETVERSIONFLAGS( p_box->data.p_urn );
977
978     MP4_GETSTRINGZ( p_box->data.p_urn->psz_name );
979     MP4_GETSTRINGZ( p_box->data.p_urn->psz_location ); 
980    
981 #ifdef MP4_VERBOSE
982     msg_Dbg( p_stream->p_input, "Read Box: \"urn\" name %s location %s",
983                       p_box->data.p_urn->psz_name,
984                       p_box->data.p_urn->psz_location );
985 #endif
986     MP4_READBOX_EXIT( 1 );
987 }
988 void MP4_FreeBox_urn( input_thread_t *p_input, MP4_Box_t *p_box )
989 {
990     FREE( p_box->data.p_urn->psz_name );
991     FREE( p_box->data.p_urn->psz_location );
992 }
993
994
995 int MP4_ReadBox_dref( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
996 {
997     MP4_READBOX_ENTER( MP4_Box_data_dref_t );
998     
999     MP4_GETVERSIONFLAGS( p_box->data.p_dref );
1000
1001     MP4_GET4BYTES( p_box->data.p_dref->i_entry_count );
1002    
1003     MP4_SeekStream( p_stream, p_box->i_pos + MP4_BOX_HEADERSIZE( p_box ) + 8 );
1004     MP4_ReadBoxContainerRaw( p_stream, p_box );
1005
1006 #ifdef MP4_VERBOSE
1007     msg_Dbg( p_stream->p_input, "Read Box: \"dref\" entry-count %d",
1008                       p_box->data.p_dref->i_entry_count );
1009
1010 #endif
1011     MP4_READBOX_EXIT( 1 );
1012 }
1013
1014
1015 int MP4_ReadBox_stts( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
1016 {
1017     unsigned int i;
1018     MP4_READBOX_ENTER( MP4_Box_data_stts_t ); 
1019
1020     MP4_GETVERSIONFLAGS( p_box->data.p_stts );
1021     MP4_GET4BYTES( p_box->data.p_stts->i_entry_count );
1022
1023     p_box->data.p_stts->i_sample_count = 
1024         calloc( sizeof( uint32_t ), p_box->data.p_stts->i_entry_count );
1025     p_box->data.p_stts->i_sample_delta =
1026         calloc( sizeof( uint32_t ), p_box->data.p_stts->i_entry_count );
1027     
1028     for( i = 0; (i < p_box->data.p_stts->i_entry_count )&&( i_read >=8 ); i++ )
1029     {
1030         MP4_GET4BYTES( p_box->data.p_stts->i_sample_count[i] );
1031         MP4_GET4BYTES( p_box->data.p_stts->i_sample_delta[i] );
1032     }
1033     
1034     
1035 #ifdef MP4_VERBOSE
1036     msg_Dbg( p_stream->p_input, "Read Box: \"stts\" entry-count %d",
1037                       p_box->data.p_stts->i_entry_count );
1038
1039 #endif
1040     MP4_READBOX_EXIT( 1 );
1041 }
1042
1043 void MP4_FreeBox_stts( input_thread_t *p_input, MP4_Box_t *p_box )
1044 {
1045     FREE( p_box->data.p_stts->i_sample_count );
1046     FREE( p_box->data.p_stts->i_sample_delta );
1047             
1048 }
1049
1050 int MP4_ReadBox_ctts( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
1051 {
1052     unsigned int i;
1053     MP4_READBOX_ENTER( MP4_Box_data_ctts_t );
1054     
1055     MP4_GETVERSIONFLAGS( p_box->data.p_ctts );
1056  
1057     MP4_GET4BYTES( p_box->data.p_ctts->i_entry_count );
1058
1059     p_box->data.p_ctts->i_sample_count = 
1060         calloc( sizeof( uint32_t ), p_box->data.p_ctts->i_entry_count );
1061     p_box->data.p_ctts->i_sample_offset =
1062         calloc( sizeof( uint32_t ), p_box->data.p_ctts->i_entry_count );
1063     
1064     for( i = 0; (i < p_box->data.p_ctts->i_entry_count )&&( i_read >=8 ); i++ )
1065     {
1066         MP4_GET4BYTES( p_box->data.p_ctts->i_sample_count[i] );
1067         MP4_GET4BYTES( p_box->data.p_ctts->i_sample_offset[i] );
1068     }
1069     
1070     
1071 #ifdef MP4_VERBOSE
1072     msg_Dbg( p_stream->p_input, "Read Box: \"ctts\" entry-count %d",
1073                       p_box->data.p_ctts->i_entry_count );
1074
1075 #endif
1076     MP4_READBOX_EXIT( 1 );
1077 }
1078
1079 void MP4_FreeBox_ctts( input_thread_t *p_input, MP4_Box_t *p_box )
1080 {
1081     FREE( p_box->data.p_ctts->i_sample_count );
1082     FREE( p_box->data.p_ctts->i_sample_offset );
1083 }
1084
1085 static int MP4_ReadLengthDescriptor( uint8_t **pp_peek, int64_t  *i_read )
1086 {
1087     unsigned int i_b;
1088     unsigned int i_len = 0;
1089     do
1090     {
1091         i_b = **pp_peek;
1092
1093         (*pp_peek)++;
1094         (*i_read)--;
1095         i_len = ( i_len << 7 ) + ( i_b&0x7f );
1096     } while( i_b&0x80 );
1097     return( i_len );    
1098 }
1099
1100 int MP4_ReadBox_esds( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
1101 {
1102 #define es_descriptor p_box->data.p_esds->es_descriptor
1103     unsigned int i_len;
1104     unsigned int i_flags;
1105     unsigned int i_type;
1106
1107     MP4_READBOX_ENTER( MP4_Box_data_esds_t );
1108
1109     MP4_GETVERSIONFLAGS( p_box->data.p_esds );
1110
1111
1112     MP4_GET1BYTE( i_type );
1113     if( i_type == 0x03 ) /* MP4ESDescrTag */
1114     {
1115         i_len = MP4_ReadLengthDescriptor( &p_peek, &i_read );
1116
1117         MP4_GET2BYTES( es_descriptor.i_ES_ID );
1118         MP4_GET1BYTE( i_flags );
1119         es_descriptor.b_stream_dependence = ( (i_flags&0x80) != 0);
1120         es_descriptor.b_url = ( (i_flags&0x40) != 0);
1121         es_descriptor.b_OCRstream = ( (i_flags&0x20) != 0);
1122
1123         es_descriptor.i_stream_priority = i_flags&0x1f;
1124         if( es_descriptor.b_stream_dependence )
1125         {
1126             MP4_GET2BYTES( es_descriptor.i_depend_on_ES_ID );
1127         }
1128         if( es_descriptor.b_url )
1129         {
1130             unsigned int i_len;
1131         
1132             MP4_GET1BYTE( i_len );
1133             es_descriptor.psz_URL = calloc( sizeof(char), i_len + 1 );
1134             memcpy( es_descriptor.psz_URL, p_peek, i_len );
1135             es_descriptor.psz_URL[i_len] = 0;
1136             p_peek += i_len;
1137             i_read -= i_len;
1138         }
1139         else
1140         {
1141             es_descriptor.psz_URL = NULL;
1142         }
1143         if( es_descriptor.b_OCRstream )
1144         {
1145             MP4_GET2BYTES( es_descriptor.i_OCR_ES_ID );
1146         }
1147         MP4_GET1BYTE( i_type ); /* get next type */
1148     }
1149
1150     if( i_type != 0x04)/* MP4DecConfigDescrTag */
1151     {
1152         MP4_READBOX_EXIT( 1 ); /* rest isn't interesting up to now */
1153     }
1154
1155     i_len = MP4_ReadLengthDescriptor( &p_peek, &i_read );
1156     es_descriptor.p_decConfigDescr = 
1157             malloc( sizeof( MP4_descriptor_decoder_config_t ));
1158
1159     MP4_GET1BYTE( es_descriptor.p_decConfigDescr->i_objectTypeIndication );
1160     MP4_GET1BYTE( i_flags );
1161     es_descriptor.p_decConfigDescr->i_streamType = i_flags >> 2;
1162     es_descriptor.p_decConfigDescr->b_upStream = ( i_flags >> 1 )&0x01;
1163     MP4_GET3BYTES( es_descriptor.p_decConfigDescr->i_buffer_sizeDB );
1164     MP4_GET4BYTES( es_descriptor.p_decConfigDescr->i_max_bitrate );
1165     MP4_GET4BYTES( es_descriptor.p_decConfigDescr->i_avg_bitrate );
1166     MP4_GET1BYTE( i_type );
1167     if( i_type !=  0x05 )/* MP4DecSpecificDescrTag */
1168     {
1169         MP4_READBOX_EXIT( 1 );
1170     }
1171    
1172     i_len = MP4_ReadLengthDescriptor( &p_peek, &i_read );
1173     es_descriptor.p_decConfigDescr->i_decoder_specific_info_len = i_len;
1174     es_descriptor.p_decConfigDescr->p_decoder_specific_info = malloc( i_len );
1175     memcpy( es_descriptor.p_decConfigDescr->p_decoder_specific_info, 
1176             p_peek, i_len );
1177
1178     MP4_READBOX_EXIT( 1 );
1179
1180 #undef es_descriptor
1181 }
1182
1183 void MP4_FreeBox_esds( input_thread_t *p_input, MP4_Box_t *p_box )
1184 {
1185     FREE( p_box->data.p_esds->es_descriptor.psz_URL );
1186     FREE( p_box->data.p_esds->es_descriptor.p_decConfigDescr );
1187 }
1188
1189 int MP4_ReadBox_sample_soun( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
1190 {
1191     unsigned int i;    
1192     
1193     MP4_READBOX_ENTER( MP4_Box_data_sample_soun_t );
1194
1195     for( i = 0; i < 6 ; i++ )
1196     {
1197         MP4_GET1BYTE( p_box->data.p_sample_soun->i_reserved1[i] );
1198     }
1199
1200     MP4_GET2BYTES( p_box->data.p_sample_soun->i_data_reference_index );
1201     
1202     for( i = 0; i < 2 ; i++ )
1203     {
1204         MP4_GET4BYTES( p_box->data.p_sample_soun->i_reserved2[i] );
1205     }
1206    
1207     MP4_GET2BYTES( p_box->data.p_sample_soun->i_channelcount );
1208     MP4_GET2BYTES( p_box->data.p_sample_soun->i_samplesize );
1209     MP4_GET2BYTES( p_box->data.p_sample_soun->i_predefined );
1210     MP4_GET2BYTES( p_box->data.p_sample_soun->i_reserved3 );
1211     MP4_GET2BYTES( p_box->data.p_sample_soun->i_sampleratehi );
1212     MP4_GET2BYTES( p_box->data.p_sample_soun->i_sampleratelo );
1213     
1214     MP4_SeekStream( p_stream, p_box->i_pos + MP4_BOX_HEADERSIZE( p_box ) + 28 );
1215     MP4_ReadBoxContainerRaw( p_stream, p_box ); /* esds */
1216    
1217 #ifdef MP4_VERBOSE
1218     msg_Dbg( p_stream->p_input, "Read Box: \"soun\" in stsd channel %d sample size %d sampl rate %f",
1219                       p_box->data.p_sample_soun->i_channelcount,
1220                       p_box->data.p_sample_soun->i_samplesize,
1221                       (float)p_box->data.p_sample_soun->i_sampleratehi + 
1222                     (float)p_box->data.p_sample_soun->i_sampleratelo / 65536 );
1223
1224 #endif
1225     MP4_READBOX_EXIT( 1 );
1226 }
1227
1228 #if 0
1229 int MP4_ReadBox_sample_mp4a( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
1230 {
1231     unsigned int i;    
1232
1233     MP4_READBOX_ENTER( MP4_Box_data_sample_mp4a_t );
1234     
1235     for( i = 0; i < 6 ; i++ )
1236     {
1237         MP4_GET1BYTE( p_box->data.p_sample_mp4a->i_reserved1[i] );
1238     }
1239
1240     MP4_GET2BYTES( p_box->data.p_sample_mp4a->i_data_reference_index );
1241     
1242     for( i = 0; i < 2 ; i++ )
1243     {
1244         MP4_GET4BYTES( p_box->data.p_sample_mp4a->i_reserved2[i] );
1245     }
1246    
1247     MP4_GET2BYTES( p_box->data.p_sample_mp4a->i_channelcount );
1248     MP4_GET2BYTES( p_box->data.p_sample_mp4a->i_samplesize );
1249     MP4_GET2BYTES( p_box->data.p_sample_mp4a->i_predefined );
1250     MP4_GET2BYTES( p_box->data.p_sample_mp4a->i_reserved3 );
1251     MP4_GET2BYTES( p_box->data.p_sample_mp4a->i_sampleratehi );
1252     MP4_GET2BYTES( p_box->data.p_sample_mp4a->i_sampleratelo );
1253     
1254     MP4_SeekStream( p_stream, p_box->i_pos + MP4_BOX_HEADERSIZE( p_box ) + 28 );
1255     MP4_ReadBoxContainerRaw( p_stream, p_box ); /* esds */
1256
1257 #ifdef MP4_VERBOSE
1258     msg_Dbg( p_stream->p_input, "Read Box: \"mp4a\" in stsd channel %d sample size %d sampl rate %f",
1259                       p_box->data.p_sample_mp4a->i_channelcount,
1260                       p_box->data.p_sample_mp4a->i_samplesize,
1261                       (float)p_box->data.p_sample_mp4a->i_sampleratehi + 
1262                         (float)p_box->data.p_sample_mp4a->i_sampleratelo / 65536 );
1263
1264 #endif
1265     MP4_READBOX_EXIT( 1 );
1266 }
1267 #endif
1268
1269 int MP4_ReadBox_sample_vide( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
1270 {
1271     unsigned int i;    
1272
1273     MP4_READBOX_ENTER( MP4_Box_data_sample_vide_t );
1274
1275     for( i = 0; i < 6 ; i++ )
1276     {
1277         MP4_GET1BYTE( p_box->data.p_sample_vide->i_reserved1[i] );
1278     }
1279
1280     MP4_GET2BYTES( p_box->data.p_sample_vide->i_data_reference_index );
1281
1282     MP4_GET2BYTES( p_box->data.p_sample_vide->i_predefined1 );
1283     MP4_GET2BYTES( p_box->data.p_sample_vide->i_reserved2 );
1284
1285     for( i = 0; i < 3 ; i++ )
1286     {
1287         MP4_GET4BYTES( p_box->data.p_sample_vide->i_predefined2[i] );
1288     }
1289
1290     MP4_GET2BYTES( p_box->data.p_sample_vide->i_width );
1291     MP4_GET2BYTES( p_box->data.p_sample_vide->i_height );
1292     
1293     MP4_GET4BYTES( p_box->data.p_sample_vide->i_horizresolution );
1294     MP4_GET4BYTES( p_box->data.p_sample_vide->i_vertresolution );
1295
1296     MP4_GET4BYTES( p_box->data.p_sample_vide->i_reserved3 );
1297     MP4_GET2BYTES( p_box->data.p_sample_vide->i_predefined3 );
1298
1299     memcpy( &p_box->data.p_sample_vide->i_compressorname, p_peek, 32 );
1300     p_peek += 32; i_read -= 32;
1301
1302     MP4_GET2BYTES( p_box->data.p_sample_vide->i_depth );
1303     MP4_GET2BYTES( p_box->data.p_sample_vide->i_predefined4 );
1304     
1305     MP4_SeekStream( p_stream, p_box->i_pos + MP4_BOX_HEADERSIZE( p_box ) + 78);
1306     MP4_ReadBoxContainerRaw( p_stream, p_box );
1307    
1308 #ifdef MP4_VERBOSE
1309     msg_Dbg( p_stream->p_input, "Read Box: \"vide\" in stsd %dx%d depth %d",
1310                       p_box->data.p_sample_vide->i_width,
1311                       p_box->data.p_sample_vide->i_height,
1312                       p_box->data.p_sample_vide->i_depth );
1313
1314 #endif
1315     MP4_READBOX_EXIT( 1 );
1316 }
1317
1318
1319 int MP4_ReadBox_stsd( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
1320 {
1321
1322     MP4_READBOX_ENTER( MP4_Box_data_stsd_t );
1323
1324     MP4_GETVERSIONFLAGS( p_box->data.p_stsd );
1325
1326     MP4_GET4BYTES( p_box->data.p_stsd->i_entry_count );
1327
1328     MP4_SeekStream( p_stream, p_box->i_pos + MP4_BOX_HEADERSIZE( p_box ) + 8 ); 
1329
1330     MP4_ReadBoxContainerRaw( p_stream, p_box );
1331
1332 #ifdef MP4_VERBOSE
1333     msg_Dbg( p_stream->p_input, "Read Box: \"stsd\" entry-count %d",
1334                       p_box->data.p_stsd->i_entry_count );
1335
1336 #endif
1337     MP4_READBOX_EXIT( 1 );
1338 }
1339
1340
1341 int MP4_ReadBox_stsz( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
1342 {
1343     unsigned int i;
1344
1345     MP4_READBOX_ENTER( MP4_Box_data_stsz_t );
1346     
1347     MP4_GETVERSIONFLAGS( p_box->data.p_stsz );
1348     
1349     MP4_GET4BYTES( p_box->data.p_stsz->i_sample_size );
1350
1351     MP4_GET4BYTES( p_box->data.p_stsz->i_sample_count );
1352
1353     p_box->data.p_stsz->i_entry_size = 
1354         calloc( sizeof( uint32_t ), p_box->data.p_stsz->i_sample_count );
1355     
1356     if( !p_box->data.p_stsz->i_sample_size )
1357     {
1358         for( i=0; (i<p_box->data.p_stsz->i_sample_count)&&(i_read >= 4 ); i++ )
1359         {
1360             MP4_GET4BYTES( p_box->data.p_stsz->i_entry_size[i] );
1361         }
1362     }
1363     
1364     
1365 #ifdef MP4_VERBOSE 
1366     msg_Dbg( p_stream->p_input, "Read Box: \"stsz\" sample-size %d sample-count %d",
1367                       p_box->data.p_stsz->i_sample_size,
1368                       p_box->data.p_stsz->i_sample_count );
1369
1370 #endif
1371     MP4_READBOX_EXIT( 1 );
1372 }
1373
1374 void MP4_FreeBox_stsz( input_thread_t *p_input, MP4_Box_t *p_box )
1375 {
1376     FREE( p_box->data.p_stsz->i_entry_size );
1377 }
1378
1379 int MP4_ReadBox_stsc( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
1380 {
1381     unsigned int i;
1382     
1383     MP4_READBOX_ENTER( MP4_Box_data_stsc_t );
1384
1385     MP4_GETVERSIONFLAGS( p_box->data.p_stsc );
1386     
1387     MP4_GET4BYTES( p_box->data.p_stsc->i_entry_count );
1388
1389     p_box->data.p_stsc->i_first_chunk = 
1390         calloc( sizeof( uint32_t ), p_box->data.p_stsc->i_entry_count );
1391     p_box->data.p_stsc->i_samples_per_chunk = 
1392         calloc( sizeof( uint32_t ), p_box->data.p_stsc->i_entry_count );
1393     p_box->data.p_stsc->i_sample_description_index = 
1394         calloc( sizeof( uint32_t ), p_box->data.p_stsc->i_entry_count );
1395
1396     for( i = 0; (i < p_box->data.p_stsc->i_entry_count )&&( i_read >= 12 );i++ )
1397     {
1398         MP4_GET4BYTES( p_box->data.p_stsc->i_first_chunk[i] );
1399         MP4_GET4BYTES( p_box->data.p_stsc->i_samples_per_chunk[i] );
1400         MP4_GET4BYTES( p_box->data.p_stsc->i_sample_description_index[i] );
1401     }
1402     
1403     
1404 #ifdef MP4_VERBOSE 
1405     msg_Dbg( p_stream->p_input, "Read Box: \"stsc\" entry-count %d",
1406                       p_box->data.p_stsc->i_entry_count );
1407
1408 #endif
1409     MP4_READBOX_EXIT( 1 );
1410 }
1411
1412 void MP4_FreeBox_stsc( input_thread_t *p_input, MP4_Box_t *p_box )
1413 {
1414     FREE( p_box->data.p_stsc->i_first_chunk );
1415     FREE( p_box->data.p_stsc->i_samples_per_chunk );
1416     FREE( p_box->data.p_stsc->i_sample_description_index );
1417 }
1418
1419 int MP4_ReadBox_stco_co64( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
1420 {
1421     unsigned int i;
1422     
1423     MP4_READBOX_ENTER( MP4_Box_data_co64_t );
1424
1425     MP4_GETVERSIONFLAGS( p_box->data.p_co64 );
1426
1427     MP4_GET4BYTES( p_box->data.p_co64->i_entry_count );
1428
1429     p_box->data.p_co64->i_chunk_offset = 
1430         calloc( sizeof( uint64_t ), p_box->data.p_co64->i_entry_count );
1431
1432     for( i = 0; i < p_box->data.p_co64->i_entry_count; i++ )
1433     {
1434         if( p_box->i_type == FOURCC_stco )
1435         {
1436             if( i_read < 4 )
1437             {
1438                 break;
1439             }
1440             MP4_GET4BYTES( p_box->data.p_co64->i_chunk_offset[i] );
1441         }
1442         else
1443         {
1444             if( i_read < 8 )
1445             {
1446                 break;
1447             }
1448             MP4_GET8BYTES( p_box->data.p_co64->i_chunk_offset[i] );
1449         }
1450     }
1451     
1452     
1453 #ifdef MP4_VERBOSE 
1454     msg_Dbg( p_stream->p_input, "Read Box: \"co64\" entry-count %d",
1455                       p_box->data.p_co64->i_entry_count );
1456
1457 #endif
1458     MP4_READBOX_EXIT( 1 );
1459 }
1460
1461 void MP4_FreeBox_stco_co64( input_thread_t *p_input, MP4_Box_t *p_box )
1462 {
1463     FREE( p_box->data.p_co64->i_chunk_offset );
1464 }
1465
1466 int MP4_ReadBox_stss( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
1467 {
1468     unsigned int i;
1469     
1470     MP4_READBOX_ENTER( MP4_Box_data_stss_t ); 
1471
1472     MP4_GETVERSIONFLAGS( p_box->data.p_stss );
1473
1474     MP4_GET4BYTES( p_box->data.p_stss->i_entry_count );
1475
1476     p_box->data.p_stss->i_sample_number = 
1477         calloc( sizeof( uint32_t ), p_box->data.p_stss->i_entry_count );
1478
1479     for( i = 0; (i < p_box->data.p_stss->i_entry_count )&&( i_read >= 4 ); i++ )
1480     {
1481
1482         MP4_GET4BYTES( p_box->data.p_stss->i_sample_number[i] );
1483         /* XXX in libmp4 sample begin at 0 */
1484         p_box->data.p_stss->i_sample_number[i]--;
1485     }
1486     
1487     
1488 #ifdef MP4_VERBOSE 
1489     msg_Dbg( p_stream->p_input, "Read Box: \"stss\" entry-count %d",
1490                       p_box->data.p_stss->i_entry_count );
1491
1492 #endif
1493     MP4_READBOX_EXIT( 1 );
1494 }
1495
1496 void MP4_FreeBox_stss( input_thread_t *p_input, MP4_Box_t *p_box )
1497 {
1498     FREE( p_box->data.p_stss->i_sample_number )
1499 }
1500
1501 int MP4_ReadBox_stsh( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
1502 {
1503     unsigned int i;
1504     
1505     MP4_READBOX_ENTER( MP4_Box_data_stsh_t );
1506
1507     MP4_GETVERSIONFLAGS( p_box->data.p_stsh );
1508
1509
1510     MP4_GET4BYTES( p_box->data.p_stsh->i_entry_count );
1511
1512     p_box->data.p_stsh->i_shadowed_sample_number = 
1513         calloc( sizeof( uint32_t ), p_box->data.p_stsh->i_entry_count );
1514
1515     p_box->data.p_stsh->i_sync_sample_number = 
1516         calloc( sizeof( uint32_t ), p_box->data.p_stsh->i_entry_count );
1517
1518
1519     for( i = 0; (i < p_box->data.p_stss->i_entry_count )&&( i_read >= 8 ); i++ )
1520     {
1521
1522         MP4_GET4BYTES( p_box->data.p_stsh->i_shadowed_sample_number[i] );
1523         MP4_GET4BYTES( p_box->data.p_stsh->i_sync_sample_number[i] );
1524     }
1525     
1526     
1527 #ifdef MP4_VERBOSE 
1528     msg_Dbg( p_stream->p_input, "Read Box: \"stsh\" entry-count %d",
1529                       p_box->data.p_stsh->i_entry_count );
1530 #endif
1531     MP4_READBOX_EXIT( 1 );
1532 }
1533
1534 void MP4_FreeBox_stsh( input_thread_t *p_input, MP4_Box_t *p_box )
1535 {
1536     FREE( p_box->data.p_stsh->i_shadowed_sample_number )
1537     FREE( p_box->data.p_stsh->i_sync_sample_number )
1538 }
1539
1540
1541 int MP4_ReadBox_stdp( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
1542 {
1543     unsigned int i;
1544    
1545     MP4_READBOX_ENTER( MP4_Box_data_stdp_t ); 
1546
1547     MP4_GETVERSIONFLAGS( p_box->data.p_stdp );
1548
1549     p_box->data.p_stdp->i_priority = 
1550         calloc( sizeof( uint16_t ), i_read / 2 );
1551
1552     for( i = 0; i < i_read / 2 ; i++ )
1553     {
1554
1555         MP4_GET2BYTES( p_box->data.p_stdp->i_priority[i] );
1556     }
1557     
1558     
1559 #ifdef MP4_VERBOSE 
1560     msg_Dbg( p_stream->p_input, "Read Box: \"stdp\" entry-count "I64Fd,
1561                       i_read / 2 );
1562
1563 #endif
1564     MP4_READBOX_EXIT( 1 );
1565 }
1566
1567 void MP4_FreeBox_stdp( input_thread_t *p_input, MP4_Box_t *p_box )
1568 {
1569     FREE( p_box->data.p_stdp->i_priority )
1570 }
1571
1572 int MP4_ReadBox_padb( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
1573 {
1574     unsigned int i;
1575     
1576     MP4_READBOX_ENTER( MP4_Box_data_padb_t );
1577
1578     MP4_GETVERSIONFLAGS( p_box->data.p_padb );
1579
1580
1581     MP4_GET4BYTES( p_box->data.p_padb->i_sample_count );
1582
1583     p_box->data.p_padb->i_reserved1 = 
1584         calloc( sizeof( uint16_t ), ( p_box->data.p_padb->i_sample_count + 1 ) / 2 );
1585     p_box->data.p_padb->i_pad2 = 
1586         calloc( sizeof( uint16_t ), ( p_box->data.p_padb->i_sample_count + 1 ) / 2 );
1587     p_box->data.p_padb->i_reserved2 = 
1588         calloc( sizeof( uint16_t ), ( p_box->data.p_padb->i_sample_count + 1 ) / 2 );
1589     p_box->data.p_padb->i_pad1 = 
1590         calloc( sizeof( uint16_t ), ( p_box->data.p_padb->i_sample_count + 1 ) / 2 );
1591
1592
1593     for( i = 0; i < i_read / 2 ; i++ )
1594     {
1595         p_box->data.p_padb->i_reserved1[i] = ( (*p_peek) >> 7 )&0x01;
1596         p_box->data.p_padb->i_pad2[i] = ( (*p_peek) >> 4 )&0x07;
1597         p_box->data.p_padb->i_reserved1[i] = ( (*p_peek) >> 3 )&0x01;
1598         p_box->data.p_padb->i_pad1[i] = ( (*p_peek) )&0x07;
1599
1600         p_peek += 1; i_read -= 1;
1601     }
1602     
1603     
1604 #ifdef MP4_VERBOSE 
1605     msg_Dbg( p_stream->p_input, "Read Box: \"stdp\" entry-count "I64Fd,
1606                       i_read / 2 );
1607
1608 #endif
1609     MP4_READBOX_EXIT( 1 );
1610 }
1611
1612 void MP4_FreeBox_padb( input_thread_t *p_input, MP4_Box_t *p_box )
1613 {
1614     FREE( p_box->data.p_padb->i_reserved1 );
1615     FREE( p_box->data.p_padb->i_pad2 );
1616     FREE( p_box->data.p_padb->i_reserved2 );
1617     FREE( p_box->data.p_padb->i_pad1 );
1618 }
1619
1620 int MP4_ReadBox_elst( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
1621 {
1622     unsigned int i;
1623     
1624     MP4_READBOX_ENTER( MP4_Box_data_padb_t );
1625
1626     MP4_GETVERSIONFLAGS( p_box->data.p_elst );
1627
1628
1629     MP4_GET4BYTES( p_box->data.p_elst->i_entry_count );
1630
1631     p_box->data.p_elst->i_segment_duration =
1632         calloc( sizeof( uint64_t ), p_box->data.p_elst->i_entry_count );
1633     p_box->data.p_elst->i_media_time =
1634         calloc( sizeof( uint64_t ), p_box->data.p_elst->i_entry_count );
1635     p_box->data.p_elst->i_media_rate_integer =
1636         calloc( sizeof( uint16_t ), p_box->data.p_elst->i_entry_count );
1637     p_box->data.p_elst->i_media_rate_fraction= 
1638         calloc( sizeof( uint16_t ), p_box->data.p_elst->i_entry_count );
1639
1640
1641     for( i = 0; i < p_box->data.p_elst->i_entry_count; i++ )
1642     {
1643         if( p_box->data.p_elst->i_version == 1 )
1644         {
1645
1646             MP4_GET8BYTES( p_box->data.p_elst->i_segment_duration[i] );
1647
1648             MP4_GET8BYTES( p_box->data.p_elst->i_media_time[i] );
1649         }
1650         else
1651         {
1652
1653             MP4_GET4BYTES( p_box->data.p_elst->i_segment_duration[i] );
1654
1655             MP4_GET4BYTES( p_box->data.p_elst->i_media_time[i] );
1656         }
1657
1658         MP4_GET2BYTES( p_box->data.p_elst->i_media_rate_integer[i] );
1659         MP4_GET2BYTES( p_box->data.p_elst->i_media_rate_fraction[i] );
1660     }
1661     
1662     
1663 #ifdef MP4_VERBOSE 
1664     msg_Dbg( p_stream->p_input, "Read Box: \"elst\" entry-count "I64Fd,
1665                       i_read / 2 );
1666
1667 #endif
1668     MP4_READBOX_EXIT( 1 );
1669 }
1670
1671 void MP4_FreeBox_elst( input_thread_t *p_input, MP4_Box_t *p_box )
1672 {
1673     FREE( p_box->data.p_elst->i_segment_duration );
1674     FREE( p_box->data.p_elst->i_media_time );
1675     FREE( p_box->data.p_elst->i_media_rate_integer );
1676     FREE( p_box->data.p_elst->i_media_rate_fraction );
1677 }
1678
1679 int MP4_ReadBox_cprt( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
1680 {
1681     unsigned int i_language;
1682     unsigned int i;
1683     
1684     MP4_READBOX_ENTER( MP4_Box_data_cprt_t );
1685
1686     MP4_GETVERSIONFLAGS( p_box->data.p_cprt );
1687
1688     i_language = GetWBE( p_peek ); 
1689     for( i = 0; i < 3; i++ )
1690     {
1691         p_box->data.p_cprt->i_language[i] = 
1692             ( ( i_language >> ( (2-i)*5 ) )&0x1f ) + 0x60;
1693     }
1694     p_peek += 2; i_read -= 2;  
1695     MP4_GETSTRINGZ( p_box->data.p_cprt->psz_notice );
1696
1697 #ifdef MP4_VERBOSE
1698     msg_Dbg( p_stream->p_input, "Read Box: \"cprt\" language %c%c%c notice %s",
1699                       p_box->data.p_cprt->i_language[0],
1700                       p_box->data.p_cprt->i_language[1],
1701                       p_box->data.p_cprt->i_language[2],
1702                       p_box->data.p_cprt->psz_notice );
1703
1704 #endif
1705     MP4_READBOX_EXIT( 1 );
1706 }
1707
1708 void MP4_FreeBox_cprt( input_thread_t *p_input, MP4_Box_t *p_box )
1709 {
1710     FREE( p_box->data.p_cprt->psz_notice );
1711 }
1712
1713
1714 int MP4_ReadBox_dcom( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
1715 {
1716     MP4_READBOX_ENTER( MP4_Box_data_dcom_t );
1717     
1718     MP4_GETFOURCC( p_box->data.p_dcom->i_algorithm );
1719 #ifdef MP4_VERBOSE
1720     msg_Dbg( p_stream->p_input, 
1721              "Read Box: \"dcom\" compression algorithm : %c%c%c%c",
1722                       ( p_box->data.p_dcom->i_algorithm )&0xff,
1723                       ( p_box->data.p_dcom->i_algorithm >> 8 )&0xff,
1724                       ( p_box->data.p_dcom->i_algorithm >> 16 )&0xff,
1725                       ( p_box->data.p_dcom->i_algorithm >> 24 )&0xff );
1726 #endif 
1727     
1728     MP4_READBOX_EXIT( 1 );
1729 }
1730
1731 int MP4_ReadBox_cmvd( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
1732 {
1733     MP4_READBOX_ENTER( MP4_Box_data_cmvd_t );
1734
1735     
1736     MP4_GET4BYTES( p_box->data.p_cmvd->i_uncompressed_size );
1737
1738     p_box->data.p_cmvd->i_compressed_size = i_read;
1739     
1740     if( !( p_box->data.p_cmvd->p_data = malloc( i_read ) ) )
1741     {
1742         msg_Dbg( p_stream->p_input, "Read Box: \"cmvd\" not enough memory to load data" );
1743         return( 1 );
1744     }
1745     
1746     /* now copy compressed data */
1747     memcpy( p_box->data.p_cmvd->p_data,
1748             p_peek,
1749             i_read);
1750     
1751     p_box->data.p_cmvd->b_compressed = 1;
1752      
1753 #ifdef MP4_VERBOSE
1754     msg_Dbg( p_stream->p_input, "Read Box: \"cmvd\" compressed data size %d",
1755                       p_box->data.p_cmvd->i_compressed_size );
1756 #endif 
1757     
1758     MP4_READBOX_EXIT( 1 );
1759 }
1760 void MP4_FreeBox_cmvd( input_thread_t *p_input, MP4_Box_t *p_box )
1761 {
1762     FREE( p_box->data.p_cmvd->p_data );
1763 }
1764
1765
1766 int MP4_ReadBox_cmov( MP4_Stream_t *p_stream, MP4_Box_t *p_box )
1767 {
1768     MP4_Stream_t *p_stream_memory;
1769     MP4_Box_t *p_umov;
1770     
1771     MP4_Box_t *p_dcom;
1772     MP4_Box_t *p_cmvd;
1773 #ifdef HAVE_ZLIB_H
1774     z_stream  z_data;
1775 #endif
1776     uint8_t *p_data;
1777     
1778     int i_result;
1779
1780     if( !( p_box->data.p_cmov = malloc( sizeof( MP4_Box_data_cmov_t ) ) ) )
1781     {
1782         msg_Err( p_stream->p_input, "out of memory" );
1783         return( 0 );
1784     }
1785     memset( p_box->data.p_cmov, 0, sizeof( MP4_Box_data_cmov_t ) );
1786     
1787     if( !( p_box->p_father )||
1788         ( p_box->p_father->i_type != FOURCC_moov ) )
1789     {
1790         msg_Warn( p_stream->p_input, "Read box: \"cmov\" box alone" );
1791         return( 1 );
1792     }
1793
1794     if( !(i_result = MP4_ReadBoxContainer( p_stream, p_box ) ) )
1795     {
1796         return( 0 );
1797     }
1798     
1799     if( !( p_dcom = MP4_FindBox( p_box, FOURCC_dcom ) )||
1800         !( p_cmvd = MP4_FindBox( p_box, FOURCC_cmvd ) )||
1801         !( p_cmvd->data.p_cmvd->p_data ) )
1802     {
1803         msg_Warn( p_stream->p_input, "Read Box: \"cmov\" incomplete" );
1804         return( 1 );
1805     }
1806
1807     if( p_dcom->data.p_dcom->i_algorithm != FOURCC_zlib )
1808     {
1809         msg_Dbg( p_stream->p_input, "Read Box: \"cmov\" compression algorithm : %c%c%c%c not supported",
1810                     ( p_dcom->data.p_dcom->i_algorithm )&0xff,
1811                     ( p_dcom->data.p_dcom->i_algorithm >> 8 )&0xff,
1812                     ( p_dcom->data.p_dcom->i_algorithm >> 16 )&0xff,
1813                     ( p_dcom->data.p_dcom->i_algorithm >> 24 )&0xff );
1814         return( 1 );
1815     }
1816
1817 #ifndef HAVE_ZLIB_H
1818     msg_Dbg( p_stream->p_input,
1819              "Read Box: \"cmov\" zlib unsupported" );
1820     return( 1 );
1821 #else 
1822     /* decompress data */
1823     /* allocate a new buffer */
1824     if( !( p_data = malloc( p_cmvd->data.p_cmvd->i_uncompressed_size ) ) )
1825     {
1826         msg_Err( p_stream->p_input, 
1827                  "Read Box: \"cmov\" not enough memory to uncompress data" );
1828         return( 1 );
1829     }
1830     /* init default structures */
1831     z_data.next_in   = p_cmvd->data.p_cmvd->p_data;
1832     z_data.avail_in  = p_cmvd->data.p_cmvd->i_compressed_size;
1833     z_data.next_out  = p_data;
1834     z_data.avail_out = p_cmvd->data.p_cmvd->i_uncompressed_size;
1835     z_data.zalloc    = (alloc_func)Z_NULL;
1836     z_data.zfree     = (free_func)Z_NULL;
1837     z_data.opaque    = (voidpf)Z_NULL;
1838
1839     /* init zlib */
1840     if( ( i_result = inflateInit( &z_data ) ) != Z_OK )
1841     {
1842         msg_Err( p_stream->p_input, 
1843                  "Read Box: \"cmov\" error while uncompressing data" );
1844         free( p_data );
1845         return( 1 );
1846     }
1847
1848     /* uncompress */
1849     i_result = inflate( &z_data, Z_NO_FLUSH );
1850     if( ( i_result != Z_OK )&&( i_result != Z_STREAM_END ) )
1851     {
1852         msg_Err( p_stream->p_input, 
1853                  "Read Box: \"cmov\" error while uncompressing data" );
1854         free( p_data );
1855         return( 1 );
1856     }
1857
1858     if( p_cmvd->data.p_cmvd->i_uncompressed_size != z_data.total_out )
1859     {
1860         msg_Warn( p_stream->p_input, 
1861                   "Read Box: \"cmov\" uncompressing data size mismatch" );
1862     }
1863     p_cmvd->data.p_cmvd->i_uncompressed_size = z_data.total_out;
1864
1865     /* close zlib */ 
1866     i_result = inflateEnd( &z_data );
1867     if( i_result != Z_OK )
1868     {
1869         msg_Warn( p_stream->p_input, 
1870            "Read Box: \"cmov\" error while uncompressing data (ignored)" );
1871     }
1872
1873
1874     free( p_cmvd->data.p_cmvd->p_data );
1875     p_cmvd->data.p_cmvd->p_data = p_data;
1876     p_cmvd->data.p_cmvd->b_compressed = 0;
1877
1878     msg_Dbg( p_stream->p_input, 
1879              "Read Box: \"cmov\" box succesfully uncompressed" );
1880
1881     /* now create a memory stream */
1882     p_stream_memory = MP4_MemoryStream( p_stream->p_input, 
1883                                         p_cmvd->data.p_cmvd->i_uncompressed_size,
1884                                         p_cmvd->data.p_cmvd->p_data );
1885
1886     /* and read uncompressd moov */
1887     p_umov = malloc( sizeof( MP4_Box_t ) );
1888     
1889     i_result = MP4_ReadBox( p_stream_memory, p_umov, NULL );
1890   
1891     p_box->data.p_cmov->p_moov = p_umov;
1892     free( p_stream_memory );
1893
1894 #ifdef MP4_VERBOSE
1895     msg_Dbg( p_stream->p_input, 
1896              "Read Box: \"cmov\" compressed movie header completed" );
1897 #endif
1898     return( i_result );
1899 #endif /* HAVE_ZLIB_H */
1900 }
1901
1902
1903 /**** ------------------------------------------------------------------- ****/
1904 /****                   "Higher level" Functions                          ****/
1905 /**** ------------------------------------------------------------------- ****/
1906
1907 static struct 
1908 {
1909     uint32_t i_type;
1910     int  (*MP4_ReadBox_function )( MP4_Stream_t *p_stream, MP4_Box_t *p_box ); 
1911     void (*MP4_FreeBox_function )( input_thread_t *p_input, MP4_Box_t *p_box );
1912 } MP4_Box_Function [] =
1913 {
1914     /* Containers */
1915     { FOURCC_moov,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
1916     { FOURCC_trak,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
1917     { FOURCC_mdia,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
1918     { FOURCC_moof,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
1919     { FOURCC_minf,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
1920     { FOURCC_stbl,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
1921     { FOURCC_dinf,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
1922     { FOURCC_edts,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
1923     { FOURCC_udta,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
1924     { FOURCC_nmhd,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
1925     { FOURCC_hnti,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
1926
1927     /* specific box */
1928     { FOURCC_ftyp,  MP4_ReadBox_ftyp,       MP4_FreeBox_ftyp },
1929     { FOURCC_cmov,  MP4_ReadBox_cmov,       MP4_FreeBox_Common },
1930     { FOURCC_mvhd,  MP4_ReadBox_mvhd,       MP4_FreeBox_Common },
1931     { FOURCC_tkhd,  MP4_ReadBox_tkhd,       MP4_FreeBox_Common },
1932     { FOURCC_tref,  MP4_ReadBox_tref,       MP4_FreeBox_Common },
1933     { FOURCC_mdhd,  MP4_ReadBox_mdhd,       MP4_FreeBox_Common },
1934     { FOURCC_hdlr,  MP4_ReadBox_hdlr,       MP4_FreeBox_hdlr },
1935     { FOURCC_vmhd,  MP4_ReadBox_vmhd,       MP4_FreeBox_Common },
1936     { FOURCC_smhd,  MP4_ReadBox_smhd,       MP4_FreeBox_Common },
1937     { FOURCC_hmhd,  MP4_ReadBox_hmhd,       MP4_FreeBox_Common },
1938     { FOURCC_url,   MP4_ReadBox_url,        MP4_FreeBox_url },
1939     { FOURCC_urn,   MP4_ReadBox_urn,        MP4_FreeBox_urn },
1940     { FOURCC_dref,  MP4_ReadBox_dref,       MP4_FreeBox_Common },
1941     { FOURCC_stts,  MP4_ReadBox_stts,       MP4_FreeBox_stts },
1942     { FOURCC_ctts,  MP4_ReadBox_ctts,       MP4_FreeBox_ctts },
1943     { FOURCC_stsd,  MP4_ReadBox_stsd,       MP4_FreeBox_Common },
1944     { FOURCC_stsz,  MP4_ReadBox_stsz,       MP4_FreeBox_stsz },
1945     { FOURCC_stsc,  MP4_ReadBox_stsc,       MP4_FreeBox_stsc },
1946     { FOURCC_stco,  MP4_ReadBox_stco_co64,  MP4_FreeBox_stco_co64 },
1947     { FOURCC_co64,  MP4_ReadBox_stco_co64,  MP4_FreeBox_stco_co64 },
1948     { FOURCC_stss,  MP4_ReadBox_stss,       MP4_FreeBox_stss },
1949     { FOURCC_stsh,  MP4_ReadBox_stsh,       MP4_FreeBox_stsh },
1950     { FOURCC_stdp,  MP4_ReadBox_stdp,       MP4_FreeBox_stdp },
1951     { FOURCC_padb,  MP4_ReadBox_padb,       MP4_FreeBox_padb },
1952     { FOURCC_elst,  MP4_ReadBox_elst,       MP4_FreeBox_elst },
1953     { FOURCC_cprt,  MP4_ReadBox_cprt,       MP4_FreeBox_cprt },
1954     { FOURCC_esds,  MP4_ReadBox_esds,       MP4_FreeBox_esds },
1955     { FOURCC_dcom,  MP4_ReadBox_dcom,       MP4_FreeBox_Common },
1956     { FOURCC_cmvd,  MP4_ReadBox_cmvd,       MP4_FreeBox_cmvd },
1957
1958     /* Nothing to do with this box */
1959     { FOURCC_mdat,  MP4_ReadBoxSkip,        MP4_FreeBox_Common },
1960     { FOURCC_skip,  MP4_ReadBoxSkip,        MP4_FreeBox_Common },
1961     { FOURCC_free,  MP4_ReadBoxSkip,        MP4_FreeBox_Common },
1962     { FOURCC_wide,  MP4_ReadBoxSkip,        MP4_FreeBox_Common },
1963
1964     /* for codecs */
1965     { FOURCC_soun,  MP4_ReadBox_sample_soun,    MP4_FreeBox_Common },
1966     { FOURCC__mp3,  MP4_ReadBox_sample_soun,    MP4_FreeBox_Common },
1967     { FOURCC_ms55,  MP4_ReadBox_sample_soun,    MP4_FreeBox_Common },
1968     { FOURCC_mp4a,  MP4_ReadBox_sample_soun,    MP4_FreeBox_Common },
1969
1970     { FOURCC_vide,  MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },
1971     { FOURCC_mp4v,  MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },
1972     { FOURCC_SVQ1,  MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },
1973     { FOURCC_DIVX,  MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },
1974     { FOURCC_h263,  MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },
1975     { FOURCC_cvid,  MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },
1976     { FOURCC_3IV1,  MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },
1977     { FOURCC_3IV2,  MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },
1978     { FOURCC_mjpa,  MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },
1979     { FOURCC_mjpb,  MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },
1980     { FOURCC_mjqt,  NULL,                       NULL }, /* found in mjpa/b */
1981     { FOURCC_mjht,  NULL,                       NULL },
1982  
1983     { FOURCC_jpeg,  MP4_ReadBox_sample_vide,    MP4_FreeBox_Common },
1984
1985     { FOURCC_mp4s,  NULL,                       MP4_FreeBox_Common },
1986
1987     /* XXX there is 2 box where we could find this entry stbl and tref*/
1988     { FOURCC_hint,  NULL,                       MP4_FreeBox_Common },
1989
1990     /* found in tref box */
1991     { FOURCC_dpnd,  NULL,   NULL },
1992     { FOURCC_ipir,  NULL,   NULL },
1993     { FOURCC_mpod,  NULL,   NULL },
1994     
1995     /* found in hnti */
1996     { FOURCC_rtp,   NULL,   NULL },
1997     
1998     /* Last entry */
1999     
2000     { 0,            NULL,                   NULL }
2001 };
2002
2003
2004
2005 /*****************************************************************************
2006  * MP4_ReadBox : parse the actual box and the children 
2007  *  XXX : Do not go to the next box
2008  *****************************************************************************/
2009 int MP4_ReadBox( MP4_Stream_t *p_stream, MP4_Box_t *p_box, MP4_Box_t *p_father )
2010 {
2011     int i_result;
2012     unsigned int i_index;
2013     
2014     if( !MP4_ReadBoxCommon( p_stream, p_box ) )
2015     {
2016         msg_Warn( p_stream->p_input, "Cannot read one box" );
2017         return( 0 );
2018     }
2019     if( !p_box->i_size )
2020     {
2021         msg_Dbg( p_stream->p_input, "Found an empty box (null size)" );
2022         return( 0 );
2023     }
2024     p_box->p_father = p_father;
2025
2026     /* Now search function to call */
2027     for( i_index = 0; ; i_index++ )
2028     {
2029         if( ( MP4_Box_Function[i_index].i_type == p_box->i_type )||
2030             ( MP4_Box_Function[i_index].i_type == 0 ) )
2031         {
2032             break;
2033         }
2034     }
2035     if( MP4_Box_Function[i_index].MP4_ReadBox_function == NULL )
2036     {
2037         msg_Warn( p_stream->p_input,
2038                   "Unknown box type %c%c%c%c (uncompletetly loaded)",
2039                   (p_box->i_type)&0xff, 
2040                   (p_box->i_type>>8)&0xff,
2041                   (p_box->i_type>>16)&0xff,
2042                   (p_box->i_type>>24)&0xff );
2043         return( 1 );
2044     }
2045     else
2046     {
2047         i_result = 
2048            (MP4_Box_Function[i_index].MP4_ReadBox_function)( p_stream, p_box );
2049     }
2050
2051     if( !MP4_GotoBox( p_stream, p_box ) )
2052     {
2053         return( 0 );
2054     }
2055     return( i_result );
2056 }
2057 #if 0
2058 /*****************************************************************************
2059  * MP4_CountBox: given a box, count how many child have the requested type 
2060  * FIXME : support GUUID 
2061  *****************************************************************************/
2062 int MP4_CountBox( MP4_Box_t *p_box, uint32_t i_type )
2063 {
2064     unsigned int i_count;
2065     MP4_Box_t *p_child;
2066     
2067     if( !p_box )
2068     {
2069         return( 0 );
2070     }
2071
2072     i_count = 0;
2073     p_child = p_box->p_first;
2074     while( p_child )
2075     {
2076         if( p_child->i_type == i_type )
2077         {   
2078             i_count++;
2079         }
2080         p_child = p_child->p_next;
2081     }
2082     
2083     return( i_count );
2084 }
2085 #endif
2086
2087 /*****************************************************************************
2088  * MP4_FindBox:  find first box with i_type child of p_box
2089  *      return NULL if not found
2090  *****************************************************************************/
2091
2092 MP4_Box_t *MP4_FindBox( MP4_Box_t *p_box, uint32_t i_type )
2093 {
2094     MP4_Box_t *p_child;
2095     
2096     if( !p_box )
2097     {
2098         return( NULL );
2099     }
2100
2101     p_child = p_box->p_first;
2102     while( p_child )
2103     {
2104         if( p_child->i_type == i_type )
2105         {   
2106             return( p_child );
2107         }
2108         p_child = p_child->p_next;
2109     }
2110     
2111     return( NULL );
2112 }
2113
2114
2115 #if 0
2116 /*****************************************************************************
2117  * MP4_FindNextBox:  find next box with thesame type and at the same level 
2118  *                  than p_box
2119  *****************************************************************************/
2120 MP4_Box_t *MP4_FindNextBox( MP4_Box_t *p_box )
2121 {
2122     MP4_Box_t *p_next;
2123     
2124     if( !p_box )
2125     {
2126         return( NULL );
2127     }
2128
2129     p_next = p_box->p_next;
2130     while( p_next )
2131     {
2132         if( p_next->i_type == p_box->i_type )
2133         {
2134             return( p_next );
2135         }
2136         p_next = p_next->p_next;
2137     }
2138     return( NULL );
2139 }
2140 /*****************************************************************************
2141  * MP4_FindNbBox:  find the box i_number
2142  *****************************************************************************/
2143 MP4_Box_t *MP4_FindNbBox( MP4_Box_t *p_box, uint32_t i_number )
2144 {
2145     MP4_Box_t *p_child = p_box->p_first;
2146     
2147     if( !p_child )
2148     {
2149         return( NULL );
2150     }
2151
2152     while( i_number )
2153     {
2154         if( !( p_child = p_child->p_next ) )
2155         {
2156             return( NULL );
2157         }
2158         i_number--;
2159     }
2160     return( p_child );
2161 }
2162 #endif
2163
2164 /*****************************************************************************
2165  * MP4_FreeBox : free memory after read with MP4_ReadBox and all 
2166  * the children
2167  *****************************************************************************/
2168 void MP4_BoxFree( input_thread_t *p_input, MP4_Box_t *p_box )
2169 {
2170     unsigned int i_index;
2171
2172     MP4_Box_t *p_child;
2173     MP4_Box_t *p_next;
2174
2175     if( !p_box )
2176     {
2177         return; /* hehe */
2178     }
2179     p_child = p_box->p_first;
2180     while( p_child )
2181     {
2182         p_next = p_child->p_next;
2183         MP4_BoxFree( p_input, p_child );
2184         /* MP4_FreeBoxChildren have free all data expect p_child itself */
2185         free( p_child );
2186         p_child = p_next; 
2187     }
2188
2189     /* Now search function to call */
2190     if( p_box->data.p_data )
2191     {
2192         for( i_index = 0; ; i_index++ )
2193         {
2194             if( ( MP4_Box_Function[i_index].i_type == p_box->i_type )||
2195                 ( MP4_Box_Function[i_index].i_type == 0 ) )
2196             {
2197                 break;
2198             }
2199         }
2200         if( MP4_Box_Function[i_index].MP4_FreeBox_function == NULL )
2201         {
2202             /* Should not happen */
2203             msg_Warn( p_input, 
2204                       "cannot free box %c%c%c%c, type unknown",
2205                       (p_box->i_type)&0xff,
2206                       (p_box->i_type >> 8)&0xff, 
2207                       (p_box->i_type >> 16)&0xff, 
2208                       (p_box->i_type >> 24)&0xff );
2209         }
2210         else
2211         {
2212             MP4_Box_Function[i_index].MP4_FreeBox_function( p_input, p_box );
2213         }
2214
2215         free( p_box->data.p_data );
2216         p_box->data.p_data = NULL;
2217     }
2218
2219     p_box->p_first = NULL;
2220     p_box->p_last = NULL;
2221     
2222 }
2223
2224 /*****************************************************************************
2225  * MP4_BoxGetRoot : Parse the entire file, and create all boxes in memory
2226  *****************************************************************************
2227  *  The first box is a virtual box "root" and is the father for all first 
2228  *  level boxes for the file, a sort of virtual contener
2229  *****************************************************************************/
2230 int MP4_BoxGetRoot( input_thread_t *p_input, MP4_Box_t *p_root )
2231 {
2232     
2233     MP4_Stream_t *p_stream;
2234     int i_result;
2235     
2236     MP4_SeekAbsolute( p_input, 0 );     /* Go to the begining */
2237     p_root->i_pos = 0;
2238     p_root->i_type = VLC_FOURCC( 'r', 'o', 'o', 't' );
2239     p_root->i_shortsize = 1;
2240     p_root->i_size = p_input->stream.p_selected_area->i_size;
2241     CreateUUID( &p_root->i_uuid, p_root->i_type );
2242
2243     p_root->data.p_data = NULL;
2244     p_root->p_father = NULL;
2245     p_root->p_first  = NULL;
2246     p_root->p_last  = NULL;
2247     p_root->p_next   = NULL;
2248     
2249     p_stream = MP4_InputStream( p_input );
2250     
2251     i_result = MP4_ReadBoxContainerRaw( p_stream, p_root );
2252
2253     free( p_stream );
2254     
2255     if( i_result )
2256     {
2257         MP4_Box_t *p_child; 
2258         MP4_Box_t *p_moov;
2259         MP4_Box_t *p_cmov;
2260
2261         /* check if there is a cmov, if so replace 
2262           compressed moov by  uncompressed one */
2263         if( ( p_moov = MP4_FindBox( p_root, FOURCC_moov ) )&&
2264             ( p_cmov = MP4_FindBox( p_moov, FOURCC_cmov ) ) )
2265         {
2266             /* rename the compressed moov as a box to skip */
2267             p_moov->i_type = FOURCC_skip;
2268                 
2269             /* get uncompressed p_moov */
2270             p_moov = p_cmov->data.p_cmov->p_moov;
2271             p_cmov->data.p_cmov->p_moov = NULL;
2272
2273             /* make p_root father of this new moov */
2274             p_moov->p_father = p_root;
2275
2276             /* insert this new moov box as first child of p_root */
2277             p_moov->p_next = p_child = p_root->p_first;
2278             p_root->p_first = p_moov;
2279         }
2280     }
2281     return( i_result );
2282 }
2283
2284
2285 static void __MP4_BoxDumpStructure( input_thread_t *p_input,
2286                                     MP4_Box_t *p_box, unsigned int i_level )
2287 {
2288     MP4_Box_t *p_child;
2289
2290     if( !i_level )
2291     {
2292         msg_Dbg( p_input, "Dumping root Box \"%c%c%c%c \"",
2293                           (p_box->i_type ) &0xff,
2294                           (p_box->i_type >>8 ) &0xff,
2295                           (p_box->i_type >>16 ) &0xff,
2296                           (p_box->i_type >>24) &0xff );
2297     }
2298     else
2299     {
2300         char str[512];
2301         unsigned int i;
2302         memset( str, (uint8_t)' ', 512 );
2303         for( i = 0; i < i_level; i++ )
2304         {
2305             str[i*5] = '|';
2306         }
2307         sprintf( str + i_level * 5, "+ %c%c%c%c size %d",
2308                       (p_box->i_type ) &0xff,
2309                       (p_box->i_type>>8 ) &0xff,
2310                       (p_box->i_type>>16 ) &0xff,
2311                       (p_box->i_type>>24 ) &0xff,
2312                       (uint32_t)p_box->i_size );
2313         
2314         msg_Dbg( p_input, "%s", str );
2315     }
2316     p_child = p_box->p_first;
2317     while( p_child )
2318     {
2319         __MP4_BoxDumpStructure( p_input, p_child, i_level + 1 );
2320         p_child = p_child->p_next;
2321     }
2322     
2323 }
2324
2325 void MP4_BoxDumpStructure( input_thread_t *p_input, MP4_Box_t *p_box )
2326 {
2327     __MP4_BoxDumpStructure( p_input, p_box, 0 );
2328 }
2329
2330
2331
2332 /*****************************************************************************
2333  *****************************************************************************
2334  **
2335  **  High level methods to acces an MP4 file
2336  **
2337  *****************************************************************************
2338  *****************************************************************************/
2339 static void __get_token( char **ppsz_path, char **ppsz_token, int *pi_number )
2340 {
2341     size_t i_len ;
2342     if( !*ppsz_path[0] )
2343     {
2344         *ppsz_token = NULL;
2345         *pi_number = 0;
2346         return;
2347     }
2348     i_len = 0;
2349     while(  (*ppsz_path)[i_len] && 
2350             (*ppsz_path)[i_len] != '/' && (*ppsz_path)[i_len] != '[' )
2351     {
2352         i_len++;
2353     }
2354     if( !i_len && **ppsz_path == '/' )
2355     {
2356         i_len = 1;
2357     }
2358     *ppsz_token = malloc( i_len + 1 );
2359         
2360     memcpy( *ppsz_token, *ppsz_path, i_len );
2361
2362     (*ppsz_token)[i_len] = '\0';
2363
2364     *ppsz_path += i_len;
2365         
2366     if( **ppsz_path == '[' )
2367     {
2368         (*ppsz_path)++;
2369         *pi_number = strtol( *ppsz_path, NULL, 10 );
2370         while( **ppsz_path && **ppsz_path != ']' )
2371         {
2372             (*ppsz_path)++;
2373         }
2374         if( **ppsz_path == ']' )
2375         {
2376             (*ppsz_path)++;
2377         }
2378     }
2379     else
2380     {
2381         *pi_number = 0;
2382     }
2383     while( **ppsz_path == '/' )
2384     {
2385         (*ppsz_path)++;
2386     }
2387 }
2388
2389 static void __MP4_BoxGet( MP4_Box_t **pp_result,
2390                           MP4_Box_t *p_box, char *psz_fmt, va_list args)
2391 {
2392     char    *psz_path;
2393 #if !defined(HAVE_VASPRINTF) || defined(SYS_DARWIN)
2394     size_t  i_size;
2395 #endif
2396
2397     
2398     if( !p_box )
2399     {
2400         *pp_result = NULL;
2401         return;
2402     }
2403
2404 #if defined(HAVE_VASPRINTF) && !defined(SYS_DARWIN)
2405     vasprintf( &psz_path, psz_fmt, args );
2406 #else
2407     i_size = strlen( psz_fmt ) + 1024;
2408     psz_path = calloc( i_size, sizeof( char ) );
2409     vsnprintf( psz_path, i_size, psz_fmt, args );
2410     psz_path[i_size - 1] = 0;
2411 #endif
2412
2413     if( !psz_path || !psz_path[0] )
2414     {
2415         FREE( psz_path );
2416         *pp_result = NULL;
2417         return;
2418     }
2419
2420 //    fprintf( stderr, "path:'%s'\n", psz_path );
2421     psz_fmt = psz_path; /* keep this pointer, as it need to be unallocated */
2422     for( ; ; )
2423     {
2424         char *psz_token;
2425         int i_number;
2426
2427         __get_token( &psz_path, &psz_token, &i_number );
2428 //        fprintf( stderr, "path:'%s', token:'%s' n:%d\n", 
2429 //                 psz_path,psz_token,i_number );
2430         if( !psz_token )
2431         {
2432             FREE( psz_token );
2433             free( psz_fmt );
2434             *pp_result = p_box;
2435             return;
2436         }
2437         else
2438         if( !strcmp( psz_token, "/" ) )
2439         {
2440             /* Find root box */
2441             while( p_box && p_box->i_type != VLC_FOURCC( 'r', 'o', 'o', 't' ) )
2442             {
2443                 p_box = p_box->p_father;
2444             }
2445             if( !p_box )
2446             {
2447                 free( psz_token );
2448                 free( psz_fmt );
2449                 *pp_result = NULL;
2450                 return;
2451             }
2452         }
2453         else
2454         if( !strcmp( psz_token, "." ) )
2455         {
2456             /* Do nothing */
2457         }
2458         else
2459         if( !strcmp( psz_token, ".." ) )
2460         {
2461             p_box = p_box->p_father;
2462             if( !p_box )
2463             {
2464                 free( psz_token );
2465                 free( psz_fmt );
2466                 *pp_result = NULL;
2467                 return;
2468             }
2469         }
2470         else
2471         if( strlen( psz_token ) == 4 )
2472         {
2473             uint32_t i_fourcc;
2474             i_fourcc = VLC_FOURCC( psz_token[0], psz_token[1],
2475                                    psz_token[2], psz_token[3] );
2476             p_box = p_box->p_first;
2477             for( ; ; )
2478             {
2479                 if( !p_box )
2480                 {
2481                     free( psz_token );
2482                     free( psz_fmt );
2483                     *pp_result = NULL;
2484                     return;
2485                 }
2486                 if( p_box->i_type == i_fourcc )
2487                 {
2488                     if( !i_number )
2489                     {
2490                         break;
2491                     }
2492                     i_number--;
2493                 }
2494                 p_box = p_box->p_next;
2495             }
2496         }
2497         else
2498         if( strlen( psz_token ) == 0 )
2499         {
2500             p_box = p_box->p_first;
2501             for( ; ; )
2502             {
2503                 if( !p_box )
2504                 {
2505                     free( psz_token );
2506                     free( psz_fmt );
2507                     *pp_result = NULL;
2508                     return;
2509                 }
2510                 if( !i_number )
2511                 {
2512                     break;
2513                 }
2514                 i_number--;
2515                 p_box = p_box->p_next;
2516             }
2517         }
2518         else
2519         {
2520 //            fprintf( stderr, "Argg malformed token \"%s\"",psz_token );
2521             FREE( psz_token );
2522             free( psz_fmt );
2523             *pp_result = NULL;
2524             return;
2525         }
2526         
2527         free( psz_token );
2528     }
2529     
2530 }
2531
2532 /*****************************************************************************
2533  * MP4_BoxGet: find a box given a path relative to p_box
2534  *****************************************************************************
2535  * Path Format: . .. / as usual
2536  *              [number] to specifie box number ex: trak[12]
2537  *              
2538  * ex: /moov/trak[12]
2539  *     ../mdia
2540  *****************************************************************************/
2541 MP4_Box_t *MP4_BoxGet( MP4_Box_t *p_box, char *psz_fmt, ... )
2542 {
2543     va_list args;
2544     MP4_Box_t *p_result;
2545
2546     va_start( args, psz_fmt ); 
2547     __MP4_BoxGet( &p_result, p_box, psz_fmt, args );
2548     va_end( args );
2549
2550     return( p_result );
2551 }
2552
2553 /*****************************************************************************
2554  * MP4_BoxCount: count box given a path relative to p_box
2555  *****************************************************************************
2556  * Path Format: . .. / as usual
2557  *              [number] to specifie box number ex: trak[12]
2558  *              
2559  * ex: /moov/trak[12]
2560  *     ../mdia
2561  *****************************************************************************/
2562 int MP4_BoxCount( MP4_Box_t *p_box, char *psz_fmt, ... )
2563 {
2564     va_list args;
2565     int     i_count;
2566     MP4_Box_t *p_result, *p_next;
2567
2568     va_start( args, psz_fmt ); 
2569     __MP4_BoxGet( &p_result, p_box, psz_fmt, args );
2570     va_end( args );
2571     if( !p_result )
2572     {
2573         return( 0 );
2574     }
2575     
2576     i_count = 1;
2577     for( p_next = p_result->p_next; p_next != NULL; p_next = p_next->p_next)
2578     {
2579         if( p_next->i_type == p_result->i_type)
2580         {
2581             i_count++;
2582         }
2583     }
2584     return( i_count );
2585 }
2586