git.sesse.net Git - vlc/blob - modules/packetizer/a52.c

   1 /*****************************************************************************
   2  * a52.c
   3  *****************************************************************************
   4  * Copyright (C) 2001, 2002 VideoLAN
   5  * $Id: a52.c,v 1.5 2003/05/03 02:09:41 fenrir Exp $
   6  *
   7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
   8  *          Eric Petit <titer@videolan.org>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  23  *****************************************************************************/
  24
  25 /*****************************************************************************
  26  * Preamble
  27  *****************************************************************************/
  28 #include <vlc/vlc.h>
  29 #include <vlc/aout.h>
  30 #include <vlc/decoder.h>
  31 #include <vlc/input.h>
  32 #include <vlc/sout.h>
  33
  34 #include <stdlib.h>                                      /* malloc(), free() */
  35 #include <string.h>                                              /* strdup() */
  36 #include "codecs.h"                         /* WAVEFORMATEX BITMAPINFOHEADER */
  37 /*****************************************************************************
  38  * Local prototypes
  39  *****************************************************************************/
  40 typedef struct packetizer_s
  41 {
  42     /* Input properties */
  43     decoder_fifo_t          *p_fifo;
  44     bit_stream_t            bit_stream;
  45
  46     /* Output properties */
  47     sout_packetizer_input_t *p_sout_input;
  48     sout_format_t           output_format;
  49
  50     uint64_t                i_samplescount;
  51
  52     mtime_t                 i_last_pts;
  53 } packetizer_t;
  54
  55 static int  Open    ( vlc_object_t * );
  56 static int  Run     ( decoder_fifo_t * );
  57
  58 static int  InitThread     ( packetizer_t * );
  59 static void PacketizeThread   ( packetizer_t * );
  60 static void EndThread      ( packetizer_t * );
  61
  62 static int SyncInfo( const byte_t *, int *, int *, int * );
  63
  64 #define FREE( p ) if( p ) free( p ); p = NULL
  65
  66 /*****************************************************************************
  67  * Module descriptor
  68  *****************************************************************************/
  69
  70 vlc_module_begin();
  71     set_description( _("A/52 audio packetizer") );
  72     set_capability( "packetizer", 10 );
  73     set_callbacks( Open, NULL );
  74 vlc_module_end();
  75
  76
  77
  78 /*****************************************************************************
  79  * OpenDecoder: probe the packetizer and return score
  80  *****************************************************************************
  81  * Tries to launch a decoder and return score so that the interface is able
  82  * to choose.
  83  *****************************************************************************/
  84 static int Open( vlc_object_t *p_this )
  85 {
  86     decoder_fifo_t *p_fifo = (decoder_fifo_t*) p_this;
  87
  88     if( p_fifo->i_fourcc != VLC_FOURCC( 'a', '5', '2', ' ') &&
  89         p_fifo->i_fourcc != VLC_FOURCC( 'a', '5', '2', 'b') )
  90     {
  91         return VLC_EGENERIC;
  92     }
  93
  94     p_fifo->pf_run = Run;
  95     return VLC_SUCCESS;
  96 }
  97
  98 /*****************************************************************************
  99  * RunDecoder: this function is called just after the thread is created
 100  *****************************************************************************/
 101 static int Run( decoder_fifo_t *p_fifo )
 102 {
 103     packetizer_t *p_pack;
 104     int b_error;
 105
 106     msg_Info( p_fifo, "Running A/52 packetizer" );
 107     if( !( p_pack = malloc( sizeof( packetizer_t ) ) ) )
 108     {
 109         msg_Err( p_fifo, "out of memory" );
 110         DecoderError( p_fifo );
 111         return( -1 );
 112     }
 113     memset( p_pack, 0, sizeof( packetizer_t ) );
 114
 115     p_pack->p_fifo = p_fifo;
 116
 117     if( InitThread( p_pack ) != 0 )
 118     {
 119         DecoderError( p_fifo );
 120         return( -1 );
 121     }
 122
 123     while( ( !p_pack->p_fifo->b_die )&&( !p_pack->p_fifo->b_error ) )
 124     {
 125         PacketizeThread( p_pack );
 126     }
 127
 128
 129     if( ( b_error = p_pack->p_fifo->b_error ) )
 130     {
 131         DecoderError( p_pack->p_fifo );
 132     }
 133
 134     EndThread( p_pack );
 135
 136     if( b_error )
 137     {
 138         return( -1 );
 139     }
 140
 141     return( 0 );
 142 }
 143
 144
 145
 146 /*****************************************************************************
 147  * InitThread: initialize data before entering main loop
 148  *****************************************************************************/
 149
 150 static int InitThread( packetizer_t *p_pack )
 151 {
 152
 153     p_pack->output_format.i_cat = AUDIO_ES;
 154     p_pack->output_format.i_fourcc = VLC_FOURCC( 'a', '5', '2', ' ' );
 155
 156     p_pack->p_sout_input   = NULL;
 157
 158     p_pack->i_samplescount = 0;
 159     p_pack->i_last_pts     = 0;
 160
 161     if( InitBitstream( &p_pack->bit_stream, p_pack->p_fifo,
 162                        NULL, NULL ) != VLC_SUCCESS )
 163     {
 164         msg_Err( p_pack->p_fifo, "cannot initialize bitstream" );
 165         return -1;
 166     }
 167
 168     return( 0 );
 169 }
 170
 171 /*****************************************************************************
 172  * PacketizeThread: packetize an unit (here copy a complete pes)
 173  *****************************************************************************/
 174 static void PacketizeThread( packetizer_t *p_pack )
 175 {
 176     sout_buffer_t   *p_sout_buffer;
 177
 178
 179     uint8_t p_header[7];
 180     int     i_channels, i_samplerate, i_bitrate;
 181     int     i_framelength;
 182     mtime_t i_pts;
 183
 184     /* search a valid start code */
 185     for( ;; )
 186     {
 187         int i_skip = 0;
 188
 189         RealignBits( &p_pack->bit_stream );
 190         while( ShowBits( &p_pack->bit_stream, 16 ) != 0x0b77 &&
 191                !p_pack->p_fifo->b_die && !p_pack->p_fifo->b_error )
 192         {
 193             RemoveBits( &p_pack->bit_stream, 8 );
 194             i_skip++;
 195         }
 196         if( i_skip )
 197         {
 198             msg_Warn( p_pack->p_fifo, "trashing %d bytes", i_skip );
 199         }
 200         if( p_pack->p_fifo->b_die || p_pack->p_fifo->b_error )
 201         {
 202             return;
 203         }
 204
 205         /* Set the Presentation Time Stamp */
 206         NextPTS( &p_pack->bit_stream, &i_pts, NULL );
 207
 208         GetChunk( &p_pack->bit_stream, p_header, 7 );
 209         if( p_pack->p_fifo->b_die ) return;
 210
 211         /* Check if frame is valid and get frame info */
 212         i_framelength = SyncInfo( p_header, &i_channels, &i_samplerate,
 213                                   &i_bitrate );
 214
 215         if( !i_framelength )
 216         {
 217             msg_Warn( p_pack->p_fifo, "invalid header found" );
 218             continue;
 219         }
 220         else
 221         {
 222 //            msg_Dbg( p_pack->p_fifo, "frame length %d b", i_framelength );
 223             break;
 224         }
 225     }
 226
 227     if( !p_pack->p_sout_input )
 228     {
 229         p_pack->output_format.i_sample_rate = i_samplerate;
 230         p_pack->output_format.i_channels    = i_channels;
 231         p_pack->output_format.i_block_align = 0;
 232         p_pack->output_format.i_bitrate     = 0;
 233         p_pack->output_format.i_extra_data  = 0;
 234         p_pack->output_format.p_extra_data  = NULL;
 235
 236         p_pack->p_sout_input =
 237             sout_InputNew( p_pack->p_fifo,
 238                            &p_pack->output_format );
 239
 240         if( !p_pack->p_sout_input )
 241         {
 242             msg_Err( p_pack->p_fifo,
 243                      "cannot add a new stream" );
 244             p_pack->p_fifo->b_error = 1;
 245             return;
 246         }
 247         msg_Info( p_pack->p_fifo,
 248                  "A/52 channels:%d samplerate:%d bitrate:%d",
 249                  i_channels, i_samplerate, i_bitrate );
 250     }
 251
 252     if( i_pts <= 0 && p_pack->i_last_pts <= 0 )
 253     {
 254         msg_Dbg( p_pack->p_fifo, "need a starting pts" );
 255         return;
 256     }
 257
 258     /* fix pts */
 259     if( i_pts <= 0 )
 260     {
 261         i_pts = p_pack->i_last_pts +
 262                     (uint64_t)1000000 *
 263                     (uint64_t)A52_FRAME_NB /
 264                     (uint64_t)i_samplerate;
 265     }
 266     p_pack->i_last_pts = i_pts;
 267
 268     p_sout_buffer =
 269         sout_BufferNew( p_pack->p_sout_input->p_sout, i_framelength );
 270     if( !p_sout_buffer )
 271     {
 272         p_pack->p_fifo->b_error = 1;
 273         return;
 274     }
 275     memcpy( p_sout_buffer->p_buffer, p_header, 7 );
 276     p_sout_buffer->i_bitrate = i_bitrate;
 277
 278     p_sout_buffer->i_pts =
 279         p_sout_buffer->i_dts = i_pts;
 280
 281     p_sout_buffer->i_length =
 282             (uint64_t)1000000 *
 283             (uint64_t)A52_FRAME_NB /
 284             (uint64_t)i_samplerate;
 285
 286     p_pack->i_samplescount += A52_FRAME_NB;
 287
 288     /* we are already aligned */
 289     GetChunk( &p_pack->bit_stream,
 290               p_sout_buffer->p_buffer + 7,
 291               i_framelength - 7 );
 292
 293     sout_InputSendBuffer( p_pack->p_sout_input,
 294                           p_sout_buffer );
 295 }
 296
 297
 298 /*****************************************************************************
 299  * EndThread : packetizer thread destruction
 300  *****************************************************************************/
 301 static void EndThread ( packetizer_t *p_pack)
 302 {
 303     if( p_pack->p_sout_input )
 304     {
 305         sout_InputDelete( p_pack->p_sout_input );
 306     }
 307     free( p_pack );
 308 }
 309
 310 /*****************************************************************************
 311  * SyncInfo: parse A52 sync info
 312  *****************************************************************************
 313  * This code is borrowed from liba52 by Aaron Holtzman & Michel Lespinasse,
 314  * since we don't want to oblige S/PDIF people to use liba52 just to get
 315  * their SyncInfo...
 316  * fenrir: I've change it to report channels count
 317  *****************************************************************************/
 318 static int SyncInfo( const byte_t * p_buf, int * pi_channels,
 319                      int * pi_sample_rate, int * pi_bit_rate )
 320 {
 321     static const uint8_t halfrate[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 };
 322     static const int rate[] = { 32,  40,  48,  56,  64,  80,  96, 112,
 323                                 128, 160, 192, 224, 256, 320, 384, 448,
 324                                 512, 576, 640 };
 325     static const uint8_t lfeon[8] = { 0x10, 0x10, 0x04, 0x04,
 326                                       0x04, 0x01, 0x04, 0x01 };
 327     static const int acmod_to_channels[8] = { 2, 1, 2, 3, 3, 4, 4, 5 };
 328     int frmsizecod;
 329     int bitrate;
 330     int half;
 331     int acmod;
 332
 333     if ((p_buf[0] != 0x0b) || (p_buf[1] != 0x77))        /* syncword */
 334         return 0;
 335
 336     if (p_buf[5] >= 0x60)                /* bsid >= 12 */
 337         return 0;
 338     half = halfrate[p_buf[5] >> 3];
 339
 340     /* acmod, dsurmod and lfeon */
 341     acmod = p_buf[6] >> 5;
 342     if ( (p_buf[6] & 0xf8) == 0x50 )
 343     {
 344         /* Dolby surround = stereo + Dolby */
 345 /*        *pi_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT
 346                         | AOUT_CHAN_DOLBYSTEREO;*/
 347         *pi_channels = 2; /* FIXME ???  */
 348     }
 349     else
 350     {
 351         *pi_channels = acmod_to_channels[acmod&0x07];
 352     }
 353
 354     if ( p_buf[6] & lfeon[acmod] ) *pi_channels += 1;//|= AOUT_CHAN_LFEA;
 355
 356     frmsizecod = p_buf[4] & 63;
 357     if (frmsizecod >= 38)
 358         return 0;
 359     bitrate = rate [frmsizecod >> 1];
 360     *pi_bit_rate = (bitrate * 1000) >> half;
 361
 362     switch (p_buf[4] & 0xc0) {
 363     case 0:
 364         *pi_sample_rate = 48000 >> half;
 365         return 4 * bitrate;
 366     case 0x40:
 367         *pi_sample_rate = 44100 >> half;
 368         return 2 * (320 * bitrate / 147 + (frmsizecod & 1));
 369     case 0x80:
 370         *pi_sample_rate = 32000 >> half;
 371         return 6 * bitrate;
 372     default:
 373         return 0;
 374     }
 375 }
 376
 377