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 static int CmpGuid( const guid_t *p_guid1, const guid_t *p_guid2 )
  30 {
  31     return( ( p_guid1->v1 == p_guid2->v1 &&
  32               p_guid1->v2 == p_guid2->v2 &&
  33               p_guid1->v3 == p_guid2->v3 &&
  34               p_guid1->v4[0] == p_guid2->v4[0] &&
  35               p_guid1->v4[1] == p_guid2->v4[1] &&
  36               p_guid1->v4[2] == p_guid2->v4[2] &&
  37               p_guid1->v4[3] == p_guid2->v4[3] &&
  38               p_guid1->v4[4] == p_guid2->v4[4] &&
  39               p_guid1->v4[5] == p_guid2->v4[5] &&
  40               p_guid1->v4[6] == p_guid2->v4[6] &&
  41               p_guid1->v4[7] == p_guid2->v4[7] ) ? 1 : 0 );
  42 }
  43
  44 void E_( GenerateGuid )( guid_t *p_guid )
  45 {
  46     int i;
  47
  48     srand( mdate() & 0xffffffff );
  49
  50     /* FIXME should be generated using random data */
  51     p_guid->v1 = 0xbabac001;
  52     p_guid->v2 = ( (uint64_t)rand() << 16 ) / RAND_MAX;
  53     p_guid->v3 = ( (uint64_t)rand() << 16 ) / RAND_MAX;
  54     for( i = 0; i < 8; i++ )
  55     {
  56         p_guid->v4[i] = ( (uint64_t)rand() * 256 ) / RAND_MAX;
  57     }
  58 }
  59
  60 void E_( asf_HeaderParse )( asf_header_t *hdr,
  61                             uint8_t *p_header, int i_header )
  62 {
  63     var_buffer_t buffer;
  64     guid_t      guid;
  65     uint64_t    i_size;
  66     int         i;
  67
  68     hdr->i_file_size = 0;
  69     hdr->i_data_packets_count = 0;
  70     hdr->i_min_data_packet_size = 0;
  71     for( i = 0; i < 128; i++ )
  72     {
  73         hdr->stream[i].i_cat = ASF_STREAM_UNKNOWN;
  74         hdr->stream[i].i_selected = 0;
  75         hdr->stream[i].i_bitrate = -1;
  76     }
  77
  78     var_buffer_initread( &buffer, p_header, i_header );
  79     var_buffer_getguid( &buffer, &guid );
  80
  81     if( !CmpGuid( &guid, &asf_object_header_guid ) )
  82     {
  83         /* ERROR: */
  84     }
  85     var_buffer_getmemory( &buffer, NULL, 30 - 16 );
  86
  87     for( ;; )
  88     {
  89         var_buffer_getguid( &buffer, &guid );
  90         i_size = var_buffer_get64( &buffer );
  91
  92         if( CmpGuid( &guid, &asf_object_file_properties_guid ) )
  93         {
  94             var_buffer_getmemory( &buffer, NULL, 16 );
  95             hdr->i_file_size            = var_buffer_get64( &buffer );
  96             var_buffer_getmemory( &buffer, NULL, 8 );
  97             hdr->i_data_packets_count   = var_buffer_get64( &buffer );
  98             var_buffer_getmemory( &buffer, NULL, 8+8+8+4);
  99             hdr->i_min_data_packet_size = var_buffer_get32( &buffer );
 100
 101             var_buffer_getmemory( &buffer, NULL, i_size - 24 - 16 - 8 - 8 - 8 - 8-8-8-4 - 4);
 102         }
 103         else if( CmpGuid( &guid, &asf_object_header_extension_guid ) )
 104         {
 105             /* Enter it */
 106             var_buffer_getmemory( &buffer, NULL, 46 - 24 );
 107         }
 108         else if( CmpGuid( &guid, &asf_object_extended_stream_properties_guid ) )
 109         {
 110             /* Grrrrrr */
 111             int16_t i_count1, i_count2;
 112             int i_subsize;
 113             int i;
 114
 115             var_buffer_getmemory( &buffer, NULL, 84 - 24 );
 116
 117             i_count1 = var_buffer_get16( &buffer );
 118             i_count2 = var_buffer_get16( &buffer );
 119
 120             i_subsize = 88;
 121             for( i = 0; i < i_count1; i++ )
 122             {
 123                 int i_len;
 124
 125                 var_buffer_get16( &buffer );
 126                 i_len = var_buffer_get16( &buffer );
 127                 var_buffer_getmemory( &buffer, NULL, i_len );
 128
 129                 i_subsize = 4 + i_len;
 130             }
 131
 132             for( i = 0; i < i_count2; i++ )
 133             {
 134                 int i_len;
 135                 var_buffer_getmemory( &buffer, NULL, 16 + 2 );
 136                 i_len = var_buffer_get32( &buffer );
 137                 var_buffer_getmemory( &buffer, NULL, i_len );
 138
 139                 i_subsize += 16 + 6 + i_len;
 140             }
 141
 142             if( i_size - i_subsize <= 24 )
 143             {
 144                 var_buffer_getmemory( &buffer, NULL, i_size - i_subsize );
 145             }
 146             /* It's a hack we just skip the first part of the object until
 147              * the embed stream properties if any (ugly, but whose fault ?) */
 148         }
 149         else if( CmpGuid( &guid, &asf_object_stream_properties_guid ) )
 150         {
 151             int     i_stream_id;
 152             guid_t  stream_type;
 153
 154             var_buffer_getguid( &buffer, &stream_type );
 155             var_buffer_getmemory( &buffer, NULL, 32 );
 156
 157             i_stream_id = var_buffer_get8( &buffer ) & 0x7f;
 158             var_buffer_getmemory( &buffer, NULL, i_size - 24 - 32 - 16 - 1);
 159
 160             if( CmpGuid( &stream_type, &asf_object_stream_type_video ) )
 161             {
 162                 hdr->stream[i_stream_id].i_cat = ASF_STREAM_VIDEO;
 163             }
 164             else if( CmpGuid( &stream_type, &asf_object_stream_type_audio ) )
 165             {
 166                 hdr->stream[i_stream_id].i_cat = ASF_STREAM_AUDIO;
 167             }
 168             else
 169             {
 170                 hdr->stream[i_stream_id].i_cat = ASF_STREAM_UNKNOWN;
 171             }
 172         }
 173         else if ( CmpGuid( &guid, &asf_object_bitrate_properties_guid ) )
 174         {
 175             int     i_count;
 176             uint8_t i_stream_id;
 177
 178             i_count = var_buffer_get16( &buffer );
 179             i_size -= 2;
 180             while( i_count > 0 )
 181             {
 182                 i_stream_id = var_buffer_get16( &buffer )&0x7f;
 183                 hdr->stream[i_stream_id].i_bitrate =  var_buffer_get32( &buffer );
 184                 i_count--;
 185                 i_size -= 6;
 186             }
 187             var_buffer_getmemory( &buffer, NULL, i_size - 24 );
 188         }
 189         else
 190         {
 191             // skip unknown guid
 192             var_buffer_getmemory( &buffer, NULL, i_size - 24 );
 193         }
 194
 195         if( var_buffer_readempty( &buffer ) )
 196             return;
 197     }
 198 }
 199
 200 void E_( asf_StreamSelect ) ( asf_header_t *hdr,
 201                               int i_bitrate_max,
 202                               vlc_bool_t b_all, vlc_bool_t b_audio, vlc_bool_t b_video )
 203 {
 204     /* XXX FIXME use mututal eclusion information */
 205     int i;
 206     int i_audio, i_video;
 207     int i_bitrate_total;
 208 #if 0
 209     char *psz_stream;
 210 #endif
 211
 212     i_audio = 0;
 213     i_video = 0;
 214     i_bitrate_total = 0;
 215     if( b_all )
 216     {
 217         /* select all valid stream */
 218         for( i = 1; i < 128; i++ )
 219         {
 220             if( hdr->stream[i].i_cat != ASF_STREAM_UNKNOWN )
 221             {
 222                 hdr->stream[i].i_selected = 1;
 223             }
 224         }
 225         return;
 226     }
 227     else
 228     {
 229         for( i = 0; i < 128; i++ )
 230         {
 231             /* by default, not selected */
 232             hdr->stream[i].i_selected = 0;
 233         }
 234     }
 235
 236     /* big test:
 237      * select a stream if
 238      *    - no audio nor video stream
 239      *    - or:
 240      *         - if i_bitrate_max not set keep the highest bitrate
 241      *         - if i_bitrate_max is set, keep stream that make we used best
 242      *           quality regarding i_bitrate_max
 243      *
 244      * XXX: little buggy:
 245      *        - it doesn't use mutual exclusion info..
 246      *        - when selecting a better stream we could select
 247      *        something that make i_bitrate_total> i_bitrate_max
 248      */
 249     for( i = 1; i < 128; i++ )
 250     {
 251         if( hdr->stream[i].i_cat == ASF_STREAM_UNKNOWN )
 252         {
 253             continue;
 254         }
 255         else if( hdr->stream[i].i_cat == ASF_STREAM_AUDIO && b_audio &&
 256                  ( i_audio <= 0 ||
 257                     ( ( ( hdr->stream[i].i_bitrate > hdr->stream[i_audio].i_bitrate &&
 258                           ( i_bitrate_total + hdr->stream[i].i_bitrate - hdr->stream[i_audio].i_bitrate
 259                                             < i_bitrate_max || !i_bitrate_max) ) ||
 260                         ( hdr->stream[i].i_bitrate < hdr->stream[i_audio].i_bitrate &&
 261                               i_bitrate_max != 0 && i_bitrate_total > i_bitrate_max )
 262                       ) )  ) )
 263         {
 264             /* unselect old stream */
 265             if( i_audio > 0 )
 266             {
 267                 hdr->stream[i_audio].i_selected = 0;
 268                 if( hdr->stream[i_audio].i_bitrate> 0 )
 269                 {
 270                     i_bitrate_total -= hdr->stream[i_audio].i_bitrate;
 271                 }
 272             }
 273
 274             hdr->stream[i].i_selected = 1;
 275             if( hdr->stream[i].i_bitrate> 0 )
 276             {
 277                 i_bitrate_total += hdr->stream[i].i_bitrate;
 278             }
 279             i_audio = i;
 280         }
 281         else if( hdr->stream[i].i_cat == ASF_STREAM_VIDEO && b_video &&
 282                  ( i_video <= 0 ||
 283                     (
 284                         ( ( hdr->stream[i].i_bitrate > hdr->stream[i_video].i_bitrate &&
 285                             ( i_bitrate_total + hdr->stream[i].i_bitrate - hdr->stream[i_video].i_bitrate
 286                                             < i_bitrate_max || !i_bitrate_max) ) ||
 287                           ( hdr->stream[i].i_bitrate < hdr->stream[i_video].i_bitrate &&
 288                             i_bitrate_max != 0 && i_bitrate_total > i_bitrate_max )
 289                         ) ) )  )
 290         {
 291             /* unselect old stream */
 292             if( i_video > 0 )
 293             {
 294                 hdr->stream[i_video].i_selected = 0;
 295                 if( hdr->stream[i_video].i_bitrate> 0 )
 296                 {
 297                     i_bitrate_total -= hdr->stream[i_video].i_bitrate;
 298                 }
 299             }
 300
 301             hdr->stream[i].i_selected = 1;
 302             if( hdr->stream[i].i_bitrate> 0 )
 303             {
 304                 i_bitrate_total += hdr->stream[i].i_bitrate;
 305             }
 306             i_video = i;
 307         }
 308
 309     }
 310 }