git.sesse.net Git - vlc/blob - modules/demux/mp4/libmp4.c

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