git.sesse.net Git - vlc/blob - modules/demux/asf/libasf.c

   1 /*****************************************************************************
   2  * libasf.c : asf stream demux module for vlc
   3  *****************************************************************************
   4  * Copyright © 2001-2004, 2006-2008 VLC authors and VideoLAN
   5  *
   6  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
   7  *          Gildas Bazin <gbazin@videolan.org>
   8  *
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU Lesser General Public License as published by
  11  * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public License
  20  * along with this program; if not, write to the Free Software Foundation,
  21  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 #ifdef HAVE_CONFIG_H
  25 # include "config.h"
  26 #endif
  27
  28 #include <vlc_demux.h>
  29 #include <vlc_charset.h>          /* FromCharset */
  30
  31 #include "libasf.h"
  32
  33 #ifndef NDEBUG
  34 # define ASF_DEBUG 1
  35 #endif
  36
  37 /* Helpers:
  38  * They ensure that invalid reads will not create problems.
  39  * They are expansion safe
  40  * They make the following assumptions:
  41  *  const uint8_t *p_peek exists and points to the start of a buffer
  42  *  int i_peek gives the size of the buffer pointed by p_peek
  43  *  const uint8_t *p_data exits and points to the data inside p_peek to be read.
  44  */
  45 /* ASF_HAVE(n):
  46  *  Check that n bytes can be read */
  47 static inline bool AsfObjectHelperHave( const uint8_t *p_peek, int i_peek, const uint8_t *p_current, int i_wanted )
  48 {
  49     if( i_wanted < 0 || i_wanted > i_peek )
  50         return false;
  51     return &p_current[i_wanted] <= &p_peek[i_peek];
  52 }
  53 #define ASF_HAVE(n) AsfObjectHelperHave( p_peek, i_peek, p_data, n )
  54
  55 /* ASF_SKIP(n)
  56  *  Skip n bytes if possible */
  57 static inline void AsfObjectHelperSkip( const uint8_t *p_peek, int i_peek, uint8_t **pp_data, int i_wanted )
  58 {
  59     if( AsfObjectHelperHave( p_peek, i_peek, *pp_data, i_wanted ) )
  60         *pp_data += i_wanted;
  61     else
  62         *pp_data = (uint8_t*)&p_peek[i_peek];
  63 }
  64 #define ASF_SKIP(n) AsfObjectHelperSkip( p_peek, i_peek, (uint8_t**)&p_data, n )
  65
  66 /* ASF_READX()
  67  *  Read X byte if possible, else return 0 */
  68 #define ASF_FUNCTION_READ_X(type, x, cmd ) \
  69 static inline type AsfObjectHelperRead##x( const uint8_t *p_peek, int i_peek, uint8_t **pp_data ) { \
  70     uint8_t *p_data = *pp_data; \
  71     type i_ret = 0;  \
  72     if( ASF_HAVE(x) )   \
  73         i_ret = cmd;    \
  74     ASF_SKIP(x);        \
  75     *pp_data = p_data;  \
  76     return i_ret;   }
  77 ASF_FUNCTION_READ_X( uint8_t,  1, *p_data )
  78 ASF_FUNCTION_READ_X( uint16_t, 2, GetWLE(p_data) )
  79 ASF_FUNCTION_READ_X( uint32_t, 4, GetDWLE(p_data) )
  80 ASF_FUNCTION_READ_X( uint64_t, 8, GetQWLE(p_data) )
  81 #define ASF_READ1() AsfObjectHelperRead1( p_peek, i_peek, (uint8_t**)&p_data )
  82 #define ASF_READ2() AsfObjectHelperRead2( p_peek, i_peek, (uint8_t**)&p_data )
  83 #define ASF_READ4() AsfObjectHelperRead4( p_peek, i_peek, (uint8_t**)&p_data )
  84 #define ASF_READ8() AsfObjectHelperRead8( p_peek, i_peek, (uint8_t**)&p_data )
  85
  86 /* ASF_READS(n)
  87  *  Read a string of n/2 wchar long ie n bytes. Do a stupid conversion (suppose latin1)
  88  *  Return allocated "" if not possible */
  89 static char *AsfObjectHelperReadString( const uint8_t *p_peek, int i_peek, uint8_t **pp_data, int i_size )
  90 {
  91     uint8_t *p_data = *pp_data;
  92     char *psz_string;
  93     if( ASF_HAVE(i_size) )
  94     {
  95         psz_string = calloc( i_size/2 + 1, sizeof( char ) );
  96         if( psz_string )
  97         {
  98             for( int i = 0; i < i_size/2; i++ )
  99                 psz_string[i] = GetWLE( &p_data[2*i] );
 100             psz_string[i_size/2] = '\0';
 101         }
 102     }
 103     else
 104     {
 105         psz_string = strdup("");
 106     }
 107     ASF_SKIP(i_size);
 108     *pp_data = p_data;
 109     return psz_string;
 110 }
 111 #define ASF_READS(n) AsfObjectHelperReadString( p_peek, i_peek, (uint8_t**)&p_data, n )
 112
 113 /****************************************************************************
 114  *
 115  ****************************************************************************/
 116 static int ASF_ReadObject( stream_t *, asf_object_t *,  asf_object_t * );
 117
 118 /****************************************************************************
 119  *
 120  ****************************************************************************/
 121 static int ASF_ReadObjectCommon( stream_t *s, asf_object_t *p_obj )
 122 {
 123     asf_object_common_t *p_common = &p_obj->common;
 124     const uint8_t *p_peek;
 125
 126     if( stream_Peek( s, &p_peek, 24 ) < 24 )
 127         return VLC_EGENERIC;
 128
 129     ASF_GetGUID( &p_common->i_object_id, p_peek );
 130     p_common->i_object_size = GetQWLE( p_peek + 16 );
 131     p_common->i_object_pos  = stream_Tell( s );
 132     p_common->p_next = NULL;
 133
 134 #ifdef ASF_DEBUG
 135     msg_Dbg( s,
 136              "found object guid: " GUID_FMT " size:%"PRId64" at %"PRId64,
 137              GUID_PRINT( p_common->i_object_id ),
 138              p_common->i_object_size, p_common->i_object_pos );
 139 #endif
 140
 141     return VLC_SUCCESS;
 142 }
 143
 144 static int ASF_NextObject( stream_t *s, asf_object_t *p_obj, uint64_t i_boundary )
 145 {
 146     asf_object_t obj;
 147
 148     int64_t i_pos = stream_Tell( s );
 149     if ( i_boundary && i_pos >= 0 && (uint64_t) i_pos >= i_boundary )
 150     {
 151         return VLC_EGENERIC;
 152     }
 153
 154     if( p_obj == NULL )
 155     {
 156         if( ASF_ReadObjectCommon( s, &obj ) )
 157             return VLC_EGENERIC;
 158
 159         p_obj = &obj;
 160     }
 161
 162     if( p_obj->common.i_object_size <= 0 )
 163         return VLC_EGENERIC;
 164
 165     if( p_obj->common.p_father &&
 166         p_obj->common.p_father->common.i_object_size != 0 )
 167     {
 168         if( p_obj->common.p_father->common.i_object_pos +
 169             p_obj->common.p_father->common.i_object_size <
 170                 p_obj->common.i_object_pos + p_obj->common.i_object_size + 24 )
 171                                 /* 24 is min size of an object */
 172         {
 173             return VLC_EGENERIC;
 174         }
 175
 176     }
 177
 178     return stream_Seek( s, p_obj->common.i_object_pos +
 179                         p_obj->common.i_object_size );
 180 }
 181
 182 static void ASF_FreeObject_Null( asf_object_t *pp_obj )
 183 {
 184     VLC_UNUSED(pp_obj);
 185 }
 186
 187 static int  ASF_ReadObject_Header( stream_t *s, asf_object_t *p_obj )
 188 {
 189     asf_object_header_t *p_hdr = &p_obj->header;
 190     asf_object_t        *p_subobj;
 191     const uint8_t       *p_peek;
 192
 193     if( stream_Peek( s, &p_peek, 30 ) < 30 )
 194        return VLC_EGENERIC;
 195
 196     p_hdr->i_sub_object_count = GetDWLE( p_peek + 24 );
 197     p_hdr->i_reserved1 = p_peek[28];
 198     p_hdr->i_reserved2 = p_peek[29];
 199     p_hdr->p_first = NULL;
 200     p_hdr->p_last  = NULL;
 201
 202 #ifdef ASF_DEBUG
 203     msg_Dbg( s,
 204              "read \"header object\" subobj:%d, reserved1:%d, reserved2:%d",
 205              p_hdr->i_sub_object_count,
 206              p_hdr->i_reserved1,
 207              p_hdr->i_reserved2 );
 208 #endif
 209
 210     /* Cannot fail as peek succeed */
 211     stream_Read( s, NULL, 30 );
 212
 213     /* Now load sub object */
 214     for( ; ; )
 215     {
 216         p_subobj = malloc( sizeof( asf_object_t ) );
 217
 218         if( !p_subobj || ASF_ReadObject( s, p_subobj, (asf_object_t*)p_hdr ) )
 219         {
 220             free( p_subobj );
 221             break;
 222         }
 223         if( ASF_NextObject( s, p_subobj, 0 ) ) /* Go to the next object */
 224             break;
 225     }
 226     return VLC_SUCCESS;
 227 }
 228
 229 static int ASF_ReadObject_Data( stream_t *s, asf_object_t *p_obj )
 230 {
 231     asf_object_data_t *p_data = &p_obj->data;
 232     const uint8_t     *p_peek;
 233
 234     if( stream_Peek( s, &p_peek, 50 ) < 50 )
 235        return VLC_EGENERIC;
 236
 237     ASF_GetGUID( &p_data->i_file_id, p_peek + 24 );
 238     p_data->i_total_data_packets = GetQWLE( p_peek + 40 );
 239     p_data->i_reserved = GetWLE( p_peek + 48 );
 240
 241 #ifdef ASF_DEBUG
 242     msg_Dbg( s,
 243              "read \"data object\" file_id:" GUID_FMT " total data packet:"
 244              "%"PRId64" reserved:%d",
 245              GUID_PRINT( p_data->i_file_id ),
 246              p_data->i_total_data_packets,
 247              p_data->i_reserved );
 248 #endif
 249
 250     return VLC_SUCCESS;
 251 }
 252
 253 static int ASF_ReadObject_Index( stream_t *s, asf_object_t *p_obj )
 254 {
 255     asf_object_index_t *p_index = &p_obj->index;
 256     const uint8_t      *p_peek;
 257     unsigned int       i;
 258
 259     /* We just ignore error on the index */
 260     if( stream_Peek( s, &p_peek, p_index->i_object_size ) <
 261         __MAX( (int64_t)p_index->i_object_size, 56 ) )
 262         return VLC_SUCCESS;
 263
 264     ASF_GetGUID( &p_index->i_file_id, p_peek + 24 );
 265     p_index->i_index_entry_time_interval = GetQWLE( p_peek + 40 );
 266     p_index->i_max_packet_count = GetDWLE( p_peek + 48 );
 267     p_index->i_index_entry_count = GetDWLE( p_peek + 52 );
 268     p_index->index_entry = NULL;
 269
 270 #ifdef ASF_DEBUG
 271     msg_Dbg( s,
 272             "read \"index object\" file_id:" GUID_FMT
 273             " index_entry_time_interval:%"PRId64" max_packet_count:%d "
 274             "index_entry_count:%ld",
 275             GUID_PRINT( p_index->i_file_id ),
 276             p_index->i_index_entry_time_interval,
 277             p_index->i_max_packet_count,
 278             (long int)p_index->i_index_entry_count );
 279 #endif
 280
 281     /* Sanity checking */
 282     if( p_index->i_index_entry_count > (p_index->i_object_size - 56) / 6 )
 283         p_index->i_index_entry_count = (p_index->i_object_size - 56) / 6;
 284
 285     p_index->index_entry = calloc( p_index->i_index_entry_count,
 286                                    sizeof(asf_index_entry_t) );
 287     if( !p_index->index_entry )
 288         return VLC_ENOMEM;
 289
 290     for( i = 0, p_peek += 56; i < p_index->i_index_entry_count; i++, p_peek += 6 )
 291     {
 292         p_index->index_entry[i].i_packet_number = GetDWLE( p_peek );
 293         p_index->index_entry[i].i_packet_count = GetWLE( p_peek + 4 );
 294     }
 295
 296     return VLC_SUCCESS;
 297 }
 298
 299 static void ASF_FreeObject_Index( asf_object_t *p_obj )
 300 {
 301     asf_object_index_t *p_index = &p_obj->index;
 302
 303     FREENULL( p_index->index_entry );
 304 }
 305
 306 static int ASF_ReadObject_file_properties( stream_t *s, asf_object_t *p_obj )
 307 {
 308     asf_object_file_properties_t *p_fp = &p_obj->file_properties;
 309     const uint8_t *p_peek;
 310
 311     if( stream_Peek( s, &p_peek,  104 ) < 104 )
 312        return VLC_EGENERIC;
 313
 314     ASF_GetGUID( &p_fp->i_file_id, p_peek + 24 );
 315     p_fp->i_file_size = GetQWLE( p_peek + 40 );
 316     p_fp->i_creation_date = GetQWLE( p_peek + 48 );
 317     p_fp->i_data_packets_count = GetQWLE( p_peek + 56 );
 318     p_fp->i_play_duration = GetQWLE( p_peek + 64 );
 319     p_fp->i_send_duration = GetQWLE( p_peek + 72 );
 320     p_fp->i_preroll = GetQWLE( p_peek + 80 );
 321     p_fp->i_flags = GetDWLE( p_peek + 88 );
 322     p_fp->i_min_data_packet_size = __MAX( GetDWLE( p_peek + 92 ), (uint32_t) 1 );
 323     p_fp->i_max_data_packet_size = __MAX( GetDWLE( p_peek + 96 ), (uint32_t) 1 );
 324     p_fp->i_max_bitrate = GetDWLE( p_peek + 100 );
 325
 326 #ifdef ASF_DEBUG
 327     msg_Dbg( s,
 328             "read \"file properties object\" file_id:" GUID_FMT
 329             " file_size:%"PRId64" creation_date:%"PRId64" data_packets_count:"
 330             "%"PRId64" play_duration:%"PRId64" send_duration:%"PRId64" preroll:%"PRId64
 331             " flags:%d min_data_packet_size:%d "
 332             " max_data_packet_size:%d max_bitrate:%d",
 333             GUID_PRINT( p_fp->i_file_id ), p_fp->i_file_size,
 334             p_fp->i_creation_date, p_fp->i_data_packets_count,
 335             p_fp->i_play_duration, p_fp->i_send_duration,
 336             p_fp->i_preroll, p_fp->i_flags,
 337             p_fp->i_min_data_packet_size, p_fp->i_max_data_packet_size,
 338             p_fp->i_max_bitrate );
 339 #endif
 340
 341     return VLC_SUCCESS;
 342 }
 343
 344 static void ASF_FreeObject_metadata( asf_object_t *p_obj )
 345 {
 346     asf_object_metadata_t *p_meta = &p_obj->metadata;
 347
 348     for( unsigned int i = 0; i < p_meta->i_record_entries_count; i++ )
 349     {
 350         free( p_meta->record[i].psz_name );
 351         free( p_meta->record[i].p_data );
 352     }
 353     free( p_meta->record );
 354 }
 355
 356 static int ASF_ReadObject_metadata( stream_t *s, asf_object_t *p_obj )
 357 {
 358     asf_object_metadata_t *p_meta = &p_obj->metadata;
 359
 360     int i_peek;
 361     unsigned int i;
 362     const uint8_t *p_peek, *p_data;
 363
 364     if( ( i_peek = stream_Peek( s, &p_peek, p_meta->i_object_size ) ) <
 365         __MAX( (int64_t)p_meta->i_object_size, 26 ) )
 366        return VLC_EGENERIC;
 367
 368     p_meta->i_record_entries_count = GetWLE( p_peek + 24 );
 369
 370     p_data = p_peek + 26;
 371
 372     p_meta->record = calloc( p_meta->i_record_entries_count,
 373                              sizeof(asf_metadata_record_t) );
 374     if( !p_meta->record )
 375         return VLC_ENOMEM;
 376
 377     for( i = 0; i < p_meta->i_record_entries_count; i++ )
 378     {
 379         asf_metadata_record_t *p_record = &p_meta->record[i];
 380         int i_name;
 381         int i_data;
 382
 383         if( !ASF_HAVE( 2+2+2+2+4 ) )
 384             break;
 385
 386         if( ASF_READ2() != 0 )
 387             break;
 388
 389         p_record->i_stream = ASF_READ2();
 390         i_name = ASF_READ2();
 391         p_record->i_type = ASF_READ2();
 392         i_data = ASF_READ4();
 393
 394         if( !ASF_HAVE( i_name + i_data ) )
 395             break;
 396
 397         /* Read name */
 398         p_record->psz_name = ASF_READS( i_name );
 399
 400         /* Read data */
 401         if( p_record->i_type == ASF_METADATA_TYPE_STRING )
 402         {
 403             p_record->p_data = (uint8_t *)ASF_READS( i_data );
 404             p_record->i_data = i_data/2; /* FIXME Is that needed ? */
 405         }
 406         else if( p_record->i_type == ASF_METADATA_TYPE_BYTE )
 407         {
 408             p_record->p_data = malloc( i_data );
 409             p_record->i_data = i_data;
 410             if( p_record->p_data && i_data > 0 )
 411                 memcpy( p_record->p_data, p_data, i_data );
 412
 413             p_data += i_data;
 414         }
 415         else if( p_record->i_type == ASF_METADATA_TYPE_QWORD )
 416         {
 417             p_record->i_val = ASF_READ8();
 418         }
 419         else if( p_record->i_type == ASF_METADATA_TYPE_DWORD )
 420         {
 421             p_record->i_val = ASF_READ4();
 422         }
 423         else if( p_record->i_type == ASF_METADATA_TYPE_WORD )
 424         {
 425             p_record->i_val = ASF_READ2();
 426         }
 427         else if( p_record->i_type == ASF_METADATA_TYPE_BOOL )
 428         {
 429             p_record->i_val = ASF_READ2();
 430         }
 431         else
 432         {
 433             /* Unknown */
 434             p_data += i_data;
 435         }
 436     }
 437     p_meta->i_record_entries_count = i;
 438
 439 #ifdef ASF_DEBUG
 440     msg_Dbg( s,
 441             "read \"metadata object\" %d entries",
 442             p_meta->i_record_entries_count );
 443     for( unsigned int j = 0; j < p_meta->i_record_entries_count; j++ )
 444     {
 445         asf_metadata_record_t *p_rec = &p_meta->record[j];
 446
 447         if( p_rec->i_type == ASF_METADATA_TYPE_STRING )
 448             msg_Dbg( s, "  - %s=%s",
 449                      p_rec->psz_name, p_rec->p_data );
 450         else if( p_rec->i_type == ASF_METADATA_TYPE_BYTE )
 451             msg_Dbg( s, "  - %s (%i bytes)",
 452                      p_rec->psz_name, p_rec->i_data );
 453         else
 454             msg_Dbg( s, "  - %s=%"PRId64,
 455                      p_rec->psz_name, p_rec->i_val );
 456     }
 457 #endif
 458
 459     return VLC_SUCCESS;
 460 }
 461
 462 static int ASF_ReadObject_header_extension( stream_t *s, asf_object_t *p_obj )
 463 {
 464     asf_object_header_extension_t *p_he = &p_obj->header_extension;
 465     int     i_peek;
 466     const uint8_t *p_peek;
 467
 468     if( ( i_peek = stream_Peek( s, &p_peek, p_he->i_object_size ) ) <  46)
 469     {
 470        return VLC_EGENERIC;
 471     }
 472     ASF_GetGUID( &p_he->i_reserved1, p_peek + 24 );
 473     p_he->i_reserved2 = GetWLE( p_peek + 40 );
 474     p_he->i_header_extension_size = GetDWLE( p_peek + 42 );
 475     if( p_he->i_header_extension_size )
 476     {
 477         if( (unsigned int)(i_peek-46) < p_he->i_header_extension_size )
 478             return VLC_EGENERIC;
 479
 480         p_he->p_header_extension_data =
 481             malloc( p_he->i_header_extension_size );
 482         if( !p_he->p_header_extension_data )
 483             return VLC_ENOMEM;
 484
 485         memcpy( p_he->p_header_extension_data, p_peek + 46,
 486                 p_he->i_header_extension_size );
 487     }
 488     else
 489     {
 490         p_he->p_header_extension_data = NULL;
 491     }
 492
 493 #ifdef ASF_DEBUG
 494     msg_Dbg( s,
 495             "read \"header extension object\" reserved1:" GUID_FMT
 496             " reserved2:%d header_extension_size:%d",
 497             GUID_PRINT( p_he->i_reserved1 ), p_he->i_reserved2,
 498             p_he->i_header_extension_size );
 499 #endif
 500
 501     if( !p_he->i_header_extension_size ) return VLC_SUCCESS;
 502
 503     /* Read the extension objects */
 504     stream_Read( s, NULL, 46 );
 505     for( ; ; )
 506     {
 507         asf_object_t *p_obj = malloc( sizeof( asf_object_t ) );
 508
 509         if( !p_obj || ASF_ReadObject( s, p_obj, (asf_object_t*)p_he ) )
 510         {
 511             free( p_obj );
 512             break;
 513         }
 514
 515         if( ASF_NextObject( s, p_obj, 0 ) ) /* Go to the next object */
 516         {
 517             break;
 518         }
 519     }
 520
 521     return VLC_SUCCESS;
 522 }
 523
 524 static void ASF_FreeObject_header_extension( asf_object_t *p_obj )
 525 {
 526     asf_object_header_extension_t *p_he = &p_obj->header_extension;
 527
 528     FREENULL( p_he->p_header_extension_data );
 529 }
 530
 531 static int ASF_ReadObject_stream_properties( stream_t *s, asf_object_t *p_obj )
 532 {
 533     asf_object_stream_properties_t *p_sp = &p_obj->stream_properties;
 534     size_t        i_peek;
 535     const uint8_t *p_peek;
 536
 537     if( ( i_peek = stream_Peek( s, &p_peek,  p_sp->i_object_size ) ) < 78 )
 538        return VLC_EGENERIC;
 539
 540     ASF_GetGUID( &p_sp->i_stream_type, p_peek + 24 );
 541     ASF_GetGUID( &p_sp->i_error_correction_type, p_peek + 40 );
 542     p_sp->i_time_offset = GetQWLE( p_peek + 56 );
 543     p_sp->i_type_specific_data_length = GetDWLE( p_peek + 64 );
 544     p_sp->i_error_correction_data_length = GetDWLE( p_peek + 68 );
 545     p_sp->i_flags = GetWLE( p_peek + 72 );
 546         p_sp->i_stream_number = p_sp->i_flags&0x07f;
 547     p_sp->i_reserved = GetDWLE( p_peek + 74 );
 548     i_peek -= 78;
 549
 550     if( p_sp->i_type_specific_data_length )
 551     {
 552         if( i_peek < p_sp->i_type_specific_data_length )
 553             return VLC_EGENERIC;
 554
 555         p_sp->p_type_specific_data =
 556             malloc( p_sp->i_type_specific_data_length );
 557         if( !p_sp->p_type_specific_data )
 558             return VLC_ENOMEM;
 559
 560         memcpy( p_sp->p_type_specific_data, p_peek + 78,
 561                 p_sp->i_type_specific_data_length );
 562         i_peek -= p_sp->i_type_specific_data_length;
 563     }
 564
 565     if( p_sp->i_error_correction_data_length )
 566     {
 567         if( i_peek < p_sp->i_error_correction_data_length )
 568         {
 569             free( p_sp->p_type_specific_data );
 570             return VLC_EGENERIC;
 571         }
 572
 573         p_sp->p_error_correction_data =
 574             malloc( p_sp->i_error_correction_data_length );
 575         if( !p_sp->p_error_correction_data )
 576         {
 577             free( p_sp->p_type_specific_data );
 578             return VLC_ENOMEM;
 579         }
 580         memcpy( p_sp->p_error_correction_data,
 581                 p_peek + 78 + p_sp->i_type_specific_data_length,
 582                 p_sp->i_error_correction_data_length );
 583     }
 584
 585 #ifdef ASF_DEBUG
 586     msg_Dbg( s,
 587             "read \"stream Properties object\" stream_type:" GUID_FMT
 588             " error_correction_type:" GUID_FMT " time_offset:%"PRId64
 589             " type_specific_data_length:%d error_correction_data_length:%d"
 590             " flags:0x%x stream_number:%d",
 591             GUID_PRINT( p_sp->i_stream_type ),
 592             GUID_PRINT( p_sp->i_error_correction_type ),
 593             p_sp->i_time_offset,
 594             p_sp->i_type_specific_data_length,
 595             p_sp->i_error_correction_data_length,
 596             p_sp->i_flags,
 597             p_sp->i_stream_number );
 598
 599 #endif
 600     return VLC_SUCCESS;
 601 }
 602
 603 static void ASF_FreeObject_stream_properties( asf_object_t *p_obj )
 604 {
 605     asf_object_stream_properties_t *p_sp = &p_obj->stream_properties;
 606
 607     FREENULL( p_sp->p_type_specific_data );
 608     FREENULL( p_sp->p_error_correction_data );
 609 }
 610
 611
 612 static int ASF_ReadObject_codec_list( stream_t *s, asf_object_t *p_obj )
 613 {
 614     asf_object_codec_list_t *p_cl = &p_obj->codec_list;
 615     int     i_peek;
 616     const uint8_t *p_peek, *p_data;
 617
 618     unsigned int i_codec;
 619
 620     if( ( i_peek = stream_Peek( s, &p_peek, p_cl->i_object_size ) ) < 44 )
 621        return VLC_EGENERIC;
 622
 623     ASF_GetGUID( &p_cl->i_reserved, p_peek + 24 );
 624     p_cl->i_codec_entries_count = GetDWLE( p_peek + 40 );
 625
 626     p_data = p_peek + 44;
 627
 628     if( p_cl->i_codec_entries_count > 0 )
 629     {
 630         p_cl->codec = calloc( p_cl->i_codec_entries_count,
 631                               sizeof( asf_codec_entry_t ) );
 632         if( !p_cl->codec )
 633             return VLC_ENOMEM;
 634
 635         for( i_codec = 0; i_codec < p_cl->i_codec_entries_count; i_codec++ )
 636         {
 637             asf_codec_entry_t *p_codec = &p_cl->codec[i_codec];
 638
 639             if( !ASF_HAVE( 2+2+2 ) )
 640                 break;
 641
 642             /* */
 643             p_codec->i_type = ASF_READ2();
 644
 645             /* XXX the length here are the number of *unicode* characters and
 646              * not of bytes like nearly every elsewhere */
 647
 648             /* codec name */
 649             p_codec->psz_name = ASF_READS( 2*ASF_READ2() );
 650
 651             /* description */
 652             p_codec->psz_description = ASF_READS( 2*ASF_READ2() );
 653
 654             /* opaque information */
 655             p_codec->i_information_length = ASF_READ2();
 656             if( p_codec->i_information_length > 0 && ASF_HAVE( p_codec->i_information_length ) )
 657             {
 658                 p_codec->p_information = malloc( p_codec->i_information_length );
 659                 if( p_codec->p_information )
 660                     memcpy( p_codec->p_information, p_data, p_codec->i_information_length );
 661                 else
 662                     p_codec->i_information_length = 0;
 663                 p_data += p_codec->i_information_length;
 664             }
 665         }
 666         p_cl->i_codec_entries_count = i_codec;
 667     }
 668
 669 #ifdef ASF_DEBUG
 670     msg_Dbg( s, "read \"codec list object\" reserved_guid:" GUID_FMT
 671              " codec_entries_count:%d",
 672             GUID_PRINT( p_cl->i_reserved ), p_cl->i_codec_entries_count );
 673
 674     for( i_codec = 0; i_codec < p_cl->i_codec_entries_count; i_codec++ )
 675     {
 676         const asf_codec_entry_t *p_codec = &p_cl->codec[i_codec];
 677
 678         msg_Dbg( s, "  - codec[%d] %s name:\"%s\" "
 679                  "description:\"%s\" information_length:%d",
 680                  i_codec, ( p_codec->i_type == ASF_CODEC_TYPE_VIDEO ) ?
 681                  "video" : ( ( p_codec->i_type == ASF_CODEC_TYPE_AUDIO ) ?
 682                  "audio" : "unknown" ),
 683                  p_codec->psz_name, p_codec->psz_description,
 684                  p_codec->i_information_length );
 685     }
 686 #endif
 687
 688     return VLC_SUCCESS;
 689 }
 690
 691 static void ASF_FreeObject_codec_list( asf_object_t *p_obj )
 692 {
 693     asf_object_codec_list_t *p_cl = &p_obj->codec_list;
 694
 695     for( unsigned int i_codec = 0; i_codec < p_cl->i_codec_entries_count; i_codec++ )
 696     {
 697         asf_codec_entry_t *p_codec = &p_cl->codec[i_codec];
 698
 699         FREENULL( p_codec->psz_name );
 700         FREENULL( p_codec->psz_description );
 701         FREENULL( p_codec->p_information );
 702     }
 703     FREENULL( p_cl->codec );
 704 }
 705
 706 static inline char *get_wstring( const uint8_t *p_data, size_t i_size )
 707 {
 708     char *psz_str = FromCharset( "UTF-16LE", p_data, i_size );
 709     if( psz_str )
 710         p_data += i_size;
 711     return psz_str;
 712 }
 713
 714 /* Microsoft should go to hell. This time the length give number of bytes
 715  * and for the some others object, length give char16 count ... */
 716 static int ASF_ReadObject_content_description(stream_t *s, asf_object_t *p_obj)
 717 {
 718     asf_object_content_description_t *p_cd = &p_obj->content_description;
 719     const uint8_t *p_peek, *p_data;
 720     int i_peek, i_title, i_artist, i_copyright, i_description, i_rating;
 721
 722     if( ( i_peek = stream_Peek( s, &p_peek, p_cd->i_object_size ) ) < 34 )
 723        return VLC_EGENERIC;
 724
 725     p_data = p_peek + 24;
 726
 727     i_title         = ASF_READ2();
 728     i_artist        = ASF_READ2();
 729     i_copyright     = ASF_READ2();
 730     i_description   = ASF_READ2();
 731     i_rating        = ASF_READ2();
 732
 733     if( !ASF_HAVE( i_title+i_artist+i_copyright+i_description+i_rating ) )
 734         return VLC_EGENERIC;
 735
 736     p_cd->psz_title = get_wstring( p_data, i_title );
 737     p_cd->psz_artist = get_wstring( p_data, i_artist );
 738     p_cd->psz_copyright = get_wstring( p_data, i_copyright );
 739     p_cd->psz_description = get_wstring( p_data, i_description );
 740     p_cd->psz_rating = get_wstring( p_data, i_rating );
 741
 742 #ifdef ASF_DEBUG
 743     msg_Dbg( s,
 744              "read \"content description object\" title:\"%s\" artist:\"%s\" copyright:\"%s\" description:\"%s\" rating:\"%s\"",
 745              p_cd->psz_title,
 746              p_cd->psz_artist,
 747              p_cd->psz_copyright,
 748              p_cd->psz_description,
 749              p_cd->psz_rating );
 750 #endif
 751
 752     return VLC_SUCCESS;
 753 }
 754
 755 static void ASF_FreeObject_content_description( asf_object_t *p_obj)
 756 {
 757     asf_object_content_description_t *p_cd = &p_obj->content_description;
 758
 759     FREENULL( p_cd->psz_title );
 760     FREENULL( p_cd->psz_artist );
 761     FREENULL( p_cd->psz_copyright );
 762     FREENULL( p_cd->psz_description );
 763     FREENULL( p_cd->psz_rating );
 764 }
 765
 766 /* Language list: */
 767 static int ASF_ReadObject_language_list(stream_t *s, asf_object_t *p_obj)
 768 {
 769     asf_object_language_list_t *p_ll = &p_obj->language_list;
 770     const uint8_t *p_peek, *p_data;
 771     int i_peek;
 772     int i;
 773
 774     if( ( i_peek = stream_Peek( s, &p_peek, p_ll->i_object_size ) ) < 26 )
 775        return VLC_EGENERIC;
 776
 777     p_data = &p_peek[24];
 778
 779     p_ll->i_language = ASF_READ2();
 780     if( p_ll->i_language > 0 )
 781     {
 782         p_ll->ppsz_language = calloc( p_ll->i_language, sizeof( char *) );
 783         if( !p_ll->ppsz_language )
 784             return VLC_ENOMEM;
 785
 786         for( i = 0; i < p_ll->i_language; i++ )
 787         {
 788             if( !ASF_HAVE(1) )
 789                 break;
 790             p_ll->ppsz_language[i] = ASF_READS( ASF_READ1() );
 791         }
 792         p_ll->i_language = i;
 793     }
 794
 795 #ifdef ASF_DEBUG
 796     msg_Dbg( s, "read \"language list object\" %d entries",
 797              p_ll->i_language );
 798     for( i = 0; i < p_ll->i_language; i++ )
 799         msg_Dbg( s, "  - '%s'",
 800                  p_ll->ppsz_language[i] );
 801 #endif
 802     return VLC_SUCCESS;
 803 }
 804
 805 static void ASF_FreeObject_language_list( asf_object_t *p_obj)
 806 {
 807     asf_object_language_list_t *p_ll = &p_obj->language_list;
 808     int i;
 809
 810     for( i = 0; i < p_ll->i_language; i++ )
 811         FREENULL( p_ll->ppsz_language[i] );
 812     FREENULL( p_ll->ppsz_language );
 813 }
 814
 815 /* Stream bitrate properties */
 816 static int ASF_ReadObject_stream_bitrate_properties( stream_t *s,
 817                                                      asf_object_t *p_obj)
 818 {
 819     asf_object_stream_bitrate_properties_t *p_sb = &p_obj->stream_bitrate;
 820     const uint8_t *p_peek, *p_data;
 821     int i_peek;
 822     int i;
 823
 824     if( ( i_peek = stream_Peek( s, &p_peek, p_sb->i_object_size ) ) < 26 )
 825        return VLC_EGENERIC;
 826
 827     p_data = &p_peek[24];
 828
 829     p_sb->i_bitrate = ASF_READ2();
 830     if( p_sb->i_bitrate > 127 )
 831         p_sb->i_bitrate = 127;  /* Buggy ? */
 832     for( i = 0; i < p_sb->i_bitrate; i++ )
 833     {
 834         if( !ASF_HAVE(2 + 4) )
 835             break;
 836         p_sb->bitrate[i].i_stream_number = ASF_READ2()& 0x7f;
 837         p_sb->bitrate[i].i_avg_bitrate = ASF_READ4();
 838     }
 839     p_sb->i_bitrate = i;
 840
 841 #ifdef ASF_DEBUG
 842     msg_Dbg( s,"read \"stream bitrate properties object\"" );
 843     for( i = 0; i < p_sb->i_bitrate; i++ )
 844     {
 845         msg_Dbg( s,"  - stream=%d bitrate=%d",
 846                  p_sb->bitrate[i].i_stream_number,
 847                  p_sb->bitrate[i].i_avg_bitrate );
 848     }
 849 #endif
 850     return VLC_SUCCESS;
 851 }
 852 static void ASF_FreeObject_stream_bitrate_properties( asf_object_t *p_obj)
 853 {
 854     VLC_UNUSED(p_obj);
 855 }
 856
 857 static int ASF_ReadObject_extended_stream_properties( stream_t *s,
 858                                                       asf_object_t *p_obj)
 859 {
 860     asf_object_extended_stream_properties_t *p_esp = &p_obj->ext_stream;
 861     const uint8_t *p_peek, *p_data;
 862     int i_peek, i;
 863
 864     if( ( i_peek = stream_Peek( s, &p_peek, p_esp->i_object_size ) ) < 88 )
 865        return VLC_EGENERIC;
 866
 867     p_data = &p_peek[24];
 868
 869     p_esp->i_start_time = GetQWLE( &p_data[0] );
 870     p_esp->i_end_time = GetQWLE( &p_data[8] );
 871     p_esp->i_data_bitrate = GetDWLE( &p_data[16] );
 872     p_esp->i_buffer_size = GetDWLE( &p_data[20] );
 873     p_esp->i_initial_buffer_fullness = GetDWLE( &p_data[24] );
 874     p_esp->i_alternate_data_bitrate = GetDWLE( &p_data[28] );
 875     p_esp->i_alternate_buffer_size = GetDWLE( &p_data[32] );
 876     p_esp->i_alternate_initial_buffer_fullness = GetDWLE( &p_data[36] );
 877     p_esp->i_maximum_object_size = GetDWLE( &p_data[40] );
 878     p_esp->i_flags = GetDWLE( &p_data[44] );
 879     p_esp->i_stream_number = GetWLE( &p_data[48] );
 880     p_esp->i_language_index = GetWLE( &p_data[50] );
 881     p_esp->i_average_time_per_frame= GetQWLE( &p_data[52] );
 882     p_esp->i_stream_name_count = GetWLE( &p_data[60] );
 883     p_esp->i_payload_extension_system_count = GetWLE( &p_data[62] );
 884
 885     p_data += 64;
 886
 887     p_esp->pi_stream_name_language = calloc( p_esp->i_stream_name_count,
 888                                              sizeof(int) );
 889     p_esp->ppsz_stream_name = calloc( p_esp->i_stream_name_count,
 890                                       sizeof(char*) );
 891     if( !p_esp->pi_stream_name_language ||
 892         !p_esp->ppsz_stream_name )
 893     {
 894         free( p_esp->pi_stream_name_language );
 895         free( p_esp->ppsz_stream_name );
 896         return VLC_ENOMEM;
 897     }
 898     for( i = 0; i < p_esp->i_stream_name_count; i++ )
 899     {
 900         if( !ASF_HAVE( 2+2 ) )
 901             break;
 902         p_esp->pi_stream_name_language[i] = ASF_READ2();
 903         p_esp->ppsz_stream_name[i] = ASF_READS( ASF_READ2() );
 904     }
 905     p_esp->i_stream_name_count = i;
 906
 907     p_esp->p_ext = calloc( p_esp->i_payload_extension_system_count,
 908                            sizeof( asf_payload_extension_system_t ) );
 909     if ( p_esp->p_ext )
 910     {
 911         for( i = 0; i < p_esp->i_payload_extension_system_count; i++ )
 912         {
 913             asf_payload_extension_system_t *p_ext = & p_esp->p_ext[i];
 914             if( !ASF_HAVE( 16+2+4 ) ) break;
 915             ASF_GetGUID( &p_ext->i_extension_id, p_data );
 916             ASF_SKIP( 16 );   // GUID
 917             p_ext->i_data_size = ASF_READ2();
 918             p_ext->i_info_length = ASF_READ4();
 919             if ( p_ext->i_info_length )
 920             {
 921                 if( !ASF_HAVE( p_ext->i_info_length ) ) break;
 922                 p_ext->pi_info = malloc( p_ext->i_info_length );
 923                 if ( p_ext->pi_info )
 924                     memcpy( p_ext->pi_info, p_data, p_ext->i_info_length );
 925                 ASF_SKIP( p_ext->i_info_length );
 926             }
 927         }
 928     } else p_esp->i_payload_extension_system_count = 0;
 929
 930     p_esp->p_sp = NULL;
 931     if( p_data < &p_peek[i_peek] )
 932     {
 933         asf_object_t *p_sp;
 934         /* Cannot fail as peek succeed */
 935         stream_Read( s, NULL, p_data - p_peek );
 936
 937         p_sp = malloc( sizeof( asf_object_t ) );
 938
 939         if( !p_sp || ASF_ReadObject( s, p_sp, NULL ) )
 940         {
 941             free( p_sp );
 942         }
 943         else
 944         {
 945             /* This p_sp will be inserted by ReadRoot later */
 946             p_esp->p_sp = (asf_object_stream_properties_t*)p_sp;
 947         }
 948     }
 949
 950 #ifdef ASF_DEBUG
 951     msg_Dbg( s, "read \"extended stream properties object\":" );
 952     msg_Dbg( s, "  - start=%"PRId64" end=%"PRId64,
 953              p_esp->i_start_time, p_esp->i_end_time );
 954     msg_Dbg( s, "  - data bitrate=%d buffer=%d initial fullness=%d",
 955              p_esp->i_data_bitrate,
 956              p_esp->i_buffer_size,
 957              p_esp->i_initial_buffer_fullness );
 958     msg_Dbg( s, "  - alternate data bitrate=%d buffer=%d initial fullness=%d",
 959              p_esp->i_alternate_data_bitrate,
 960              p_esp->i_alternate_buffer_size,
 961              p_esp->i_alternate_initial_buffer_fullness );
 962     msg_Dbg( s, "  - maximum object size=%d", p_esp->i_maximum_object_size );
 963     msg_Dbg( s, "  - flags=0x%x", p_esp->i_flags );
 964     msg_Dbg( s, "  - stream number=%d language=%d",
 965              p_esp->i_stream_number, p_esp->i_language_index );
 966     msg_Dbg( s, "  - average time per frame=%"PRId64,
 967              p_esp->i_average_time_per_frame );
 968     msg_Dbg( s, "  - stream name count=%d", p_esp->i_stream_name_count );
 969     for( i = 0; i < p_esp->i_stream_name_count; i++ )
 970         msg_Dbg( s, "     - lang id=%d name=%s",
 971                  p_esp->pi_stream_name_language[i],
 972                  p_esp->ppsz_stream_name[i] );
 973     msg_Dbg( s, "  - payload extension system count=%d",
 974              p_esp->i_payload_extension_system_count );
 975     for( i = 0; i < p_esp->i_payload_extension_system_count; i++ )
 976         msg_Dbg( s, "  - %d  - payload extension: " GUID_FMT, i,
 977                  GUID_PRINT( p_esp->p_ext[i].i_extension_id ) );
 978 #endif
 979     return VLC_SUCCESS;
 980 }
 981 static void ASF_FreeObject_extended_stream_properties( asf_object_t *p_obj)
 982 {
 983     asf_object_extended_stream_properties_t *p_esp = &p_obj->ext_stream;
 984
 985     if ( p_esp->p_ext )
 986     {
 987         for( int i = 0; i < p_esp->i_payload_extension_system_count; i++ )
 988             free( p_esp->p_ext[i].pi_info );
 989         FREENULL( p_esp->p_ext );
 990     }
 991     for( int i = 0; i < p_esp->i_stream_name_count; i++ )
 992         FREENULL( p_esp->ppsz_stream_name[i] );
 993     FREENULL( p_esp->pi_stream_name_language );
 994     FREENULL( p_esp->ppsz_stream_name );
 995 }
 996
 997
 998 static int ASF_ReadObject_advanced_mutual_exclusion( stream_t *s,
 999                                                      asf_object_t *p_obj)
