git.sesse.net Git - vlc/blob - modules/access/mms/asf.c

   1 /*****************************************************************************
   2  * asf.c: MMS access plug-in
   3  *****************************************************************************
   4  * Copyright (C) 2001-2004 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 #include <vlc/vlc.h>
  25
  26 #include "asf.h"
  27 #include "buffer.h"
  28
  29
  30 static int CmpGuid( const guid_t *p_guid1, const guid_t *p_guid2 )
  31 {
  32     return( ( p_guid1->v1 == p_guid2->v1 &&
  33               p_guid1->v2 == p_guid2->v2 &&
  34               p_guid1->v3 == p_guid2->v3 &&
  35               p_guid1->v4[0] == p_guid2->v4[0] &&
  36               p_guid1->v4[1] == p_guid2->v4[1] &&
  37               p_guid1->v4[2] == p_guid2->v4[2] &&
  38               p_guid1->v4[3] == p_guid2->v4[3] &&
  39               p_guid1->v4[4] == p_guid2->v4[4] &&
  40               p_guid1->v4[5] == p_guid2->v4[5] &&
  41               p_guid1->v4[6] == p_guid2->v4[6] &&
  42               p_guid1->v4[7] == p_guid2->v4[7] ) ? 1 : 0 );
  43 }
  44
  45 void E_( GenerateGuid )( guid_t *p_guid )
  46 {
  47     int i;
  48
  49     srand( mdate() & 0xffffffff );
  50
  51     /* FIXME should be generated using random data */
  52     p_guid->v1 = 0xbabac001;
  53     p_guid->v2 = ( (uint64_t)rand() << 16 ) / RAND_MAX;
  54     p_guid->v3 = ( (uint64_t)rand() << 16 ) / RAND_MAX;
  55     for( i = 0; i < 8; i++ )
  56     {
  57         p_guid->v4[i] = ( (uint64_t)rand() * 256 ) / RAND_MAX;
  58     }
  59 }
  60
  61 void E_( asf_HeaderParse )( asf_header_t *hdr,
  62                             uint8_t *p_header, int i_header )
  63 {
  64     var_buffer_t buffer;
  65     guid_t      guid;
  66     uint64_t    i_size;
  67     int         i;
  68
  69     hdr->i_file_size = 0;
  70     hdr->i_data_packets_count = 0;
  71     hdr->i_min_data_packet_size = 0;
  72     for( i = 0; i < 128; i++ )
  73     {
  74         hdr->stream[i].i_cat = ASF_STREAM_UNKNOWN;
  75         hdr->stream[i].i_selected = 0;
  76         hdr->stream[i].i_bitrate = -1;
  77     }
  78
  79     //fprintf( stderr, " ---------------------header:%d\n", i_header );
  80     var_buffer_initread( &buffer, p_header, i_header );
  81
  82     var_buffer_getguid( &buffer, &guid );
  83
  84     if( !CmpGuid( &guid, &asf_object_header_guid ) )
  85     {
  86 //        XXX Error
  87 //        fprintf( stderr, " ---------------------ERROR------\n" );
  88     }
  89     var_buffer_getmemory( &buffer, NULL, 30 - 16 );
  90
  91     for( ;; )
  92     {
  93         //fprintf( stderr, " ---------------------data:%d\n", buffer.i_data );
  94
  95         var_buffer_getguid( &buffer, &guid );
  96         i_size = var_buffer_get64( &buffer );
  97
  98         //fprintf( stderr, "  guid=0x%8.8x-0x%4.4x-0x%4.4x-%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x size=%lld\n",
  99         //                  guid.v1,guid.v2, guid.v3,
 100         //                  guid.v4[0],guid.v4[1],guid.v4[2],guid.v4[3],
 101         //                  guid.v4[4],guid.v4[5],guid.v4[6],guid.v4[7],
 102         //                  i_size );
 103
 104         if( CmpGuid( &guid, &asf_object_file_properties_guid ) )
 105         {
 106             var_buffer_getmemory( &buffer, NULL, 16 );
 107             hdr->i_file_size            = var_buffer_get64( &buffer );
 108             var_buffer_getmemory( &buffer, NULL, 8 );
 109             hdr->i_data_packets_count   = var_buffer_get64( &buffer );
 110             var_buffer_getmemory( &buffer, NULL, 8+8+8+4);
 111             hdr->i_min_data_packet_size = var_buffer_get32( &buffer );
 112
 113             var_buffer_getmemory( &buffer, NULL, i_size - 24 - 16 - 8 - 8 - 8 - 8-8-8-4 - 4);
 114         }
 115         else if( CmpGuid( &guid, &asf_object_header_extension_guid ) )
 116         {
 117             /* Enter it */
 118             var_buffer_getmemory( &buffer, NULL, 46 - 24 );
 119         }
 120         else if( CmpGuid( &guid, &asf_object_extended_stream_properties_guid ) )
 121         {
 122             /* Grrrrrr */
 123             int16_t i_count1, i_count2;
 124             int i_subsize;
 125             int i;
 126
 127             //fprintf( stderr, "extended stream properties\n" );
 128
 129             var_buffer_getmemory( &buffer, NULL, 84 - 24 );
 130
 131             i_count1 = var_buffer_get16( &buffer );
 132             i_count2 = var_buffer_get16( &buffer );
 133
 134             i_subsize = 88;
 135             for( i = 0; i < i_count1; i++ )
 136             {
 137                 int i_len;
 138
 139                 var_buffer_get16( &buffer );
 140                 i_len = var_buffer_get16( &buffer );
 141                 var_buffer_getmemory( &buffer, NULL, i_len );
 142
 143                 i_subsize = 4 + i_len;
 144             }
 145
 146             for( i = 0; i < i_count2; i++ )
 147             {
 148                 int i_len;
 149                 var_buffer_getmemory( &buffer, NULL, 16 + 2 );
 150                 i_len = var_buffer_get32( &buffer );
 151                 var_buffer_getmemory( &buffer, NULL, i_len );
 152
 153                 i_subsize += 16 + 6 + i_len;
 154             }
 155
 156             //fprintf( stderr, "extended stream properties left=%d\n",
 157             //         i_size - i_subsize );
 158
 159             if( i_size - i_subsize <= 24 )
 160             {
 161                 var_buffer_getmemory( &buffer, NULL, i_size - i_subsize );
 162             }
 163             /* It's a hack we just skip the first part of the object until
 164              * the embed stream properties if any (ugly, but whose fault ?) */
 165         }
 166         else if( CmpGuid( &guid, &asf_object_stream_properties_guid ) )
 167         {
 168             int     i_stream_id;
 169             guid_t  stream_type;
 170
 171             //fprintf( stderr, "stream properties\n" );
 172
 173             var_buffer_getguid( &buffer, &stream_type );
 174             var_buffer_getmemory( &buffer, NULL, 32 );
 175             i_stream_id = var_buffer_get8( &buffer ) & 0x7f;
 176
 177             //fprintf( stderr, " 1---------------------skip:%lld\n", i_size - 24 - 32 - 16 - 1 );
 178             var_buffer_getmemory( &buffer, NULL, i_size - 24 - 32 - 16 - 1);
 179
 180             if( CmpGuid( &stream_type, &asf_object_stream_type_video ) )
 181             {
 182                 //fprintf( stderr, "\nvideo stream[%d] found\n", i_stream_id );
 183                 hdr->stream[i_stream_id].i_cat = ASF_STREAM_VIDEO;
 184             }
 185             else if( CmpGuid( &stream_type, &asf_object_stream_type_audio ) )
 186             {
 187                 //fprintf( stderr, "\naudio stream[%d] found\n", i_stream_id );
 188                 hdr->stream[i_stream_id].i_cat = ASF_STREAM_AUDIO;
 189             }
 190             else
 191             {
 192                 hdr->stream[i_stream_id].i_cat = ASF_STREAM_UNKNOWN;
 193             }
 194         }
 195         else if ( CmpGuid( &guid, &asf_object_bitrate_properties_guid ) )
 196         {
 197             int     i_count;
 198             uint8_t i_stream_id;
 199
 200             //fprintf( stderr, "bitrate properties\n" );
 201
 202             i_count = var_buffer_get16( &buffer );
 203             i_size -= 2;
 204             while( i_count > 0 )
 205             {
 206                 i_stream_id = var_buffer_get16( &buffer )&0x7f;
 207                 hdr->stream[i_stream_id].i_bitrate =  var_buffer_get32( &buffer );
 208                 i_count--;
 209                 i_size -= 6;
 210             }
 211             //fprintf( stderr, " 2---------------------skip:%lld\n", i_size - 24);
 212             var_buffer_getmemory( &buffer, NULL, i_size - 24 );
 213         }
 214         else
 215         {
 216             //fprintf( stderr, "unknown\n" );
 217             //fprintf( stderr, " 3---------------------skip:%lld\n", i_size - 24);
 218             // skip unknown guid
 219             var_buffer_getmemory( &buffer, NULL, i_size - 24 );
 220         }
 221
 222         if( var_buffer_readempty( &buffer ) )
 223             return;
 224     }
 225 }
 226
 227 void E_( asf_StreamSelect ) ( asf_header_t *hdr,
 228                               int i_bitrate_max,
 229                               vlc_bool_t b_all, vlc_bool_t b_audio, vlc_bool_t b_video )
 230 {
 231     /* XXX FIXME use mututal eclusion information */
 232     int i;
 233     int i_audio, i_video;
 234     int i_bitrate_total;
 235 #if 0
 236     char *psz_stream;
 237 #endif
 238
 239     i_audio = 0;
 240     i_video = 0;
 241     i_bitrate_total = 0;
 242     if( b_all )
 243     {
 244         /* select all valid stream */
 245         for( i = 1; i < 128; i++ )
 246         {
 247             if( hdr->stream[i].i_cat != ASF_STREAM_UNKNOWN )
 248             {
 249                 hdr->stream[i].i_selected = 1;
 250             }
 251         }
 252         return;
 253     }
 254     else
 255     {
 256         for( i = 0; i < 128; i++ )
 257         {
 258             hdr->stream[i].i_selected = 0; /* by default, not selected */
 259         }
 260     }
 261
 262     /* big test:
 263      * select a stream if
 264      *    - no audio nor video stream
 265      *    - or:
 266      *         - if i_bitrate_max not set keep the highest bitrate
 267      *         - if i_bitrate_max is set, keep stream that make we used best
 268      *           quality regarding i_bitrate_max
 269      *
 270      * XXX: little buggy:
 271      *        - it doesn't use mutual exclusion info..
 272      *        - when selecting a better stream we could select
 273      *        something that make i_bitrate_total> i_bitrate_max
 274      */
 275     for( i = 1; i < 128; i++ )
 276     {
 277         if( hdr->stream[i].i_cat == ASF_STREAM_UNKNOWN )
 278         {
 279             continue;
 280         }
 281         else if( hdr->stream[i].i_cat == ASF_STREAM_AUDIO && b_audio &&
 282                  ( i_audio <= 0 ||
 283                     ( ( ( hdr->stream[i].i_bitrate > hdr->stream[i_audio].i_bitrate &&
 284                           ( i_bitrate_total + hdr->stream[i].i_bitrate - hdr->stream[i_audio].i_bitrate
 285                                             < i_bitrate_max || !i_bitrate_max) ) ||
 286                         ( hdr->stream[i].i_bitrate < hdr->stream[i_audio].i_bitrate &&
 287                               i_bitrate_max != 0 && i_bitrate_total > i_bitrate_max )
 288                       ) )  ) )
 289         {
 290             /* unselect old stream */
 291             if( i_audio > 0 )
 292             {
 293                 hdr->stream[i_audio].i_selected = 0;
 294                 if( hdr->stream[i_audio].i_bitrate> 0 )
 295                 {
 296                     i_bitrate_total -= hdr->stream[i_audio].i_bitrate;
 297                 }
 298             }
 299
 300             hdr->stream[i].i_selected = 1;
 301             if( hdr->stream[i].i_bitrate> 0 )
 302             {
 303                 i_bitrate_total += hdr->stream[i].i_bitrate;
 304             }
 305             i_audio = i;
 306         }
 307         else if( hdr->stream[i].i_cat == ASF_STREAM_VIDEO && b_video &&
 308                  ( i_video <= 0 ||
 309                     (
 310                         ( ( hdr->stream[i].i_bitrate > hdr->stream[i_video].i_bitrate &&
 311                             ( i_bitrate_total + hdr->stream[i].i_bitrate - hdr->stream[i_video].i_bitrate
 312                                             < i_bitrate_max || !i_bitrate_max) ) ||
 313                           ( hdr->stream[i].i_bitrate < hdr->stream[i_video].i_bitrate &&
 314                             i_bitrate_max != 0 && i_bitrate_total > i_bitrate_max )
 315                         ) ) )  )
 316         {
 317             /* unselect old stream */
 318
 319             if( i_video > 0 )
 320             {
 321                 hdr->stream[i_video].i_selected = 0;
 322                 if( hdr->stream[i_video].i_bitrate> 0 )
 323                 {
 324                     i_bitrate_total -= hdr->stream[i_video].i_bitrate;
 325                 }
 326             }
 327
 328             hdr->stream[i].i_selected = 1;
 329             if( hdr->stream[i].i_bitrate> 0 )
 330             {
 331                 i_bitrate_total += hdr->stream[i].i_bitrate;
 332             }
 333             i_video = i;
 334         }
 335
 336     }
 337 }
 338