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