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.10 2003/11/21 16:07:20 fenrir 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
 253         p_sys->i_bitrate_avg = MPGA_BITRATE( header ) * 1000;
 254         if( ( i_xing = stream_Peek( p_input->s, &p_xing, 1024 ) ) >= 21 )
 255         {
 256             int i_skip;
 257
 258             if( MPGA_VERSION( header) == 0 )
 259             {
 260                 i_skip = MPGA_MODE( header ) != 3 ? 36 : 21;
 261             }
 262             else
 263             {
 264                 i_skip = MPGA_MODE( header ) != 3 ? 21 : 13;
 265             }
 266             if( i_skip + 8 < i_xing &&
 267                 !strncmp( &p_xing[i_skip], "Xing", 4 ) )
 268             {
 269                 unsigned int i_flags = GetDWBE( &p_xing[i_skip+4] );
 270                 unsigned int i_bytes = 0, i_frames = 0;
 271
 272                 p_xing += i_skip + 8;
 273                 i_xing -= i_skip + 8;
 274
 275                 i_skip = 0;
 276                 if( i_flags&0x01 && i_skip + 4 <= i_xing )   /* XING_FRAMES */
 277                 {
 278                     i_frames = GetDWBE( &p_xing[i_skip] );
 279                     i_skip += 4;
 280                 }
 281                 if( i_flags&0x02 && i_skip + 4 <= i_xing )   /* XING_BYTES */
 282                 {
 283                     i_bytes = GetDWBE( &p_xing[i_skip] );
 284                     i_skip += 4;
 285                 }
 286                 if( i_flags&0x04 )   /* XING_TOC */
 287                 {
 288                     i_skip += 100;
 289                 }
 290                 if( i_flags&0x08 && i_skip + 4 <= i_xing )   /* XING_VBR */
 291                 {
 292                     p_sys->i_bitrate_avg = GetDWBE( &p_xing[i_skip] );
 293                     msg_Dbg( p_input, "xing vbr value present (%d)", p_sys->i_bitrate_avg );
 294                 }
 295                 else if( i_frames > 0 && i_bytes > 0 )
 296                 {
 297                     p_sys->i_bitrate_avg = (int64_t)i_bytes *
 298                                            (int64_t)8 *
 299                                            (int64_t)MPGA_SAMPLE_RATE( header ) /
 300                                            (int64_t)i_frames /
 301                                            (int64_t)mpga_frame_samples( header );
 302                     msg_Dbg( p_input, "xing frames&bytes value present (%db/s)", p_sys->i_bitrate_avg );
 303                 }
 304             }
 305         }
 306
 307         msg_Dbg( p_input, "version=%d layer=%d channels=%d samplerate=%d",
 308                  MPGA_VERSION( header) + 1,
 309                  MPGA_LAYER( header ) + 1,
 310                  MPGA_CHANNELS( header ),
 311                  MPGA_SAMPLE_RATE( header ) );
 312
 313         fmt.audio.i_channels = MPGA_CHANNELS( header );
 314         fmt.audio.i_rate = MPGA_SAMPLE_RATE( header );
 315         fmt.i_bitrate = p_sys->i_bitrate_avg;
 316     }
 317
 318     vlc_mutex_lock( &p_input->stream.stream_lock );
 319     if( input_InitStream( p_input, 0 ) == -1)
 320     {
 321         vlc_mutex_unlock( &p_input->stream.stream_lock );
 322         msg_Err( p_input, "cannot init stream" );
 323         goto error;
 324     }
 325     p_input->stream.i_mux_rate = p_sys->i_bitrate_avg / 8 / 50;
 326     vlc_mutex_unlock( &p_input->stream.stream_lock );
 327
 328     p_sys->p_es = es_out_Add( p_input->p_es_out, &fmt );
 329     return VLC_SUCCESS;
 330
 331 error:
 332     free( p_sys );
 333     return VLC_EGENERIC;
 334 }
 335
 336
 337 /*****************************************************************************
 338  * Demux: reads and demuxes data packets
 339  *****************************************************************************
 340  * Returns -1 in case of error, 0 in case of EOF, 1 otherwise
 341  *****************************************************************************/
 342 static int Demux( input_thread_t * p_input )
 343 {
 344     demux_sys_t  *p_sys = p_input->p_demux_data;
 345     block_t      *p_frame;
 346
 347     uint32_t     header;
 348     uint8_t      *p_peek;
 349
 350     if( stream_Peek( p_input->s, &p_peek, 4 ) < 4 )
 351     {
 352         msg_Warn( p_input, "cannot peek" );
 353         return 0;
 354     }
 355
 356     if( !HeaderCheck( header = GetDWBE( p_peek ) ) )
 357     {
 358         /* we need to resynch */
 359         vlc_bool_t  b_ok = VLC_FALSE;
 360         int         i_skip = 0;
 361         int         i_peek;
 362
 363         i_peek = stream_Peek( p_input->s, &p_peek, 8096 );
 364         if( i_peek < 4 )
 365         {
 366             msg_Warn( p_input, "cannot peek" );
 367             return 0;
 368         }
 369
 370         while( i_peek >= 4 )
 371         {
 372             if( HeaderCheck( header = GetDWBE( p_peek ) ) )
 373             {
 374                 b_ok = VLC_TRUE;
 375                 break;
 376             }
 377
 378             p_peek++;
 379             i_peek--;
 380             i_skip++;
 381         }
 382
 383         msg_Warn( p_input, "garbage=%d bytes", i_skip );
 384         stream_Read( p_input->s, NULL, i_skip );
 385         return 1;
 386     }
 387
 388     input_ClockManageRef( p_input,
 389                           p_input->stream.p_selected_program,
 390                           p_sys->i_time * 9 / 100 );
 391
 392     if( ( p_frame = stream_Block( p_input->s, mpga_frame_size( header ) ) ) == NULL )
 393     {
 394         msg_Warn( p_input, "cannot read data" );
 395         return 0;
 396     }
 397
 398     p_frame->i_dts =
 399     p_frame->i_pts =
 400         input_ClockGetTS( p_input,
 401                           p_input->stream.p_selected_program,
 402                           p_sys->i_time * 9 / 100 );
 403
 404     es_out_Send( p_input->p_es_out, p_sys->p_es, p_frame );
 405
 406     p_sys->i_time += (mtime_t)1000000 *
 407                      (mtime_t)mpga_frame_samples( header ) /
 408                      (mtime_t)MPGA_SAMPLE_RATE( header );
 409     return( 1 );
 410 }
 411
 412 /*****************************************************************************
 413  * Close: frees unused data
 414  *****************************************************************************/
 415 static void Close( vlc_object_t * p_this )
 416 {
 417     input_thread_t *p_input = (input_thread_t*)p_this;
 418     demux_sys_t    *p_sys = p_input->p_demux_data;
 419
 420     free( p_sys );
 421 }
 422