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 = calloc( 1, 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 off_t i_box_end = p_box->i_size + p_box->i_pos;
 261         const off_t 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_READBOX_EXIT( 0 );
 804     }
 805
 806     for( i = 0; (i < p_box->data.p_stts->i_entry_count )&&( i_read >=8 ); i++ )
 807     {
 808         MP4_GET4BYTES( p_box->data.p_stts->i_sample_count[i] );
 809         MP4_GET4BYTES( p_box->data.p_stts->i_sample_delta[i] );
 810     }
 811
 812 #ifdef MP4_VERBOSE
 813     msg_Dbg( p_stream, "read box: \"stts\" entry-count %d",
 814                       p_box->data.p_stts->i_entry_count );
 815
 816 #endif
 817     MP4_READBOX_EXIT( 1 );
 818 }
 819
 820
 821 static void MP4_FreeBox_ctts( MP4_Box_t *p_box )
 822 {
 823     FREENULL( p_box->data.p_ctts->i_sample_count );
 824     FREENULL( p_box->data.p_ctts->i_sample_offset );
 825 }
 826
 827 static int MP4_ReadBox_ctts( stream_t *p_stream, MP4_Box_t *p_box )
 828 {
 829     unsigned int i;
 830     MP4_READBOX_ENTER( MP4_Box_data_ctts_t );
 831
 832     MP4_GETVERSIONFLAGS( p_box->data.p_ctts );
 833
 834     MP4_GET4BYTES( p_box->data.p_ctts->i_entry_count );
 835
 836     p_box->data.p_ctts->i_sample_count =
 837         calloc( p_box->data.p_ctts->i_entry_count, sizeof(uint32_t) );
 838     p_box->data.p_ctts->i_sample_offset =
 839         calloc( p_box->data.p_ctts->i_entry_count, sizeof(uint32_t) );
 840     if( ( p_box->data.p_ctts->i_sample_count == NULL )
 841      || ( p_box->data.p_ctts->i_sample_offset == NULL ) )
 842     {
 843         MP4_READBOX_EXIT( 0 );
 844     }
 845
 846     for( i = 0; (i < p_box->data.p_ctts->i_entry_count )&&( i_read >=8 ); i++ )
 847     {
 848         MP4_GET4BYTES( p_box->data.p_ctts->i_sample_count[i] );
 849         MP4_GET4BYTES( p_box->data.p_ctts->i_sample_offset[i] );
 850     }
 851
 852 #ifdef MP4_VERBOSE
 853     msg_Dbg( p_stream, "read box: \"ctts\" entry-count %d",
 854                       p_box->data.p_ctts->i_entry_count );
 855
 856 #endif
 857     MP4_READBOX_EXIT( 1 );
 858 }
 859
 860
 861 static int MP4_ReadLengthDescriptor( uint8_t **pp_peek, int64_t  *i_read )
 862 {
 863     unsigned int i_b;
 864     unsigned int i_len = 0;
 865     do
 866     {
 867         i_b = **pp_peek;
 868
 869         (*pp_peek)++;
 870         (*i_read)--;
 871         i_len = ( i_len << 7 ) + ( i_b&0x7f );
 872     } while( i_b&0x80 );
 873     return( i_len );
 874 }
 875
 876
 877 static void MP4_FreeBox_esds( MP4_Box_t *p_box )
 878 {
 879     FREENULL( p_box->data.p_esds->es_descriptor.psz_URL );
 880     if( p_box->data.p_esds->es_descriptor.p_decConfigDescr )
 881     {
 882         FREENULL( p_box->data.p_esds->es_descriptor.p_decConfigDescr->p_decoder_specific_info );
 883         FREENULL( p_box->data.p_esds->es_descriptor.p_decConfigDescr );
 884     }
 885 }
 886
 887 static int MP4_ReadBox_esds( stream_t *p_stream, MP4_Box_t *p_box )
 888 {
 889 #define es_descriptor p_box->data.p_esds->es_descriptor
 890     unsigned int i_len;
 891     unsigned int i_flags;
 892     unsigned int i_type;
 893
 894     MP4_READBOX_ENTER( MP4_Box_data_esds_t );
 895
 896     MP4_GETVERSIONFLAGS( p_box->data.p_esds );
 897
 898
 899     MP4_GET1BYTE( i_type );
 900     if( i_type == 0x03 ) /* MP4ESDescrTag */
 901     {
 902         i_len = MP4_ReadLengthDescriptor( &p_peek, &i_read );
 903
 904 #ifdef MP4_VERBOSE
 905         msg_Dbg( p_stream, "found esds MPEG4ESDescr (%dBytes)",
 906                  i_len );
 907 #endif
 908
 909         MP4_GET2BYTES( es_descriptor.i_ES_ID );
 910         MP4_GET1BYTE( i_flags );
 911         es_descriptor.b_stream_dependence = ( (i_flags&0x80) != 0);
 912         es_descriptor.b_url = ( (i_flags&0x40) != 0);
 913         es_descriptor.b_OCRstream = ( (i_flags&0x20) != 0);
 914
 915         es_descriptor.i_stream_priority = i_flags&0x1f;
 916         if( es_descriptor.b_stream_dependence )
 917         {
 918             MP4_GET2BYTES( es_descriptor.i_depend_on_ES_ID );
 919         }
 920         if( es_descriptor.b_url )
 921         {
 922             unsigned int i_len;
 923
 924             MP4_GET1BYTE( i_len );
 925             es_descriptor.psz_URL = malloc( i_len + 1 );
 926             if( es_descriptor.psz_URL )
 927             {
 928                 memcpy( es_descriptor.psz_URL, p_peek, i_len );
 929                 es_descriptor.psz_URL[i_len] = 0;
 930             }
 931             p_peek += i_len;
 932             i_read -= i_len;
 933         }
 934         else
 935         {
 936             es_descriptor.psz_URL = NULL;
 937         }
 938         if( es_descriptor.b_OCRstream )
 939         {
 940             MP4_GET2BYTES( es_descriptor.i_OCR_ES_ID );
 941         }
 942         MP4_GET1BYTE( i_type ); /* get next type */
 943     }
 944
 945     if( i_type != 0x04)/* MP4DecConfigDescrTag */
 946     {
 947          es_descriptor.p_decConfigDescr = NULL;
 948          MP4_READBOX_EXIT( 1 ); /* rest isn't interesting up to now */
 949     }
 950
 951     i_len = MP4_ReadLengthDescriptor( &p_peek, &i_read );
 952
 953 #ifdef MP4_VERBOSE
 954         msg_Dbg( p_stream, "found esds MP4DecConfigDescr (%dBytes)",
 955                  i_len );
 956 #endif
 957
 958     es_descriptor.p_decConfigDescr =
 959             calloc( 1, sizeof( MP4_descriptor_decoder_config_t ));
 960     if( es_descriptor.p_decConfigDescr == NULL )
 961         MP4_READBOX_EXIT( 0 );
 962
 963     MP4_GET1BYTE( es_descriptor.p_decConfigDescr->i_objectTypeIndication );
 964     MP4_GET1BYTE( i_flags );
 965     es_descriptor.p_decConfigDescr->i_streamType = i_flags >> 2;
 966     es_descriptor.p_decConfigDescr->b_upStream = ( i_flags >> 1 )&0x01;
 967     MP4_GET3BYTES( es_descriptor.p_decConfigDescr->i_buffer_sizeDB );
 968     MP4_GET4BYTES( es_descriptor.p_decConfigDescr->i_max_bitrate );
 969     MP4_GET4BYTES( es_descriptor.p_decConfigDescr->i_avg_bitrate );
 970     MP4_GET1BYTE( i_type );
 971     if( i_type !=  0x05 )/* MP4DecSpecificDescrTag */
 972     {
 973         es_descriptor.p_decConfigDescr->i_decoder_specific_info_len = 0;
 974         es_descriptor.p_decConfigDescr->p_decoder_specific_info  = NULL;
 975         MP4_READBOX_EXIT( 1 );
 976     }
 977
 978     i_len = MP4_ReadLengthDescriptor( &p_peek, &i_read );
 979
 980 #ifdef MP4_VERBOSE
 981         msg_Dbg( p_stream, "found esds MP4DecSpecificDescr (%dBytes)",
 982                  i_len );
 983 #endif
 984     if( i_len > i_read )
 985         MP4_READBOX_EXIT( 0 );
 986
 987     es_descriptor.p_decConfigDescr->i_decoder_specific_info_len = i_len;
 988     es_descriptor.p_decConfigDescr->p_decoder_specific_info = malloc( i_len );
 989     if( es_descriptor.p_decConfigDescr->p_decoder_specific_info == NULL )
 990         MP4_READBOX_EXIT( 0 );
 991
 992     memcpy( es_descriptor.p_decConfigDescr->p_decoder_specific_info,
 993             p_peek, i_len );
 994
 995     MP4_READBOX_EXIT( 1 );
 996 #undef es_descriptor
 997 }
 998
 999 static void MP4_FreeBox_avcC( MP4_Box_t *p_box )
