93d02892ebdcafb19741933abf8ff79b1ec6cfc0
[vlc.git] / modules / demux / asf / libasf.c
1 /*****************************************************************************
2  * libasf.c : 
3  *****************************************************************************
4  * Copyright (C) 2001 VideoLAN
5  * $Id: libasf.c,v 1.1 2002/10/20 17:22:33 fenrir Exp $
6  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
7  * 
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  * 
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
21  *****************************************************************************/
22
23 #include <stdlib.h>                                      /* malloc(), free() */
24 #include <string.h>                                              /* strdup() */
25 #include <errno.h>
26 #include <sys/types.h>
27
28 #include <vlc/vlc.h>
29 #include <vlc/input.h>
30
31 #include "libasf.h"
32
33 #define ASF_DEBUG 1
34
35 #define FREE( p ) \
36     if( p ) {free( p ); p = NULL; }
37    
38 #define GUID_FMT "0x%x-0x%x-0x%x-0x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x"
39 #define GUID_PRINT( guid )  \
40     (guid).v1,              \
41     (guid).v2,              \
42     (guid).v3,              \
43     (guid).v4[0],(guid).v4[1],(guid).v4[2],(guid).v4[3],    \
44     (guid).v4[4],(guid).v4[5],(guid).v4[6],(guid).v4[7]
45
46 /* Some functions to manipulate memory */
47 static u16 GetWLE( u8 *p_buff )
48 {
49     return( (p_buff[0]) + ( p_buff[1] <<8 ) );
50 }
51
52 static u32 GetDWLE( u8 *p_buff )
53 {
54     return( p_buff[0] + ( p_buff[1] <<8 ) +
55             ( p_buff[2] <<16 ) + ( p_buff[3] <<24 ) );
56 }
57
58 static u64 GetQWLE( u8 *p_buff )
59 {
60     return( ( (u64)GetDWLE( p_buff ) )|( (u64)GetDWLE( p_buff + 4 ) << 32) );
61 }
62
63 void GetGUID( guid_t *p_guid, u8 *p_data )
64 {
65     p_guid->v1 = GetDWLE( p_data );
66     p_guid->v2 = GetWLE( p_data + 4);
67     p_guid->v3 = GetWLE( p_data + 6);
68     memcpy( p_guid->v4, p_data + 8, 8 );
69 }
70
71 int CmpGUID( const guid_t *p_guid1, const guid_t *p_guid2 )
72 {
73     if( (p_guid1->v1 != p_guid2->v1 )||(p_guid1->v2 != p_guid2->v2 )||
74         (p_guid1->v3 != p_guid2->v3 )||
75         ( memcmp( p_guid1->v4, p_guid2->v4,8 )) )
76     {
77         return( 0 );
78     }
79     else
80     {
81         return( 1 ); /* match */
82     }
83 }
84 /*****************************************************************************
85  * Some basic functions to manipulate stream more easily in vlc
86  *
87  * ASF_TellAbsolute get file position
88  * 
89  * ASF_SeekAbsolute seek in the file
90  *
91  * ASF_ReadData read data from the file in a buffer
92  *
93  *****************************************************************************/
94 off_t ASF_TellAbsolute( input_thread_t *p_input )
95 {
96     off_t i_pos;
97     
98     vlc_mutex_lock( &p_input->stream.stream_lock );
99     
100     i_pos= p_input->stream.p_selected_area->i_tell -
101             ( p_input->p_last_data - p_input->p_current_data  );
102
103     vlc_mutex_unlock( &p_input->stream.stream_lock );
104
105     return( i_pos );
106 }
107  
108 int ASF_SeekAbsolute( input_thread_t *p_input,
109                       off_t i_pos)
110 {
111     off_t i_filepos;
112
113     if( i_pos >= p_input->stream.p_selected_area->i_size )
114     {
115         return( 0 );
116     }
117             
118     i_filepos = ASF_TellAbsolute( p_input );
119     if( i_pos != i_filepos )
120     {
121         p_input->pf_seek( p_input, i_pos );
122         input_AccessReinit( p_input );
123     }
124     return( 1 );
125 }
126
127 /* return 1 if success, 0 if fail */
128 int ASF_ReadData( input_thread_t *p_input, u8 *p_buff, int i_size )
129 {
130     data_packet_t *p_data;
131
132     int i_read;
133
134                 
135     if( !i_size )
136     {
137         return( 1 );
138     }
139
140     do
141     {
142         i_read = input_SplitBuffer(p_input, &p_data, __MIN( i_size, 1024 ) );
143         if( i_read <= 0 )
144         {
145             return( 0 );
146         }
147         memcpy( p_buff, p_data->p_payload_start, i_read );
148         input_DeletePacket( p_input->p_method_data, p_data );
149         
150         p_buff += i_read;
151         i_size -= i_read;
152                 
153     } while( i_size );
154     
155     return( 1 );
156 }
157
158 int  ASF_SkipBytes( input_thread_t *p_input, int i_count )
159 {
160     return( ASF_SeekAbsolute( p_input, 
161                               ASF_TellAbsolute( p_input ) + i_count ) );
162 }
163
164 /****************************************************************************/
165 int  ASF_ReadObjectCommon( input_thread_t *p_input, 
166                            asf_object_t *p_obj )
167 {
168     asf_object_common_t *p_common = (asf_object_common_t*)p_obj;
169     u8  *p_peek;
170
171     if( input_Peek( p_input, &p_peek, 24 ) < 24 )
172     {
173         return( 0 );
174     }
175     GetGUID( &p_common->i_object_id, p_peek ); 
176     p_common->i_object_size = GetQWLE( p_peek + 16 );
177     p_common->i_object_pos = ASF_TellAbsolute( p_input );
178     p_common->p_next = NULL;
179 #ifdef ASF_DEBUG
180     msg_Dbg(p_input,
181             "Found Object guid: " GUID_FMT " size:%lld",
182             GUID_PRINT( p_common->i_object_id ),
183             p_common->i_object_size );
184 #endif
185     
186     return( 1 ); 
187 }
188
189 int ASF_NextObject( input_thread_t *p_input,
190                     asf_object_t *p_obj )
191 {
192     asf_object_t obj;
193     if( !p_obj )
194     {
195         if( !ASF_ReadObjectCommon( p_input, &obj ) )
196         {
197             return( 0 );
198         }
199         p_obj = &obj;
200     }
201
202     if( !p_obj->common.i_object_size )
203     {
204         return( 0 ); /* failed */
205     }
206     if( p_obj->common.p_father )
207     {
208         if( p_obj->common.p_father->common.i_object_pos + p_obj->common.p_father->common.i_object_size <
209                 p_obj->common.i_object_pos + p_obj->common.i_object_size + 24 )  
210                                 /* 24 is min size of an object */
211         {
212             return( 0 );
213         }
214
215     }
216     return( ASF_SeekAbsolute( p_input, 
217                               p_obj->common.i_object_pos + p_obj->common.i_object_size ) );
218 }
219
220 int  ASF_GotoObject( input_thread_t *p_input,
221                      asf_object_t *p_obj )
222 {
223     if( !p_obj )
224     {
225         return( 0 );
226     }
227     return( ASF_SeekAbsolute( p_input, p_obj->common.i_object_pos ) );
228 }
229
230
231 void ASF_FreeObject_Null( input_thread_t *p_input,
232                             asf_object_t *pp_obj )
233 {
234
235
236 }
237
238 int  ASF_ReadObject_Header( input_thread_t *p_input,
239                             asf_object_t *p_obj )
240 {
241     asf_object_header_t *p_hdr = (asf_object_header_t*)p_obj;
242     asf_object_t *p_subobj;
243     int i_peek;
244     u8  *p_peek;
245     
246     if( ( i_peek = input_Peek( p_input, &p_peek, 30 ) ) < 30 )
247     {
248        return( 0 );
249     }
250     p_hdr->i_sub_object_count = GetDWLE( p_peek + 24 );
251     p_hdr->i_reserved1 = p_peek[28];
252     p_hdr->i_reserved2 = p_peek[29];
253     p_hdr->p_first = NULL;
254     p_hdr->p_last  = NULL;
255 #ifdef ASF_DEBUG
256     msg_Dbg(p_input,
257             "Read \"Header Object\" subobj:%d, reserved1:%d, reserved2:%d",
258             p_hdr->i_sub_object_count,
259             p_hdr->i_reserved1,
260             p_hdr->i_reserved2 );
261 #endif
262     ASF_SkipBytes( p_input, 30 );
263     /* Now load sub object */
264     for( ; ; )
265     {
266         p_subobj  = malloc( sizeof( asf_object_t ) );
267
268         if( !( ASF_ReadObject( p_input, p_subobj, (asf_object_t*)p_hdr ) ) )
269         {
270             break; 
271         }
272         if( !ASF_NextObject( p_input, p_subobj ) ) /* Go to the next object */
273         {
274             break;
275         }
276     }
277     return( 1 );
278 }
279
280 int  ASF_ReadObject_Data( input_thread_t *p_input,
281                           asf_object_t *p_obj )
282 {
283     asf_object_data_t *p_data = (asf_object_data_t*)p_obj;
284     int i_peek;
285     u8  *p_peek;
286     
287     if( ( i_peek = input_Peek( p_input, &p_peek, 50 ) ) < 50 )
288     {
289        return( 0 );
290     }
291     GetGUID( &p_data->i_file_id, p_peek + 24 );
292     p_data->i_total_data_packets = GetQWLE( p_peek + 40 );
293     p_data->i_reserved = GetWLE( p_peek + 48 );
294 #ifdef ASF_DEBUG
295     msg_Dbg( p_input,
296             "Read \"Data Object\" file_id:" GUID_FMT " total data packet:%lld reserved:%d",
297             GUID_PRINT( p_data->i_file_id ),
298             p_data->i_total_data_packets,
299             p_data->i_reserved );
300 #endif
301     return( 1 );
302 }
303
304 int  ASF_ReadObject_Index( input_thread_t *p_input,
305                            asf_object_t *p_obj )
306 {
307     asf_object_index_t *p_index = (asf_object_index_t*)p_obj;
308     int i_peek;
309     u8  *p_peek;
310     
311     if( ( i_peek = input_Peek( p_input, &p_peek, 56 ) ) < 56 )
312     {
313        return( 0 );
314     }
315     GetGUID( &p_index->i_file_id, p_peek + 24 );
316     p_index->i_index_entry_time_interval = GetQWLE( p_peek + 40 );
317     p_index->i_max_packet_count = GetDWLE( p_peek + 48 );
318     p_index->i_index_entry_count = GetDWLE( p_peek + 52 );
319     p_index->index_entry = NULL; /* FIXME */
320
321 #ifdef ASF_DEBUG
322     msg_Dbg( p_input,
323             "Read \"Index Object\" file_id:" GUID_FMT " index_entry_time_interval:%lld max_packet_count:%d index_entry_count:%d",
324             GUID_PRINT( p_index->i_file_id ),
325             p_index->i_max_packet_count,
326             p_index->i_index_entry_count );
327 #endif
328     return( 1 );
329 }
330 void ASF_FreeObject_Index( input_thread_t *p_input,
331                           asf_object_t *p_obj )
332 {
333     asf_object_index_t *p_index = (asf_object_index_t*)p_obj;
334
335     FREE( p_index->index_entry );
336 }
337
338 int  ASF_ReadObject_file_properties( input_thread_t *p_input,
339                                      asf_object_t *p_obj )
340 {
341     asf_object_file_properties_t *p_fp = (asf_object_file_properties_t*)p_obj;
342     int i_peek;
343     u8  *p_peek;
344     
345     if( ( i_peek = input_Peek( p_input, &p_peek,  92) ) < 92 )
346     {
347        return( 0 );
348     }
349     GetGUID( &p_fp->i_file_id, p_peek + 24 );
350     p_fp->i_file_size = GetQWLE( p_peek + 40 );
351     p_fp->i_creation_date = GetQWLE( p_peek + 48 );
352     p_fp->i_data_packets_count = GetQWLE( p_peek + 56 );
353     p_fp->i_play_duration = GetQWLE( p_peek + 64 );
354     p_fp->i_send_duration = GetQWLE( p_peek + 72 );
355     p_fp->i_preroll = GetQWLE( p_peek + 80 );
356     p_fp->i_flags = GetDWLE( p_peek + 88 );
357     p_fp->i_min_data_packet_size = GetDWLE( p_peek + 92 );
358     p_fp->i_max_data_packet_size = GetDWLE( p_peek + 96 );
359     p_fp->i_max_bitrate = GetDWLE( p_peek + 100 );
360         
361 #ifdef ASF_DEBUG
362     msg_Dbg( p_input,
363             "Read \"File Properties Object\" file_id:" GUID_FMT " file_size:%lld creation_date:%lld data_packets_count:%lld play_duration:%lld send_duration:%lld preroll:%lld flags:%d min_data_packet_size:%d max_data_packet_size:%d max_bitrate:%d",
364             GUID_PRINT( p_fp->i_file_id ),
365             p_fp->i_file_size,
366             p_fp->i_creation_date,
367             p_fp->i_data_packets_count,
368             p_fp->i_play_duration,
369             p_fp->i_send_duration,
370             p_fp->i_preroll,
371             p_fp->i_flags,
372             p_fp->i_min_data_packet_size,
373             p_fp->i_max_data_packet_size,
374             p_fp->i_max_bitrate );
375 #endif
376     return( 1 );
377 }
378
379 int  ASF_ReadObject_header_extention( input_thread_t *p_input,
380                                       asf_object_t *p_obj )
381 {
382     asf_object_header_extention_t *p_he = (asf_object_header_extention_t*)p_obj;
383     int i_peek;
384     u8  *p_peek;
385     
386     if( ( i_peek = input_Peek( p_input, &p_peek, p_he->i_object_size ) ) <  46)
387     {
388        return( 0 );
389     }
390     GetGUID( &p_he->i_reserved1, p_peek + 24 );
391     p_he->i_reserved2 = GetWLE( p_peek + 40 );
392     p_he->i_header_extention_size = GetDWLE( p_peek + 42 );
393     if( p_he->i_header_extention_size )
394     {
395         p_he->p_header_extention_data = malloc( p_he->i_header_extention_size );
396         memcpy( p_he->p_header_extention_data,
397                 p_peek + 46,
398                 p_he->i_header_extention_size );
399     }
400     else
401     {
402         p_he->p_header_extention_data = NULL;
403     }
404 #ifdef ASF_DEBUG
405     msg_Dbg( p_input,
406             "Read \"Header Extention Object\" reserved1:" GUID_FMT " reserved2:%d header_extention_size:%d",
407             GUID_PRINT( p_he->i_reserved1 ),
408             p_he->i_reserved2,
409             p_he->i_header_extention_size );
410 #endif 
411     return( 1 );
412 }
413 void ASF_FreeObject_header_extention( input_thread_t *p_input,
414                                       asf_object_t *p_obj )
415 {
416     asf_object_header_extention_t *p_he = (asf_object_header_extention_t*)p_obj;
417
418     FREE( p_he->p_header_extention_data );
419 }
420
421 int  ASF_ReadObject_stream_properties( input_thread_t *p_input,
422                                        asf_object_t *p_obj )
423 {
424     asf_object_stream_properties_t *p_sp = 
425                     (asf_object_stream_properties_t*)p_obj;
426     int i_peek;
427     u8  *p_peek;
428     
429     if( ( i_peek = input_Peek( p_input, &p_peek,  p_sp->i_object_size ) ) < 74 )
430     {
431        return( 0 );
432     }
433     GetGUID( &p_sp->i_stream_type, p_peek + 24 );
434     GetGUID( &p_sp->i_error_correction_type, p_peek + 40 );
435     p_sp->i_time_offset = GetQWLE( p_peek + 56 );
436     p_sp->i_type_specific_data_length = GetDWLE( p_peek + 64 );
437     p_sp->i_error_correction_data_length = GetDWLE( p_peek + 68 );
438     p_sp->i_flags = GetWLE( p_peek + 72 );
439         p_sp->i_stream_number = p_sp->i_flags&0x07f;
440     p_sp->i_reserved = GetDWLE( p_peek + 74 );
441     if( p_sp->i_type_specific_data_length )
442     {
443         p_sp->p_type_specific_data = malloc( p_sp->i_type_specific_data_length );
444         memcpy( p_sp->p_type_specific_data,
445                 p_peek + 78,
446                 p_sp->i_type_specific_data_length );
447     }
448     else
449     {
450         p_sp->p_type_specific_data = NULL;
451     }
452     if( p_sp->i_error_correction_data_length )
453     {
454         p_sp->p_error_correction_data = malloc( p_sp->i_error_correction_data_length );
455         memcpy( p_sp->p_error_correction_data,
456                 p_peek + 78 + p_sp->i_type_specific_data_length,
457                 p_sp->i_error_correction_data_length );
458     }
459     else
460     {
461         p_sp->p_error_correction_data = NULL;
462     }
463
464 #ifdef ASF_DEBUG
465     msg_Dbg( p_input,
466             "Read \"Stream Properties Object\" stream_type:" GUID_FMT " error_correction_type:" GUID_FMT " time_offset:%lld type_specific_data_length:%d error_correction_data_length:%d flags:0x%x stream_number:%d",
467             GUID_PRINT( p_sp->i_stream_type ),
468             GUID_PRINT( p_sp->i_error_correction_type ),
469             p_sp->i_time_offset,
470             p_sp->i_type_specific_data_length,
471             p_sp->i_error_correction_data_length,
472             p_sp->i_flags,
473             p_sp->i_stream_number );
474
475 #endif
476     return( 1 );
477 }
478
479 void ASF_FreeObject_stream_properties( input_thread_t *p_input,
480                                       asf_object_t *p_obj )
481 {
482     asf_object_stream_properties_t *p_sp = 
483                 (asf_object_stream_properties_t*)p_obj;
484
485     FREE( p_sp->p_type_specific_data );
486     FREE( p_sp->p_error_correction_data );
487 }
488
489
490 int  ASF_ReadObject_codec_list( input_thread_t *p_input,
491                                 asf_object_t *p_obj )
492 {
493     asf_object_codec_list_t *p_cl = (asf_object_codec_list_t*)p_obj;
494     int i_peek;
495     u8  *p_peek, *p_data;
496
497     int i_codec;
498     
499     if( ( i_peek = input_Peek( p_input, &p_peek, p_cl->i_object_size ) ) < 44 )
500     {
501        return( 0 );
502     }
503
504     GetGUID( &p_cl->i_reserved, p_peek + 24 );
505     p_cl->i_codec_entries_count = GetWLE( p_peek + 40 );
506     if( p_cl->i_codec_entries_count > 0 )
507     {
508
509         p_cl->codec = calloc( p_cl->i_codec_entries_count, sizeof( asf_codec_entry_t ) );
510         memset( p_cl->codec, 0, p_cl->i_codec_entries_count * sizeof( asf_codec_entry_t ) );
511
512         p_data = p_peek + 44;
513         for( i_codec = 0; i_codec < p_cl->i_codec_entries_count; i_codec++ )
514         {
515 #define codec p_cl->codec[i_codec]
516             int i_len, i;
517
518             codec.i_type = GetWLE( p_data ); p_data += 2;
519             /* codec name */
520             i_len = GetWLE( p_data ); p_data += 2;
521             codec.psz_name = calloc( sizeof( char ), i_len + 1);
522             for( i = 0; i < i_len; i++ )
523             {
524                 codec.psz_name[i] = GetWLE( p_data + 2*i );
525             }
526             codec.psz_name[i_len] = '\0';
527             p_data += 2 * i_len;
528
529             /* description */
530             i_len = GetWLE( p_data ); p_data += 2;
531             codec.psz_description = calloc( sizeof( char ), i_len + 1);
532             for( i = 0; i < i_len; i++ )
533             {
534                 codec.psz_description[i] = GetWLE( p_data + 2*i );
535             }
536             codec.psz_description[i_len] = '\0';
537             p_data += 2 * i_len;
538             
539             /* opaque information */
540             codec.i_information_length = GetWLE( p_data ); p_data += 2;
541             if( codec.i_information_length > 0 )
542             {
543                 codec.p_information = malloc( codec.i_information_length );
544                 memcpy( codec.p_information, p_data, codec.i_information_length );
545                 p_data += codec.i_information_length;
546             }
547             else
548             {
549                 codec.p_information = NULL;
550             }
551 #undef  codec
552         }
553
554     }
555     else
556     {
557         p_cl->codec = NULL;
558     }
559
560 #ifdef ASF_DEBUG
561     msg_Dbg( p_input,
562             "Read \"Codec List Object\" reserved_guid:" GUID_FMT " codec_entries_count:%d",
563             GUID_PRINT( p_cl->i_reserved ),
564             p_cl->i_codec_entries_count );
565     for( i_codec = 0; i_codec < p_cl->i_codec_entries_count; i_codec++ )
566     {
567 #define codec p_cl->codec[i_codec]
568          msg_Dbg( p_input,
569                  "Read \"Codec List Object\" codec[%d] %s name:\"%s\" description:\"%s\" information_length:%d",
570                  i_codec,
571                  ( codec.i_type == ASF_CODEC_TYPE_VIDEO ) ? "video" : ( ( codec.i_type == ASF_CODEC_TYPE_AUDIO ) ? "audio" : "unknown" ),
572                  codec.psz_name, 
573                  codec.psz_description, 
574                  codec.i_information_length );
575        
576 #undef  codec
577     }
578 #endif
579     return( 1 );
580 }
581 void ASF_FreeObject_codec_list( input_thread_t *p_input,
582                                 asf_object_t *p_obj )
583 {
584     asf_object_codec_list_t *p_cl = (asf_object_codec_list_t*)p_obj;
585     int i_codec;
586
587     for( i_codec = 0; i_codec < p_cl->i_codec_entries_count; i_codec++ )
588     {
589 #define codec p_cl->codec[i_codec]
590         FREE( codec.psz_name );
591         FREE( codec.psz_description );
592         FREE( codec.p_information );
593
594 #undef  codec
595     }
596     FREE( p_cl->codec );
597 }
598
599 /* Microsoft should qo to hell. This time the length give number of bytes
600  * and for the some others object, length give char16 count ... */
601 int  ASF_ReadObject_content_description( input_thread_t *p_input,
602                                          asf_object_t *p_obj )
603 {
604     asf_object_content_description_t *p_cd = (asf_object_content_description_t*)p_obj;
605     int i_peek;
606     u8  *p_peek, *p_data;
607
608     int i_len;
609     int i_title;
610     int i_author;
611     int i_copyright;
612     int i_description;
613     int i_rating;
614     
615 #define GETSTRINGW( psz_str, i_size ) \
616    psz_str = calloc( i_size/2 + 1, sizeof( char ) ); \
617    for( i_len = 0; i_len < i_size/2; i_len++ ) \
618    { \
619        psz_str[i_len] = GetWLE( p_data + 2*i_len ); \
620    } \
621    psz_str[i_size/2] = '\0'; \
622    p_data += i_size;
623    
624     if( ( i_peek = input_Peek( p_input, &p_peek, p_cd->i_object_size ) ) < 34 )
625     {
626        return( 0 );
627     }
628     p_data = p_peek + 24;
629
630     i_title = GetWLE( p_data ); p_data += 2;
631     i_author= GetWLE( p_data ); p_data += 2;
632     i_copyright     = GetWLE( p_data ); p_data += 2;
633     i_description   = GetWLE( p_data ); p_data += 2;
634     i_rating        = GetWLE( p_data ); p_data += 2;
635
636     GETSTRINGW( p_cd->psz_title, i_title );
637     GETSTRINGW( p_cd->psz_author, i_author );
638     GETSTRINGW( p_cd->psz_copyright, i_copyright );
639     GETSTRINGW( p_cd->psz_description, i_description );
640     GETSTRINGW( p_cd->psz_rating, i_rating );
641
642 #undef  GETSTRINGW
643
644 #ifdef ASF_DEBUG
645     msg_Dbg( p_input,
646              "Read \"Content Description Object\" title:\"%s\" author:\"%s\" copyright:\"%s\" description:\"%s\" rating:\"%s\"",
647              p_cd->psz_title,
648              p_cd->psz_author,
649              p_cd->psz_copyright,
650              p_cd->psz_description,
651              p_cd->psz_rating );
652 #endif 
653     return( 1 );
654 }
655
656 void ASF_FreeObject_content_description( input_thread_t *p_input,
657                                          asf_object_t *p_obj )
658 {
659     asf_object_content_description_t *p_cd = (asf_object_content_description_t*)p_obj;
660     
661     FREE( p_cd->psz_title );
662     FREE( p_cd->psz_author );
663     FREE( p_cd->psz_copyright );
664     FREE( p_cd->psz_description );
665     FREE( p_cd->psz_rating );
666 }
667
668 static struct
669 {
670     const guid_t  *p_id;
671     int     i_type;
672     int     (*ASF_ReadObject_function)( input_thread_t *p_input, 
673                                         asf_object_t *p_obj );
674     void    (*ASF_FreeObject_function)( input_thread_t *p_input,
675                                         asf_object_t *p_obj );
676 } ASF_Object_Function [] =
677 {
678     { &asf_object_header_guid,            ASF_OBJECT_TYPE_HEADER,             ASF_ReadObject_Header, ASF_FreeObject_Null },
679     { &asf_object_data_guid,              ASF_OBJECT_TYPE_DATA,               ASF_ReadObject_Data,   ASF_FreeObject_Null },
680     { &asf_object_index_guid,             ASF_OBJECT_TYPE_INDEX,              ASF_ReadObject_Index,  ASF_FreeObject_Index },
681     { &asf_object_file_properties_guid,   ASF_OBJECT_TYPE_FILE_PROPERTIES,    ASF_ReadObject_file_properties,  ASF_FreeObject_Null },
682     { &asf_object_stream_properties_guid, ASF_OBJECT_TYPE_STREAM_PROPERTIES,  ASF_ReadObject_stream_properties,ASF_FreeObject_stream_properties },
683     { &asf_object_header_extention_guid,  ASF_OBJECT_TYPE_EXTENTION_HEADER,   ASF_ReadObject_header_extention, ASF_FreeObject_header_extention},
684     { &asf_object_codec_list_guid,        ASF_OBJECT_TYPE_CODEC_LIST,         ASF_ReadObject_codec_list,       ASF_FreeObject_codec_list },
685     { &asf_object_marker_guid,            ASF_OBJECT_TYPE_MARKER,             NULL,                  NULL },
686     { &asf_object_content_description_guid, ASF_OBJECT_TYPE_CONTENT_DESCRIPTION, ASF_ReadObject_content_description, ASF_FreeObject_content_description },
687
688     { &asf_object_null_guid,   0,                      NULL,                  NULL }
689 };
690
691 int  ASF_ReadObject( input_thread_t *p_input,
692                      asf_object_t *p_obj,
693                      asf_object_t *p_father )
694 {
695     int i_result;
696     int i_index;
697
698     if( !p_obj )
699     {
700         return( 0 );
701     }
702     if( !ASF_ReadObjectCommon( p_input, p_obj ) )
703     {
704         msg_Warn( p_input, "Cannot read one asf object" );
705         return( 0 );
706     }
707     p_obj->common.p_father = p_father;
708     p_obj->common.p_first = NULL;
709     p_obj->common.p_next = NULL;
710     p_obj->common.p_last = NULL;
711     
712
713     if( p_obj->common.i_object_size < 24 )
714     {
715         msg_Warn( p_input, "Found a corrupted asf object (size<24)" );
716         return( 0 );
717     }
718     /* find this object */
719     for( i_index = 0; ; i_index++ )
720     {
721         if( CmpGUID( ASF_Object_Function[i_index].p_id,
722                      &p_obj->common.i_object_id )||
723             CmpGUID( ASF_Object_Function[i_index].p_id,
724                      &asf_object_null_guid ) )
725         {
726             break;
727         }
728     }
729     p_obj->common.i_type = ASF_Object_Function[i_index].i_type;
730
731     /* Now load this object */
732     if( ASF_Object_Function[i_index].ASF_ReadObject_function == NULL )
733     {
734         msg_Warn( p_input, "Unknown asf object (not loaded)" );
735         i_result = 1;
736     }
737     else
738     {
739         /* XXX ASF_ReadObject_function realloc *pp_obj XXX */
740         i_result =  
741             (ASF_Object_Function[i_index].ASF_ReadObject_function)( p_input,
742                                                                     p_obj );
743     }
744     
745     /* link this object with father */
746     if( p_father )
747     {
748         if( p_father->common.p_first )
749         {
750             p_father->common.p_last->common.p_next = p_obj;
751         }
752         else
753         {
754             p_father->common.p_first = p_obj;
755         }
756         p_father->common.p_last = p_obj;
757     }
758
759     return( i_result );
760 }
761
762 void ASF_FreeObject( input_thread_t *p_input,
763                      asf_object_t *p_obj )
764 {
765     int i_index;
766     asf_object_t *p_child;
767     
768     if( !p_obj )
769     {
770         return;
771     }
772     
773     /* Free all child object */
774     p_child = p_obj->common.p_first;
775     while( p_child )
776     {
777         asf_object_t *p_next;
778         p_next = p_child->common.p_next;
779         ASF_FreeObject( p_input, p_child );
780         p_child = p_next;
781     }
782
783     /* find this object */
784     for( i_index = 0; ; i_index++ )
785     {
786         if( CmpGUID( ASF_Object_Function[i_index].p_id,
787                      &p_obj->common.i_object_id )||
788             CmpGUID( ASF_Object_Function[i_index].p_id,
789                      &asf_object_null_guid ) )
790         {
791             break;
792         }
793     }
794
795     /* Now free this object */
796     if( ASF_Object_Function[i_index].ASF_FreeObject_function == NULL )
797     {
798         msg_Warn( p_input, 
799                   "Unknown asf object " GUID_FMT,
800                   GUID_PRINT( p_obj->common.i_object_id ) );
801     }
802     else
803     {
804 #ifdef ASF_DEBUG
805         msg_Dbg( p_input, 
806                   "Free asf object " GUID_FMT,
807                   GUID_PRINT( p_obj->common.i_object_id ) );
808 #endif
809         (ASF_Object_Function[i_index].ASF_FreeObject_function)( p_input,
810                                                                 p_obj );
811     }
812     free( p_obj );
813     return;
814 }
815
816 /*****************************************************************************
817  * ASF_ReadObjetRoot : parse the entire stream/file
818  *****************************************************************************/
819 int ASF_ReadObjectRoot( input_thread_t *p_input,
820                         asf_object_root_t *p_root,
821                         int b_seekable )
822 {
823     asf_object_t *p_obj;
824
825     p_root->i_type = ASF_OBJECT_TYPE_ROOT;
826     memcpy( &p_root->i_object_id, &asf_object_null_guid, sizeof( guid_t ) );
827     p_root->i_object_pos = 0;
828     p_root->i_object_size = p_input->stream.p_selected_area->i_size;
829     p_root->p_first = NULL;
830     p_root->p_last = NULL;
831     p_root->p_next = NULL;
832     p_root->p_hdr = NULL;
833     p_root->p_data = NULL;
834     p_root->p_index = NULL;
835    
836     for( ; ; )
837     {
838         p_obj  = malloc( sizeof( asf_object_t ) );
839
840         if( !( ASF_ReadObject( p_input, p_obj, (asf_object_t*)p_root ) ) )
841         {
842             return( 1 );
843         }
844         switch( p_obj->common.i_type )
845         {
846             case( ASF_OBJECT_TYPE_HEADER ):
847                 p_root->p_hdr = (asf_object_header_t*)p_obj;
848                 break;
849             case( ASF_OBJECT_TYPE_DATA ):
850                 p_root->p_data = (asf_object_data_t*)p_obj;
851                 break;
852             case( ASF_OBJECT_TYPE_INDEX ):
853                 p_root->p_index = (asf_object_index_t*)p_obj;
854                 break;
855             default:
856                 msg_Warn( p_input, "Unknow Object found" );
857                 break;
858         }
859         if( !b_seekable && ( p_root->p_hdr && p_root->p_data ) )
860         {
861             /* For unseekable stream it's enouth to play */
862             return( 1 );
863         }
864
865         if( !ASF_NextObject( p_input, p_obj ) ) /* Go to the next object */
866         {
867             return( 1 );
868         }
869     }
870 }
871
872 void ASF_FreeObjectRoot( input_thread_t *p_input,
873                          asf_object_root_t *p_root )
874 {
875     asf_object_t *p_obj;
876     
877     p_obj = p_root->p_first;
878     while( p_obj )
879     {
880         asf_object_t *p_next;
881         p_next = p_obj->common.p_next;
882         ASF_FreeObject( p_input, p_obj );
883         p_obj = p_next;
884     }
885     p_root->p_first = NULL;
886     p_root->p_last = NULL;
887     p_root->p_next = NULL;
888
889     p_root->p_hdr = NULL;
890     p_root->p_data = NULL;
891     p_root->p_index = NULL;
892     
893 }
894
895 int  ASF_CountObject( asf_object_t *p_obj, const guid_t *p_guid )
896 {
897     int i_count;
898     asf_object_t *p_child;
899
900     if( !p_obj )
901     {
902         return( 0 );
903     }
904
905     i_count = 0;
906     p_child = p_obj->common.p_first;
907     while( p_child )
908     {
909         if( CmpGUID( &p_child->common.i_object_id, p_guid ) )
910         {
911             i_count++;
912         }
913         p_child = p_child->common.p_next;
914     }
915     return( i_count );
916 }
917
918 asf_object_t *ASF_FindObject( asf_object_t *p_obj, const guid_t *p_guid, int i_number )
919 {
920     asf_object_t *p_child;
921
922     p_child = p_obj->common.p_first;
923
924     while( p_child )
925     {
926         if( CmpGUID( &p_child->common.i_object_id, p_guid ) )
927         {
928             if( i_number == 0 )
929             {
930                 /* We found it */
931                 return( p_child );
932             }
933
934             i_number--;
935         }
936         p_child = p_child->common.p_next;
937     }
938     return( NULL );
939 }
940
941