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