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.9 2002/12/18 14:17:10 sam 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:%ld",
 357             GUID_PRINT( p_index->i_file_id ),
 358             p_index->i_index_entry_time_interval,
 359             p_index->i_max_packet_count,
 360             (long int)p_index->i_index_entry_count );
 361 #endif
 362     return( 1 );
 363 }
 364 void ASF_FreeObject_Index( input_thread_t *p_input,
 365                           asf_object_t *p_obj )
 366 {
 367     asf_object_index_t *p_index = (asf_object_index_t*)p_obj;
 368
 369     FREE( p_index->index_entry );
 370 }
 371
 372 int  ASF_ReadObject_file_properties( input_thread_t *p_input,
 373                                      asf_object_t *p_obj )
 374 {
 375     asf_object_file_properties_t *p_fp = (asf_object_file_properties_t*)p_obj;
 376     int      i_peek;
 377     uint8_t  *p_peek;
 378
 379     if( ( i_peek = input_Peek( p_input, &p_peek,  92) ) < 92 )
 380     {
 381        return( 0 );
 382     }
 383     GetGUID( &p_fp->i_file_id, p_peek + 24 );
 384     p_fp->i_file_size = GetQWLE( p_peek + 40 );
 385     p_fp->i_creation_date = GetQWLE( p_peek + 48 );
 386     p_fp->i_data_packets_count = GetQWLE( p_peek + 56 );
 387     p_fp->i_play_duration = GetQWLE( p_peek + 64 );
 388     p_fp->i_send_duration = GetQWLE( p_peek + 72 );
 389     p_fp->i_preroll = GetQWLE( p_peek + 80 );
 390     p_fp->i_flags = GetDWLE( p_peek + 88 );
 391     p_fp->i_min_data_packet_size = GetDWLE( p_peek + 92 );
 392     p_fp->i_max_data_packet_size = GetDWLE( p_peek + 96 );
 393     p_fp->i_max_bitrate = GetDWLE( p_peek + 100 );
 394
 395 #ifdef ASF_DEBUG
 396     msg_Dbg( p_input,
 397             "Read \"File Properties Object\" file_id:" GUID_FMT
 398             " file_size:"I64Fd" creation_date:"I64Fd" data_packets_count:"
 399             I64Fd" play_duration:"I64Fd" send_duration:"I64Fd" preroll:"
 400             I64Fd" flags:%d min_data_packet_size:%d max_data_packet_size:%d "
 401             "max_bitrate:%d",
 402             GUID_PRINT( p_fp->i_file_id ),
 403             p_fp->i_file_size,
 404             p_fp->i_creation_date,
 405             p_fp->i_data_packets_count,
 406             p_fp->i_play_duration,
 407             p_fp->i_send_duration,
 408             p_fp->i_preroll,
 409             p_fp->i_flags,
 410             p_fp->i_min_data_packet_size,
 411             p_fp->i_max_data_packet_size,
 412             p_fp->i_max_bitrate );
 413 #endif
 414     return( 1 );
 415 }
 416
 417 int  ASF_ReadObject_header_extention( input_thread_t *p_input,
 418                                       asf_object_t *p_obj )
 419 {
 420     asf_object_header_extention_t *p_he = (asf_object_header_extention_t*)p_obj;
 421     int     i_peek;
 422     uint8_t *p_peek;
 423
 424     if( ( i_peek = input_Peek( p_input, &p_peek, p_he->i_object_size ) ) <  46)
 425     {
 426        return( 0 );
 427     }
 428     GetGUID( &p_he->i_reserved1, p_peek + 24 );
 429     p_he->i_reserved2 = GetWLE( p_peek + 40 );
 430     p_he->i_header_extention_size = GetDWLE( p_peek + 42 );
 431     if( p_he->i_header_extention_size )
 432     {
 433         p_he->p_header_extention_data = malloc( p_he->i_header_extention_size );
 434         memcpy( p_he->p_header_extention_data,
 435                 p_peek + 46,
 436                 p_he->i_header_extention_size );
 437     }
 438     else
 439     {
 440         p_he->p_header_extention_data = NULL;
 441     }
 442 #ifdef ASF_DEBUG
 443     msg_Dbg( p_input,
 444             "Read \"Header Extention Object\" reserved1:" GUID_FMT " reserved2:%d header_extention_size:%d",
 445             GUID_PRINT( p_he->i_reserved1 ),
 446             p_he->i_reserved2,
 447             p_he->i_header_extention_size );
 448 #endif
 449     return( 1 );
 450 }
 451 void ASF_FreeObject_header_extention( input_thread_t *p_input,
 452                                       asf_object_t *p_obj )
 453 {
 454     asf_object_header_extention_t *p_he = (asf_object_header_extention_t*)p_obj;
 455
 456     FREE( p_he->p_header_extention_data );
 457 }
 458
 459 int  ASF_ReadObject_stream_properties( input_thread_t *p_input,
 460                                        asf_object_t *p_obj )
 461 {
 462     asf_object_stream_properties_t *p_sp =
 463                     (asf_object_stream_properties_t*)p_obj;
 464     int     i_peek;
 465     uint8_t *p_peek;
 466
 467     if( ( i_peek = input_Peek( p_input, &p_peek,  p_sp->i_object_size ) ) < 74 )
 468     {
 469        return( 0 );
 470     }
 471     GetGUID( &p_sp->i_stream_type, p_peek + 24 );
 472     GetGUID( &p_sp->i_error_correction_type, p_peek + 40 );
 473     p_sp->i_time_offset = GetQWLE( p_peek + 56 );
 474     p_sp->i_type_specific_data_length = GetDWLE( p_peek + 64 );
 475     p_sp->i_error_correction_data_length = GetDWLE( p_peek + 68 );
 476     p_sp->i_flags = GetWLE( p_peek + 72 );
 477         p_sp->i_stream_number = p_sp->i_flags&0x07f;
 478     p_sp->i_reserved = GetDWLE( p_peek + 74 );
 479     if( p_sp->i_type_specific_data_length )
 480     {
 481         p_sp->p_type_specific_data = malloc( p_sp->i_type_specific_data_length );
 482         memcpy( p_sp->p_type_specific_data,
 483                 p_peek + 78,
 484                 p_sp->i_type_specific_data_length );
 485     }
 486     else
 487     {
 488         p_sp->p_type_specific_data = NULL;
 489     }
 490     if( p_sp->i_error_correction_data_length )
 491     {
 492         p_sp->p_error_correction_data = malloc( p_sp->i_error_correction_data_length );
 493         memcpy( p_sp->p_error_correction_data,
 494                 p_peek + 78 + p_sp->i_type_specific_data_length,
 495                 p_sp->i_error_correction_data_length );
 496     }
 497     else
 498     {
 499         p_sp->p_error_correction_data = NULL;
 500     }
 501
 502 #ifdef ASF_DEBUG
 503     msg_Dbg( p_input,
 504             "Read \"Stream Properties Object\" stream_type:" GUID_FMT
 505             " error_correction_type:" GUID_FMT " time_offset:"I64Fd
 506             " type_specific_data_length:%d error_correction_data_length:%d"
 507             " flags:0x%x stream_number:%d",
 508             GUID_PRINT( p_sp->i_stream_type ),
 509             GUID_PRINT( p_sp->i_error_correction_type ),
 510             p_sp->i_time_offset,
 511             p_sp->i_type_specific_data_length,
 512             p_sp->i_error_correction_data_length,
 513             p_sp->i_flags,
 514             p_sp->i_stream_number );
 515
 516 #endif
 517     return( 1 );
 518 }
 519
 520 void ASF_FreeObject_stream_properties( input_thread_t *p_input,
 521                                       asf_object_t *p_obj )
 522 {
 523     asf_object_stream_properties_t *p_sp =
 524                 (asf_object_stream_properties_t*)p_obj;
 525
 526     FREE( p_sp->p_type_specific_data );
 527     FREE( p_sp->p_error_correction_data );
 528 }
 529
 530
 531 int  ASF_ReadObject_codec_list( input_thread_t *p_input,
 532                                 asf_object_t *p_obj )
 533 {
 534     asf_object_codec_list_t *p_cl = (asf_object_codec_list_t*)p_obj;
 535     int     i_peek;
 536     uint8_t *p_peek, *p_data;
 537
 538     unsigned int i_codec;
 539
 540     if( ( i_peek = input_Peek( p_input, &p_peek, p_cl->i_object_size ) ) < 44 )
 541     {
 542        return( 0 );
 543     }
 544
 545     GetGUID( &p_cl->i_reserved, p_peek + 24 );
 546     p_cl->i_codec_entries_count = GetWLE( p_peek + 40 );
 547     if( p_cl->i_codec_entries_count > 0 )
 548     {
 549
 550         p_cl->codec = calloc( p_cl->i_codec_entries_count, sizeof( asf_codec_entry_t ) );
 551         memset( p_cl->codec, 0, p_cl->i_codec_entries_count * sizeof( asf_codec_entry_t ) );
 552
 553         p_data = p_peek + 44;
 554         for( i_codec = 0; i_codec < p_cl->i_codec_entries_count; i_codec++ )
 555         {
 556 #define codec p_cl->codec[i_codec]
 557             int i_len, i;
 558
 559             codec.i_type = GetWLE( p_data ); p_data += 2;
 560             /* codec name */
 561             i_len = GetWLE( p_data ); p_data += 2;
 562             codec.psz_name = calloc( sizeof( char ), i_len + 1);
 563             for( i = 0; i < i_len; i++ )
 564             {
 565                 codec.psz_name[i] = GetWLE( p_data + 2*i );
 566             }
 567             codec.psz_name[i_len] = '\0';
 568             p_data += 2 * i_len;
 569
 570             /* description */
 571             i_len = GetWLE( p_data ); p_data += 2;
 572             codec.psz_description = calloc( sizeof( char ), i_len + 1);
 573             for( i = 0; i < i_len; i++ )
 574             {
 575                 codec.psz_description[i] = GetWLE( p_data + 2*i );
 576             }
 577             codec.psz_description[i_len] = '\0';
 578             p_data += 2 * i_len;
 579
 580             /* opaque information */
 581             codec.i_information_length = GetWLE( p_data ); p_data += 2;
 582             if( codec.i_information_length > 0 )
 583             {
 584                 codec.p_information = malloc( codec.i_information_length );
 585                 memcpy( codec.p_information, p_data, codec.i_information_length );
 586                 p_data += codec.i_information_length;
 587             }
 588             else
 589             {
 590                 codec.p_information = NULL;
 591             }
 592 #undef  codec
 593         }
 594
 595     }
 596     else
 597     {
 598         p_cl->codec = NULL;
 599     }
 600
 601 #ifdef ASF_DEBUG
 602     msg_Dbg( p_input,
 603             "Read \"Codec List Object\" reserved_guid:" GUID_FMT " codec_entries_count:%d",
 604             GUID_PRINT( p_cl->i_reserved ),
 605             p_cl->i_codec_entries_count );
 606     for( i_codec = 0; i_codec < p_cl->i_codec_entries_count; i_codec++ )
 607     {
 608 #define codec p_cl->codec[i_codec]
 609          msg_Dbg( p_input,
 610                  "Read \"Codec List Object\" codec[%d] %s name:\"%s\" description:\"%s\" information_length:%d",
 611                  i_codec,
 612                  ( codec.i_type == ASF_CODEC_TYPE_VIDEO ) ? "video" : ( ( codec.i_type == ASF_CODEC_TYPE_AUDIO ) ? "audio" : "unknown" ),
 613                  codec.psz_name,
 614                  codec.psz_description,
 615                  codec.i_information_length );
 616
 617 #undef  codec
 618     }
 619 #endif
 620     return( 1 );
 621 }
 622 void ASF_FreeObject_codec_list( input_thread_t *p_input,
 623                                 asf_object_t *p_obj )
 624 {
 625     asf_object_codec_list_t *p_cl = (asf_object_codec_list_t*)p_obj;
 626     unsigned int i_codec;
 627
 628     for( i_codec = 0; i_codec < p_cl->i_codec_entries_count; i_codec++ )
 629     {
 630 #define codec p_cl->codec[i_codec]
 631         FREE( codec.psz_name );
 632         FREE( codec.psz_description );
 633         FREE( codec.p_information );
 634
 635 #undef  codec
 636     }
 637     FREE( p_cl->codec );
 638 }
 639
 640 /* Microsoft should qo to hell. This time the length give number of bytes
 641  * and for the some others object, length give char16 count ... */
 642 int  ASF_ReadObject_content_description( input_thread_t *p_input,
 643                                          asf_object_t *p_obj )
 644 {
 645     asf_object_content_description_t *p_cd =
 646                                     (asf_object_content_description_t*)p_obj;
 647     int     i_peek;
 648     uint8_t *p_peek, *p_data;
 649
 650     int i_len;
 651     int i_title;
 652     int i_author;
 653     int i_copyright;
 654     int i_description;
 655     int i_rating;
 656
 657 #define GETSTRINGW( psz_str, i_size ) \
 658    psz_str = calloc( i_size/2 + 1, sizeof( char ) ); \
 659    for( i_len = 0; i_len < i_size/2; i_len++ ) \
 660    { \
 661        psz_str[i_len] = GetWLE( p_data + 2*i_len ); \
 662    } \
 663    psz_str[i_size/2] = '\0'; \
 664    p_data += i_size;
 665
 666     if( ( i_peek = input_Peek( p_input, &p_peek, p_cd->i_object_size ) ) < 34 )
 667     {
 668        return( 0 );
 669     }
 670     p_data = p_peek + 24;
 671
 672     i_title = GetWLE( p_data ); p_data += 2;
 673     i_author= GetWLE( p_data ); p_data += 2;
 674     i_copyright     = GetWLE( p_data ); p_data += 2;
 675     i_description   = GetWLE( p_data ); p_data += 2;
 676     i_rating        = GetWLE( p_data ); p_data += 2;
 677
 678     GETSTRINGW( p_cd->psz_title, i_title );
 679     GETSTRINGW( p_cd->psz_author, i_author );
 680     GETSTRINGW( p_cd->psz_copyright, i_copyright );
 681     GETSTRINGW( p_cd->psz_description, i_description );
 682     GETSTRINGW( p_cd->psz_rating, i_rating );
 683
 684 #undef  GETSTRINGW
 685
 686 #ifdef ASF_DEBUG
 687     msg_Dbg( p_input,
 688              "Read \"Content Description Object\" title:\"%s\" author:\"%s\" copyright:\"%s\" description:\"%s\" rating:\"%s\"",
 689              p_cd->psz_title,
 690              p_cd->psz_author,
 691              p_cd->psz_copyright,
 692              p_cd->psz_description,
 693              p_cd->psz_rating );
 694 #endif
 695     return( 1 );
 696 }
 697
 698 void ASF_FreeObject_content_description( input_thread_t *p_input,
 699                                          asf_object_t *p_obj )
 700 {
 701     asf_object_content_description_t *p_cd = (asf_object_content_description_t*)p_obj;
 702
 703     FREE( p_cd->psz_title );
 704     FREE( p_cd->psz_author );
 705     FREE( p_cd->psz_copyright );
 706     FREE( p_cd->psz_description );
 707     FREE( p_cd->psz_rating );
 708 }
 709
 710 static struct
 711 {
 712     const guid_t  *p_id;
 713     int     i_type;
 714     int     (*ASF_ReadObject_function)( input_thread_t *p_input,
 715                                         asf_object_t *p_obj );
 716     void    (*ASF_FreeObject_function)( input_thread_t *p_input,
 717                                         asf_object_t *p_obj );
 718 } ASF_Object_Function [] =
 719 {
 720     { &asf_object_header_guid,            ASF_OBJECT_TYPE_HEADER,             ASF_ReadObject_Header, ASF_FreeObject_Null },
 721     { &asf_object_data_guid,              ASF_OBJECT_TYPE_DATA,               ASF_ReadObject_Data,   ASF_FreeObject_Null },
 722     { &asf_object_index_guid,             ASF_OBJECT_TYPE_INDEX,              ASF_ReadObject_Index,  ASF_FreeObject_Index },
 723     { &asf_object_file_properties_guid,   ASF_OBJECT_TYPE_FILE_PROPERTIES,    ASF_ReadObject_file_properties,  ASF_FreeObject_Null },
 724     { &asf_object_stream_properties_guid, ASF_OBJECT_TYPE_STREAM_PROPERTIES,  ASF_ReadObject_stream_properties,ASF_FreeObject_stream_properties },
 725     { &asf_object_header_extention_guid,  ASF_OBJECT_TYPE_EXTENTION_HEADER,   ASF_ReadObject_header_extention, ASF_FreeObject_header_extention},
 726     { &asf_object_codec_list_guid,        ASF_OBJECT_TYPE_CODEC_LIST,         ASF_ReadObject_codec_list,       ASF_FreeObject_codec_list },
 727     { &asf_object_marker_guid,            ASF_OBJECT_TYPE_MARKER,             NULL,                  NULL },
 728     { &asf_object_content_description_guid, ASF_OBJECT_TYPE_CONTENT_DESCRIPTION, ASF_ReadObject_content_description, ASF_FreeObject_content_description },
 729
 730     { &asf_object_null_guid,   0,                      NULL,                  NULL }
 731 };
 732
 733 int  ASF_ReadObject( input_thread_t *p_input,
 734                      asf_object_t *p_obj,
 735                      asf_object_t *p_father )
 736 {
 737     int i_result;
 738     int i_index;
 739
 740     if( !p_obj )
 741     {
 742         return( 0 );
 743     }
 744     if( !ASF_ReadObjectCommon( p_input, p_obj ) )
 745     {
 746         msg_Warn( p_input, "Cannot read one asf object" );
 747         return( 0 );
 748     }
 749     p_obj->common.p_father = p_father;
 750     p_obj->common.p_first = NULL;
 751     p_obj->common.p_next = NULL;
 752     p_obj->common.p_last = NULL;
 753
 754
 755     if( p_obj->common.i_object_size < 24 )
 756     {
 757         msg_Warn( p_input, "Found a corrupted asf object (size<24)" );
 758         return( 0 );
 759     }
 760     /* find this object */
 761     for( i_index = 0; ; i_index++ )
 762     {
 763         if( CmpGUID( ASF_Object_Function[i_index].p_id,
 764                      &p_obj->common.i_object_id )||
 765             CmpGUID( ASF_Object_Function[i_index].p_id,
 766                      &asf_object_null_guid ) )
 767         {
 768             break;
 769         }
 770     }
 771     p_obj->common.i_type = ASF_Object_Function[i_index].i_type;
 772
 773     /* Now load this object */
 774     if( ASF_Object_Function[i_index].ASF_ReadObject_function == NULL )
 775     {
 776         msg_Warn( p_input, "Unknown asf object (not loaded)" );
 777         i_result = 1;
 778     }
 779     else
 780     {
 781         /* XXX ASF_ReadObject_function realloc *pp_obj XXX */
 782         i_result =
 783             (ASF_Object_Function[i_index].ASF_ReadObject_function)( p_input,
 784                                                                     p_obj );
 785     }
 786
 787     /* link this object with father */
 788     if( p_father )
 789     {
 790         if( p_father->common.p_first )
 791         {
 792             p_father->common.p_last->common.p_next = p_obj;
 793         }
 794         else
 795         {
 796             p_father->common.p_first = p_obj;
 797         }
 798         p_father->common.p_last = p_obj;
 799     }
 800
 801     return( i_result );
 802 }
 803
 804 void ASF_FreeObject( input_thread_t *p_input,
 805                      asf_object_t *p_obj )
 806 {
 807     int i_index;
 808     asf_object_t *p_child;
 809
 810     if( !p_obj )
 811     {
 812         return;
 813     }
 814
 815     /* Free all child object */
 816     p_child = p_obj->common.p_first;
 817     while( p_child )
 818     {
 819         asf_object_t *p_next;
 820         p_next = p_child->common.p_next;
 821         ASF_FreeObject( p_input, p_child );
 822         p_child = p_next;
 823     }
 824
 825     /* find this object */
 826     for( i_index = 0; ; i_index++ )
 827     {
 828         if( CmpGUID( ASF_Object_Function[i_index].p_id,
 829                      &p_obj->common.i_object_id )||
 830             CmpGUID( ASF_Object_Function[i_index].p_id,
 831                      &asf_object_null_guid ) )
 832         {
 833             break;
 834         }
 835     }
 836
 837     /* Now free this object */
 838     if( ASF_Object_Function[i_index].ASF_FreeObject_function == NULL )
 839     {
 840         msg_Warn( p_input,
 841                   "Unknown asf object " GUID_FMT,
 842                   GUID_PRINT( p_obj->common.i_object_id ) );
 843     }
 844     else
 845     {
 846 #ifdef ASF_DEBUG
 847         msg_Dbg( p_input,
 848                   "Free asf object " GUID_FMT,
 849                   GUID_PRINT( p_obj->common.i_object_id ) );
 850 #endif
 851         (ASF_Object_Function[i_index].ASF_FreeObject_function)( p_input,
 852                                                                 p_obj );
 853     }
 854     free( p_obj );
 855     return;
 856 }
 857
 858 /*****************************************************************************
 859  * ASF_ReadObjetRoot : parse the entire stream/file
 860  *****************************************************************************/
 861 int ASF_ReadObjectRoot( input_thread_t *p_input,
 862                         asf_object_root_t *p_root,
 863                         int b_seekable )
 864 {
 865     asf_object_t *p_obj;
 866
 867     p_root->i_type = ASF_OBJECT_TYPE_ROOT;
 868     memcpy( &p_root->i_object_id, &asf_object_null_guid, sizeof( guid_t ) );
 869     p_root->i_object_pos = 0;
 870     p_root->i_object_size = p_input->stream.p_selected_area->i_size;
 871     p_root->p_first = NULL;
 872     p_root->p_last = NULL;
 873     p_root->p_next = NULL;
 874     p_root->p_hdr = NULL;
 875     p_root->p_data = NULL;
 876     p_root->p_index = NULL;
 877
 878     for( ; ; )
 879     {
 880         p_obj  = malloc( sizeof( asf_object_t ) );
 881
 882         if( !( ASF_ReadObject( p_input, p_obj, (asf_object_t*)p_root ) ) )
 883         {
 884             return( 1 );
 885         }
 886         switch( p_obj->common.i_type )
 887         {
 888             case( ASF_OBJECT_TYPE_HEADER ):
 889                 p_root->p_hdr = (asf_object_header_t*)p_obj;
 890                 break;
 891             case( ASF_OBJECT_TYPE_DATA ):
 892                 p_root->p_data = (asf_object_data_t*)p_obj;
 893                 break;
 894             case( ASF_OBJECT_TYPE_INDEX ):
 895                 p_root->p_index = (asf_object_index_t*)p_obj;
 896                 break;
 897             default:
 898                 msg_Warn( p_input, "Unknow Object found" );
 899                 break;
 900         }
 901         if( !b_seekable && ( p_root->p_hdr && p_root->p_data ) )
 902         {
 903             /* For unseekable stream it's enouth to play */
 904             return( 1 );
 905         }
 906
 907         if( !ASF_NextObject( p_input, p_obj ) ) /* Go to the next object */
 908         {
 909             return( 1 );
 910         }
 911     }
 912 }
 913
 914 void ASF_FreeObjectRoot( input_thread_t *p_input,
 915                          asf_object_root_t *p_root )
 916 {
 917     asf_object_t *p_obj;
 918
 919     p_obj = p_root->p_first;
 920     while( p_obj )
 921     {
 922         asf_object_t *p_next;
 923         p_next = p_obj->common.p_next;
 924         ASF_FreeObject( p_input, p_obj );
 925         p_obj = p_next;
 926     }
 927     p_root->p_first = NULL;
 928     p_root->p_last = NULL;
 929     p_root->p_next = NULL;
 930
 931     p_root->p_hdr = NULL;
 932     p_root->p_data = NULL;
 933     p_root->p_index = NULL;
 934
 935 }
 936
 937 int  __ASF_CountObject( asf_object_t *p_obj, const guid_t *p_guid )
 938 {
 939     int i_count;
 940     asf_object_t *p_child;
 941
 942     if( !p_obj )
 943     {
 944         return( 0 );
 945     }
 946
 947     i_count = 0;
 948     p_child = p_obj->common.p_first;
 949     while( p_child )
 950     {
 951         if( CmpGUID( &p_child->common.i_object_id, p_guid ) )
 952         {
 953             i_count++;
 954         }
 955         p_child = p_child->common.p_next;
 956     }
 957     return( i_count );
 958 }
 959
 960 void *__ASF_FindObject( asf_object_t *p_obj, const guid_t *p_guid, int i_number )
 961 {
 962     asf_object_t *p_child;
 963
 964     p_child = p_obj->common.p_first;
 965
 966     while( p_child )
 967     {
 968         if( CmpGUID( &p_child->common.i_object_id, p_guid ) )
 969         {
 970             if( i_number == 0 )
 971             {
 972                 /* We found it */
 973                 return( p_child );
 974             }
 975
 976             i_number--;
 977         }
 978         p_child = p_child->common.p_next;
 979     }
 980     return( NULL );
 981 }
 982
 983