c9070d514a3d6ff4ef32eee10af0a3c70aed1d2a
[vlc.git] / 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 = GetDWLE( p_peek + 92 );
323     p_fp->i_max_data_packet_size = GetDWLE( p_peek + 96 );
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     for( i = 0; i < p_esp->i_payload_extension_system_count; i++ )
908     {
909         ASF_SKIP( 16 );   // GUID
910         ASF_SKIP( 2 );
911         ASF_SKIP( ASF_READ4() );
912     }
913
914     p_esp->p_sp = NULL;
915     if( p_data < &p_peek[i_peek] )
916     {
917         asf_object_t *p_sp;
918         /* Cannot fail as peek succeed */
919         stream_Read( s, NULL, p_data - p_peek );
920
921         p_sp = malloc( sizeof( asf_object_t ) );
922
923         if( !p_sp || ASF_ReadObject( s, p_sp, NULL ) )
924         {
925             free( p_sp );
926         }
927         else
928         {
929             /* This p_sp will be inserted by ReadRoot later */
930             p_esp->p_sp = (asf_object_stream_properties_t*)p_sp;
931         }
932     }
933
934 #ifdef ASF_DEBUG
935     msg_Dbg( s, "read \"extended stream properties object\":" );
936     msg_Dbg( s, "  - start=%"PRId64" end=%"PRId64,
937              p_esp->i_start_time, p_esp->i_end_time );
938     msg_Dbg( s, "  - data bitrate=%d buffer=%d initial fullness=%d",
939              p_esp->i_data_bitrate,
940              p_esp->i_buffer_size,
941              p_esp->i_initial_buffer_fullness );
942     msg_Dbg( s, "  - alternate data bitrate=%d buffer=%d initial fullness=%d",
943              p_esp->i_alternate_data_bitrate,
944              p_esp->i_alternate_buffer_size,
945              p_esp->i_alternate_initial_buffer_fullness );
946     msg_Dbg( s, "  - maximum object size=%d", p_esp->i_maximum_object_size );
947     msg_Dbg( s, "  - flags=0x%x", p_esp->i_flags );
948     msg_Dbg( s, "  - stream number=%d language=%d",
949              p_esp->i_stream_number, p_esp->i_language_index );
950     msg_Dbg( s, "  - average time per frame=%"PRId64,
951              p_esp->i_average_time_per_frame );
952     msg_Dbg( s, "  - stream name count=%d", p_esp->i_stream_name_count );
953     for( i = 0; i < p_esp->i_stream_name_count; i++ )
954         msg_Dbg( s, "     - lang id=%d name=%s",
955                  p_esp->pi_stream_name_language[i],
956                  p_esp->ppsz_stream_name[i] );
957     msg_Dbg( s, "  - payload extension system count=%d",
958              p_esp->i_payload_extension_system_count );
959 #endif
960     return VLC_SUCCESS;
961 }
962 static void ASF_FreeObject_extended_stream_properties( asf_object_t *p_obj)
963 {
964     asf_object_extended_stream_properties_t *p_esp = &p_obj->ext_stream;
965
966     for( int i = 0; i < p_esp->i_stream_name_count; i++ )
967         FREENULL( p_esp->ppsz_stream_name[i] );
968     FREENULL( p_esp->pi_stream_name_language );
969     FREENULL( p_esp->ppsz_stream_name );
970 }
971
972
973 static int ASF_ReadObject_advanced_mutual_exclusion( stream_t *s,
974                                                      asf_object_t *p_obj)
975 {
976     asf_object_advanced_mutual_exclusion_t *p_ae = &p_obj->advanced_mutual_exclusion;
977     const uint8_t *p_peek, *p_data;
978     int i_peek;
979     int i;
980
981     if( ( i_peek = stream_Peek( s, &p_peek, p_ae->i_object_size ) ) < 42 )
982        return VLC_EGENERIC;
983
984     p_data = &p_peek[24];
985
986     if( !ASF_HAVE( 16 + 2 * sizeof(uint16_t) ) ) /* at least one entry */
987         return VLC_EGENERIC;
988
989     if ( guidcmp( (const guid_t *) p_data, &asf_guid_mutex_language ) )
990         p_ae->exclusion_type = LANGUAGE;
991     else if ( guidcmp( (const guid_t *) p_data, &asf_guid_mutex_bitrate ) )
992         p_ae->exclusion_type = BITRATE;
993     ASF_SKIP( 16 );
994
995     p_ae->i_stream_number_count = ASF_READ2();
996     p_ae->pi_stream_number = calloc( p_ae->i_stream_number_count, sizeof(int) );
997
998     for( i = 0; i < p_ae->i_stream_number_count; i++ )
999     {
1000         if( !ASF_HAVE(2) )
1001             break;
1002         p_ae->pi_stream_number[i] = ASF_READ2();
1003     }
1004     p_ae->i_stream_number_count = i;
1005
1006 #ifdef ASF_DEBUG
1007     msg_Dbg( s, "read \"advanced mutual exclusion object\" type %s",
1008              p_ae->exclusion_type == LANGUAGE ? "Language" :
1009              ( p_ae->exclusion_type == BITRATE ) ? "Bitrate" : "Unknown"
1010     );
1011     for( i = 0; i < p_ae->i_stream_number_count; i++ )
1012         msg_Dbg( s, "  - stream=%d", p_ae->pi_stream_number[i] );
1013 #endif
1014     return VLC_SUCCESS;
1015 }
1016 static void ASF_FreeObject_advanced_mutual_exclusion( asf_object_t *p_obj)
1017 {
1018     asf_object_advanced_mutual_exclusion_t *p_ae = &p_obj->advanced_mutual_exclusion;
1019
1020     FREENULL( p_ae->pi_stream_number );
1021 }
1022
1023
1024 static int ASF_ReadObject_stream_prioritization( stream_t *s,
1025                                                  asf_object_t *p_obj)
1026 {
1027     asf_object_stream_prioritization_t *p_sp = &p_obj->stream_prioritization;
1028     const uint8_t *p_peek, *p_data;
1029     int i_peek;
1030     int i;
1031
1032     if( ( i_peek = stream_Peek( s, &p_peek, p_sp->i_object_size ) ) < 26 )
1033        return VLC_EGENERIC;
1034
1035     p_data = &p_peek[24];
1036
1037     p_sp->i_priority_count = ASF_READ2();
1038
1039     p_sp->pi_priority_flag = calloc( p_sp->i_priority_count, sizeof(int) );
1040     p_sp->pi_priority_stream_number =
1041                              calloc( p_sp->i_priority_count, sizeof(int) );
1042
1043     if( !p_sp->pi_priority_flag || !p_sp->pi_priority_stream_number )
1044     {
1045         free( p_sp->pi_priority_flag );
1046         free( p_sp->pi_priority_stream_number );
1047         return VLC_ENOMEM;
1048     }
1049
1050     for( i = 0; i < p_sp->i_priority_count; i++ )
1051     {
1052         if( !ASF_HAVE(2+2) )
1053             break;
1054         p_sp->pi_priority_stream_number[i] = ASF_READ2();
1055         p_sp->pi_priority_flag[i] = ASF_READ2();
1056     }
1057     p_sp->i_priority_count = i;
1058
1059 #ifdef ASF_DEBUG
1060     msg_Dbg( s, "read \"stream prioritization object\"" );
1061     for( i = 0; i < p_sp->i_priority_count; i++ )
1062         msg_Dbg( s, "  - Stream:%d flags=0x%x",
1063                  p_sp->pi_priority_stream_number[i],
1064                  p_sp->pi_priority_flag[i] );
1065 #endif
1066     return VLC_SUCCESS;
1067 }
1068 static void ASF_FreeObject_stream_prioritization( asf_object_t *p_obj)
1069 {
1070     asf_object_stream_prioritization_t *p_sp = &p_obj->stream_prioritization;
1071
1072     FREENULL( p_sp->pi_priority_stream_number );
1073     FREENULL( p_sp->pi_priority_flag );
1074 }
1075
1076 static int ASF_ReadObject_bitrate_mutual_exclusion( stream_t *s, asf_object_t *p_obj )
1077 {
1078     asf_object_bitrate_mutual_exclusion_t *p_ex = &p_obj->bitrate_mutual_exclusion;
1079     const uint8_t *p_peek, *p_data;
1080     int i_peek;
1081
1082     if( ( i_peek = stream_Peek( s, &p_peek, p_ex->i_object_size ) ) < 42 )
1083        return VLC_EGENERIC;
1084
1085     p_data = &p_peek[24];
1086
1087     if( !ASF_HAVE( 16 + 2 * sizeof(uint16_t) ) ) /* at least one entry */
1088         return VLC_EGENERIC;
1089
1090     if ( guidcmp( (const guid_t *) p_data, &asf_guid_mutex_language ) )
1091         p_ex->exclusion_type = LANGUAGE;
1092     else if ( guidcmp( (const guid_t *) p_data, &asf_guid_mutex_bitrate ) )
1093         p_ex->exclusion_type = BITRATE;
1094     ASF_SKIP( 16 );
1095
1096     p_ex->i_stream_number_count = ASF_READ2();
1097     p_ex->pi_stream_numbers = calloc( p_ex->i_stream_number_count, sizeof(uint16_t) );
1098     if ( ! p_ex->pi_stream_numbers )
1099     {
1100         p_ex->i_stream_number_count = 0;
1101         return VLC_ENOMEM;
1102     }
1103
1104     for( uint16_t i = 0; i < p_ex->i_stream_number_count; i++ )
1105     {
1106         if( !ASF_HAVE(2) )
1107             break;
1108         p_ex->pi_stream_numbers[i] = ASF_READ2();
1109     }
1110
1111 #ifdef ASF_DEBUG
1112     msg_Dbg( s, "read \"bitrate exclusion object\" type %s",
1113              p_ex->exclusion_type == LANGUAGE ? "Language" :
1114              ( p_ex->exclusion_type == BITRATE ) ? "Bitrate" : "Unknown"
1115     );
1116     for( uint16_t i = 0; i < p_ex->i_stream_number_count; i++ )
1117         msg_Dbg( s, "  - stream=%i", p_ex->pi_stream_numbers[i] );
1118 #endif
1119
1120     return VLC_SUCCESS;
1121 }
1122 static void ASF_FreeObject_bitrate_mutual_exclusion( asf_object_t *p_obj)
1123 {
1124     asf_object_bitrate_mutual_exclusion_t *p_ex = &p_obj->bitrate_mutual_exclusion;
1125
1126     FREENULL( p_ex->pi_stream_numbers );
1127     p_ex->i_stream_number_count = 0;
1128 }
1129
1130 static int ASF_ReadObject_extended_content_description( stream_t *s,
1131                                                         asf_object_t *p_obj)
1132 {
1133     asf_object_extended_content_description_t *p_ec =
1134                                         &p_obj->extended_content_description;
1135     const uint8_t *p_peek, *p_data;
1136     int i_peek;
1137     int i;
1138
1139     if( ( i_peek = stream_Peek( s, &p_peek, p_ec->i_object_size ) ) < 26 )
1140        return VLC_EGENERIC;
1141
1142     p_data = &p_peek[24];
1143
1144     p_ec->i_count = ASF_READ2();
1145     p_ec->ppsz_name  = calloc( p_ec->i_count, sizeof(char*) );
1146     p_ec->ppsz_value = calloc( p_ec->i_count, sizeof(char*) );
1147     if( !p_ec->ppsz_name || !p_ec->ppsz_value )
1148     {
1149         free( p_ec->ppsz_name );
1150         free( p_ec->ppsz_value );
1151         return VLC_ENOMEM;
1152     }
1153     for( i = 0; i < p_ec->i_count; i++ )
1154     {
1155         int i_size;
1156         int i_type;
1157
1158         if( !ASF_HAVE(2 + 2+2) )
1159             break;
1160
1161         p_ec->ppsz_name[i] = ASF_READS( ASF_READ2() );
1162
1163         /* Grrr */
1164         i_type = ASF_READ2();
1165         i_size = ASF_READ2();
1166
1167         if( i_type == 0 )
1168         {
1169             /* Unicode string */
1170             p_ec->ppsz_value[i] = ASF_READS( i_size );
1171         }
1172         else if( i_type == 1 )
1173         {
1174             /* Byte array */
1175             static const char hex[16] = "0123456789ABCDEF";
1176
1177             p_ec->ppsz_value[i] = malloc( 2*i_size + 1 );
1178             if( p_ec->ppsz_value[i] )
1179             {
1180                 char *psz_value = p_ec->ppsz_value[i];
1181                 for( int j = 0; j < i_size; j++ )
1182                 {
1183                     const uint8_t v = ASF_READ1();
1184                     psz_value[2*j+0] = hex[v>>4];
1185                     psz_value[2*j+1] = hex[v&0xf];
1186                 }
1187                 psz_value[2*i_size] = '\0';
1188             }
1189         }
1190         else if( i_type == 2 )
1191         {
1192             /* Bool */
1193             p_ec->ppsz_value[i] = strdup( ASF_READ1() ? "true" : "false" );
1194             ASF_SKIP(i_size-1);
1195         }
1196         else if( i_type == 3 )
1197         {
1198             /* DWord */
1199             if( asprintf( &p_ec->ppsz_value[i], "%d", ASF_READ4() ) == -1 )
1200                 p_ec->ppsz_value[i] = NULL;
1201         }
1202         else if( i_type == 4 )
1203         {
1204             /* QWord */
1205             if( asprintf( &p_ec->ppsz_value[i], "%"PRId64, ASF_READ8() ) == -1 )
1206                 p_ec->ppsz_value[i] = NULL;
1207         }
1208         else if( i_type == 5 )
1209         {
1210             /* Word */
1211             if( asprintf( &p_ec->ppsz_value[i], "%d", ASF_READ2() ) == -1 )
1212                 p_ec->ppsz_value[i] = NULL;
1213         }
1214         else
1215         {
1216             p_ec->ppsz_value[i] = NULL;
1217             ASF_SKIP(i_size);
1218         }
1219     }
1220     p_ec->i_count = i;
1221
1222 #ifdef ASF_DEBUG
1223     msg_Dbg( s, "read \"extended content description object\"" );
1224     for( i = 0; i < p_ec->i_count; i++ )
1225         msg_Dbg( s, "  - '%s' = '%s'",
1226                  p_ec->ppsz_name[i],
1227                  p_ec->ppsz_value[i] );
1228 #endif
1229     return VLC_SUCCESS;
1230 }
1231 static void ASF_FreeObject_extended_content_description( asf_object_t *p_obj)
1232 {
1233     asf_object_extended_content_description_t *p_ec =
1234                                         &p_obj->extended_content_description;
1235
1236     for( int i = 0; i < p_ec->i_count; i++ )
1237     {
1238         FREENULL( p_ec->ppsz_name[i] );
1239         FREENULL( p_ec->ppsz_value[i] );
1240     }
1241     FREENULL( p_ec->ppsz_name );
1242     FREENULL( p_ec->ppsz_value );
1243 }
1244
1245 static int ASF_ReadObject_marker(stream_t *s, asf_object_t *p_obj)
1246 {
1247     asf_object_marker_t *p_mk = (asf_object_marker_t *)p_obj;
1248     const uint8_t *p_peek, *p_data;
1249     int i_peek;
1250
1251     if( ( i_peek = stream_Peek( s, &p_peek, p_mk->i_object_size ) ) < 24 )
1252        return VLC_EGENERIC;
1253
1254     p_data = &p_peek[24];
1255
1256     ASF_GetGUID( &p_mk->i_reserved1, p_data );
1257     ASF_SKIP( 16 );
1258     p_mk->i_count = ASF_READ4();
1259     p_mk->i_reserved2 = ASF_READ2();
1260     p_mk->name = ASF_READS( ASF_READ2() );
1261
1262     if( p_mk->i_count > 0 )
1263     {
1264         p_mk->marker = calloc( p_mk->i_count,
1265                               sizeof( asf_marker_t ) );
1266         if( !p_mk->marker )
1267             return VLC_ENOMEM;
1268
1269         for( unsigned i = 0; i < p_mk->i_count; i++ )
1270         {
1271             asf_marker_t *p_marker = &p_mk->marker[i];
1272
1273             if( !ASF_HAVE(8+8+2+4+4+4) )
1274                 break;
1275
1276             p_marker->i_offset = ASF_READ8();
1277             p_marker->i_presentation_time = ASF_READ8();
1278             p_marker->i_entry_length = ASF_READ2();
1279             p_marker->i_send_time = ASF_READ4();
1280             p_marker->i_flags = ASF_READ4();
1281             p_marker->i_marker_description_length = ASF_READ4();
1282             p_marker->p_marker_description = ASF_READS( p_marker->i_marker_description_length * 2 );
1283         }
1284     }
1285
1286 #ifdef ASF_DEBUG
1287     msg_Dbg( s, "Read \"marker object\": %i chapters: %s", p_mk->i_count, p_mk->name );
1288
1289     for( unsigned i = 0; i < p_mk->i_count; i++ )
1290         msg_Dbg( s, "New chapter named: %s", p_mk->marker[i].p_marker_description );
1291 #endif
1292     return VLC_SUCCESS;
1293 }
1294 static void ASF_FreeObject_marker( asf_object_t *p_obj)
1295 {
1296     asf_object_marker_t *p_mk = (asf_object_marker_t *)p_obj;
1297
1298     for( unsigned i = 0; i < p_mk->i_count; i++ )
1299     {
1300         FREENULL( p_mk->marker[i].p_marker_description  );
1301     }
1302     FREENULL( p_mk->name );
1303 }
1304
1305 static int ASF_ReadObject_Raw(stream_t *s, asf_object_t *p_obj)
1306 {
1307     VLC_UNUSED(s);
1308     VLC_UNUSED(p_obj);
1309     return VLC_SUCCESS;
1310 }
1311
1312 #if 0
1313 static int ASF_ReadObject_XXX(stream_t *s, asf_object_t *p_obj)
1314 {
1315     asf_object_XXX_t *p_XX =
1316         (asf_object_XXX_t *)p_obj;
1317     const uint8_t *p_peek;
1318     uint8_t *p_data;
1319     int i_peek;
1320
1321     if( ( i_peek = stream_Peek( s, &p_peek, p_XX->i_object_size ) ) < XXX )
1322        return VLC_EGENERIC;
1323
1324     p_data = &p_peek[24];
1325
1326 #ifdef ASF_DEBUG
1327     msg_Dbg( s,
1328              "Read \"XXX object\"" );
1329 #endif
1330     return VLC_SUCCESS;
1331 }
1332 static void ASF_FreeObject_XXX( asf_object_t *p_obj)
1333 {
1334     asf_object_XXX_t *p_XX =
1335         (asf_object_XXX_t *)p_obj;
1336 }
1337 #endif
1338
1339
1340 /* */
1341 static const struct
1342 {
1343     const guid_t  *p_id;
1344     int     i_type;
1345     int     (*ASF_ReadObject_function)( stream_t *, asf_object_t *p_obj );
1346     void    (*ASF_FreeObject_function)( asf_object_t *p_obj );
1347
1348 } ASF_Object_Function [] =
1349 {
1350     { &asf_object_header_guid, ASF_OBJECT_HEADER,
1351       ASF_ReadObject_Header, ASF_FreeObject_Null },
1352     { &asf_object_data_guid, ASF_OBJECT_DATA,
1353       ASF_ReadObject_Data, ASF_FreeObject_Null },
1354     { &asf_object_simple_index_guid, ASF_OBJECT_INDEX,
1355       ASF_ReadObject_Index, ASF_FreeObject_Index },
1356     { &asf_object_file_properties_guid, ASF_OBJECT_FILE_PROPERTIES,
1357       ASF_ReadObject_file_properties, ASF_FreeObject_Null },
1358     { &asf_object_stream_properties_guid, ASF_OBJECT_STREAM_PROPERTIES,
1359       ASF_ReadObject_stream_properties,ASF_FreeObject_stream_properties },
1360     { &asf_object_header_extension_guid, ASF_OBJECT_HEADER_EXTENSION,
1361       ASF_ReadObject_header_extension, ASF_FreeObject_header_extension},
1362     { &asf_object_metadata_guid, ASF_OBJECT_METADATA,
1363       ASF_ReadObject_metadata, ASF_FreeObject_metadata},
1364     { &asf_object_codec_list_guid, ASF_OBJECT_CODEC_LIST,
1365       ASF_ReadObject_codec_list, ASF_FreeObject_codec_list },
1366     { &asf_object_marker_guid, ASF_OBJECT_MARKER, 
1367       ASF_ReadObject_marker, ASF_FreeObject_marker },
1368     { &asf_object_padding, ASF_OBJECT_PADDING, NULL, NULL },
1369     { &asf_object_compatibility_guid, ASF_OBJECT_OTHER, NULL, NULL },
1370     { &asf_object_content_description_guid, ASF_OBJECT_CONTENT_DESCRIPTION,
1371       ASF_ReadObject_content_description, ASF_FreeObject_content_description },
1372     { &asf_object_language_list, ASF_OBJECT_OTHER,
1373       ASF_ReadObject_language_list, ASF_FreeObject_language_list },
1374     { &asf_object_stream_bitrate_properties, ASF_OBJECT_OTHER,
1375       ASF_ReadObject_stream_bitrate_properties,
1376       ASF_FreeObject_stream_bitrate_properties },
1377     { &asf_object_extended_stream_properties_guid, ASF_OBJECT_OTHER,
1378       ASF_ReadObject_extended_stream_properties,
1379       ASF_FreeObject_extended_stream_properties },
1380     { &asf_object_advanced_mutual_exclusion, ASF_OBJECT_OTHER,
1381       ASF_ReadObject_advanced_mutual_exclusion,
1382       ASF_FreeObject_advanced_mutual_exclusion },
1383     { &asf_object_stream_prioritization, ASF_OBJECT_OTHER,
1384       ASF_ReadObject_stream_prioritization,
1385       ASF_FreeObject_stream_prioritization },
1386     { &asf_object_bitrate_mutual_exclusion_guid, ASF_OBJECT_OTHER,
1387       ASF_ReadObject_bitrate_mutual_exclusion,
1388       ASF_FreeObject_bitrate_mutual_exclusion },
1389     { &asf_object_extended_content_description, ASF_OBJECT_OTHER,
1390       ASF_ReadObject_extended_content_description,
1391       ASF_FreeObject_extended_content_description },
1392     { &asf_object_content_encryption_guid, ASF_OBJECT_OTHER,
1393       ASF_ReadObject_Raw, ASF_FreeObject_Null },
1394     { &asf_object_advanced_content_encryption_guid, ASF_OBJECT_OTHER,
1395       ASF_ReadObject_Raw, ASF_FreeObject_Null },
1396     { &asf_object_extended_content_encryption_guid, ASF_OBJECT_OTHER,
1397       ASF_ReadObject_Raw, ASF_FreeObject_Null },
1398
1399     { &asf_object_null_guid, 0, NULL, NULL }
1400 };
1401
1402 static int ASF_ReadObject( stream_t *s, asf_object_t *p_obj,
1403                            asf_object_t *p_father )
1404 {
1405     int i_result;
1406     int i_index;
1407
1408     if( !p_obj )
1409         return 0;
1410
1411     memset( p_obj, 0, sizeof( *p_obj ) );
1412
1413     if( ASF_ReadObjectCommon( s, p_obj ) )
1414     {
1415         msg_Warn( s, "cannot read one asf object" );
1416         return VLC_EGENERIC;
1417     }
1418     p_obj->common.p_father = p_father;
1419     p_obj->common.p_first = NULL;
1420     p_obj->common.p_next = NULL;
1421     p_obj->common.p_last = NULL;
1422
1423     if( p_obj->common.i_object_size < 24 )
1424     {
1425         msg_Warn( s, "found a corrupted asf object (size<24)" );
1426         return VLC_EGENERIC;
1427     }
1428
1429     /* find this object */
1430     for( i_index = 0; ; i_index++ )
1431     {
1432         if( guidcmp( ASF_Object_Function[i_index].p_id,
1433                          &p_obj->common.i_object_id ) ||
1434             guidcmp( ASF_Object_Function[i_index].p_id,
1435                          &asf_object_null_guid ) )
1436         {
1437             break;
1438         }
1439     }
1440     p_obj->common.i_type = ASF_Object_Function[i_index].i_type;
1441
1442     if( i_index == sizeof(ASF_Object_Function)/sizeof(ASF_Object_Function[0]) - 1 )
1443         msg_Warn( s, "unknown asf object (not loaded): " GUID_FMT,
1444                 GUID_PRINT( p_obj->common.i_object_id ) );
1445
1446     /* Now load this object */
1447     if( ASF_Object_Function[i_index].ASF_ReadObject_function == NULL )
1448     {
1449         i_result = VLC_SUCCESS;
1450     }
1451     else
1452     {
1453         /* XXX ASF_ReadObject_function realloc *pp_obj XXX */
1454         i_result =
1455           (ASF_Object_Function[i_index].ASF_ReadObject_function)( s, p_obj );
1456     }
1457
1458     /* link this object with father */
1459     if( p_father && ! i_result )
1460     {
1461         if( p_father->common.p_first )
1462         {
1463             p_father->common.p_last->common.p_next = p_obj;
1464         }
1465         else
1466         {
1467             p_father->common.p_first = p_obj;
1468         }
1469         p_father->common.p_last = p_obj;
1470     }
1471
1472     return i_result;
1473 }
1474
1475 static void ASF_FreeObject( stream_t *s, asf_object_t *p_obj )
1476 {
1477     int i_index;
1478     asf_object_t *p_child;
1479
1480     if( !p_obj )
1481         return;
1482
1483     /* Free all child object */
1484     p_child = p_obj->common.p_first;
1485     while( p_child )
1486     {
1487         asf_object_t *p_next;
1488         p_next = p_child->common.p_next;
1489         ASF_FreeObject( s, p_child );
1490         p_child = p_next;
1491     }
1492
1493     /* find this object */
1494     for( i_index = 0; ; i_index++ )
1495     {
1496         if( guidcmp( ASF_Object_Function[i_index].p_id,
1497                      &p_obj->common.i_object_id )||
1498             guidcmp( ASF_Object_Function[i_index].p_id,
1499                      &asf_object_null_guid ) )
1500         {
1501             break;
1502         }
1503     }
1504
1505     /* Now free this object */
1506     if( ASF_Object_Function[i_index].ASF_FreeObject_function != NULL )
1507     {
1508 #ifdef ASF_DEBUG
1509         msg_Dbg( s,
1510                   "free asf object " GUID_FMT,
1511                   GUID_PRINT( p_obj->common.i_object_id ) );
1512 #endif
1513         (ASF_Object_Function[i_index].ASF_FreeObject_function)( p_obj );
1514     }
1515     free( p_obj );
1516 }
1517
1518 /*****************************************************************************
1519  * ASF_ObjectDumpDebug:
1520  *****************************************************************************/
1521 static const struct
1522 {
1523     const guid_t *p_id;
1524     const char *psz_name;
1525 } ASF_ObjectDumpDebugInfo[] =
1526 {
1527     { &vlc_object_root_guid, "Root" },
1528     { &asf_object_header_guid, "Header" },
1529     { &asf_object_data_guid, "Data" },
1530     { &asf_object_index_guid, "Index" },
1531     { &asf_object_simple_index_guid, "Simple Index" },
1532     { &asf_object_file_properties_guid, "File Properties" },
1533     { &asf_object_stream_properties_guid, "Stream Properties" },
1534     { &asf_object_content_description_guid, "Content Description" },
1535     { &asf_object_header_extension_guid, "Header Extension" },
1536     { &asf_object_metadata_guid, "Metadata" },
1537     { &asf_object_codec_list_guid, "Codec List" },
1538     { &asf_object_marker_guid, "Marker" },
1539     { &asf_object_stream_type_audio, "Stream Type Audio" },
1540     { &asf_object_stream_type_video, "Stream Type Video" },
1541     { &asf_object_stream_type_command, "Stream Type Command" },
1542     { &asf_object_language_list, "Language List" },
1543     { &asf_object_stream_bitrate_properties, "Stream Bitrate Properties" },
1544     { &asf_object_padding, "Padding" },
1545     { &asf_object_extended_stream_properties_guid, "Extended Stream Properties" },
1546     { &asf_object_advanced_mutual_exclusion, "Advanced Mutual Exclusion" },
1547     { &asf_object_stream_prioritization, "Stream Prioritization" },
1548     { &asf_object_bitrate_mutual_exclusion_guid, "Bitrate Mutual Exclusion" },
1549     { &asf_object_extended_content_description, "Extended content description"},
1550     { &asf_object_content_encryption_guid, "Content Encryption"},
1551     { &asf_object_advanced_content_encryption_guid, "Advanced Content Encryption"},
1552     { &asf_object_extended_content_encryption_guid, "Entended Content Encryption"},
1553     /* Non Readable from this point */
1554     { &nonasf_object_index_placeholder_guid, "Index Placeholder"},
1555     { &nonasf_object_compatibility, "Object Compatibility"},
1556
1557     { NULL, "Unknown" },
1558 };
1559
1560
1561 static void ASF_ObjectDumpDebug( vlc_object_t *p_obj,
1562                                  asf_object_common_t *p_node, unsigned i_level )
1563 {
1564     unsigned i;
1565     union asf_object_u *p_child;
1566     const char *psz_name;
1567
1568     /* Find the name */
1569     for( i = 0; ASF_ObjectDumpDebugInfo[i].p_id != NULL; i++ )
1570     {
1571         if( guidcmp( ASF_ObjectDumpDebugInfo[i].p_id,
1572                           &p_node->i_object_id ) )
1573             break;
1574     }
1575     psz_name = ASF_ObjectDumpDebugInfo[i].psz_name;
1576
1577     char str[512];
1578     if( i_level >= (sizeof(str) - 1)/5 )
1579         return;
1580
1581     memset( str, ' ', sizeof( str ) );
1582     for( i = 0; i < i_level; i++ )
1583     {
1584         str[i * 4] = '|';
1585     }
1586     snprintf( &str[4*i_level], sizeof(str) - 5*i_level,
1587              "+ '%s'"
1588 #ifdef ASF_DEBUG
1589              "GUID "GUID_FMT" size:%"PRIu64" pos:%"PRIu64
1590 #endif
1591              , psz_name
1592
1593 #ifdef ASF_DEBUG
1594              , GUID_PRINT( p_node->i_object_id ),
1595              p_node->i_object_size, p_node->i_object_pos
1596 #endif
1597              );
1598
1599
1600     msg_Dbg( p_obj, "%s", str );
1601
1602     for( p_child = p_node->p_first; p_child != NULL;
1603                                              p_child = p_child->common.p_next )
1604     {
1605         ASF_ObjectDumpDebug( p_obj, &p_child->common, i_level + 1 );
1606     }
1607 }
1608
1609 /*****************************************************************************
1610  * ASF_ReadObjetRoot : parse the entire stream/file
1611  *****************************************************************************/
1612 asf_object_root_t *ASF_ReadObjectRoot( stream_t *s, int b_seekable )
1613 {
1614     asf_object_root_t *p_root = malloc( sizeof( asf_object_root_t ) );
1615     asf_object_t *p_obj;
1616     uint64_t i_boundary = 0;
1617
1618     if( !p_root )
1619         return NULL;
1620
1621     p_root->i_type = ASF_OBJECT_ROOT;
1622     memcpy( &p_root->i_object_id, &vlc_object_root_guid, sizeof( guid_t ) );
1623     p_root->i_object_pos = stream_Tell( s );
1624     p_root->i_object_size = 0;
1625     p_root->p_first = NULL;
1626     p_root->p_last  = NULL;
1627     p_root->p_next  = NULL;
1628     p_root->p_hdr   = NULL;
1629     p_root->p_data  = NULL;
1630     p_root->p_fp    = NULL;
1631     p_root->p_index = NULL;
1632     p_root->p_metadata = NULL;
1633
1634     for( ; ; )
1635     {
1636         p_obj = malloc( sizeof( asf_object_t ) );
1637
1638         if( !p_obj || ASF_ReadObject( s, p_obj, (asf_object_t*)p_root ) )
1639         {
1640             free( p_obj );
1641             break;
1642         }
1643         switch( p_obj->common.i_type )
1644         {
1645             case( ASF_OBJECT_HEADER ):
1646                 if ( p_root->p_index || p_root->p_data || p_root->p_hdr ) break;
1647                 p_root->p_hdr = (asf_object_header_t*)p_obj;
1648                 break;
1649             case( ASF_OBJECT_DATA ):
1650                 if ( p_root->p_index || p_root->p_data ) break;
1651                 p_root->p_data = (asf_object_data_t*)p_obj;
1652             break;
1653             case( ASF_OBJECT_INDEX ):
1654                 if ( p_root->p_index ) break;
1655                 p_root->p_index = (asf_object_index_t*)p_obj;
1656                 break;
1657             default:
1658                 msg_Warn( s, "unknown top-level object found: " GUID_FMT,
1659                       GUID_PRINT( p_obj->common.i_object_id ) );
1660                 break;
1661         }
1662
1663         /* Set a limit to avoid junk when possible */
1664         if ( guidcmp( &p_obj->common.i_object_id, &asf_object_file_properties_guid ) )
1665         {
1666             i_boundary = p_obj->file_properties.i_file_size;
1667         }
1668
1669         if( p_obj->common.i_type == ASF_OBJECT_DATA &&
1670             p_obj->common.i_object_size <= 50 )
1671         {
1672             /* probably a dump of broadcasted asf */
1673             break;
1674         }
1675         if( !b_seekable && p_root->p_hdr && p_root->p_data )
1676         {
1677             /* For unseekable stream it's enough to play */
1678             break;
1679         }
1680
1681         if( ASF_NextObject( s, p_obj, i_boundary ) ) /* Go to the next object */
1682             break;
1683     }
1684
1685     if( p_root->p_hdr != NULL && p_root->p_data != NULL )
1686     {
1687         p_root->p_fp = ASF_FindObject( p_root->p_hdr,
1688                                        &asf_object_file_properties_guid, 0 );
1689
1690         if( p_root->p_fp )
1691         {
1692             asf_object_t *p_hdr_ext =
1693                 ASF_FindObject( p_root->p_hdr,
1694                                 &asf_object_header_extension_guid, 0 );
1695             if( p_hdr_ext )
1696             {
1697                 int i_ext_stream;
1698
1699                 p_root->p_metadata =
1700                     ASF_FindObject( p_hdr_ext,
1701                                     &asf_object_metadata_guid, 0 );
1702                 /* Special case for broken designed file format :( */
1703                 i_ext_stream = ASF_CountObject( p_hdr_ext,
1704                                     &asf_object_extended_stream_properties_guid );
1705                 for( int i = 0; i < i_ext_stream; i++ )
1706                 {
1707                     asf_object_t *p_esp =
1708                         ASF_FindObject( p_hdr_ext,
1709                                    &asf_object_extended_stream_properties_guid, i );
1710                     if( p_esp->ext_stream.p_sp )
1711                     {
1712                         asf_object_t *p_sp =
1713                                          (asf_object_t*)p_esp->ext_stream.p_sp;
1714
1715                         /* Insert this p_sp */
1716                         p_root->p_hdr->p_last->common.p_next = p_sp;
1717                         p_root->p_hdr->p_last = p_sp;
1718
1719                         p_sp->common.p_father = (asf_object_t*)p_root->p_hdr;
1720                     }
1721                 }
1722             }
1723
1724             ASF_ObjectDumpDebug( VLC_OBJECT(s),
1725                                  (asf_object_common_t*)p_root, 0 );
1726             return p_root;
1727         }
1728         msg_Warn( s, "cannot find file properties object" );
1729     }
1730
1731     /* Invalid file */
1732     ASF_FreeObjectRoot( s, p_root );
1733     return NULL;
1734 }
1735
1736 void ASF_FreeObjectRoot( stream_t *s, asf_object_root_t *p_root )
1737 {
1738     asf_object_t *p_obj;
1739
1740     p_obj = p_root->p_first;
1741     while( p_obj )
1742     {
1743         asf_object_t *p_next;
1744         p_next = p_obj->common.p_next;
1745         ASF_FreeObject( s, p_obj );
1746         p_obj = p_next;
1747     }
1748     free( p_root );
1749 }
1750
1751 int ASF_CountObject( void *_p_obj, const guid_t *p_guid )
1752 {
1753     int i_count;
1754     asf_object_t *p_child, *p_obj;
1755
1756     p_obj = (asf_object_t *)_p_obj;
1757     if( !p_obj )
1758         return 0;
1759
1760     i_count = 0;
1761     p_child = p_obj->common.p_first;
1762     while( p_child )
1763     {
1764         if( guidcmp( &p_child->common.i_object_id, p_guid ) )
1765             i_count++;
1766
1767         p_child = p_child->common.p_next;
1768     }
1769     return i_count;
1770 }
1771
1772 void *ASF_FindObject( void *_p_obj, const guid_t *p_guid,
1773                         int i_number )
1774 {
1775     asf_object_t *p_child, *p_obj;
1776
1777     p_obj = (asf_object_t *)_p_obj;
1778     p_child = p_obj->common.p_first;
1779
1780     while( p_child )
1781     {
1782         if( guidcmp( &p_child->common.i_object_id, p_guid ) )
1783         {
1784             if( i_number == 0 )
1785                 return p_child;
1786
1787             i_number--;
1788         }
1789         p_child = p_child->common.p_next;
1790     }
1791     return NULL;
1792 }