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

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