git.sesse.net Git - vlc/blob - modules/demux/mpeg/mpga.c

   1 /*****************************************************************************
   2  * mpga.c : MPEG-I/II Audio input module for vlc
   3  *****************************************************************************
   4  * Copyright (C) 2001 VideoLAN
   5  * $Id: mpga.c,v 1.13 2003/12/27 14:47:10 asmax Exp $
   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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27 #include <stdlib.h>                                      /* malloc(), free() */
  28
  29 #include <vlc/vlc.h>
  30 #include <vlc/input.h>
  31
  32 /*****************************************************************************
  33  * Module descriptor
  34  *****************************************************************************/
  35 static int  Open    ( vlc_object_t * );
  36 static void Close  ( vlc_object_t * );
  37
  38 vlc_module_begin();
  39     set_description( _("MPEG-I/II audio demuxer" ) );
  40     set_capability( "demux", 100 );
  41     set_callbacks( Open, Close );
  42     add_shortcut( "mpga" );
  43     add_shortcut( "mp3" );
  44 vlc_module_end();
  45
  46 /* TODO:
  47  * - free bitrate
  48  */
  49
  50 /*****************************************************************************
  51  * Local prototypes
  52  *****************************************************************************/
  53 static int  Demux       ( input_thread_t * );
  54
  55 struct demux_sys_t
  56 {
  57     mtime_t         i_time;
  58
  59     int             i_bitrate_avg;  /* extracted from Xing header */
  60
  61     es_out_id_t     *p_es;
  62 };
  63
  64 static int HeaderCheck( uint32_t h )
  65 {
  66     if( ((( h >> 21 )&0x07FF) != 0x07FF )   /* header sync */
  67         || (((h >> 17)&0x03) == 0 )         /* valid layer ?*/
  68         || (((h >> 12)&0x0F) == 0x0F )
  69         || (((h >> 12)&0x0F) == 0x00 )      /* valid bitrate ? */
  70         || (((h >> 10) & 0x03) == 0x03 )    /* valide sampling freq ? */
  71         || ((h & 0x03) == 0x02 ))           /* valid emphasis ? */
  72     {
  73         return( VLC_FALSE );
  74     }
  75     return( VLC_TRUE );
  76 }
  77
  78 static int mpga_sample_rate[2][4] =
  79 {
  80     { 44100, 48000, 32000, 0 },
  81     { 22050, 24000, 16000, 0 }
  82 };
  83
  84 static int mpga_bitrate[2][3][16] =
  85 {
  86   {
  87     { 0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 0},
  88     { 0, 32, 48, 56,  64,  80,  96, 112, 128, 160, 192, 224, 256, 320, 384, 0},
  89     { 0, 32, 40, 48,  56,  64,  80,  96, 112, 128, 160, 192, 224, 256, 320, 0}
  90   },
  91   {
  92     { 0, 32, 48, 56,  64,  80,  96, 112, 128, 144, 160, 176, 192, 224, 256, 0},
  93     { 0,  8, 16, 24,  32,  40,  48,  56,  64,  80,  96, 112, 128, 144, 160, 0},
  94     { 0,  8, 16, 24,  32,  40,  48,  56,  64,  80,  96, 112, 128, 144, 160, 0}
  95   }
  96 };
  97
  98
  99 #define MPGA_VERSION( h )   ( 1 - (((h)>>19)&0x01) )
 100 #define MPGA_LAYER( h )     ( 3 - (((h)>>17)&0x03) )
 101 #define MPGA_SAMPLE_RATE(h) \
 102     ( mpga_sample_rate[MPGA_VERSION(h)][((h)>>10)&0x03] / ( ((h>>20)&0x01) ? 1 : 2) )
 103 #define MPGA_CHANNELS(h)    ( (((h)>>6)&0x03) == 3 ? 1 : 2)
 104 #define MPGA_BITRATE(h)     mpga_bitrate[MPGA_VERSION(h)][MPGA_LAYER(h)][((h)>>12)&0x0f]
 105 #define MPGA_PADDING(h)     ( ((h)>>9)&0x01 )
 106 #define MPGA_MODE(h)        (((h)>> 6)&0x03)
 107
 108 static int mpga_frame_size( uint32_t h )
 109 {
 110     switch( MPGA_LAYER(h) )
 111     {
 112         case 0:
 113             return ( ( 12000 * MPGA_BITRATE(h) ) / MPGA_SAMPLE_RATE(h) + MPGA_PADDING(h) ) * 4;
 114         case 1:
 115             return ( 144000 * MPGA_BITRATE(h) ) / MPGA_SAMPLE_RATE(h) + MPGA_PADDING(h);
 116         case 2:
 117             return ( ( MPGA_VERSION(h) ? 72000 : 144000 ) * MPGA_BITRATE(h) ) / MPGA_SAMPLE_RATE(h) + MPGA_PADDING(h);
 118         default:
 119             return 0;
 120     }
 121 }
 122
 123 static int mpga_frame_samples( uint32_t h )
 124 {
 125     switch( MPGA_LAYER(h) )
 126     {
 127         case 0:
 128             return 384;
 129         case 1:
 130             return 1152;
 131         case 2:
 132             return MPGA_VERSION(h) ? 576 : 1152;
 133         default:
 134             return 0;
 135     }
 136 }
 137
 138 #if 0
 139 static int CheckPS( input_thread_t *p_input )
 140 {
 141     uint8_t  *p_peek;
 142     int i_startcode = 0;
 143     int i_size = input_Peek( p_input, &p_peek, 8196 );
 144
 145     while( i_size > 4 )
 146     {
 147         if( ( p_peek[0] == 0 ) && ( p_peek[1] == 0 ) &&
 148             ( p_peek[2] == 1 ) && ( p_peek[3] >= 0xb9 ) &&
 149             ++i_startcode >= 3 )
 150         {
 151             return 1;
 152         }
 153         p_peek++;
 154         i_size--;
 155     }
 156
 157     return 0;
 158 }
 159 #endif
 160
 161 /*****************************************************************************
 162  * Open: initializes demux structures
 163  *****************************************************************************/
 164 static int Open( vlc_object_t * p_this )
 165 {
 166     input_thread_t *p_input = (input_thread_t *)p_this;
 167     demux_sys_t    *p_sys;
 168     vlc_bool_t     b_forced = VLC_FALSE;
 169     vlc_bool_t     b_extention = VLC_FALSE;
 170
 171     uint32_t       header;
 172
 173     uint8_t        *p_peek;
 174
 175     module_t       *p_id3;
 176
 177     es_format_t    fmt;
 178
 179
 180     if( p_input->psz_demux &&
 181         ( !strncmp( p_input->psz_demux, "mpga", 4 ) ||
 182           !strncmp( p_input->psz_demux, "mp3", 3 ) ) )
 183     {
 184         b_forced = VLC_TRUE;
 185     }
 186     if( p_input->psz_name )
 187     {
 188         int  i_len = strlen( p_input->psz_name );
 189
 190         if( i_len > 4 && !strcasecmp( &p_input->psz_name[i_len - 4], ".mp3" ) )
 191         {
 192             b_extention = VLC_TRUE;
 193         }
 194     }
 195
 196     /* skip possible id3 header */
 197     p_id3 = module_Need( p_input, "id3", NULL );
 198     if ( p_id3 )
 199     {
 200         module_Unneed( p_input, p_id3 );
 201     }
 202
 203     if( input_Peek( p_input, &p_peek, 4 ) < 4 )
 204     {
 205         msg_Err( p_input, "cannot peek" );
 206         return VLC_EGENERIC;
 207     }
 208
 209     if( !HeaderCheck( header = GetDWBE( p_peek ) ) )
 210     {
 211         vlc_bool_t b_ok = VLC_FALSE;
 212         int i_peek;
 213
 214         if( !b_forced && !b_extention )
 215         {
 216             msg_Warn( p_input, "mpga module discarded" );
 217             return VLC_EGENERIC;
 218         }
 219
 220         i_peek = input_Peek( p_input, &p_peek, 8096 );
 221
 222         while( i_peek > 4 )
 223         {
 224             if( HeaderCheck( header = GetDWBE( p_peek ) ) )
 225             {
 226                 b_ok = VLC_TRUE;
 227                 break;
 228             }
 229             p_peek += 4;
 230             i_peek -= 4;
 231         }
 232         if( !b_ok && !b_forced )
 233         {
 234             msg_Warn( p_input, "mpga module discarded" );
 235             return VLC_EGENERIC;
 236         }
 237     }
 238
 239     p_input->pf_demux = Demux;
 240     p_input->pf_demux_control = demux_vaControlDefault;
 241
 242     p_input->p_demux_data = p_sys = malloc( sizeof( demux_sys_t ) );
 243     p_sys->i_time = 0;
 244     p_sys->i_bitrate_avg = 0;
 245
 246     es_format_Init( &fmt, AUDIO_ES, VLC_FOURCC( 'm', 'p', 'g', 'a' ) );
 247
 248     if( HeaderCheck( header ) )
 249     {
 250         int     i_xing;
 251         uint8_t *p_xing;
 252         char psz_description[50];
 253
 254         p_sys->i_bitrate_avg = MPGA_BITRATE( header ) * 1000;
 255     fprintf(stderr,"rate1 %d\n", p_sys->i_bitrate_avg);
 256         if( ( i_xing = stream_Peek( p_input->s, &p_xing, 1024 ) ) >= 21 )
 257         {
 258             int i_skip;
 259
 260             if( MPGA_VERSION( header) == 0 )
 261             {
 262                 i_skip = MPGA_MODE( header ) != 3 ? 36 : 21;
 263             }
 264             else
 265             {
 266                 i_skip = MPGA_MODE( header ) != 3 ? 21 : 13;
 267             }
 268             if( i_skip + 8 < i_xing &&
 269                 !strncmp( &p_xing[i_skip], "Xing", 4 ) )
 270             {
 271                 unsigned int i_flags = GetDWBE( &p_xing[i_skip+4] );
 272                 unsigned int i_bytes = 0, i_frames = 0;
 273
 274                 p_xing += i_skip + 8;
 275                 i_xing -= i_skip + 8;
 276
 277                 i_skip = 0;
 278                 if( i_flags&0x01 && i_skip + 4 <= i_xing )   /* XING_FRAMES */
 279                 {
 280                     i_frames = GetDWBE( &p_xing[i_skip] );
 281                     i_skip += 4;
 282                 }
 283                 if( i_flags&0x02 && i_skip + 4 <= i_xing )   /* XING_BYTES */
 284                 {
 285                     i_bytes = GetDWBE( &p_xing[i_skip] );
 286                     i_skip += 4;
 287                 }
 288                 if( i_flags&0x04 )   /* XING_TOC */
 289                 {
 290                     i_skip += 100;
 291                 }
 292 #if 0
 293 // FIXME: doesn't return the right bitrage average, at least with some MP3's
 294                 if( i_flags&0x08 && i_skip + 4 <= i_xing )   /* XING_VBR */
 295                 {
 296                     p_sys->i_bitrate_avg = GetDWBE( &p_xing[i_skip] );
 297     fprintf(stderr,"rate2 %d\n", p_sys->i_bitrate_avg);
 298                     msg_Dbg( p_input, "xing vbr value present (%d)", p_sys->i_bitrate_avg );
 299                 }
 300                 else
 301 #endif
 302                 if( i_frames > 0 && i_bytes > 0 )
 303                 {
 304                     p_sys->i_bitrate_avg = (int64_t)i_bytes *
 305                                            (int64_t)8 *
 306                                            (int64_t)MPGA_SAMPLE_RATE( header ) /
 307                                            (int64_t)i_frames /
 308                                            (int64_t)mpga_frame_samples( header );
 309                     msg_Dbg( p_input, "xing frames&bytes value present (%db/s)", p_sys->i_bitrate_avg );
 310                 }
 311             }
 312         }
 313
 314         msg_Dbg( p_input, "version=%d layer=%d channels=%d samplerate=%d",
 315                  MPGA_VERSION( header ) + 1,
 316                  MPGA_LAYER( header ) + 1,
 317                  MPGA_CHANNELS( header ),
 318                  MPGA_SAMPLE_RATE( header ) );
 319
 320         fmt.audio.i_channels = MPGA_CHANNELS( header );
 321         fmt.audio.i_rate = MPGA_SAMPLE_RATE( header );
 322         fmt.i_bitrate = p_sys->i_bitrate_avg;
 323         sprintf( psz_description, "MPEG Audio Layer %d, version %d",
 324                  MPGA_LAYER ( header ) + 1, MPGA_VERSION ( header ) + 1 );
 325         fmt.psz_description = strdup( psz_description );
 326     }
 327
 328     vlc_mutex_lock( &p_input->stream.stream_lock );
 329     if( input_InitStream( p_input, 0 ) == -1)
 330     {
 331         vlc_mutex_unlock( &p_input->stream.stream_lock );
 332         msg_Err( p_input, "cannot init stream" );
 333         goto error;
 334     }
 335     p_input->stream.i_mux_rate = p_sys->i_bitrate_avg / 8 / 50;
 336     vlc_mutex_unlock( &p_input->stream.stream_lock );
 337
 338     p_sys->p_es = es_out_Add( p_input->p_es_out, &fmt );
 339     return VLC_SUCCESS;
 340
 341 error:
 342     free( p_sys );
 343     return VLC_EGENERIC;
 344 }
 345
 346
 347 /*****************************************************************************
 348  * Demux: reads and demuxes data packets
 349  *****************************************************************************
 350  * Returns -1 in case of error, 0 in case of EOF, 1 otherwise
 351  *****************************************************************************/
 352 static int Demux( input_thread_t * p_input )
 353 {
 354     demux_sys_t  *p_sys = p_input->p_demux_data;
 355     block_t      *p_frame;
 356
 357     uint32_t     header;
 358     uint8_t      *p_peek;
 359
 360     if( stream_Peek( p_input->s, &p_peek, 4 ) < 4 )
 361     {
 362         msg_Warn( p_input, "cannot peek" );
 363         return 0;
 364     }
 365
 366     if( !HeaderCheck( header = GetDWBE( p_peek ) ) )
 367     {
 368         /* we need to resynch */
 369         vlc_bool_t  b_ok = VLC_FALSE;
 370         int         i_skip = 0;
 371         int         i_peek;
 372
 373         i_peek = stream_Peek( p_input->s, &p_peek, 8096 );
 374         if( i_peek < 4 )
 375         {
 376             msg_Warn( p_input, "cannot peek" );
 377             return 0;
 378         }
 379
 380         while( i_peek >= 4 )
 381         {
 382             if( HeaderCheck( header = GetDWBE( p_peek ) ) )
 383             {
 384                 b_ok = VLC_TRUE;
 385                 break;
 386             }
 387
 388             p_peek++;
 389             i_peek--;
 390             i_skip++;
 391         }
 392
 393         msg_Warn( p_input, "garbage=%d bytes", i_skip );
 394         stream_Read( p_input->s, NULL, i_skip );
 395         return 1;
 396     }
 397
 398     input_ClockManageRef( p_input,
 399                           p_input->stream.p_selected_program,
 400                           p_sys->i_time * 9 / 100 );
 401
 402     if( ( p_frame = stream_Block( p_input->s, mpga_frame_size( header ) ) ) == NULL )
 403     {
 404         msg_Warn( p_input, "cannot read data" );
 405         return 0;
 406     }
 407
 408     p_frame->i_dts =
 409     p_frame->i_pts =
 410         input_ClockGetTS( p_input,
 411                           p_input->stream.p_selected_program,
 412                           p_sys->i_time * 9 / 100 );
 413
 414     es_out_Send( p_input->p_es_out, p_sys->p_es, p_frame );
 415
 416     p_sys->i_time += (mtime_t)1000000 *
 417                      (mtime_t)mpga_frame_samples( header ) /
 418                      (mtime_t)MPGA_SAMPLE_RATE( header );
 419     return( 1 );
 420 }
 421
 422 /*****************************************************************************
 423  * Close: frees unused data
 424  *****************************************************************************/
 425 static void Close( vlc_object_t * p_this )
 426 {
 427     input_thread_t *p_input = (input_thread_t*)p_this;
 428     demux_sys_t    *p_sys = p_input->p_demux_data;
 429
 430     free( p_sys );
 431 }
 432