1000 {
1001     MP4_Box_data_avcC_t *p_avcC = p_box->data.p_avcC;
1002     int i;
1003
1004     if( p_avcC->i_avcC > 0 ) FREENULL( p_avcC->p_avcC );
1005
1006     if( p_avcC->sps )
1007     {
1008         for( i = 0; i < p_avcC->i_sps; i++ )
1009             FREENULL( p_avcC->sps[i] );
1010     }
1011     if( p_avcC->pps )
1012     {
1013         for( i = 0; i < p_avcC->i_pps; i++ )
1014             FREENULL( p_avcC->pps[i] );
1015     }
1016     if( p_avcC->i_sps > 0 ) FREENULL( p_avcC->sps );
1017     if( p_avcC->i_sps > 0 ) FREENULL( p_avcC->i_sps_length );
1018     if( p_avcC->i_pps > 0 ) FREENULL( p_avcC->pps );
1019     if( p_avcC->i_pps > 0 ) FREENULL( p_avcC->i_pps_length );
1020 }
1021
1022 static int MP4_ReadBox_avcC( stream_t *p_stream, MP4_Box_t *p_box )
1023 {
1024     MP4_Box_data_avcC_t *p_avcC;
1025     int i;
1026
1027     MP4_READBOX_ENTER( MP4_Box_data_avcC_t );
1028     p_avcC = p_box->data.p_avcC;
1029
1030     p_avcC->i_avcC = i_read;
1031     if( p_avcC->i_avcC > 0 )
1032     {
1033         uint8_t * p = p_avcC->p_avcC = malloc( p_avcC->i_avcC );
1034         if( p )
1035             memcpy( p, p_peek, i_read );
1036     }
1037
1038     MP4_GET1BYTE( p_avcC->i_version );
1039     MP4_GET1BYTE( p_avcC->i_profile );
1040     MP4_GET1BYTE( p_avcC->i_profile_compatibility );
1041     MP4_GET1BYTE( p_avcC->i_level );
1042     MP4_GET1BYTE( p_avcC->i_reserved1 );
1043     p_avcC->i_length_size = (p_avcC->i_reserved1&0x03) + 1;
1044     p_avcC->i_reserved1 >>= 2;
1045
1046     MP4_GET1BYTE( p_avcC->i_reserved2 );
1047     p_avcC->i_sps = p_avcC->i_reserved2&0x1f;
1048     p_avcC->i_reserved2 >>= 5;
1049
1050     if( p_avcC->i_sps > 0 )
1051     {
1052         p_avcC->i_sps_length = calloc( p_avcC->i_sps, sizeof( uint16_t ) );
1053         p_avcC->sps = calloc( p_avcC->i_sps, sizeof( uint8_t* ) );
1054
1055         if( !p_avcC->i_sps_length || !p_avcC->sps )
1056             goto error;
1057
1058         for( i = 0; i < p_avcC->i_sps; i++ )
1059         {
1060             MP4_GET2BYTES( p_avcC->i_sps_length[i] );
1061             p_avcC->sps[i] = malloc( p_avcC->i_sps_length[i] );
1062             if( p_avcC->sps[i] )
1063                 memcpy( p_avcC->sps[i], p_peek, p_avcC->i_sps_length[i] );
1064
1065             p_peek += p_avcC->i_sps_length[i];
1066             i_read -= p_avcC->i_sps_length[i];
1067         }
1068     }
1069
1070     MP4_GET1BYTE( p_avcC->i_pps );
1071     if( p_avcC->i_pps > 0 )
1072     {
1073         p_avcC->i_pps_length = calloc( p_avcC->i_pps, sizeof( uint16_t ) );
1074         p_avcC->pps = calloc( p_avcC->i_pps, sizeof( uint8_t* ) );
1075
1076         if( !p_avcC->i_pps_length || !p_avcC->pps )
1077             goto error;
1078
1079         for( i = 0; i < p_avcC->i_pps; i++ )
1080         {
1081             MP4_GET2BYTES( p_avcC->i_pps_length[i] );
1082             p_avcC->pps[i] = malloc( p_avcC->i_pps_length[i] );
1083             if( p_avcC->pps[i] )
1084                 memcpy( p_avcC->pps[i], p_peek, p_avcC->i_pps_length[i] );
1085
1086             p_peek += p_avcC->i_pps_length[i];
1087             i_read -= p_avcC->i_pps_length[i];
1088         }
1089     }
1090 #ifdef MP4_VERBOSE
1091     msg_Dbg( p_stream,
1092              "read box: \"avcC\" version=%d profile=0x%x level=0x%x length size=%d sps=%d pps=%d",
1093              p_avcC->i_version, p_avcC->i_profile, p_avcC->i_level,
1094              p_avcC->i_length_size,
1095              p_avcC->i_sps, p_avcC->i_pps );
1096     for( i = 0; i < p_avcC->i_sps; i++ )
1097     {
1098         msg_Dbg( p_stream, "         - sps[%d] length=%d",
1099                  i, p_avcC->i_sps_length[i] );
1100     }
1101     for( i = 0; i < p_avcC->i_pps; i++ )
1102     {
1103         msg_Dbg( p_stream, "         - pps[%d] length=%d",
1104                  i, p_avcC->i_pps_length[i] );
1105     }
1106
1107 #endif
1108     MP4_READBOX_EXIT( 1 );
1109
1110 error:
1111     MP4_READBOX_EXIT( 0 );
1112 }
1113
1114 static int MP4_ReadBox_dac3( stream_t *p_stream, MP4_Box_t *p_box )
1115 {
1116     MP4_Box_data_dac3_t *p_dac3;
1117     MP4_READBOX_ENTER( MP4_Box_data_dac3_t );
1118
1119     p_dac3 = p_box->data.p_dac3;
1120
1121     unsigned i_header;
1122     MP4_GET3BYTES( i_header );
1123
1124     p_dac3->i_fscod = ( i_header >> 22 ) & 0x03;
1125     p_dac3->i_bsid  = ( i_header >> 17 ) & 0x01f;
1126     p_dac3->i_bsmod = ( i_header >> 14 ) & 0x07;
1127     p_dac3->i_acmod = ( i_header >> 11 ) & 0x07;
1128     p_dac3->i_lfeon = ( i_header >> 10 ) & 0x01;
1129     p_dac3->i_bitrate_code = ( i_header >> 5) & 0x1f;
1130
1131 #ifdef MP4_VERBOSE
1132     msg_Dbg( p_stream,
1133              "read box: \"dac3\" fscod=0x%x bsid=0x%x bsmod=0x%x acmod=0x%x lfeon=0x%x bitrate_code=0x%x",
1134              p_dac3->i_fscod, p_dac3->i_bsid, p_dac3->i_bsmod, p_dac3->i_acmod, p_dac3->i_lfeon, p_dac3->i_bitrate_code );
1135 #endif
1136     MP4_READBOX_EXIT( 1 );
1137 }
1138
1139 static int MP4_ReadBox_enda( stream_t *p_stream, MP4_Box_t *p_box )
1140 {
1141     MP4_Box_data_enda_t *p_enda;
1142     MP4_READBOX_ENTER( MP4_Box_data_enda_t );
1143
1144     p_enda = p_box->data.p_enda;
1145
1146     MP4_GET2BYTES( p_enda->i_little_endian );
1147
1148 #ifdef MP4_VERBOSE
1149     msg_Dbg( p_stream,
1150              "read box: \"enda\" little_endian=%d", p_enda->i_little_endian );
1151 #endif
1152     MP4_READBOX_EXIT( 1 );
1153 }
1154
1155 static int MP4_ReadBox_sample_soun( stream_t *p_stream, MP4_Box_t *p_box )
1156 {
1157     unsigned int i;
1158
1159     MP4_READBOX_ENTER( MP4_Box_data_sample_soun_t );
1160     p_box->data.p_sample_soun->p_qt_description = NULL;
1161
1162     /* Sanity check needed because the "wave" box does also contain an
1163      * "mp4a" box that we don't understand. */
1164     if( i_read < 28 )
1165     {
1166         i_read -= 30;
1167         MP4_READBOX_EXIT( 1 );
1168     }
1169
1170     for( i = 0; i < 6 ; i++ )
1171     {
1172         MP4_GET1BYTE( p_box->data.p_sample_soun->i_reserved1[i] );
1173     }
1174
1175     MP4_GET2BYTES( p_box->data.p_sample_soun->i_data_reference_index );
1176
1177     /*
1178      * XXX hack -> produce a copy of the nearly complete chunk
1179      */
1180     p_box->data.p_sample_soun->i_qt_description = 0;
1181     p_box->data.p_sample_soun->p_qt_description = NULL;
1182     if( i_read > 0 )
1183     {
1184         p_box->data.p_sample_soun->p_qt_description = malloc( i_read );
1185         if( p_box->data.p_sample_soun->p_qt_description )
1186         {
1187             p_box->data.p_sample_soun->i_qt_description = i_read;
1188             memcpy( p_box->data.p_sample_soun->p_qt_description, p_peek, i_read );
1189         }
1190     }
1191
1192     MP4_GET2BYTES( p_box->data.p_sample_soun->i_qt_version );
1193     MP4_GET2BYTES( p_box->data.p_sample_soun->i_qt_revision_level );
1194     MP4_GET4BYTES( p_box->data.p_sample_soun->i_qt_vendor );
1195
1196     MP4_GET2BYTES( p_box->data.p_sample_soun->i_channelcount );
1197     MP4_GET2BYTES( p_box->data.p_sample_soun->i_samplesize );
1198     MP4_GET2BYTES( p_box->data.p_sample_soun->i_predefined );
1199     MP4_GET2BYTES( p_box->data.p_sample_soun->i_reserved3 );
1200     MP4_GET2BYTES( p_box->data.p_sample_soun->i_sampleratehi );
1201     MP4_GET2BYTES( p_box->data.p_sample_soun->i_sampleratelo );
1202
1203     if( p_box->data.p_sample_soun->i_qt_version == 1 && i_read >= 16 )
1204     {
1205         /* SoundDescriptionV1 */
1206         MP4_GET4BYTES( p_box->data.p_sample_soun->i_sample_per_packet );
1207         MP4_GET4BYTES( p_box->data.p_sample_soun->i_bytes_per_packet );
1208         MP4_GET4BYTES( p_box->data.p_sample_soun->i_bytes_per_frame );
1209         MP4_GET4BYTES( p_box->data.p_sample_soun->i_bytes_per_sample );
1210
1211 #ifdef MP4_VERBOSE
1212         msg_Dbg( p_stream,
1213                  "read box: \"soun\" qt3+ sample/packet=%d bytes/packet=%d "
1214                  "bytes/frame=%d bytes/sample=%d",
1215                  p_box->data.p_sample_soun->i_sample_per_packet,
1216                  p_box->data.p_sample_soun->i_bytes_per_packet,
1217                  p_box->data.p_sample_soun->i_bytes_per_frame,
1218                  p_box->data.p_sample_soun->i_bytes_per_sample );
1219 #endif
1220         stream_Seek( p_stream, p_box->i_pos +
1221                         MP4_BOX_HEADERSIZE( p_box ) + 44 );
1222     }
1223     else if( p_box->data.p_sample_soun->i_qt_version == 2 && i_read >= 36 )
1224     {
1225         /* SoundDescriptionV2 */
1226         double f_sample_rate;
1227         int64_t dummy;
1228         uint32_t i_channel;
1229
1230         MP4_GET4BYTES( p_box->data.p_sample_soun->i_sample_per_packet );
1231         MP4_GET8BYTES( dummy );
1232         memcpy( &f_sample_rate, &dummy, 8 );
1233
1234         msg_Dbg( p_stream, "read box: %f Hz", f_sample_rate );
1235         p_box->data.p_sample_soun->i_sampleratehi = (int)f_sample_rate % 65536;
1236         p_box->data.p_sample_soun->i_sampleratelo = f_sample_rate / 65536;
1237
1238         MP4_GET4BYTES( i_channel );
1239         p_box->data.p_sample_soun->i_channelcount = i_channel;
1240
1241 #ifdef MP4_VERBOSE
1242         msg_Dbg( p_stream, "read box: \"soun\" V2" );
1243 #endif
1244         stream_Seek( p_stream, p_box->i_pos +
1245                         MP4_BOX_HEADERSIZE( p_box ) + 28 + 36 );
1246     }
1247     else
1248     {
1249         p_box->data.p_sample_soun->i_sample_per_packet = 0;
1250         p_box->data.p_sample_soun->i_bytes_per_packet = 0;
1251         p_box->data.p_sample_soun->i_bytes_per_frame = 0;
1252         p_box->data.p_sample_soun->i_bytes_per_sample = 0;
1253
1254         msg_Dbg( p_stream, "read box: \"soun\" mp4 or qt1/2 (rest=%"PRId64")",
1255                  i_read );
1256         stream_Seek( p_stream, p_box->i_pos +
1257                         MP4_BOX_HEADERSIZE( p_box ) + 28 );
1258     }
1259
1260     if( p_box->i_type == FOURCC_drms )
1261     {
1262         char *home = config_GetUserDir( VLC_HOME_DIR );
1263         if( home != NULL )
1264         {
1265             p_box->data.p_sample_soun->p_drms = drms_alloc( home );
1266             if( p_box->data.p_sample_soun->p_drms == NULL )
1267                 msg_Err( p_stream, "drms_alloc() failed" );
1268         }
1269     }
1270
1271     if( p_box->i_type == FOURCC_samr || p_box->i_type == FOURCC_sawb )
1272     {
1273         /* Ignore channelcount for AMR (3gpp AMRSpecificBox) */
1274         p_box->data.p_sample_soun->i_channelcount = 1;
1275     }
1276
1277     MP4_ReadBoxContainerRaw( p_stream, p_box ); /* esds/wave/... */
1278
1279 #ifdef MP4_VERBOSE
1280     msg_Dbg( p_stream, "read box: \"soun\" in stsd channel %d "
1281              "sample size %d sample rate %f",
1282              p_box->data.p_sample_soun->i_channelcount,
1283              p_box->data.p_sample_soun->i_samplesize,
1284              (float)p_box->data.p_sample_soun->i_sampleratehi +
1285              (float)p_box->data.p_sample_soun->i_sampleratelo / 65536 );
1286
1287 #endif
1288     MP4_READBOX_EXIT( 1 );
1289 }
1290
1291
1292 static void MP4_FreeBox_sample_soun( MP4_Box_t *p_box )
1293 {
1294     FREENULL( p_box->data.p_sample_soun->p_qt_description );
1295
1296     if( p_box->i_type == FOURCC_drms )
1297     {
1298         if( p_box->data.p_sample_soun->p_drms )
1299         {
1300             drms_free( p_box->data.p_sample_soun->p_drms );
1301         }
1302     }
1303 }
1304
1305
1306 int MP4_ReadBox_sample_vide( stream_t *p_stream, MP4_Box_t *p_box )
1307 {
1308     unsigned int i;
1309
1310     MP4_READBOX_ENTER( MP4_Box_data_sample_vide_t );
1311
1312     for( i = 0; i < 6 ; i++ )
1313     {
1314         MP4_GET1BYTE( p_box->data.p_sample_vide->i_reserved1[i] );
1315     }
1316
1317     MP4_GET2BYTES( p_box->data.p_sample_vide->i_data_reference_index );
1318
1319     /*
1320      * XXX hack -> produce a copy of the nearly complete chunk
1321      */
1322     if( i_read > 0 )
1323     {
1324         p_box->data.p_sample_vide->p_qt_image_description = malloc( i_read );
1325         if( p_box->data.p_sample_vide->p_qt_image_description == NULL )
1326             MP4_READBOX_EXIT( 0 );
1327         p_box->data.p_sample_vide->i_qt_image_description = i_read;
1328         memcpy( p_box->data.p_sample_vide->p_qt_image_description,
1329                 p_peek, i_read );
1330     }
1331     else
1332     {
1333         p_box->data.p_sample_vide->i_qt_image_description = 0;
1334         p_box->data.p_sample_vide->p_qt_image_description = NULL;
1335     }
1336
1337     MP4_GET2BYTES( p_box->data.p_sample_vide->i_qt_version );
1338     MP4_GET2BYTES( p_box->data.p_sample_vide->i_qt_revision_level );
1339     MP4_GET4BYTES( p_box->data.p_sample_vide->i_qt_vendor );
1340
1341     MP4_GET4BYTES( p_box->data.p_sample_vide->i_qt_temporal_quality );
1342     MP4_GET4BYTES( p_box->data.p_sample_vide->i_qt_spatial_quality );
1343
1344     MP4_GET2BYTES( p_box->data.p_sample_vide->i_width );
1345     MP4_GET2BYTES( p_box->data.p_sample_vide->i_height );
1346
1347     MP4_GET4BYTES( p_box->data.p_sample_vide->i_horizresolution );
1348     MP4_GET4BYTES( p_box->data.p_sample_vide->i_vertresolution );
1349
1350     MP4_GET4BYTES( p_box->data.p_sample_vide->i_qt_data_size );
1351     MP4_GET2BYTES( p_box->data.p_sample_vide->i_qt_frame_count );
1352
1353     memcpy( &p_box->data.p_sample_vide->i_compressorname, p_peek, 32 );
1354     p_peek += 32; i_read -= 32;
1355
1356     MP4_GET2BYTES( p_box->data.p_sample_vide->i_depth );
1357     MP4_GET2BYTES( p_box->data.p_sample_vide->i_qt_color_table );
1358
1359     stream_Seek( p_stream, p_box->i_pos + MP4_BOX_HEADERSIZE( p_box ) + 78);
1360
1361     if( p_box->i_type == FOURCC_drmi )
1362     {
1363         char *home = config_GetUserDir( VLC_HOME_DIR );
1364         if( home != NULL )
1365         {
1366             p_box->data.p_sample_vide->p_drms = drms_alloc( home );
1367             if( p_box->data.p_sample_vide->p_drms == NULL )
1368                 msg_Err( p_stream, "drms_alloc() failed" );
1369         }
1370     }
1371
1372     MP4_ReadBoxContainerRaw( p_stream, p_box );
1373
1374 #ifdef MP4_VERBOSE
1375     msg_Dbg( p_stream, "read box: \"vide\" in stsd %dx%d depth %d",
1376                       p_box->data.p_sample_vide->i_width,
1377                       p_box->data.p_sample_vide->i_height,
1378                       p_box->data.p_sample_vide->i_depth );
1379
1380 #endif
1381     MP4_READBOX_EXIT( 1 );
1382 }
1383
1384
1385 void MP4_FreeBox_sample_vide( MP4_Box_t *p_box )
1386 {
1387     FREENULL( p_box->data.p_sample_vide->p_qt_image_description );
1388
1389     if( p_box->i_type == FOURCC_drmi )
1390     {
1391         if( p_box->data.p_sample_vide->p_drms )
1392         {
1393             drms_free( p_box->data.p_sample_vide->p_drms );
1394         }
1395     }
1396 }
1397
1398 static int MP4_ReadBox_sample_mp4s( stream_t *p_stream, MP4_Box_t *p_box )
1399 {
1400     stream_Seek( p_stream, p_box->i_pos + MP4_BOX_HEADERSIZE( p_box ) + 8 );
1401     MP4_ReadBoxContainerRaw( p_stream, p_box );
1402     return 1;
1403 }
1404
1405 static int MP4_ReadBox_sample_text( stream_t *p_stream, MP4_Box_t *p_box )
1406 {
1407     int32_t t;
1408
1409     MP4_READBOX_ENTER( MP4_Box_data_sample_text_t );
1410
1411     MP4_GET4BYTES( p_box->data.p_sample_text->i_reserved1 );
1412     MP4_GET2BYTES( p_box->data.p_sample_text->i_reserved2 );
1413
1414     MP4_GET2BYTES( p_box->data.p_sample_text->i_data_reference_index );
1415
1416     MP4_GET4BYTES( p_box->data.p_sample_text->i_display_flags );
1417
1418     MP4_GET4BYTES( t );
1419     switch( t )
1420     {
1421         /* FIXME search right signification */
1422         case 1: // Center
1423             p_box->data.p_sample_text->i_justification_horizontal = 1;
1424             p_box->data.p_sample_text->i_justification_vertical = 1;
1425             break;
1426         case -1:    // Flush Right
1427             p_box->data.p_sample_text->i_justification_horizontal = -1;
1428             p_box->data.p_sample_text->i_justification_vertical = -1;
1429             break;
1430         case -2:    // Flush Left
1431             p_box->data.p_sample_text->i_justification_horizontal = 0;
1432             p_box->data.p_sample_text->i_justification_vertical = 0;
1433             break;
1434         case 0: // Flush Default
1435         default:
1436             p_box->data.p_sample_text->i_justification_horizontal = 1;
1437             p_box->data.p_sample_text->i_justification_vertical = -1;
1438             break;
1439     }
1440
1441     MP4_GET2BYTES( p_box->data.p_sample_text->i_background_color[0] );
1442     MP4_GET2BYTES( p_box->data.p_sample_text->i_background_color[1] );
1443     MP4_GET2BYTES( p_box->data.p_sample_text->i_background_color[2] );
1444     p_box->data.p_sample_text->i_background_color[3] = 0;
1445
1446     MP4_GET2BYTES( p_box->data.p_sample_text->i_text_box_top );
1447     MP4_GET2BYTES( p_box->data.p_sample_text->i_text_box_left );
1448     MP4_GET2BYTES( p_box->data.p_sample_text->i_text_box_bottom );
1449     MP4_GET2BYTES( p_box->data.p_sample_text->i_text_box_right );
1450
1451 #ifdef MP4_VERBOSE
1452     msg_Dbg( p_stream, "read box: \"text\" in stsd text" );
1453 #endif
1454     MP4_READBOX_EXIT( 1 );
1455 }
1456
1457 static int MP4_ReadBox_sample_tx3g( stream_t *p_stream, MP4_Box_t *p_box )
1458 {
1459     MP4_READBOX_ENTER( MP4_Box_data_sample_text_t );
1460
1461     MP4_GET4BYTES( p_box->data.p_sample_text->i_reserved1 );
1462     MP4_GET2BYTES( p_box->data.p_sample_text->i_reserved2 );
1463
1464     MP4_GET2BYTES( p_box->data.p_sample_text->i_data_reference_index );
1465
1466     MP4_GET4BYTES( p_box->data.p_sample_text->i_display_flags );
1467
1468     MP4_GET1BYTE ( p_box->data.p_sample_text->i_justification_horizontal );
1469     MP4_GET1BYTE ( p_box->data.p_sample_text->i_justification_vertical );
1470
1471     MP4_GET1BYTE ( p_box->data.p_sample_text->i_background_color[0] );
1472     MP4_GET1BYTE ( p_box->data.p_sample_text->i_background_color[1] );
1473     MP4_GET1BYTE ( p_box->data.p_sample_text->i_background_color[2] );
1474     MP4_GET1BYTE ( p_box->data.p_sample_text->i_background_color[3] );
1475
1476     MP4_GET2BYTES( p_box->data.p_sample_text->i_text_box_top );
1477     MP4_GET2BYTES( p_box->data.p_sample_text->i_text_box_left );
1478     MP4_GET2BYTES( p_box->data.p_sample_text->i_text_box_bottom );
1479     MP4_GET2BYTES( p_box->data.p_sample_text->i_text_box_right );
1480
1481 #ifdef MP4_VERBOSE
1482     msg_Dbg( p_stream, "read box: \"tx3g\" in stsd text" );
1483 #endif
1484     MP4_READBOX_EXIT( 1 );
1485 }
1486
1487
1488 #if 0
1489 /* We can't easily call it, and anyway ~ 20 bytes lost isn't a real problem */
1490 static void MP4_FreeBox_sample_text( MP4_Box_t *p_box )
1491 {
1492     FREENULL( p_box->data.p_sample_text->psz_text_name );
1493 }
1494 #endif
1495
1496
1497 static int MP4_ReadBox_stsd( stream_t *p_stream, MP4_Box_t *p_box )
1498 {
1499
1500     MP4_READBOX_ENTER( MP4_Box_data_stsd_t );
1501
1502     MP4_GETVERSIONFLAGS( p_box->data.p_stsd );
1503
1504     MP4_GET4BYTES( p_box->data.p_stsd->i_entry_count );
1505
1506     stream_Seek( p_stream, p_box->i_pos + MP4_BOX_HEADERSIZE( p_box ) + 8 );
1507
1508     MP4_ReadBoxContainerRaw( p_stream, p_box );
1509
1510 #ifdef MP4_VERBOSE
1511     msg_Dbg( p_stream, "read box: \"stsd\" entry-count %d",
1512                       p_box->data.p_stsd->i_entry_count );
1513
1514 #endif
1515     MP4_READBOX_EXIT( 1 );
1516 }
1517
1518
1519 static int MP4_ReadBox_stsz( stream_t *p_stream, MP4_Box_t *p_box )
1520 {
1521     unsigned int i;
1522
1523     MP4_READBOX_ENTER( MP4_Box_data_stsz_t );
1524
1525     MP4_GETVERSIONFLAGS( p_box->data.p_stsz );
1526
1527     MP4_GET4BYTES( p_box->data.p_stsz->i_sample_size );
1528
1529     MP4_GET4BYTES( p_box->data.p_stsz->i_sample_count );
1530
1531     p_box->data.p_stsz->i_entry_size =
1532         calloc( p_box->data.p_stsz->i_sample_count, sizeof(uint32_t) );
1533     if( p_box->data.p_stsz->i_entry_size == NULL )
1534         MP4_READBOX_EXIT( 0 );
1535
1536     if( !p_box->data.p_stsz->i_sample_size )
1537     {
1538         for( i=0; (i<p_box->data.p_stsz->i_sample_count)&&(i_read >= 4 ); i++ )
1539         {
1540             MP4_GET4BYTES( p_box->data.p_stsz->i_entry_size[i] );
1541         }
1542     }
1543
1544 #ifdef MP4_VERBOSE
1545     msg_Dbg( p_stream, "read box: \"stsz\" sample-size %d sample-count %d",
1546                       p_box->data.p_stsz->i_sample_size,
1547                       p_box->data.p_stsz->i_sample_count );
1548
1549 #endif
1550     MP4_READBOX_EXIT( 1 );
1551 }
1552
1553 static void MP4_FreeBox_stsz( MP4_Box_t *p_box )
1554 {
1555     FREENULL( p_box->data.p_stsz->i_entry_size );
1556 }
1557
1558 static void MP4_FreeBox_stsc( MP4_Box_t *p_box )
1559 {
1560     FREENULL( p_box->data.p_stsc->i_first_chunk );
1561     FREENULL( p_box->data.p_stsc->i_samples_per_chunk );
1562     FREENULL( p_box->data.p_stsc->i_sample_description_index );
1563 }
1564
1565 static int MP4_ReadBox_stsc( stream_t *p_stream, MP4_Box_t *p_box )
1566 {
1567     unsigned int i;
1568
1569     MP4_READBOX_ENTER( MP4_Box_data_stsc_t );
1570
1571     MP4_GETVERSIONFLAGS( p_box->data.p_stsc );
1572
1573     MP4_GET4BYTES( p_box->data.p_stsc->i_entry_count );
1574
1575     p_box->data.p_stsc->i_first_chunk =
1576         calloc( p_box->data.p_stsc->i_entry_count, sizeof(uint32_t) );
1577     p_box->data.p_stsc->i_samples_per_chunk =
1578         calloc( p_box->data.p_stsc->i_entry_count, sizeof(uint32_t) );
1579     p_box->data.p_stsc->i_sample_description_index =
1580         calloc( p_box->data.p_stsc->i_entry_count, sizeof(uint32_t) );
1581     if( p_box->data.p_stsc->i_first_chunk == NULL
1582      || p_box->data.p_stsc->i_samples_per_chunk == NULL
1583      || p_box->data.p_stsc->i_sample_description_index == NULL )
1584     {
1585         MP4_READBOX_EXIT( 0 );
1586     }
1587
1588     for( i = 0; (i < p_box->data.p_stsc->i_entry_count )&&( i_read >= 12 );i++ )
1589     {
1590         MP4_GET4BYTES( p_box->data.p_stsc->i_first_chunk[i] );
1591         MP4_GET4BYTES( p_box->data.p_stsc->i_samples_per_chunk[i] );
1592         MP4_GET4BYTES( p_box->data.p_stsc->i_sample_description_index[i] );
1593     }
1594
1595 #ifdef MP4_VERBOSE
1596     msg_Dbg( p_stream, "read box: \"stsc\" entry-count %d",
1597                       p_box->data.p_stsc->i_entry_count );
1598
1599 #endif
1600     MP4_READBOX_EXIT( 1 );
1601 }
1602
1603 static int MP4_ReadBox_stco_co64( stream_t *p_stream, MP4_Box_t *p_box )
1604 {
1605     unsigned int i;
1606
1607     MP4_READBOX_ENTER( MP4_Box_data_co64_t );
1608
1609     MP4_GETVERSIONFLAGS( p_box->data.p_co64 );
1610
1611     MP4_GET4BYTES( p_box->data.p_co64->i_entry_count );
1612
1613     p_box->data.p_co64->i_chunk_offset =
1614         calloc( p_box->data.p_co64->i_entry_count, sizeof(uint64_t) );
1615     if( p_box->data.p_co64->i_chunk_offset == NULL )
1616         MP4_READBOX_EXIT( 0 );
1617
1618     for( i = 0; i < p_box->data.p_co64->i_entry_count; i++ )
1619     {
1620         if( p_box->i_type == FOURCC_stco )
1621         {
1622             if( i_read < 4 )
1623             {
1624                 break;
1625             }
1626             MP4_GET4BYTES( p_box->data.p_co64->i_chunk_offset[i] );
1627         }
1628         else
1629         {
1630             if( i_read < 8 )
1631             {
1632                 break;
1633             }
1634             MP4_GET8BYTES( p_box->data.p_co64->i_chunk_offset[i] );
1635         }
1636     }
1637
1638 #ifdef MP4_VERBOSE
1639     msg_Dbg( p_stream, "read box: \"co64\" entry-count %d",
1640                       p_box->data.p_co64->i_entry_count );
1641
1642 #endif
1643     MP4_READBOX_EXIT( 1 );
1644 }
1645
1646 static void MP4_FreeBox_stco_co64( MP4_Box_t *p_box )
1647 {
1648     FREENULL( p_box->data.p_co64->i_chunk_offset );
1649 }
1650
1651 static int MP4_ReadBox_stss( stream_t *p_stream, MP4_Box_t *p_box )
1652 {
1653     unsigned int i;
1654
1655     MP4_READBOX_ENTER( MP4_Box_data_stss_t );
1656
1657     MP4_GETVERSIONFLAGS( p_box->data.p_stss );
1658
1659     MP4_GET4BYTES( p_box->data.p_stss->i_entry_count );
1660
1661     p_box->data.p_stss->i_sample_number =
1662         calloc( p_box->data.p_stss->i_entry_count, sizeof(uint32_t) );
1663     if( p_box->data.p_stss->i_sample_number == NULL )
1664         MP4_READBOX_EXIT( 0 );
1665
1666     for( i = 0; (i < p_box->data.p_stss->i_entry_count )&&( i_read >= 4 ); i++ )
1667     {
1668
1669         MP4_GET4BYTES( p_box->data.p_stss->i_sample_number[i] );
1670         /* XXX in libmp4 sample begin at 0 */
1671         p_box->data.p_stss->i_sample_number[i]--;
1672     }
1673
1674 #ifdef MP4_VERBOSE
1675     msg_Dbg( p_stream, "read box: \"stss\" entry-count %d",
1676                       p_box->data.p_stss->i_entry_count );
1677
1678 #endif
1679     MP4_READBOX_EXIT( 1 );
1680 }
1681
1682 static void MP4_FreeBox_stss( MP4_Box_t *p_box )
1683 {
1684     FREENULL( p_box->data.p_stss->i_sample_number );
1685 }
1686
1687 static void MP4_FreeBox_stsh( MP4_Box_t *p_box )
1688 {
1689     FREENULL( p_box->data.p_stsh->i_shadowed_sample_number );
1690     FREENULL( p_box->data.p_stsh->i_sync_sample_number );
1691 }
1692
1693 static int MP4_ReadBox_stsh( stream_t *p_stream, MP4_Box_t *p_box )
1694 {
1695     unsigned int i;
1696
1697     MP4_READBOX_ENTER( MP4_Box_data_stsh_t );
1698
1699     MP4_GETVERSIONFLAGS( p_box->data.p_stsh );
1700
1701
1702     MP4_GET4BYTES( p_box->data.p_stsh->i_entry_count );
1703
1704     p_box->data.p_stsh->i_shadowed_sample_number =
1705         calloc( p_box->data.p_stsh->i_entry_count, sizeof(uint32_t) );
1706     p_box->data.p_stsh->i_sync_sample_number =
1707         calloc( p_box->data.p_stsh->i_entry_count, sizeof(uint32_t) );
1708
1709     if( p_box->data.p_stsh->i_shadowed_sample_number == NULL
1710      || p_box->data.p_stsh->i_sync_sample_number == NULL )
1711     {
1712         MP4_READBOX_EXIT( 0 );
1713     }
1714
1715     for( i = 0; (i < p_box->data.p_stss->i_entry_count )&&( i_read >= 8 ); i++ )
1716     {
1717
1718         MP4_GET4BYTES( p_box->data.p_stsh->i_shadowed_sample_number[i] );
1719         MP4_GET4BYTES( p_box->data.p_stsh->i_sync_sample_number[i] );
1720     }
1721
1722 #ifdef MP4_VERBOSE
1723     msg_Dbg( p_stream, "read box: \"stsh\" entry-count %d",
1724                       p_box->data.p_stsh->i_entry_count );
1725 #endif
1726     MP4_READBOX_EXIT( 1 );
1727 }
1728
1729
1730 static int MP4_ReadBox_stdp( stream_t *p_stream, MP4_Box_t *p_box )
1731 {
1732     unsigned int i;
1733
1734     MP4_READBOX_ENTER( MP4_Box_data_stdp_t );
1735
1736     MP4_GETVERSIONFLAGS( p_box->data.p_stdp );
1737
1738     p_box->data.p_stdp->i_priority =
1739         calloc( i_read / 2, sizeof(uint16_t) );
1740
1741     for( i = 0; i < i_read / 2 ; i++ )
1742     {
1743
1744         MP4_GET2BYTES( p_box->data.p_stdp->i_priority[i] );
1745     }
1746
1747 #ifdef MP4_VERBOSE
1748     msg_Dbg( p_stream, "read box: \"stdp\" entry-count %"PRId64,
1749                       i_read / 2 );
1750
1751 #endif
1752     MP4_READBOX_EXIT( 1 );
1753 }
1754
1755 static void MP4_FreeBox_stdp( MP4_Box_t *p_box )
1756 {
1757     FREENULL( p_box->data.p_stdp->i_priority );
1758 }
1759
1760 static void MP4_FreeBox_padb( MP4_Box_t *p_box )
1761 {
1762     FREENULL( p_box->data.p_padb->i_reserved1 );
1763     FREENULL( p_box->data.p_padb->i_pad2 );
1764     FREENULL( p_box->data.p_padb->i_reserved2 );
1765     FREENULL( p_box->data.p_padb->i_pad1 );
1766 }
1767
1768 static int MP4_ReadBox_padb( stream_t *p_stream, MP4_Box_t *p_box )
1769 {
1770     unsigned int i;
1771     uint32_t count;
1772
1773     MP4_READBOX_ENTER( MP4_Box_data_padb_t );
1774
1775     MP4_GETVERSIONFLAGS( p_box->data.p_padb );
1776
1777     MP4_GET4BYTES( p_box->data.p_padb->i_sample_count );
1778     count = (p_box->data.p_padb->i_sample_count + 1) / 2;
1779
1780     p_box->data.p_padb->i_reserved1 = calloc( count, sizeof(uint16_t) );
1781     p_box->data.p_padb->i_pad2 = calloc( count, sizeof(uint16_t) );
1782     p_box->data.p_padb->i_reserved2 = calloc( count, sizeof(uint16_t) );
1783     p_box->data.p_padb->i_pad1 = calloc( count, sizeof(uint16_t) );
1784     if( p_box->data.p_padb->i_reserved1 == NULL
1785      || p_box->data.p_padb->i_pad2 == NULL
1786      || p_box->data.p_padb->i_reserved2 == NULL
1787      || p_box->data.p_padb->i_pad1 == NULL )
1788     {
1789         MP4_READBOX_EXIT( 0 );
1790     }
1791
1792     for( i = 0; i < i_read / 2 ; i++ )
1793     {
1794         if( i >= count )
1795         {
1796             MP4_READBOX_EXIT( 0 );
1797         }
1798         p_box->data.p_padb->i_reserved1[i] = ( (*p_peek) >> 7 )&0x01;
1799         p_box->data.p_padb->i_pad2[i] = ( (*p_peek) >> 4 )&0x07;
1800         p_box->data.p_padb->i_reserved1[i] = ( (*p_peek) >> 3 )&0x01;
1801         p_box->data.p_padb->i_pad1[i] = ( (*p_peek) )&0x07;
1802
1803         p_peek += 1; i_read -= 1;
1804     }
1805
1806 #ifdef MP4_VERBOSE
1807     msg_Dbg( p_stream, "read box: \"stdp\" entry-count %"PRId64,
1808                       i_read / 2 );
1809
1810 #endif
1811     MP4_READBOX_EXIT( 1 );
1812 }
1813
1814 static void MP4_FreeBox_elst( MP4_Box_t *p_box )
1815 {
1816     FREENULL( p_box->data.p_elst->i_segment_duration );
1817     FREENULL( p_box->data.p_elst->i_media_time );
1818     FREENULL( p_box->data.p_elst->i_media_rate_integer );
1819     FREENULL( p_box->data.p_elst->i_media_rate_fraction );
1820 }
1821
1822 static int MP4_ReadBox_elst( stream_t *p_stream, MP4_Box_t *p_box )
1823 {
1824     unsigned int i;
1825
1826     MP4_READBOX_ENTER( MP4_Box_data_elst_t );
1827
1828     MP4_GETVERSIONFLAGS( p_box->data.p_elst );
1829
1830
1831     MP4_GET4BYTES( p_box->data.p_elst->i_entry_count );
1832
1833     p_box->data.p_elst->i_segment_duration =
1834         calloc( p_box->data.p_elst->i_entry_count, sizeof(uint64_t) );
1835     p_box->data.p_elst->i_media_time =
1836         calloc( p_box->data.p_elst->i_entry_count, sizeof(uint64_t) );
1837     p_box->data.p_elst->i_media_rate_integer =
1838         calloc( p_box->data.p_elst->i_entry_count, sizeof(uint16_t) );
1839     p_box->data.p_elst->i_media_rate_fraction =
1840         calloc( p_box->data.p_elst->i_entry_count, sizeof(uint16_t) );
1841     if( p_box->data.p_elst->i_segment_duration == NULL
1842      || p_box->data.p_elst->i_media_time == NULL
1843      || p_box->data.p_elst->i_media_rate_integer == NULL
1844      || p_box->data.p_elst->i_media_rate_fraction == NULL )
1845     {
1846         MP4_READBOX_EXIT( 0 );
1847     }
1848
1849
1850     for( i = 0; i < p_box->data.p_elst->i_entry_count; i++ )
1851     {
1852         if( p_box->data.p_elst->i_version == 1 )
1853         {
1854
1855             MP4_GET8BYTES( p_box->data.p_elst->i_segment_duration[i] );
1856
1857             MP4_GET8BYTES( p_box->data.p_elst->i_media_time[i] );
1858         }
1859         else
1860         {
1861
1862             MP4_GET4BYTES( p_box->data.p_elst->i_segment_duration[i] );
1863
1864             MP4_GET4BYTES( p_box->data.p_elst->i_media_time[i] );
1865             p_box->data.p_elst->i_media_time[i] = (int32_t)p_box->data.p_elst->i_media_time[i];
1866         }
1867
1868         MP4_GET2BYTES( p_box->data.p_elst->i_media_rate_integer[i] );
1869         MP4_GET2BYTES( p_box->data.p_elst->i_media_rate_fraction[i] );
1870     }
1871
1872 #ifdef MP4_VERBOSE
1873     msg_Dbg( p_stream, "read box: \"elst\" entry-count %lu",
1874              (unsigned long)p_box->data.p_elst->i_entry_count );
1875 #endif
1876     MP4_READBOX_EXIT( 1 );
1877 }
1878
1879 static int MP4_ReadBox_cprt( stream_t *p_stream, MP4_Box_t *p_box )
1880 {
1881     unsigned int i_language;
1882     unsigned int i;
1883
1884     MP4_READBOX_ENTER( MP4_Box_data_cprt_t );
1885
1886     MP4_GETVERSIONFLAGS( p_box->data.p_cprt );
1887
1888     i_language = GetWBE( p_peek );
1889     for( i = 0; i < 3; i++ )
1890     {
1891         p_box->data.p_cprt->i_language[i] =
1892             ( ( i_language >> ( (2-i)*5 ) )&0x1f ) + 0x60;
1893     }
1894     p_peek += 2; i_read -= 2;
1895     MP4_GETSTRINGZ( p_box->data.p_cprt->psz_notice );
1896
1897 #ifdef MP4_VERBOSE
1898     msg_Dbg( p_stream, "read box: \"cprt\" language %c%c%c notice %s",
1899                       p_box->data.p_cprt->i_language[0],
1900                       p_box->data.p_cprt->i_language[1],
1901                       p_box->data.p_cprt->i_language[2],
1902                       p_box->data.p_cprt->psz_notice );
1903
1904 #endif
1905     MP4_READBOX_EXIT( 1 );
1906 }
1907
1908 static void MP4_FreeBox_cprt( MP4_Box_t *p_box )
1909 {
1910     FREENULL( p_box->data.p_cprt->psz_notice );
1911 }
1912
1913
1914 static int MP4_ReadBox_dcom( stream_t *p_stream, MP4_Box_t *p_box )
1915 {
1916     MP4_READBOX_ENTER( MP4_Box_data_dcom_t );
1917
1918     MP4_GETFOURCC( p_box->data.p_dcom->i_algorithm );
1919 #ifdef MP4_VERBOSE
1920     msg_Dbg( p_stream,
1921              "read box: \"dcom\" compression algorithm : %4.4s",
1922                       (char*)&p_box->data.p_dcom->i_algorithm );
1923 #endif
1924     MP4_READBOX_EXIT( 1 );
1925 }
1926
1927 static int MP4_ReadBox_cmvd( stream_t *p_stream, MP4_Box_t *p_box )
1928 {
1929     MP4_READBOX_ENTER( MP4_Box_data_cmvd_t );
1930
1931     MP4_GET4BYTES( p_box->data.p_cmvd->i_uncompressed_size );
1932
1933     p_box->data.p_cmvd->i_compressed_size = i_read;
1934
1935     if( !( p_box->data.p_cmvd->p_data = malloc( i_read ) ) )
1936         return( 1 );
1937
1938     /* now copy compressed data */
1939     memcpy( p_box->data.p_cmvd->p_data,
1940             p_peek,
1941             i_read);
1942
1943     p_box->data.p_cmvd->b_compressed = 1;
1944
1945 #ifdef MP4_VERBOSE
1946     msg_Dbg( p_stream, "read box: \"cmvd\" compressed data size %d",
1947                       p_box->data.p_cmvd->i_compressed_size );
1948 #endif
1949
1950     MP4_READBOX_EXIT( 1 );
1951 }
1952 static void MP4_FreeBox_cmvd( MP4_Box_t *p_box )
1953 {
1954     FREENULL( p_box->data.p_cmvd->p_data );
1955 }
1956
1957
1958 static int MP4_ReadBox_cmov( stream_t *p_stream, MP4_Box_t *p_box )
1959 {
1960     MP4_Box_t *p_dcom;
1961     MP4_Box_t *p_cmvd;
1962
1963 #ifdef HAVE_ZLIB_H
1964     stream_t *p_stream_memory;
1965     z_stream z_data;
1966     uint8_t *p_data;
1967     int i_result;
1968 #endif
1969
1970     if( !( p_box->data.p_cmov = malloc( sizeof( MP4_Box_data_cmov_t ) ) ) )
1971         return 0;
1972     memset( p_box->data.p_cmov, 0, sizeof( MP4_Box_data_cmov_t ) );
1973
1974     if( !p_box->p_father ||
1975         ( p_box->p_father->i_type != FOURCC_moov &&
1976           p_box->p_father->i_type != FOURCC_foov ) )
1977     {
1978         msg_Warn( p_stream, "Read box: \"cmov\" box alone" );
1979         return 1;
1980     }
1981
1982     if( !MP4_ReadBoxContainer( p_stream, p_box ) )
1983     {
1984         return 0;
1985     }
1986
1987     if( ( p_dcom = MP4_BoxGet( p_box, "dcom" ) ) == NULL ||
1988         ( p_cmvd = MP4_BoxGet( p_box, "cmvd" ) ) == NULL ||
1989         p_cmvd->data.p_cmvd->p_data == NULL )
1990     {
1991         msg_Warn( p_stream, "read box: \"cmov\" incomplete" );
1992         return 0;
1993     }
1994
1995     if( p_dcom->data.p_dcom->i_algorithm != FOURCC_zlib )
1996     {
1997         msg_Dbg( p_stream, "read box: \"cmov\" compression algorithm : %4.4s "
1998                  "not supported", (char*)&p_dcom->data.p_dcom->i_algorithm );
1999         return 0;
2000     }
2001
2002 #ifndef HAVE_ZLIB_H
2003     msg_Dbg( p_stream, "read box: \"cmov\" zlib unsupported" );
2004     return 0;
2005
2006 #else
2007     /* decompress data */
2008     /* allocate a new buffer */
2009     if( !( p_data = malloc( p_cmvd->data.p_cmvd->i_uncompressed_size ) ) )
2010         return 0;
2011     /* init default structures */
2012     z_data.next_in   = p_cmvd->data.p_cmvd->p_data;
2013     z_data.avail_in  = p_cmvd->data.p_cmvd->i_compressed_size;
2014     z_data.next_out  = p_data;
2015     z_data.avail_out = p_cmvd->data.p_cmvd->i_uncompressed_size;
2016     z_data.zalloc    = (alloc_func)Z_NULL;
2017     z_data.zfree     = (free_func)Z_NULL;
2018     z_data.opaque    = (voidpf)Z_NULL;
2019
2020     /* init zlib */
2021     if( inflateInit( &z_data ) != Z_OK )
2022     {
2023         msg_Err( p_stream, "read box: \"cmov\" error while uncompressing" );
2024         free( p_data );
2025         return 0;
2026     }
2027
2028     /* uncompress */
2029     i_result = inflate( &z_data, Z_NO_FLUSH );
2030     if( i_result != Z_OK && i_result != Z_STREAM_END )
2031     {
2032         msg_Err( p_stream, "read box: \"cmov\" error while uncompressing" );
2033         free( p_data );
2034         return 0;
2035     }
2036
2037     if( p_cmvd->data.p_cmvd->i_uncompressed_size != z_data.total_out )
2038     {
2039         msg_Warn( p_stream, "read box: \"cmov\" uncompressing data size "
2040                   "mismatch" );
2041     }
2042     p_cmvd->data.p_cmvd->i_uncompressed_size = z_data.total_out;
2043
2044     /* close zlib */
2045     if( inflateEnd( &z_data ) != Z_OK )
2046     {
2047         msg_Warn( p_stream, "read box: \"cmov\" error while uncompressing "
2048                   "data (ignored)" );
2049     }
2050
2051     free( p_cmvd->data.p_cmvd->p_data );
2052     p_cmvd->data.p_cmvd->p_data = p_data;
2053     p_cmvd->data.p_cmvd->b_compressed = 0;
2054
2055     msg_Dbg( p_stream, "read box: \"cmov\" box succesfully uncompressed" );
2056
2057     /* now create a memory stream */
2058     p_stream_memory =
2059         stream_MemoryNew( VLC_OBJECT(p_stream), p_cmvd->data.p_cmvd->p_data,
2060                           p_cmvd->data.p_cmvd->i_uncompressed_size, true );
2061
2062     /* and read uncompressd moov */
2063     p_box->data.p_cmov->p_moov = MP4_ReadBox( p_stream_memory, NULL );
2064
2065     stream_Delete( p_stream_memory );
2066
2067 #ifdef MP4_VERBOSE
2068     msg_Dbg( p_stream, "read box: \"cmov\" compressed movie header completed");
2069 #endif
2070
2071     return p_box->data.p_cmov->p_moov ? 1 : 0;
2072 #endif /* HAVE_ZLIB_H */
2073 }
2074
2075 static int MP4_ReadBox_rdrf( stream_t *p_stream, MP4_Box_t *p_box )
2076 {
2077     uint32_t i_len;
2078     MP4_READBOX_ENTER( MP4_Box_data_rdrf_t );
2079
2080     MP4_GETVERSIONFLAGS( p_box->data.p_rdrf );
2081     MP4_GETFOURCC( p_box->data.p_rdrf->i_ref_type );
2082     MP4_GET4BYTES( i_len );
2083     i_len++;
2084
2085     if( i_len > 0 )
2086     {
2087         uint32_t i;
2088         p_box->data.p_rdrf->psz_ref = malloc( i_len );
2089         if( p_box->data.p_rdrf->psz_ref == NULL )
2090             MP4_READBOX_EXIT( 0 );
2091         i_len--;
2092
2093         for( i = 0; i < i_len; i++ )
2094         {
2095             MP4_GET1BYTE( p_box->data.p_rdrf->psz_ref[i] );
2096         }
2097         p_box->data.p_rdrf->psz_ref[i_len] = '\0';
2098     }
2099     else
2100     {
2101         p_box->data.p_rdrf->psz_ref = NULL;
2102     }
2103
2104 #ifdef MP4_VERBOSE
2105     msg_Dbg( p_stream,
2106             "read box: \"rdrf\" type:%4.4s ref %s",
2107             (char*)&p_box->data.p_rdrf->i_ref_type,
2108             p_box->data.p_rdrf->psz_ref );
2109 #endif
2110     MP4_READBOX_EXIT( 1 );
2111 }
2112
2113 static void MP4_FreeBox_rdrf( MP4_Box_t *p_box )
2114 {
2115     FREENULL( p_box->data.p_rdrf->psz_ref );
2116 }
2117
2118
2119 static int MP4_ReadBox_rmdr( stream_t *p_stream, MP4_Box_t *p_box )
2120 {
2121     MP4_READBOX_ENTER( MP4_Box_data_rmdr_t );
2122
2123     MP4_GETVERSIONFLAGS( p_box->data.p_rmdr );
2124
2125     MP4_GET4BYTES( p_box->data.p_rmdr->i_rate );
2126
2127 #ifdef MP4_VERBOSE
2128     msg_Dbg( p_stream,
2129              "read box: \"rmdr\" rate:%d",
2130              p_box->data.p_rmdr->i_rate );
2131 #endif
2132     MP4_READBOX_EXIT( 1 );
2133 }
2134
2135 static int MP4_ReadBox_rmqu( stream_t *p_stream, MP4_Box_t *p_box )
2136 {
2137     MP4_READBOX_ENTER( MP4_Box_data_rmqu_t );
2138
2139     MP4_GET4BYTES( p_box->data.p_rmqu->i_quality );
2140
2141 #ifdef MP4_VERBOSE
2142     msg_Dbg( p_stream,
2143              "read box: \"rmqu\" quality:%d",
2144              p_box->data.p_rmqu->i_quality );
2145 #endif
2146     MP4_READBOX_EXIT( 1 );
2147 }
2148
2149 static int MP4_ReadBox_rmvc( stream_t *p_stream, MP4_Box_t *p_box )
2150 {
2151     MP4_READBOX_ENTER( MP4_Box_data_rmvc_t );
2152     MP4_GETVERSIONFLAGS( p_box->data.p_rmvc );
2153
2154     MP4_GETFOURCC( p_box->data.p_rmvc->i_gestaltType );
2155     MP4_GET4BYTES( p_box->data.p_rmvc->i_val1 );
2156     MP4_GET4BYTES( p_box->data.p_rmvc->i_val2 );
2157     MP4_GET2BYTES( p_box->data.p_rmvc->i_checkType );
2158
2159 #ifdef MP4_VERBOSE
2160     msg_Dbg( p_stream,
2161              "read box: \"rmvc\" gestaltType:%4.4s val1:0x%x val2:0x%x checkType:0x%x",
2162              (char*)&p_box->data.p_rmvc->i_gestaltType,
2163              p_box->data.p_rmvc->i_val1,p_box->data.p_rmvc->i_val2,
2164              p_box->data.p_rmvc->i_checkType );
2165 #endif
2166
2167     MP4_READBOX_EXIT( 1 );
2168 }
2169
2170 static int MP4_ReadBox_frma( stream_t *p_stream, MP4_Box_t *p_box )
2171 {
2172     MP4_READBOX_ENTER( MP4_Box_data_frma_t );
2173
2174     MP4_GETFOURCC( p_box->data.p_frma->i_type );
2175
2176 #ifdef MP4_VERBOSE
2177     msg_Dbg( p_stream, "read box: \"frma\" i_type:%4.4s",
2178              (char *)&p_box->data.p_frma->i_type );
2179 #endif
2180
2181     MP4_READBOX_EXIT( 1 );
2182 }
2183
2184 static int MP4_ReadBox_skcr( stream_t *p_stream, MP4_Box_t *p_box )
2185 {
2186     MP4_READBOX_ENTER( MP4_Box_data_frma_t );
2187
2188     MP4_GET4BYTES( p_box->data.p_skcr->i_init );
2189     MP4_GET4BYTES( p_box->data.p_skcr->i_encr );
2190     MP4_GET4BYTES( p_box->data.p_skcr->i_decr );
2191
2192 #ifdef MP4_VERBOSE
2193     msg_Dbg( p_stream, "read box: \"skcr\" i_init:%d i_encr:%d i_decr:%d",
2194              p_box->data.p_skcr->i_init,
2195              p_box->data.p_skcr->i_encr,
2196              p_box->data.p_skcr->i_decr );
2197 #endif
2198
2199     MP4_READBOX_EXIT( 1 );
2200 }
2201
2202 static int MP4_ReadBox_drms( stream_t *p_stream, MP4_Box_t *p_box )
2203 {
2204     MP4_Box_t *p_drms_box = p_box;
2205     void *p_drms = NULL;
2206
2207     MP4_READBOX_ENTER( uint8_t );
2208
2209     do
2210     {
2211         p_drms_box = p_drms_box->p_father;
2212     } while( p_drms_box && p_drms_box->i_type != FOURCC_drms
2213                         && p_drms_box->i_type != FOURCC_drmi );
2214
2215     if( p_drms_box && p_drms_box->i_type == FOURCC_drms )
2216         p_drms = p_drms_box->data.p_sample_soun->p_drms;
2217     else if( p_drms_box && p_drms_box->i_type == FOURCC_drmi )
2218         p_drms = p_drms_box->data.p_sample_vide->p_drms;
2219
2220     if( p_drms_box && p_drms )
2221     {
2222         int i_ret = drms_init( p_drms, p_box->i_type, p_peek, i_read );
2223         if( i_ret )
2224         {
2225             const char *psz_error;
2226
2227             switch( i_ret )
2228             {
2229                 case -1: psz_error = "unimplemented"; break;
2230                 case -2: psz_error = "invalid argument"; break;
2231                 case -3: psz_error = "could not get system key"; break;
2232                 case -4: psz_error = "could not get SCI data"; break;
2233                 case -5: psz_error = "no user key found in SCI data"; break;
2234                 case -6: psz_error = "invalid user key"; break;
2235                 default: psz_error = "unknown error"; break;
2236             }
2237             if MP4_BOX_TYPE_ASCII()
2238                 msg_Err( p_stream, "drms_init(%4.4s) failed (%s)",
2239                         (char *)&p_box->i_type, psz_error );
2240             else
2241                 msg_Err( p_stream, "drms_init(c%3.3s) failed (%s)",
2242                         (char *)&p_box->i_type+1, psz_error );
2243
2244             drms_free( p_drms );
2245
2246             if( p_drms_box->i_type == FOURCC_drms )
2247                 p_drms_box->data.p_sample_soun->p_drms = NULL;
2248             else if( p_drms_box->i_type == FOURCC_drmi )
2249                 p_drms_box->data.p_sample_vide->p_drms = NULL;
2250         }
2251     }
2252
2253     MP4_READBOX_EXIT( 1 );
2254 }
2255
2256 static int MP4_ReadBox_0xa9xxx( stream_t *p_stream, MP4_Box_t *p_box )
2257 {
2258     uint16_t i16;
2259
2260     MP4_READBOX_ENTER( MP4_Box_data_0xa9xxx_t );
2261
2262     p_box->data.p_0xa9xxx->psz_text = NULL;
2263
2264     MP4_GET2BYTES( i16 );
2265
2266     if( i16 > 0 )
2267     {
2268         int i_length = i16;
2269
2270         MP4_GET2BYTES( i16 );
2271         if( i_length >= i_read ) i_length = i_read + 1;
2272
2273         p_box->data.p_0xa9xxx->psz_text = malloc( i_length );
2274         if( p_box->data.p_0xa9xxx->psz_text == NULL )
2275             MP4_READBOX_EXIT( 0 );
2276
2277         i_length--;
2278         memcpy( p_box->data.p_0xa9xxx->psz_text,
2279                 p_peek, i_length );
2280         p_box->data.p_0xa9xxx->psz_text[i_length] = '\0';
2281
2282 #ifdef MP4_VERBOSE
2283         msg_Dbg( p_stream,
2284                  "read box: \"c%3.3s\" text=`%s'",
2285                  ((char*)&p_box->i_type + 1),
2286                  p_box->data.p_0xa9xxx->psz_text );
2287 #endif
2288     }
2289     else
2290     {
2291         /* try iTune/Quicktime format, rewind to start */
2292         p_peek -= 2; i_read += 2;
2293         // we are expecting a 'data' box
2294         uint32_t i_data_len;
2295         uint32_t i_data_tag;
2296
2297         MP4_GET4BYTES( i_data_len );
2298         if( i_data_len > i_read ) i_data_len = i_read;
2299         MP4_GETFOURCC( i_data_tag );
2300         if( (i_data_len > 0) && (i_data_tag == VLC_FOURCC('d', 'a', 't', 'a')) )
2301         {
2302             /* data box contains a version/flags field */
2303             uint32_t i_version;
2304             uint32_t i_reserved;
2305             MP4_GET4BYTES( i_version );
2306             MP4_GET4BYTES( i_reserved );
2307             // version should be 0, flags should be 1 for text, 0 for data
2308             if( ( i_version == 0x00000001 ) && (i_data_len >= 12 ) )
2309             {
2310                 // the rest is the text
2311                 i_data_len -= 12;
2312                 p_box->data.p_0xa9xxx->psz_text = malloc( i_data_len + 1 );
2313                 if( p_box->data.p_0xa9xxx->psz_text == NULL )
2314                     MP4_READBOX_EXIT( 0 );
2315
2316                 memcpy( p_box->data.p_0xa9xxx->psz_text,
2317                         p_peek, i_data_len );
2318                 p_box->data.p_0xa9xxx->psz_text[i_data_len] = '\0';
2319 #ifdef MP4_VERBOSE
2320         msg_Dbg( p_stream,
2321                  "read box: \"c%3.3s\" text=`%s'",
2322                  ((char*)&p_box->i_type+1),
2323                  p_box->data.p_0xa9xxx->psz_text );
2324 #endif
2325             }
2326             else
2327             {
2328                 // TODO: handle data values for ID3 tag values, track num or cover art,etc...
2329             }
2330         }
2331     }
2332
2333     MP4_READBOX_EXIT( 1 );
2334 }
2335 static void MP4_FreeBox_0xa9xxx( MP4_Box_t *p_box )
2336 {
2337     FREENULL( p_box->data.p_0xa9xxx->psz_text );
2338 }
2339
2340 /* Chapter support */
2341 static void MP4_FreeBox_chpl( MP4_Box_t *p_box )
2342 {
2343     MP4_Box_data_chpl_t *p_chpl = p_box->data.p_chpl;
2344     int i;
2345     for( i = 0; i < p_chpl->i_chapter; i++ )
2346         free( p_chpl->chapter[i].psz_name );
2347 }
2348
2349 static int MP4_ReadBox_chpl( stream_t *p_stream, MP4_Box_t *p_box )
2350 {
2351     MP4_Box_data_chpl_t *p_chpl;
2352     uint32_t i_dummy;
2353     int i;
2354     MP4_READBOX_ENTER( MP4_Box_data_chpl_t );
2355
2356     p_chpl = p_box->data.p_chpl;
2357
2358     MP4_GETVERSIONFLAGS( p_chpl );
2359
2360     MP4_GET4BYTES( i_dummy );
2361
2362     MP4_GET1BYTE( p_chpl->i_chapter );
2363
2364     for( i = 0; i < p_chpl->i_chapter; i++ )
2365     {
2366         uint64_t i_start;
2367         uint8_t i_len;
2368         int i_copy;
2369         MP4_GET8BYTES( i_start );
2370         MP4_GET1BYTE( i_len );
2371
2372         p_chpl->chapter[i].psz_name = malloc( i_len + 1 );
2373         if( !p_chpl->chapter[i].psz_name )
2374             goto error;
2375
2376         i_copy = __MIN( i_len, i_read );
2377         if( i_copy > 0 )
2378             memcpy( p_chpl->chapter[i].psz_name, p_peek, i_copy );
2379         p_chpl->chapter[i].psz_name[i_copy] = '\0';
2380         p_chpl->chapter[i].i_start = i_start;
2381
2382         p_peek += i_copy;
2383         i_read -= i_copy;
2384     }
2385     /* Bubble sort by increasing start date */
2386     do
2387     {
2388         for( i = 0; i < p_chpl->i_chapter - 1; i++ )
2389         {
2390             if( p_chpl->chapter[i].i_start > p_chpl->chapter[i+1].i_start )
2391             {
2392                 char *psz = p_chpl->chapter[i+1].psz_name;
2393                 int64_t i64 = p_chpl->chapter[i+1].i_start;
2394
2395                 p_chpl->chapter[i+1].psz_name = p_chpl->chapter[i].psz_name;
2396                 p_chpl->chapter[i+1].i_start = p_chpl->chapter[i].i_start;
2397
2398                 p_chpl->chapter[i].psz_name = psz;
2399                 p_chpl->chapter[i].i_start = i64;
2400
2401                 i = -1;
2402                 break;
2403             }
2404         }
2405     } while( i == -1 );
2406
2407 #ifdef MP4_VERBOSE
2408     msg_Dbg( p_stream, "read box: \"chpl\" %d chapters",
2409                        p_chpl->i_chapter );
2410 #endif
2411     MP4_READBOX_EXIT( 1 );
2412
2413 error:
2414     MP4_READBOX_EXIT( 0 );
2415 }
2416
2417 static int MP4_ReadBox_tref_generic( stream_t *p_stream, MP4_Box_t *p_box )
2418 {
2419     unsigned int i;
2420     MP4_READBOX_ENTER( MP4_Box_data_tref_generic_t );
2421
2422     p_box->data.p_tref_generic->i_track_ID = NULL;
2423     p_box->data.p_tref_generic->i_entry_count = i_read / sizeof(uint32_t);
2424     if( p_box->data.p_tref_generic->i_entry_count > 0 )
2425         p_box->data.p_tref_generic->i_track_ID = calloc( p_box->data.p_tref_generic->i_entry_count, sizeof(uint32_t) );
2426     if( p_box->data.p_tref_generic->i_track_ID == NULL )
2427         MP4_READBOX_EXIT( 0 );
2428
2429     for( i = 0; i < p_box->data.p_tref_generic->i_entry_count; i++ )
2430     {
2431         MP4_GET4BYTES( p_box->data.p_tref_generic->i_track_ID[i] );
2432     }
2433 #ifdef MP4_VERBOSE
2434         msg_Dbg( p_stream, "read box: \"chap\" %d references",
2435                  p_box->data.p_tref_generic->i_entry_count );
2436 #endif
2437
2438     MP4_READBOX_EXIT( 1 );
2439 }
2440 static void MP4_FreeBox_tref_generic( MP4_Box_t *p_box )
2441 {
2442     FREENULL( p_box->data.p_tref_generic->i_track_ID );
2443 }
2444
2445 static int MP4_ReadBox_meta( stream_t *p_stream, MP4_Box_t *p_box )
2446 {
2447     uint8_t meta_data[8];
2448     int i_actually_read;
2449
2450     // skip over box header
2451     i_actually_read = stream_Read( p_stream, meta_data, 8 );
2452     if( i_actually_read < 8 )
2453         return 0;
2454
2455     /* meta content starts with a 4 byte version/flags value (should be 0) */
2456     i_actually_read = stream_Read( p_stream, meta_data, 4 );
2457     if( i_actually_read < 4 )
2458         return 0;
2459
2460     /* then it behaves like a container */
2461     return MP4_ReadBoxContainerRaw( p_stream, p_box );
2462 }
2463
2464 /* For generic */
2465 static int MP4_ReadBox_default( stream_t *p_stream, MP4_Box_t *p_box )
2466 {
2467     if( !p_box->p_father )
2468     {
2469         goto unknown;
2470     }
2471     if( p_box->p_father->i_type == FOURCC_stsd )
2472     {
2473         MP4_Box_t *p_mdia = MP4_BoxGet( p_box, "../../../.." );
2474         MP4_Box_t *p_hdlr;
2475
2476         if( p_mdia == NULL || p_mdia->i_type != FOURCC_mdia ||
2477             (p_hdlr = MP4_BoxGet( p_mdia, "hdlr" )) == NULL )
2478         {
2479             goto unknown;
2480         }
2481         switch( p_hdlr->data.p_hdlr->i_handler_type )
2482         {
2483             case FOURCC_soun:
2484                 return MP4_ReadBox_sample_soun( p_stream, p_box );
2485             case FOURCC_vide:
2486                 return MP4_ReadBox_sample_vide( p_stream, p_box );
2487             case FOURCC_text:
2488                 return MP4_ReadBox_sample_text( p_stream, p_box );
2489             case FOURCC_tx3g:
2490             case FOURCC_sbtl:
2491                 return MP4_ReadBox_sample_tx3g( p_stream, p_box );
2492             default:
2493                 msg_Warn( p_stream,
2494                           "unknown handler type in stsd (incompletely loaded)" );
2495                 return 1;
2496         }
2497     }
2498
2499 unknown:
2500     if MP4_BOX_TYPE_ASCII()
2501         msg_Warn( p_stream,
2502                 "unknown box type %4.4s (incompletely loaded)",
2503                 (char*)&p_box->i_type );
2504     else
2505         msg_Warn( p_stream,
2506                 "unknown box type c%3.3s (incompletely loaded)",
2507                 (char*)&p_box->i_type+1 );
2508
2509     return 1;
2510 }
2511
2512 /**** ------------------------------------------------------------------- ****/
2513 /****                   "Higher level" Functions                          ****/
2514 /**** ------------------------------------------------------------------- ****/
2515
2516 static const struct
2517 {
2518     uint32_t i_type;
2519     int  (*MP4_ReadBox_function )( stream_t *p_stream, MP4_Box_t *p_box );
2520     void (*MP4_FreeBox_function )( MP4_Box_t *p_box );
2521 } MP4_Box_Function [] =
2522 {
2523     /* Containers */
2524     { FOURCC_moov,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
2525     { FOURCC_trak,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
2526     { FOURCC_mdia,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
2527     { FOURCC_moof,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
2528     { FOURCC_minf,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
2529     { FOURCC_stbl,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
2530     { FOURCC_dinf,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
2531     { FOURCC_edts,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
2532     { FOURCC_udta,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
2533     { FOURCC_nmhd,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
2534     { FOURCC_hnti,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
2535     { FOURCC_rmra,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
2536     { FOURCC_rmda,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
2537     { FOURCC_tref,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
2538     { FOURCC_gmhd,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
2539     { FOURCC_wave,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
2540     { FOURCC_ilst,  MP4_ReadBoxContainer,   MP4_FreeBox_Common },
2541
2542     /* specific box */
2543     { FOURCC_ftyp,  MP4_ReadBox_ftyp,       MP4_FreeBox_ftyp },
2544     { FOURCC_cmov,  MP4_ReadBox_cmov,       MP4_FreeBox_Common },
2545     { FOURCC_mvhd,  MP4_ReadBox_mvhd,       MP4_FreeBox_Common },
2546     { FOURCC_tkhd,  MP4_ReadBox_tkhd,       MP4_FreeBox_Common },
2547     { FOURCC_mdhd,  MP4_ReadBox_mdhd,       MP4_FreeBox_Common },
2548     { FOURCC_hdlr,  MP4_ReadBox_hdlr,       MP4_FreeBox_hdlr },
2549     { FOURCC_vmhd,  MP4_ReadBox_vmhd,       MP4_FreeBox_Common },
2550     { FOURCC_smhd,  MP4_ReadBox_smhd,       MP4_FreeBox_Common },
2551     { FOURCC_hmhd,  MP4_ReadBox_hmhd,       MP4_FreeBox_Common },
2552     { FOURCC_url,   MP4_ReadBox_url,        MP4_FreeBox_url },
2553     { FOURCC_urn,   MP4_ReadBox_urn,        MP4_FreeBox_urn },
2554     { FOURCC_dref,  MP4_ReadBox_dref,       MP4_FreeBox_Common },
2555     { FOURCC_stts,  MP4_ReadBox_stts,       MP4_FreeBox_stts },
2556     { FOURCC_ctts,  MP4_ReadBox_ctts,       MP4_FreeBox_ctts },
2557     { FOURCC_stsd,  MP4_ReadBox_stsd,       MP4_FreeBox_Common },
2558     { FOURCC_stsz,  MP4_ReadBox_stsz,       MP4_FreeBox_stsz },
2559     { FOURCC_stsc,  MP4_ReadBox_stsc,       MP4_FreeBox_stsc },
2560     { FOURCC_stco,  MP4_ReadBox_stco_co64,  MP4_FreeBox_stco_co64 },
2561     { FOURCC_co64,  MP4_ReadBox_stco_co64,  MP4_FreeBox_stco_co64 },
2562     { FOURCC_stss,  MP4_ReadBox_stss,       MP4_FreeBox_stss },
2563     { FOURCC_stsh,  MP4_ReadBox_stsh,       MP4_FreeBox_stsh },
2564     { FOURCC_stdp,  MP4_ReadBox_stdp,       MP4_FreeBox_stdp },
2565     { FOURCC_padb,  MP4_ReadBox_padb,       MP4_FreeBox_padb },
2566     { FOURCC_elst,  MP4_ReadBox_elst,       MP4_FreeBox_elst },
2567     { FOURCC_cprt,  MP4_ReadBox_cprt,       MP4_FreeBox_cprt },
2568     { FOURCC_esds,  MP4_ReadBox_esds,       MP4_FreeBox_esds },
2569     { FOURCC_dcom,  MP4_ReadBox_dcom,       MP4_FreeBox_Common },
2570     { FOURCC_cmvd,  MP4_ReadBox_cmvd,       MP4_FreeBox_cmvd },
2571     { FOURCC_avcC,  MP4_ReadBox_avcC,       MP4_FreeBox_avcC },
2572     { FOURCC_dac3,  MP4_ReadBox_dac3,       MP4_FreeBox_Common },
2573     { FOURCC_enda,  MP4_ReadBox_enda,       MP4_FreeBox_Common },
2574
2575     /* Nothing to do with this box */
2576     { FOURCC_mdat,  MP4_ReadBoxSkip,        MP4_FreeBox_Common },
2577     { FOURCC_skip,  MP4_ReadBoxSkip,        MP4_FreeBox_Common },
2578     { FOURCC_free,  MP4_ReadBoxSkip,        MP4_FreeBox_Common },
2579     { FOURCC_wide,  MP4_ReadBoxSkip,        MP4_FreeBox_Common },
2580
2581     /* for codecs */
2582     { FOURCC_soun,  MP4_ReadBox_sample_soun,    MP4_FreeBox_sample_soun },
2583     { FOURCC_ms02,  MP4_ReadBox_sample_soun,    MP4_FreeBox_sample_soun },
2584     { FOURCC_ms11,  MP4_ReadBox_sample_soun,    MP4_FreeBox_sample_soun },
2585     { FOURCC_ms55,  MP4_ReadBox_sample_soun,    MP4_FreeBox_sample_soun },
2586     { FOURCC__mp3,  MP4_ReadBox_sample_soun,    MP4_FreeBox_sample_soun },
2587     { FOURCC_mp4a,  MP4_ReadBox_sample_soun,    MP4_FreeBox_sample_soun },
2588     { FOURCC_twos,  MP4_ReadBox_sample_soun,    MP4_FreeBox_sample_soun },
2589     { FOURCC_sowt,  MP4_ReadBox_sample_soun,    MP4_FreeBox_sample_soun },
2590     { FOURCC_QDMC,  MP4_ReadBox_sample_soun,    MP4_FreeBox_sample_soun },
2591     { FOURCC_QDM2,  MP4_ReadBox_sample_soun,    MP4_FreeBox_sample_soun },
2592     { FOURCC_ima4,  MP4_ReadBox_sample_soun,    MP4_FreeBox_sample_soun },
2593     { FOURCC_IMA4,  MP4_ReadBox_sample_soun,    MP4_FreeBox_sample_soun },
2594     { FOURCC_dvi,   MP4_ReadBox_sample_soun,    MP4_FreeBox_sample_soun },
2595     { FOURCC_alaw,  MP4_ReadBox_sample_soun,    MP4_FreeBox_sample_soun },
2596     { FOURCC_ulaw,  MP4_ReadBox_sample_soun,    MP4_FreeBox_sample_soun },
2597     { FOURCC_raw,   MP4_ReadBox_sample_soun,    MP4_FreeBox_sample_soun },
2598     { FOURCC_MAC3,  MP4_ReadBox_sample_soun,    MP4_FreeBox_sample_soun },
2599     { FOURCC_MAC6,  MP4_ReadBox_sample_soun,    MP4_FreeBox_sample_soun },
2600     { FOURCC_Qclp,  MP4_ReadBox_sample_soun,    MP4_FreeBox_sample_soun },
2601     { FOURCC_samr,  MP4_ReadBox_sample_soun,    MP4_FreeBox_sample_soun },
2602     { FOURCC_sawb,  MP4_ReadBox_sample_soun,    MP4_FreeBox_sample_soun },
2603     { FOURCC_OggS,  MP4_ReadBox_sample_soun,    MP4_FreeBox_sample_soun },
2604     { FOURCC_alac,  MP4_ReadBox_sample_soun,    MP4_FreeBox_sample_soun },
2605
2606     { FOURCC_drmi,  MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2607     { FOURCC_vide,  MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2608     { FOURCC_mp4v,  MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2609     { FOURCC_SVQ1,  MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2610     { FOURCC_SVQ3,  MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2611     { FOURCC_ZyGo,  MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2612     { FOURCC_DIVX,  MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2613     { FOURCC_XVID,  MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2614     { FOURCC_h263,  MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2615     { FOURCC_s263,  MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2616     { FOURCC_cvid,  MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2617     { FOURCC_3IV1,  MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2618     { FOURCC_3iv1,  MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2619     { FOURCC_3IV2,  MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2620     { FOURCC_3iv2,  MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2621     { FOURCC_3IVD,  MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2622     { FOURCC_3ivd,  MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2623     { FOURCC_3VID,  MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2624     { FOURCC_3vid,  MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2625     { FOURCC_mjpa,  MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2626     { FOURCC_mjpb,  MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2627     { FOURCC_qdrw,  MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2628     { FOURCC_mp2v,  MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2629     { FOURCC_hdv2,  MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2630
2631     { FOURCC_mjqt,  MP4_ReadBox_default,        NULL }, /* found in mjpa/b */
2632     { FOURCC_mjht,  MP4_ReadBox_default,        NULL },
2633
2634     { FOURCC_dvc,   MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2635     { FOURCC_dvp,   MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2636     { FOURCC_dv5n,  MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2637     { FOURCC_dv5p,  MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2638     { FOURCC_VP31,  MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2639     { FOURCC_vp31,  MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2640     { FOURCC_h264,  MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2641
2642     { FOURCC_jpeg,  MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2643     { FOURCC_avc1,  MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2644
2645     { FOURCC_yv12,  MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2646     { FOURCC_yuv2,  MP4_ReadBox_sample_vide,    MP4_FreeBox_sample_vide },
2647
2648     { FOURCC_mp4s,  MP4_ReadBox_sample_mp4s,    MP4_FreeBox_Common },
2649
2650     /* XXX there is 2 box where we could find this entry stbl and tref*/
2651     { FOURCC_hint,  MP4_ReadBox_default,        MP4_FreeBox_Common },
2652
2653     /* found in tref box */
2654     { FOURCC_dpnd,  MP4_ReadBox_default,   NULL },
2655     { FOURCC_ipir,  MP4_ReadBox_default,   NULL },
2656     { FOURCC_mpod,  MP4_ReadBox_default,   NULL },
2657     { FOURCC_chap,  MP4_ReadBox_tref_generic,   MP4_FreeBox_tref_generic },
2658
2659     /* found in hnti */
2660     { FOURCC_rtp,   MP4_ReadBox_default,   NULL },
2661
2662     /* found in rmra */
2663     { FOURCC_rdrf,  MP4_ReadBox_rdrf,           MP4_FreeBox_rdrf   },
2664     { FOURCC_rmdr,  MP4_ReadBox_rmdr,           MP4_FreeBox_Common },
2665     { FOURCC_rmqu,  MP4_ReadBox_rmqu,           MP4_FreeBox_Common },
2666     { FOURCC_rmvc,  MP4_ReadBox_rmvc,           MP4_FreeBox_Common },
2667
2668     { FOURCC_drms,  MP4_ReadBox_sample_soun,    MP4_FreeBox_sample_soun },
2669     { FOURCC_sinf,  MP4_ReadBoxContainer,       MP4_FreeBox_Common },
2670     { FOURCC_schi,  MP4_ReadBoxContainer,       MP4_FreeBox_Common },
2671     { FOURCC_user,  MP4_ReadBox_drms,           MP4_FreeBox_Common },
2672     { FOURCC_key,   MP4_ReadBox_drms,           MP4_FreeBox_Common },
2673     { FOURCC_iviv,  MP4_ReadBox_drms,           MP4_FreeBox_Common },
2674     { FOURCC_name,  MP4_ReadBox_drms,           MP4_FreeBox_Common },
2675     { FOURCC_priv,  MP4_ReadBox_drms,           MP4_FreeBox_Common },
2676     { FOURCC_frma,  MP4_ReadBox_frma,           MP4_FreeBox_Common },
2677     { FOURCC_skcr,  MP4_ReadBox_skcr,           MP4_FreeBox_Common },
2678
2679     /* found in udta */
2680     { FOURCC_0xa9nam,MP4_ReadBox_0xa9xxx,       MP4_FreeBox_0xa9xxx },
2681     { FOURCC_0xa9aut,MP4_ReadBox_0xa9xxx,       MP4_FreeBox_0xa9xxx },
2682     { FOURCC_0xa9cpy,MP4_ReadBox_0xa9xxx,       MP4_FreeBox_0xa9xxx },
2683     { FOURCC_0xa9swr,MP4_ReadBox_0xa9xxx,       MP4_FreeBox_0xa9xxx },
2684     { FOURCC_0xa9inf,MP4_ReadBox_0xa9xxx,       MP4_FreeBox_0xa9xxx },
2685     { FOURCC_0xa9ART,MP4_ReadBox_0xa9xxx,       MP4_FreeBox_0xa9xxx },
2686     { FOURCC_0xa9dir,MP4_ReadBox_0xa9xxx,       MP4_FreeBox_0xa9xxx },
2687     { FOURCC_0xa9cmt,MP4_ReadBox_0xa9xxx,       MP4_FreeBox_0xa9xxx },
2688     { FOURCC_0xa9req,MP4_ReadBox_0xa9xxx,       MP4_FreeBox_0xa9xxx },
2689     { FOURCC_0xa9day,MP4_ReadBox_0xa9xxx,       MP4_FreeBox_0xa9xxx },
2690     { FOURCC_0xa9des,MP4_ReadBox_0xa9xxx,       MP4_FreeBox_0xa9xxx },
2691     { FOURCC_0xa9fmt,MP4_ReadBox_0xa9xxx,       MP4_FreeBox_0xa9xxx },
2692     { FOURCC_0xa9prd,MP4_ReadBox_0xa9xxx,       MP4_FreeBox_0xa9xxx },
2693     { FOURCC_0xa9prf,MP4_ReadBox_0xa9xxx,       MP4_FreeBox_0xa9xxx },
2694     { FOURCC_0xa9src,MP4_ReadBox_0xa9xxx,       MP4_FreeBox_0xa9xxx },
2695     { FOURCC_0xa9alb,MP4_ReadBox_0xa9xxx,       MP4_FreeBox_0xa9xxx },
2696     { FOURCC_0xa9dis,MP4_ReadBox_0xa9xxx,       MP4_FreeBox_0xa9xxx },
2697     { FOURCC_0xa9enc,MP4_ReadBox_0xa9xxx,       MP4_FreeBox_0xa9xxx },
2698     { FOURCC_0xa9gen,MP4_ReadBox_0xa9xxx,       MP4_FreeBox_0xa9xxx },
2699     { FOURCC_0xa9trk,MP4_ReadBox_0xa9xxx,       MP4_FreeBox_0xa9xxx },
2700     { FOURCC_0xa9dsa,MP4_ReadBox_0xa9xxx,       MP4_FreeBox_0xa9xxx },
2701     { FOURCC_0xa9hst,MP4_ReadBox_0xa9xxx,       MP4_FreeBox_0xa9xxx },
2702     { FOURCC_0xa9url,MP4_ReadBox_0xa9xxx,       MP4_FreeBox_0xa9xxx },
2703     { FOURCC_0xa9ope,MP4_ReadBox_0xa9xxx,       MP4_FreeBox_0xa9xxx },
2704     { FOURCC_0xa9com,MP4_ReadBox_0xa9xxx,       MP4_FreeBox_0xa9xxx },
2705
2706     { FOURCC_chpl,   MP4_ReadBox_chpl,          MP4_FreeBox_chpl },
2707
2708     /* iTunes/Quicktime meta info */
2709     { FOURCC_meta,  MP4_ReadBox_meta,       MP4_FreeBox_Common },
2710
2711     /* Last entry */
2712     { 0,             MP4_ReadBox_default,       NULL }
2713 };
2714
2715
2716
2717 /*****************************************************************************
2718  * MP4_ReadBox : parse the actual box and the children
2719  *  XXX : Do not go to the next box
2720  *****************************************************************************/
2721 static MP4_Box_t *MP4_ReadBox( stream_t *p_stream, MP4_Box_t *p_father )
2722 {
2723     MP4_Box_t    *p_box = calloc( 1, sizeof( MP4_Box_t ) ); /* Needed to ensure simple on error handler */
2724     unsigned int i_index;
2725
2726     if( p_box == NULL )
2727         return NULL;
2728
2729     if( !MP4_ReadBoxCommon( p_stream, p_box ) )
2730     {
2731         msg_Warn( p_stream, "cannot read one box" );
2732         free( p_box );
2733         return NULL;
2734     }
2735     if( !p_box->i_size )
2736     {
2737         msg_Dbg( p_stream, "found an empty box (null size)" );
2738         free( p_box );
2739         return NULL;
2740     }
2741     p_box->p_father = p_father;
2742
2743     /* Now search function to call */
2744     for( i_index = 0; ; i_index++ )
2745     {
2746         if( ( MP4_Box_Function[i_index].i_type == p_box->i_type )||
2747             ( MP4_Box_Function[i_index].i_type == 0 ) )
2748         {
2749             break;
2750         }
2751     }
2752
2753     if( !(MP4_Box_Function[i_index].MP4_ReadBox_function)( p_stream, p_box ) )
2754     {
2755         MP4_BoxFree( p_stream, p_box );
2756         return NULL;
2757     }
2758
2759     return p_box;
2760 }
2761
2762 /*****************************************************************************
2763  * MP4_FreeBox : free memory after read with MP4_ReadBox and all
2764  * the children
2765  *****************************************************************************/
2766 void MP4_BoxFree( stream_t *s, MP4_Box_t *p_box )
2767 {
2768     unsigned int i_index;
2769     MP4_Box_t    *p_child;
2770
2771     if( !p_box )
2772         return; /* hehe */
2773
2774     for( p_child = p_box->p_first; p_child != NULL; )
2775     {
2776         MP4_Box_t *p_next;
2777
2778         p_next = p_child->p_next;
2779         MP4_BoxFree( s, p_child );
2780         p_child = p_next;
2781     }
2782
2783     /* Now search function to call */
2784     if( p_box->data.p_data )
2785     {
2786         for( i_index = 0; ; i_index++ )
2787         {
2788             if( ( MP4_Box_Function[i_index].i_type == p_box->i_type )||
2789                 ( MP4_Box_Function[i_index].i_type == 0 ) )
2790             {
2791                 break;
2792             }
2793         }
2794         if( MP4_Box_Function[i_index].MP4_FreeBox_function == NULL )
2795         {
2796             /* Should not happen */
2797             if MP4_BOX_TYPE_ASCII()
2798                 msg_Warn( s,
2799                         "cannot free box %4.4s, type unknown",
2800                         (char*)&p_box->i_type );
2801             else
2802                 msg_Warn( s,
2803                         "cannot free box c%3.3s, type unknown",
2804                         (char*)&p_box->i_type+1 );
2805         }
2806         else
2807         {
2808             MP4_Box_Function[i_index].MP4_FreeBox_function( p_box );
2809         }
2810         free( p_box->data.p_data );
2811     }
2812     free( p_box );
2813 }
2814
2815 /*****************************************************************************
2816  * MP4_BoxGetRoot : Parse the entire file, and create all boxes in memory
2817  *****************************************************************************
2818  *  The first box is a virtual box "root" and is the father for all first
2819  *  level boxes for the file, a sort of virtual contener
2820  *****************************************************************************/
2821 MP4_Box_t *MP4_BoxGetRoot( stream_t *s )
2822 {
2823     MP4_Box_t *p_root;
2824     stream_t *p_stream;
2825     int i_result;
2826
2827     p_root = malloc( sizeof( MP4_Box_t ) );
2828     if( p_root == NULL )
2829         return NULL;
2830
2831     p_root->i_pos = 0;
2832     p_root->i_type = VLC_FOURCC( 'r', 'o', 'o', 't' );
2833     p_root->i_shortsize = 1;
2834     p_root->i_size = stream_Size( s );
2835     CreateUUID( &p_root->i_uuid, p_root->i_type );
2836
2837     p_root->data.p_data = NULL;
2838     p_root->p_father = NULL;
2839     p_root->p_first  = NULL;
2840     p_root->p_last  = NULL;
2841     p_root->p_next   = NULL;
2842
2843     p_stream = s;
2844
2845     i_result = MP4_ReadBoxContainerRaw( p_stream, p_root );
2846
2847     if( i_result )
2848     {
2849         MP4_Box_t *p_child;
2850         MP4_Box_t *p_moov;
2851         MP4_Box_t *p_cmov;
2852
2853         /* check if there is a cmov, if so replace
2854           compressed moov by  uncompressed one */
2855         if( ( ( p_moov = MP4_BoxGet( p_root, "moov" ) ) &&
2856               ( p_cmov = MP4_BoxGet( p_root, "moov/cmov" ) ) ) ||
2857             ( ( p_moov = MP4_BoxGet( p_root, "foov" ) ) &&
2858               ( p_cmov = MP4_BoxGet( p_root, "foov/cmov" ) ) ) )
2859         {
2860             /* rename the compressed moov as a box to skip */
2861             p_moov->i_type = FOURCC_skip;
2862
2863             /* get uncompressed p_moov */
2864             p_moov = p_cmov->data.p_cmov->p_moov;
2865             p_cmov->data.p_cmov->p_moov = NULL;
2866
2867             /* make p_root father of this new moov */
2868             p_moov->p_father = p_root;
2869
2870             /* insert this new moov box as first child of p_root */
2871             p_moov->p_next = p_child = p_root->p_first;
2872             p_root->p_first = p_moov;
2873         }
2874     }
2875
2876     return p_root;
2877 }
2878
2879
2880 static void __MP4_BoxDumpStructure( stream_t *s,
2881                                     MP4_Box_t *p_box, unsigned int i_level )
2882 {
2883     MP4_Box_t *p_child;
2884
2885     if( !i_level )
2886     {
2887         if MP4_BOX_TYPE_ASCII()
2888             msg_Dbg( s, "dumping root Box \"%4.4s\"",
2889                               (char*)&p_box->i_type );
2890         else
2891             msg_Dbg( s, "dumping root Box \"c%3.3s\"",
2892                               (char*)&p_box->i_type+1 );
2893     }
2894     else
2895     {
2896         unsigned int i;
2897
2898         char str[512];
2899         if( i_level * 5 + 1 >= sizeof(str) )
2900             return;
2901
2902         memset( str, ' ', sizeof(str) );
2903         for( i = 0; i < i_level; i++ )
2904         {
2905             str[i*5] = '|';
2906         }
2907         if( MP4_BOX_TYPE_ASCII() )
2908             snprintf( &str[i_level * 5], sizeof(str) - 5*i_level,
2909                       "+ %4.4s size %d",
2910                         (char*)&p_box->i_type, (uint32_t)p_box->i_size );
2911         else
2912             snprintf( &str[i_level * 5], sizeof(str) - 5*i_level,
2913                       "+ c%3.3s size %d",
2914                         (char*)&p_box->i_type+1, (uint32_t)p_box->i_size );
2915         msg_Dbg( s, "%s", str );
2916     }
2917     p_child = p_box->p_first;
2918     while( p_child )
2919     {
2920         __MP4_BoxDumpStructure( s, p_child, i_level + 1 );
2921         p_child = p_child->p_next;
2922     }
2923 }
2924
2925 void MP4_BoxDumpStructure( stream_t *s, MP4_Box_t *p_box )
2926 {
2927     __MP4_BoxDumpStructure( s, p_box, 0 );
2928 }
2929
2930
2931
2932 /*****************************************************************************
2933  *****************************************************************************
2934  **
2935  **  High level methods to acces an MP4 file
2936  **
2937  *****************************************************************************
2938  *****************************************************************************/
2939 static void __get_token( char **ppsz_path, char **ppsz_token, int *pi_number )
2940 {
2941     size_t i_len ;
2942     if( !*ppsz_path[0] )
2943     {
2944         *ppsz_token = NULL;
2945         *pi_number = 0;
2946         return;
2947     }
2948     i_len = 0;
2949     while(  (*ppsz_path)[i_len] &&
2950             (*ppsz_path)[i_len] != '/' && (*ppsz_path)[i_len] != '[' )
2951     {
2952         i_len++;
2953     }
2954     if( !i_len && **ppsz_path == '/' )
2955     {
2956         i_len = 1;
2957     }
2958     *ppsz_token = malloc( i_len + 1 );
2959
2960     memcpy( *ppsz_token, *ppsz_path, i_len );
2961
2962     (*ppsz_token)[i_len] = '\0';
2963
2964     *ppsz_path += i_len;
2965
2966     if( **ppsz_path == '[' )
2967     {
2968         (*ppsz_path)++;
2969         *pi_number = strtol( *ppsz_path, NULL, 10 );
2970         while( **ppsz_path && **ppsz_path != ']' )
2971         {
2972             (*ppsz_path)++;
2973         }
2974         if( **ppsz_path == ']' )
2975         {
2976             (*ppsz_path)++;
2977         }
2978     }
2979     else
2980     {
2981         *pi_number = 0;
2982     }
2983     while( **ppsz_path == '/' )
2984     {
2985         (*ppsz_path)++;
2986     }
2987 }
2988
2989 static void __MP4_BoxGet( MP4_Box_t **pp_result,
2990                           MP4_Box_t *p_box, const char *psz_fmt, va_list args)
2991 {
2992     char *psz_dup;
2993     char *psz_path;
2994
2995     if( !p_box )
2996     {
2997         *pp_result = NULL;
2998         return;
2999     }
3000
3001     if( vasprintf( &psz_path, psz_fmt, args ) == -1 )
3002         psz_path = NULL;
3003
3004     if( !psz_path || !psz_path[0] )
3005     {
3006         free( psz_path );
3007         *pp_result = NULL;
3008         return;
3009     }
3010
3011 //    fprintf( stderr, "path:'%s'\n", psz_path );
3012     psz_dup = psz_path; /* keep this pointer, as it need to be unallocated */
3013     for( ; ; )
3014     {
3015         char *psz_token;
3016         int i_number;
3017
3018         __get_token( &psz_path, &psz_token, &i_number );
3019 //        fprintf( stderr, "path:'%s', token:'%s' n:%d\n",
3020 //                 psz_path,psz_token,i_number );
3021         if( !psz_token )
3022         {
3023             free( psz_dup );
3024             *pp_result = p_box;
3025             return;
3026         }
3027         else
3028         if( !strcmp( psz_token, "/" ) )
3029         {
3030             /* Find root box */
3031             while( p_box && p_box->i_type != VLC_FOURCC( 'r', 'o', 'o', 't' ) )
3032             {
3033                 p_box = p_box->p_father;
3034             }
3035             if( !p_box )
3036             {
3037                 free( psz_token );
3038                 free( psz_dup );
3039                 *pp_result = NULL;
3040                 return;
3041             }
3042         }
3043         else
3044         if( !strcmp( psz_token, "." ) )
3045         {
3046             /* Do nothing */
3047         }
3048         else
3049         if( !strcmp( psz_token, ".." ) )
3050         {
3051             p_box = p_box->p_father;
3052             if( !p_box )
3053             {
3054                 free( psz_token );
3055                 free( psz_dup );
3056                 *pp_result = NULL;
3057                 return;
3058             }
3059         }
3060         else
3061         if( strlen( psz_token ) == 4 )
3062         {
3063             uint32_t i_fourcc;
3064             i_fourcc = VLC_FOURCC( psz_token[0], psz_token[1],
3065                                    psz_token[2], psz_token[3] );
3066             p_box = p_box->p_first;
3067             for( ; ; )
3068             {
3069                 if( !p_box )
3070                 {
3071                     free( psz_token );
3072                     free( psz_dup );
3073                     *pp_result = NULL;
3074                     return;
3075                 }
3076                 if( p_box->i_type == i_fourcc )
3077                 {
3078                     if( !i_number )
3079                     {
3080                         break;
3081                     }
3082                     i_number--;
3083                 }
3084                 p_box = p_box->p_next;
3085             }
3086         }
3087         else
3088         if( strlen( psz_token ) == 0 )
3089         {
3090             p_box = p_box->p_first;
3091             for( ; ; )
3092             {
3093                 if( !p_box )
3094                 {
3095                     free( psz_token );
3096                     free( psz_dup );
3097                     *pp_result = NULL;
3098                     return;
3099                 }
3100                 if( !i_number )
3101                 {
3102                     break;
3103                 }
3104                 i_number--;
3105                 p_box = p_box->p_next;
3106             }
3107         }
3108         else
3109         {
3110 //            fprintf( stderr, "Argg malformed token \"%s\"",psz_token );
3111             FREENULL( psz_token );
3112             free( psz_dup );
3113             *pp_result = NULL;
3114             return;
3115         }
3116
3117         free( psz_token );
3118     }
3119 }
3120
3121 /*****************************************************************************
3122  * MP4_BoxGet: find a box given a path relative to p_box
3123  *****************************************************************************
3124  * Path Format: . .. / as usual
3125  *              [number] to specifie box number ex: trak[12]
3126  *
3127  * ex: /moov/trak[12]
3128  *     ../mdia
3129  *****************************************************************************/
3130 MP4_Box_t *MP4_BoxGet( MP4_Box_t *p_box, const char *psz_fmt, ... )
3131 {
3132     va_list args;
3133     MP4_Box_t *p_result;
3134
3135     va_start( args, psz_fmt );
3136     __MP4_BoxGet( &p_result, p_box, psz_fmt, args );
3137     va_end( args );
3138
3139     return( p_result );
3140 }
3141
3142 /*****************************************************************************
3143  * MP4_BoxCount: count box given a path relative to p_box
3144  *****************************************************************************
3145  * Path Format: . .. / as usual
3146  *              [number] to specifie box number ex: trak[12]
3147  *
3148  * ex: /moov/trak[12]
3149  *     ../mdia
3150  *****************************************************************************/
3151 int MP4_BoxCount( MP4_Box_t *p_box, const char *psz_fmt, ... )
3152 {
3153     va_list args;
3154     int     i_count;
3155     MP4_Box_t *p_result, *p_next;
3156
3157     va_start( args, psz_fmt );
3158     __MP4_BoxGet( &p_result, p_box, psz_fmt, args );
3159     va_end( args );
3160     if( !p_result )
3161     {
3162         return( 0 );
3163     }
3164
3165     i_count = 1;
3166     for( p_next = p_result->p_next; p_next != NULL; p_next = p_next->p_next)
3167     {
3168         if( p_next->i_type == p_result->i_type)
3169         {
3170             i_count++;
3171         }
3172     }
3173     return( i_count );
3174 }