1000 {
1001     asf_object_advanced_mutual_exclusion_t *p_ae = &p_obj->advanced_mutual_exclusion;
1002     const uint8_t *p_peek, *p_data;
1003     int i_peek;
1004     uint16_t i;
1005
1006     if( ( i_peek = stream_Peek( s, &p_peek, p_ae->i_object_size ) ) < 42 )
1007        return VLC_EGENERIC;
1008
1009     p_data = &p_peek[24];
1010
1011     if( !ASF_HAVE( 16 + 2 * sizeof(uint16_t) ) ) /* at least one entry */
1012         return VLC_EGENERIC;
1013
1014     if ( guidcmp( (const guid_t *) p_data, &asf_guid_mutex_language ) )
1015         p_ae->exclusion_type = LANGUAGE;
1016     else if ( guidcmp( (const guid_t *) p_data, &asf_guid_mutex_bitrate ) )
1017         p_ae->exclusion_type = BITRATE;
1018     ASF_SKIP( 16 );
1019
1020     p_ae->i_stream_number_count = ASF_READ2();
1021     p_ae->pi_stream_number = calloc( p_ae->i_stream_number_count, sizeof(uint16_t) );
1022
1023     for( i = 0; i < p_ae->i_stream_number_count; i++ )
1024     {
1025         if( !ASF_HAVE(2) )
1026             break;
1027         p_ae->pi_stream_number[i] = ASF_READ2();
1028     }
1029     p_ae->i_stream_number_count = i;
1030
1031 #ifdef ASF_DEBUG
1032     msg_Dbg( s, "read \"advanced mutual exclusion object\" type %s",
1033              p_ae->exclusion_type == LANGUAGE ? "Language" :
1034              ( p_ae->exclusion_type == BITRATE ) ? "Bitrate" : "Unknown"
1035     );
1036     for( i = 0; i < p_ae->i_stream_number_count; i++ )
1037         msg_Dbg( s, "  - stream=%d", p_ae->pi_stream_number[i] );
1038 #endif
1039     return VLC_SUCCESS;
1040 }
1041 static void ASF_FreeObject_advanced_mutual_exclusion( asf_object_t *p_obj)
1042 {
1043     asf_object_advanced_mutual_exclusion_t *p_ae = &p_obj->advanced_mutual_exclusion;
1044
1045     FREENULL( p_ae->pi_stream_number );
1046 }
1047
1048
1049 static int ASF_ReadObject_stream_prioritization( stream_t *s,
1050                                                  asf_object_t *p_obj)
1051 {
1052     asf_object_stream_prioritization_t *p_sp = &p_obj->stream_prioritization;
1053     const uint8_t *p_peek, *p_data;
1054     int i_peek;
1055     int i;
1056
1057     if( ( i_peek = stream_Peek( s, &p_peek, p_sp->i_object_size ) ) < 26 )
1058        return VLC_EGENERIC;
1059
1060     p_data = &p_peek[24];
1061
1062     p_sp->i_priority_count = ASF_READ2();
1063
1064     p_sp->pi_priority_flag = calloc( p_sp->i_priority_count, sizeof(int) );
1065     p_sp->pi_priority_stream_number =
1066                              calloc( p_sp->i_priority_count, sizeof(int) );
1067
1068     if( !p_sp->pi_priority_flag || !p_sp->pi_priority_stream_number )
1069     {
1070         free( p_sp->pi_priority_flag );
1071         free( p_sp->pi_priority_stream_number );
1072         return VLC_ENOMEM;
1073     }
1074
1075     for( i = 0; i < p_sp->i_priority_count; i++ )
1076     {
1077         if( !ASF_HAVE(2+2) )
1078             break;
1079         p_sp->pi_priority_stream_number[i] = ASF_READ2();
1080         p_sp->pi_priority_flag[i] = ASF_READ2();
1081     }
1082     p_sp->i_priority_count = i;
1083
1084 #ifdef ASF_DEBUG
1085     msg_Dbg( s, "read \"stream prioritization object\"" );
1086     for( i = 0; i < p_sp->i_priority_count; i++ )
1087         msg_Dbg( s, "  - Stream:%d flags=0x%x",
1088                  p_sp->pi_priority_stream_number[i],
1089                  p_sp->pi_priority_flag[i] );
1090 #endif
1091     return VLC_SUCCESS;
1092 }
1093 static void ASF_FreeObject_stream_prioritization( asf_object_t *p_obj)
1094 {
1095     asf_object_stream_prioritization_t *p_sp = &p_obj->stream_prioritization;
1096
1097     FREENULL( p_sp->pi_priority_stream_number );
1098     FREENULL( p_sp->pi_priority_flag );
1099 }
1100
1101 static int ASF_ReadObject_bitrate_mutual_exclusion( stream_t *s, asf_object_t *p_obj )
1102 {
1103     asf_object_bitrate_mutual_exclusion_t *p_ex = &p_obj->bitrate_mutual_exclusion;
1104     const uint8_t *p_peek, *p_data;
1105     int i_peek;
1106
1107     if( ( i_peek = stream_Peek( s, &p_peek, p_ex->i_object_size ) ) < 42 )
1108        return VLC_EGENERIC;
1109
1110     p_data = &p_peek[24];
1111
1112     if( !ASF_HAVE( 16 + 2 * sizeof(uint16_t) ) ) /* at least one entry */
1113         return VLC_EGENERIC;
1114
1115     if ( guidcmp( (const guid_t *) p_data, &asf_guid_mutex_language ) )
1116         p_ex->exclusion_type = LANGUAGE;
1117     else if ( guidcmp( (const guid_t *) p_data, &asf_guid_mutex_bitrate ) )
1118         p_ex->exclusion_type = BITRATE;
1119     ASF_SKIP( 16 );
1120
1121     p_ex->i_stream_number_count = ASF_READ2();
1122     p_ex->pi_stream_numbers = calloc( p_ex->i_stream_number_count, sizeof(uint16_t) );
1123     if ( ! p_ex->pi_stream_numbers )
1124     {
1125         p_ex->i_stream_number_count = 0;
1126         return VLC_ENOMEM;
1127     }
1128
1129     for( uint16_t i = 0; i < p_ex->i_stream_number_count; i++ )
1130     {
1131         if( !ASF_HAVE(2) )
1132             break;
1133         p_ex->pi_stream_numbers[i] = ASF_READ2();
1134     }
1135
1136 #ifdef ASF_DEBUG
1137     msg_Dbg( s, "read \"bitrate exclusion object\" type %s",
1138              p_ex->exclusion_type == LANGUAGE ? "Language" :
1139              ( p_ex->exclusion_type == BITRATE ) ? "Bitrate" : "Unknown"
1140     );
1141     for( uint16_t i = 0; i < p_ex->i_stream_number_count; i++ )
1142         msg_Dbg( s, "  - stream=%i", p_ex->pi_stream_numbers[i] );
1143 #endif
1144
1145     return VLC_SUCCESS;
1146 }
1147 static void ASF_FreeObject_bitrate_mutual_exclusion( asf_object_t *p_obj)
1148 {
1149     asf_object_bitrate_mutual_exclusion_t *p_ex = &p_obj->bitrate_mutual_exclusion;
1150
1151     FREENULL( p_ex->pi_stream_numbers );
1152     p_ex->i_stream_number_count = 0;
1153 }
1154
1155 static int ASF_ReadObject_extended_content_description( stream_t *s,
1156                                                         asf_object_t *p_obj)
1157 {
1158     asf_object_extended_content_description_t *p_ec =
1159                                         &p_obj->extended_content_description;
1160     const uint8_t *p_peek, *p_data;
1161     int i_peek;
1162     int i;
1163
1164     if( ( i_peek = stream_Peek( s, &p_peek, p_ec->i_object_size ) ) < 26 )
1165        return VLC_EGENERIC;
1166
1167     p_data = &p_peek[24];
1168
1169     p_ec->i_count = ASF_READ2();
1170     p_ec->ppsz_name  = calloc( p_ec->i_count, sizeof(char*) );
1171     p_ec->ppsz_value = calloc( p_ec->i_count, sizeof(char*) );
1172     if( !p_ec->ppsz_name || !p_ec->ppsz_value )
1173     {
1174         free( p_ec->ppsz_name );
1175         free( p_ec->ppsz_value );
1176         return VLC_ENOMEM;
1177     }
1178     for( i = 0; i < p_ec->i_count; i++ )
1179     {
1180         int i_size;
1181         int i_type;
1182
1183         if( !ASF_HAVE(2 + 2+2) )
1184             break;
1185
1186         p_ec->ppsz_name[i] = ASF_READS( ASF_READ2() );
1187
1188         /* Grrr */
1189         i_type = ASF_READ2();
1190         i_size = ASF_READ2();
1191
1192         if( i_type == 0 )
1193         {
1194             /* Unicode string */
1195             p_ec->ppsz_value[i] = ASF_READS( i_size );
1196         }
1197         else if( i_type == 1 )
1198         {
1199             /* Byte array */
1200             static const char hex[16] = "0123456789ABCDEF";
1201
1202             p_ec->ppsz_value[i] = malloc( 2*i_size + 1 );
1203             if( p_ec->ppsz_value[i] )
1204             {
1205                 char *psz_value = p_ec->ppsz_value[i];
1206                 for( int j = 0; j < i_size; j++ )
1207                 {
1208                     const uint8_t v = ASF_READ1();
1209                     psz_value[2*j+0] = hex[v>>4];
1210                     psz_value[2*j+1] = hex[v&0xf];
1211                 }
1212                 psz_value[2*i_size] = '\0';
1213             }
1214         }
1215         else if( i_type == 2 )
1216         {
1217             /* Bool */
1218             p_ec->ppsz_value[i] = strdup( ASF_READ1() ? "true" : "false" );
1219             ASF_SKIP(i_size-1);
1220         }
1221         else if( i_type == 3 )
1222         {
1223             /* DWord */
1224             if( asprintf( &p_ec->ppsz_value[i], "%d", ASF_READ4() ) == -1 )
1225                 p_ec->ppsz_value[i] = NULL;
1226         }
1227         else if( i_type == 4 )
1228         {
1229             /* QWord */
1230             if( asprintf( &p_ec->ppsz_value[i], "%"PRId64, ASF_READ8() ) == -1 )
1231                 p_ec->ppsz_value[i] = NULL;
1232         }
1233         else if( i_type == 5 )
1234         {
1235             /* Word */
1236             if( asprintf( &p_ec->ppsz_value[i], "%d", ASF_READ2() ) == -1 )
1237                 p_ec->ppsz_value[i] = NULL;
1238         }
1239         else
1240         {
1241             p_ec->ppsz_value[i] = NULL;
1242             ASF_SKIP(i_size);
1243         }
1244     }
1245     p_ec->i_count = i;
1246
1247 #ifdef ASF_DEBUG
1248     msg_Dbg( s, "read \"extended content description object\"" );
1249     for( i = 0; i < p_ec->i_count; i++ )
1250         msg_Dbg( s, "  - '%s' = '%s'",
1251                  p_ec->ppsz_name[i],
1252                  p_ec->ppsz_value[i] );
1253 #endif
1254     return VLC_SUCCESS;
1255 }
1256 static void ASF_FreeObject_extended_content_description( asf_object_t *p_obj)
1257 {
1258     asf_object_extended_content_description_t *p_ec =
1259                                         &p_obj->extended_content_description;
1260
1261     for( int i = 0; i < p_ec->i_count; i++ )
1262     {
1263         FREENULL( p_ec->ppsz_name[i] );
1264         FREENULL( p_ec->ppsz_value[i] );
1265     }
1266     FREENULL( p_ec->ppsz_name );
1267     FREENULL( p_ec->ppsz_value );
1268 }
1269
1270 static int ASF_ReadObject_marker(stream_t *s, asf_object_t *p_obj)
1271 {
1272     asf_object_marker_t *p_mk = (asf_object_marker_t *)p_obj;
1273     const uint8_t *p_peek, *p_data;
1274     int i_peek;
1275
1276     if( ( i_peek = stream_Peek( s, &p_peek, p_mk->i_object_size ) ) < 24 )
1277        return VLC_EGENERIC;
1278
1279     p_data = &p_peek[24];
1280
1281     ASF_GetGUID( &p_mk->i_reserved1, p_data );
1282     ASF_SKIP( 16 );
1283     p_mk->i_count = ASF_READ4();
1284     p_mk->i_reserved2 = ASF_READ2();
1285     p_mk->name = ASF_READS( ASF_READ2() );
1286
1287     if( p_mk->i_count > 0 )
1288     {
1289         p_mk->marker = calloc( p_mk->i_count,
1290                               sizeof( asf_marker_t ) );
1291         if( !p_mk->marker )
1292             return VLC_ENOMEM;
1293
1294         for( unsigned i = 0; i < p_mk->i_count; i++ )
1295         {
1296             asf_marker_t *p_marker = &p_mk->marker[i];
1297
1298             if( !ASF_HAVE(8+8+2+4+4+4) )
1299                 break;
1300
1301             p_marker->i_offset = ASF_READ8();
1302             p_marker->i_presentation_time = ASF_READ8();
1303             p_marker->i_entry_length = ASF_READ2();
1304             p_marker->i_send_time = ASF_READ4();
1305             p_marker->i_flags = ASF_READ4();
1306             p_marker->i_marker_description_length = ASF_READ4();
1307             p_marker->p_marker_description = ASF_READS( p_marker->i_marker_description_length * 2 );
1308         }
1309     }
1310
1311 #ifdef ASF_DEBUG
1312     msg_Dbg( s, "Read \"marker object\": %i chapters: %s", p_mk->i_count, p_mk->name );
1313
1314     for( unsigned i = 0; i < p_mk->i_count; i++ )
1315         msg_Dbg( s, "New chapter named: %s", p_mk->marker[i].p_marker_description );
1316 #endif
1317     return VLC_SUCCESS;
1318 }
1319 static void ASF_FreeObject_marker( asf_object_t *p_obj)
1320 {
1321     asf_object_marker_t *p_mk = (asf_object_marker_t *)p_obj;
1322
1323     for( unsigned i = 0; i < p_mk->i_count; i++ )
1324     {
1325         FREENULL( p_mk->marker[i].p_marker_description  );
1326     }
1327     FREENULL( p_mk->name );
1328 }
1329
1330 static int ASF_ReadObject_Raw(stream_t *s, asf_object_t *p_obj)
1331 {
1332     VLC_UNUSED(s);
1333     VLC_UNUSED(p_obj);
1334     return VLC_SUCCESS;
1335 }
1336
1337 #if 0
1338 static int ASF_ReadObject_XXX(stream_t *s, asf_object_t *p_obj)
1339 {
1340     asf_object_XXX_t *p_XX =
1341         (asf_object_XXX_t *)p_obj;
1342     const uint8_t *p_peek;
1343     uint8_t *p_data;
1344     int i_peek;
1345
1346     if( ( i_peek = stream_Peek( s, &p_peek, p_XX->i_object_size ) ) < XXX )
1347        return VLC_EGENERIC;
1348
1349     p_data = &p_peek[24];
1350
1351 #ifdef ASF_DEBUG
1352     msg_Dbg( s,
1353              "Read \"XXX object\"" );
1354 #endif
1355     return VLC_SUCCESS;
1356 }
1357 static void ASF_FreeObject_XXX( asf_object_t *p_obj)
1358 {
1359     asf_object_XXX_t *p_XX =
1360         (asf_object_XXX_t *)p_obj;
1361 }
1362 #endif
1363
1364
1365 /* */
1366 static const struct
1367 {
1368     const guid_t  *p_id;
1369     int     i_type;
1370     int     (*ASF_ReadObject_function)( stream_t *, asf_object_t *p_obj );
1371     void    (*ASF_FreeObject_function)( asf_object_t *p_obj );
1372
1373 } ASF_Object_Function [] =
1374 {
1375     { &asf_object_header_guid, ASF_OBJECT_HEADER,
1376       ASF_ReadObject_Header, ASF_FreeObject_Null },
1377     { &asf_object_data_guid, ASF_OBJECT_DATA,
1378       ASF_ReadObject_Data, ASF_FreeObject_Null },
1379     { &asf_object_simple_index_guid, ASF_OBJECT_INDEX,
1380       ASF_ReadObject_Index, ASF_FreeObject_Index },
1381     { &asf_object_file_properties_guid, ASF_OBJECT_FILE_PROPERTIES,
1382       ASF_ReadObject_file_properties, ASF_FreeObject_Null },
1383     { &asf_object_stream_properties_guid, ASF_OBJECT_STREAM_PROPERTIES,
1384       ASF_ReadObject_stream_properties,ASF_FreeObject_stream_properties },
1385     { &asf_object_header_extension_guid, ASF_OBJECT_HEADER_EXTENSION,
1386       ASF_ReadObject_header_extension, ASF_FreeObject_header_extension},
1387     { &asf_object_metadata_guid, ASF_OBJECT_METADATA,
1388       ASF_ReadObject_metadata, ASF_FreeObject_metadata},
1389     { &asf_object_codec_list_guid, ASF_OBJECT_CODEC_LIST,
1390       ASF_ReadObject_codec_list, ASF_FreeObject_codec_list },
1391     { &asf_object_marker_guid, ASF_OBJECT_MARKER,
1392       ASF_ReadObject_marker, ASF_FreeObject_marker },
1393     { &asf_object_padding, ASF_OBJECT_PADDING, NULL, NULL },
1394     { &asf_object_compatibility_guid, ASF_OBJECT_OTHER, NULL, NULL },
1395     { &asf_object_content_description_guid, ASF_OBJECT_CONTENT_DESCRIPTION,
1396       ASF_ReadObject_content_description, ASF_FreeObject_content_description },
1397     { &asf_object_language_list, ASF_OBJECT_OTHER,
1398       ASF_ReadObject_language_list, ASF_FreeObject_language_list },
1399     { &asf_object_stream_bitrate_properties, ASF_OBJECT_OTHER,
1400       ASF_ReadObject_stream_bitrate_properties,
1401       ASF_FreeObject_stream_bitrate_properties },
1402     { &asf_object_extended_stream_properties_guid, ASF_OBJECT_OTHER,
1403       ASF_ReadObject_extended_stream_properties,
1404       ASF_FreeObject_extended_stream_properties },
1405     { &asf_object_advanced_mutual_exclusion, ASF_OBJECT_OTHER,
1406       ASF_ReadObject_advanced_mutual_exclusion,
1407       ASF_FreeObject_advanced_mutual_exclusion },
1408     { &asf_object_stream_prioritization, ASF_OBJECT_OTHER,
1409       ASF_ReadObject_stream_prioritization,
1410       ASF_FreeObject_stream_prioritization },
1411     { &asf_object_bitrate_mutual_exclusion_guid, ASF_OBJECT_OTHER,
1412       ASF_ReadObject_bitrate_mutual_exclusion,
1413       ASF_FreeObject_bitrate_mutual_exclusion },
1414     { &asf_object_extended_content_description, ASF_OBJECT_OTHER,
1415       ASF_ReadObject_extended_content_description,
1416       ASF_FreeObject_extended_content_description },
1417     { &asf_object_content_encryption_guid, ASF_OBJECT_OTHER,
1418       ASF_ReadObject_Raw, ASF_FreeObject_Null },
1419     { &asf_object_advanced_content_encryption_guid, ASF_OBJECT_OTHER,
1420       ASF_ReadObject_Raw, ASF_FreeObject_Null },
1421     { &asf_object_extended_content_encryption_guid, ASF_OBJECT_OTHER,
1422       ASF_ReadObject_Raw, ASF_FreeObject_Null },
1423
1424     { &asf_object_null_guid, 0, NULL, NULL }
1425 };
1426
1427 static int ASF_ReadObject( stream_t *s, asf_object_t *p_obj,
1428                            asf_object_t *p_father )
1429 {
1430     int i_result;
1431     int i_index;
1432
1433     if( !p_obj )
1434         return 0;
1435
1436     memset( p_obj, 0, sizeof( *p_obj ) );
1437
1438     if( ASF_ReadObjectCommon( s, p_obj ) )
1439     {
1440         msg_Warn( s, "cannot read one asf object" );
1441         return VLC_EGENERIC;
1442     }
1443     p_obj->common.p_father = p_father;
1444     p_obj->common.p_first = NULL;
1445     p_obj->common.p_next = NULL;
1446     p_obj->common.p_last = NULL;
1447
1448     if( p_obj->common.i_object_size < 24 )
1449     {
1450         msg_Warn( s, "found a corrupted asf object (size<24)" );
1451         return VLC_EGENERIC;
1452     }
1453
1454     /* find this object */
1455     for( i_index = 0; ; i_index++ )
1456     {
1457         if( guidcmp( ASF_Object_Function[i_index].p_id,
1458                          &p_obj->common.i_object_id ) ||
1459             guidcmp( ASF_Object_Function[i_index].p_id,
1460                          &asf_object_null_guid ) )
1461         {
1462             break;
1463         }
1464     }
1465     p_obj->common.i_type = ASF_Object_Function[i_index].i_type;
1466
1467     if( i_index == sizeof(ASF_Object_Function)/sizeof(ASF_Object_Function[0]) - 1 )
1468         msg_Warn( s, "unknown asf object (not loaded): " GUID_FMT,
1469                 GUID_PRINT( p_obj->common.i_object_id ) );
1470
1471     /* Now load this object */
1472     if( ASF_Object_Function[i_index].ASF_ReadObject_function == NULL )
1473     {
1474         i_result = VLC_SUCCESS;
1475     }
1476     else
1477     {
1478         /* XXX ASF_ReadObject_function realloc *pp_obj XXX */
1479         i_result =
1480           (ASF_Object_Function[i_index].ASF_ReadObject_function)( s, p_obj );
1481     }
1482
1483     /* link this object with father */
1484     if( p_father && ! i_result )
1485     {
1486         if( p_father->common.p_first )
1487         {
1488             p_father->common.p_last->common.p_next = p_obj;
1489         }
1490         else
1491         {
1492             p_father->common.p_first = p_obj;
1493         }
1494         p_father->common.p_last = p_obj;
1495     }
1496
1497     return i_result;
1498 }
1499
1500 static void ASF_FreeObject( stream_t *s, asf_object_t *p_obj )
1501 {
1502     int i_index;
1503     asf_object_t *p_child;
1504
1505     if( !p_obj )
1506         return;
1507
1508     /* Free all child object */
1509     p_child = p_obj->common.p_first;
1510     while( p_child )
1511     {
1512         asf_object_t *p_next;
1513         p_next = p_child->common.p_next;
1514         ASF_FreeObject( s, p_child );
1515         p_child = p_next;
1516     }
1517
1518     /* find this object */
1519     for( i_index = 0; ; i_index++ )
1520     {
1521         if( guidcmp( ASF_Object_Function[i_index].p_id,
1522                      &p_obj->common.i_object_id )||
1523             guidcmp( ASF_Object_Function[i_index].p_id,
1524                      &asf_object_null_guid ) )
1525         {
1526             break;
1527         }
1528     }
1529
1530     /* Now free this object */
1531     if( ASF_Object_Function[i_index].ASF_FreeObject_function != NULL )
1532     {
1533 #ifdef ASF_DEBUG
1534         msg_Dbg( s,
1535                   "free asf object " GUID_FMT,
1536                   GUID_PRINT( p_obj->common.i_object_id ) );
1537 #endif
1538         (ASF_Object_Function[i_index].ASF_FreeObject_function)( p_obj );
1539     }
1540     free( p_obj );
1541 }
1542
1543 /*****************************************************************************
1544  * ASF_ObjectDumpDebug:
1545  *****************************************************************************/
1546 static const struct
1547 {
1548     const guid_t *p_id;
1549     const char *psz_name;
1550 } ASF_ObjectDumpDebugInfo[] =
1551 {
1552     { &vlc_object_root_guid, "Root" },
1553     { &asf_object_header_guid, "Header" },
1554     { &asf_object_data_guid, "Data" },
1555     { &asf_object_index_guid, "Index" },
1556     { &asf_object_simple_index_guid, "Simple Index" },
1557     { &asf_object_file_properties_guid, "File Properties" },
1558     { &asf_object_stream_properties_guid, "Stream Properties" },
1559     { &asf_object_content_description_guid, "Content Description" },
1560     { &asf_object_header_extension_guid, "Header Extension" },
1561     { &asf_object_metadata_guid, "Metadata" },
1562     { &asf_object_codec_list_guid, "Codec List" },
1563     { &asf_object_marker_guid, "Marker" },
1564     { &asf_object_stream_type_audio, "Stream Type Audio" },
1565     { &asf_object_stream_type_video, "Stream Type Video" },
1566     { &asf_object_stream_type_command, "Stream Type Command" },
1567     { &asf_object_language_list, "Language List" },
1568     { &asf_object_stream_bitrate_properties, "Stream Bitrate Properties" },
1569     { &asf_object_padding, "Padding" },
1570     { &asf_object_extended_stream_properties_guid, "Extended Stream Properties" },
1571     { &asf_object_advanced_mutual_exclusion, "Advanced Mutual Exclusion" },
1572     { &asf_object_stream_prioritization, "Stream Prioritization" },
1573     { &asf_object_bitrate_mutual_exclusion_guid, "Bitrate Mutual Exclusion" },
1574     { &asf_object_extended_content_description, "Extended content description"},
1575     { &asf_object_content_encryption_guid, "Content Encryption"},
1576     { &asf_object_advanced_content_encryption_guid, "Advanced Content Encryption"},
1577     { &asf_object_extended_content_encryption_guid, "Entended Content Encryption"},
1578     /* Non Readable from this point */
1579     { &nonasf_object_index_placeholder_guid, "Index Placeholder"},
1580     { &nonasf_object_compatibility, "Object Compatibility"},
1581
1582     { NULL, "Unknown" },
1583 };
1584
1585
1586 static void ASF_ObjectDumpDebug( vlc_object_t *p_obj,
1587                                  asf_object_common_t *p_node, unsigned i_level )
1588 {
1589     unsigned i;
1590     union asf_object_u *p_child;
1591     const char *psz_name;
1592
1593     /* Find the name */
1594     for( i = 0; ASF_ObjectDumpDebugInfo[i].p_id != NULL; i++ )
1595     {
1596         if( guidcmp( ASF_ObjectDumpDebugInfo[i].p_id,
1597                           &p_node->i_object_id ) )
1598             break;
1599     }
1600     psz_name = ASF_ObjectDumpDebugInfo[i].psz_name;
1601
1602     char str[512];
1603     if( i_level >= (sizeof(str) - 1)/5 )
1604         return;
1605
1606     memset( str, ' ', sizeof( str ) );
1607     for( i = 0; i < i_level; i++ )
1608     {
1609         str[i * 4] = '|';
1610     }
1611     snprintf( &str[4*i_level], sizeof(str) - 5*i_level,
1612              "+ '%s'"
1613 #ifdef ASF_DEBUG
1614              "GUID "GUID_FMT" size:%"PRIu64" pos:%"PRIu64
1615 #endif
1616              , psz_name
1617
1618 #ifdef ASF_DEBUG
1619              , GUID_PRINT( p_node->i_object_id ),
1620              p_node->i_object_size, p_node->i_object_pos
1621 #endif
1622              );
1623
1624
1625     msg_Dbg( p_obj, "%s", str );
1626
1627     for( p_child = p_node->p_first; p_child != NULL;
1628                                              p_child = p_child->common.p_next )
1629     {
1630         ASF_ObjectDumpDebug( p_obj, &p_child->common, i_level + 1 );
1631     }
1632 }
1633
1634 /*****************************************************************************
1635  * ASF_ReadObjetRoot : parse the entire stream/file
1636  *****************************************************************************/
1637 asf_object_root_t *ASF_ReadObjectRoot( stream_t *s, int b_seekable )
1638 {
1639     asf_object_root_t *p_root = malloc( sizeof( asf_object_root_t ) );
1640     asf_object_t *p_obj;
1641     uint64_t i_boundary = 0;
1642
1643     if( !p_root )
1644         return NULL;
1645
1646     p_root->i_type = ASF_OBJECT_ROOT;
1647     memcpy( &p_root->i_object_id, &vlc_object_root_guid, sizeof( guid_t ) );
1648     p_root->i_object_pos = stream_Tell( s );
1649     p_root->i_object_size = 0;
1650     p_root->p_first = NULL;
1651     p_root->p_last  = NULL;
1652     p_root->p_next  = NULL;
1653     p_root->p_hdr   = NULL;
1654     p_root->p_data  = NULL;
1655     p_root->p_fp    = NULL;
1656     p_root->p_index = NULL;
1657     p_root->p_metadata = NULL;
1658
1659     for( ; ; )
1660     {
1661         p_obj = malloc( sizeof( asf_object_t ) );
1662
1663         if( !p_obj || ASF_ReadObject( s, p_obj, (asf_object_t*)p_root ) )
1664         {
1665             free( p_obj );
1666             break;
1667         }
1668         switch( p_obj->common.i_type )
1669         {
1670             case( ASF_OBJECT_HEADER ):
1671                 if ( p_root->p_index || p_root->p_data || p_root->p_hdr ) break;
1672                 p_root->p_hdr = (asf_object_header_t*)p_obj;
1673                 break;
1674             case( ASF_OBJECT_DATA ):
1675                 if ( p_root->p_index || p_root->p_data ) break;
1676                 p_root->p_data = (asf_object_data_t*)p_obj;
1677             break;
1678             case( ASF_OBJECT_INDEX ):
1679                 if ( p_root->p_index ) break;
1680                 p_root->p_index = (asf_object_index_t*)p_obj;
1681                 break;
1682             default:
1683                 msg_Warn( s, "unknown top-level object found: " GUID_FMT,
1684                       GUID_PRINT( p_obj->common.i_object_id ) );
1685                 break;
1686         }
1687
1688         /* Set a limit to avoid junk when possible */
1689         if ( guidcmp( &p_obj->common.i_object_id, &asf_object_file_properties_guid ) )
1690         {
1691             i_boundary = p_obj->file_properties.i_file_size;
1692         }
1693
1694         if( p_obj->common.i_type == ASF_OBJECT_DATA &&
1695             p_obj->common.i_object_size <= 50 )
1696         {
1697             /* probably a dump of broadcasted asf */
1698             break;
1699         }
1700         if( !b_seekable && p_root->p_hdr && p_root->p_data )
1701         {
1702             /* For unseekable stream it's enough to play */
1703             break;
1704         }
1705
1706         if( ASF_NextObject( s, p_obj, i_boundary ) ) /* Go to the next object */
1707             break;
1708     }
1709
1710     if( p_root->p_hdr != NULL && p_root->p_data != NULL )
1711     {
1712         p_root->p_fp = ASF_FindObject( p_root->p_hdr,
1713                                        &asf_object_file_properties_guid, 0 );
1714
1715         if( p_root->p_fp )
1716         {
1717             asf_object_t *p_hdr_ext =
1718                 ASF_FindObject( p_root->p_hdr,
1719                                 &asf_object_header_extension_guid, 0 );
1720             if( p_hdr_ext )
1721             {
1722                 int i_ext_stream;
1723
1724                 p_root->p_metadata =
1725                     ASF_FindObject( p_hdr_ext,
1726                                     &asf_object_metadata_guid, 0 );
1727                 /* Special case for broken designed file format :( */
1728                 i_ext_stream = ASF_CountObject( p_hdr_ext,
1729                                     &asf_object_extended_stream_properties_guid );
1730                 for( int i = 0; i < i_ext_stream; i++ )
1731                 {
1732                     asf_object_t *p_esp =
1733                         ASF_FindObject( p_hdr_ext,
1734                                    &asf_object_extended_stream_properties_guid, i );
1735                     if( p_esp->ext_stream.p_sp )
1736                     {
1737                         asf_object_t *p_sp =
1738                                          (asf_object_t*)p_esp->ext_stream.p_sp;
1739
1740                         /* Insert this p_sp */
1741                         p_root->p_hdr->p_last->common.p_next = p_sp;
1742                         p_root->p_hdr->p_last = p_sp;
1743
1744                         p_sp->common.p_father = (asf_object_t*)p_root->p_hdr;
1745                     }
1746                 }
1747             }
1748
1749             ASF_ObjectDumpDebug( VLC_OBJECT(s),
1750                                  (asf_object_common_t*)p_root, 0 );
1751             return p_root;
1752         }
1753         msg_Warn( s, "cannot find file properties object" );
1754     }
1755
1756     /* Invalid file */
1757     ASF_FreeObjectRoot( s, p_root );
1758     return NULL;
1759 }
1760
1761 void ASF_FreeObjectRoot( stream_t *s, asf_object_root_t *p_root )
1762 {
1763     asf_object_t *p_obj;
1764
1765     p_obj = p_root->p_first;
1766     while( p_obj )
1767     {
1768         asf_object_t *p_next;
1769         p_next = p_obj->common.p_next;
1770         ASF_FreeObject( s, p_obj );
1771         p_obj = p_next;
1772     }
1773     free( p_root );
1774 }
1775
1776 int ASF_CountObject( void *_p_obj, const guid_t *p_guid )
1777 {
1778     int i_count;
1779     asf_object_t *p_child, *p_obj;
1780
1781     p_obj = (asf_object_t *)_p_obj;
1782     if( !p_obj )
1783         return 0;
1784
1785     i_count = 0;
1786     p_child = p_obj->common.p_first;
1787     while( p_child )
1788     {
1789         if( guidcmp( &p_child->common.i_object_id, p_guid ) )
1790             i_count++;
1791
1792         p_child = p_child->common.p_next;
1793     }
1794     return i_count;
1795 }
1796
1797 void *ASF_FindObject( void *_p_obj, const guid_t *p_guid,
1798                         int i_number )
1799 {
1800     asf_object_t *p_child, *p_obj;
1801
1802     p_obj = (asf_object_t *)_p_obj;
1803     p_child = p_obj->common.p_first;
1804
1805     while( p_child )
1806     {
1807         if( guidcmp( &p_child->common.i_object_id, p_guid ) )
1808         {
1809             if( i_number == 0 )
1810                 return p_child;
1811
1812             i_number--;
1813         }
1814         p_child = p_child->common.p_next;
1815     }
1816     return NULL;
1817 }