modules/codec/mad.c

   1 /*****************************************************************************
   2  * mad.c: MPEG-1 & 2 audio layer I, II, III + MPEG 2.5 decoder,
   3  * using MAD (MPEG Audio Decoder)
   4  *****************************************************************************
   5  * Copyright (C) 2001-2016 VLC authors and VideoLAN
   6  * $Id$
   7  *
   8  * Authors: Christophe Massiot <massiot@via.ecp.fr>
   9  *          Jean-Paul Saman <jpsaman _at_ videolan _dot_ org>
  10  *
  11  * This program is free software; you can redistribute it and/or modify it
  12  * under the terms of the GNU Lesser General Public License as published by
  13  * the Free Software Foundation; either version 2.1 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  19  * GNU Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * along with this program; if not, write to the Free Software Foundation,
  23  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  24  *****************************************************************************/
  25
  26 /*****************************************************************************
  27  * NOTA BENE: this module requires the linking against a library which is
  28  * known to require licensing under the GNU General Public License version 2
  29  * (or later). Therefore, the result of compiling this module will normally
  30  * be subject to the terms of that later license.
  31  *****************************************************************************/
  32
  33
  34 /*****************************************************************************
  35  * Preamble
  36  *****************************************************************************/
  37
  38 #include <mad.h>
  39
  40 #ifdef HAVE_CONFIG_H
  41 # include "config.h"
  42 #endif
  43 #include <assert.h>
  44
  45 #include <vlc_common.h>
  46 #include <vlc_plugin.h>
  47 #include <vlc_block.h>
  48 #include <vlc_aout.h>
  49 #include <vlc_codec.h>
  50
  51 #define MAD_BUFFER_GUARD 8
  52
  53 /*****************************************************************************
  54  * Local prototypes
  55  *****************************************************************************/
  56 static int  Open ( vlc_object_t * );
  57 static void Close( vlc_object_t * );
  58
  59 /*****************************************************************************
  60  * Local structures
  61  *****************************************************************************/
  62 typedef struct
  63 {
  64     struct mad_stream mad_stream;
  65     struct mad_frame  mad_frame;
  66     struct mad_synth  mad_synth;
  67
  68     int               i_reject_count;
  69     block_t          *p_last_buf;
  70 } decoder_sys_t;
  71
  72 /*****************************************************************************
  73  * Module descriptor
  74  *****************************************************************************/
  75 vlc_module_begin ()
  76     set_category( CAT_INPUT )
  77     set_subcategory( SUBCAT_INPUT_ACODEC )
  78     set_description( N_("MPEG audio layer I/II/III decoder") )
  79     set_capability( "audio decoder", 99 )
  80     set_callbacks( Open, Close )
  81 vlc_module_end ()
  82
  83 /*****************************************************************************
  84  * DecodeBlock: decode an MPEG audio frame.
  85  *****************************************************************************/
  86 static block_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
  87 {
  88     decoder_sys_t *p_sys = p_dec->p_sys;
  89     block_t *p_out_buf = NULL, *p_last_buf = NULL;
  90
  91     if( !pp_block )
  92     {
  93         /* Drain */
  94         p_last_buf = p_sys->p_last_buf;
  95         p_sys->p_last_buf = NULL;
  96         if( !p_last_buf )
  97             return NULL;
  98     }
  99     else
 100     {
 101         if( !*pp_block )
 102             return NULL;
 103         block_t *p_in_buf = *pp_block;
 104         *pp_block = NULL;
 105
 106         if( p_in_buf->i_buffer < MAD_BUFFER_GUARD )
 107         {
 108             block_Release( p_in_buf );
 109             return NULL;
 110         }
 111
 112         /* Buffers passed to the mad_stream_buffer() function need to ends with
 113          * the header (MAD_BUFFER_GUARD) of the following block. Therefore,
 114          * this DecodeBlock() function will always return the output buffer
 115          * corresponding to the last input buffer. */
 116         if( !p_sys->p_last_buf )
 117         {
 118             /* Wait for the next block */
 119             p_sys->p_last_buf = p_in_buf;
 120             return NULL;
 121         }
 122         p_last_buf = p_sys->p_last_buf;
 123         p_sys->p_last_buf = p_in_buf;
 124
 125         /* Put the header of the current buffer at the end of the last one.
 126          * Normally, this won't do a real realloc() since VLC blocks are
 127          * allocated with pre and post padding */
 128         p_last_buf = block_Realloc( p_last_buf, 0,
 129                                     p_last_buf->i_buffer + MAD_BUFFER_GUARD );
 130         if( !p_last_buf )
 131             return NULL;
 132         memcpy( &p_last_buf->p_buffer[p_last_buf->i_buffer - MAD_BUFFER_GUARD],
 133                 p_in_buf->p_buffer, MAD_BUFFER_GUARD);
 134     }
 135
 136     mad_stream_buffer( &p_sys->mad_stream, p_last_buf->p_buffer,
 137                        p_last_buf->i_buffer );
 138     /* Do the actual decoding now (ignore EOF error when draining). */
 139     if ( mad_frame_decode( &p_sys->mad_frame, &p_sys->mad_stream ) == -1
 140      && ( pp_block != NULL || p_sys->mad_stream.error != MAD_ERROR_BUFLEN ) )
 141     {
 142         msg_Err( p_dec, "libmad error: %s",
 143                   mad_stream_errorstr( &p_sys->mad_stream ) );
 144         if( !MAD_RECOVERABLE( p_sys->mad_stream.error ) )
 145             p_sys->i_reject_count = 3;
 146     }
 147     else if( p_last_buf->i_flags & BLOCK_FLAG_DISCONTINUITY )
 148     {
 149         p_sys->i_reject_count = 3;
 150     }
 151
 152     if( p_sys->i_reject_count > 0 )
 153         goto reject;
 154
 155     mad_synth_frame( &p_sys->mad_synth, &p_sys->mad_frame );
 156
 157     struct mad_pcm * p_pcm = &p_sys->mad_synth.pcm;
 158     unsigned int i_samples = p_pcm->length;
 159     mad_fixed_t const * p_left = p_pcm->samples[0];
 160     mad_fixed_t const * p_right = p_pcm->samples[1];
 161     p_out_buf = decoder_NewAudioBuffer( p_dec, i_samples );
 162     if( !p_out_buf )
 163         goto end;
 164     p_out_buf->i_dts = p_last_buf->i_dts;
 165     p_out_buf->i_pts = p_last_buf->i_pts;
 166     p_out_buf->i_length = p_last_buf->i_length;
 167     float *p_samples = (float *)p_out_buf->p_buffer;
 168
 169     if (p_pcm->channels > p_dec->fmt_out.audio.i_channels)
 170     {
 171         msg_Err( p_dec, "wrong channels count (corrupt stream?): %u > %u",
 172                  p_pcm->channels, p_dec->fmt_out.audio.i_channels);
 173         p_sys->i_reject_count = 3;
 174         goto reject;
 175     }
 176
 177     if( i_samples != p_out_buf->i_nb_samples )
 178     {
 179         msg_Err( p_dec, "unexpected samples count (corrupt stream?): "
 180                  "%u / %u", i_samples, p_out_buf->i_nb_samples );
 181         p_sys->i_reject_count = 3;
 182         goto reject;
 183     }
 184
 185     /* Interleave and keep buffers in mad_fixed_t format */
 186     if ( p_pcm->channels == 2 )
 187     {
 188         while ( i_samples-- )
 189         {
 190             //assert( *p_left < MAD_F_ONE );
 191             //assert( *p_left >= -MAD_F_ONE );
 192             //assert( *p_right < MAD_F_ONE );
 193             //assert( *p_right >= -MAD_F_ONE );
 194             *p_samples++ = (float)*p_left++ / (float)MAD_F_ONE;
 195             *p_samples++ = (float)*p_right++ / (float)MAD_F_ONE;
 196         }
 197     }
 198     else
 199     {
 200         assert( p_pcm->channels == 1 );
 201         while ( i_samples-- )
 202         {
 203             //assert( *p_left < MAD_F_ONE );
 204             //assert( *p_left >= -MAD_F_ONE );
 205             *p_samples++ = (float)*p_left++ / (float)MAD_F_ONE;
 206         }
 207     }
 208
 209 end:
 210     block_Release( p_last_buf );
 211     return p_out_buf;
 212 reject:
 213     p_sys->i_reject_count--;
 214     if( p_out_buf )
 215     {
 216         block_Release( p_out_buf );
 217         p_out_buf = NULL;
 218     }
 219     goto end;
 220 }
 221
 222 static int DecodeAudio( decoder_t *p_dec, block_t *p_block )
 223 {
 224     block_t **pp_block = p_block ? &p_block : NULL, *p_out;
 225     while( ( p_out = DecodeBlock( p_dec, pp_block ) ) != NULL )
 226         decoder_QueueAudio( p_dec, p_out );
 227     return VLCDEC_SUCCESS;
 228 }
 229
 230 static void DecodeFlush( decoder_t *p_dec )
 231 {
 232     decoder_sys_t *p_sys = p_dec->p_sys;
 233
 234     if( p_sys->p_last_buf )
 235         block_Release( p_sys->p_last_buf );
 236     p_sys->p_last_buf = NULL;
 237 }
 238
 239 /*****************************************************************************
 240  * Open:
 241  *****************************************************************************/
 242 static int Open( vlc_object_t *p_this )
 243 {
 244     decoder_t *p_dec = (decoder_t *)p_this;
 245     decoder_sys_t *p_sys;
 246
 247     if( ( p_dec->fmt_in.i_codec != VLC_CODEC_MPGA
 248      && p_dec->fmt_in.i_codec != VLC_CODEC_MP3
 249      && p_dec->fmt_in.i_codec != VLC_FOURCC('m','p','g','3') )
 250      || p_dec->fmt_in.audio.i_rate == 0
 251      || p_dec->fmt_in.audio.i_physical_channels == 0
 252      || p_dec->fmt_in.audio.i_bytes_per_frame == 0
 253      || p_dec->fmt_in.audio.i_frame_length == 0 )
 254         return VLC_EGENERIC;
 255
 256     /* Allocate the memory needed to store the module's structure */
 257     p_sys = p_dec->p_sys = malloc( sizeof(decoder_sys_t) );
 258     if( p_sys == NULL )
 259         return VLC_ENOMEM;
 260     p_sys->i_reject_count = 0;
 261     p_sys->p_last_buf = NULL;
 262
 263     /* Initialize libmad */
 264     mad_stream_init( &p_sys->mad_stream );
 265     mad_frame_init( &p_sys->mad_frame );
 266     mad_synth_init( &p_sys->mad_synth );
 267     mad_stream_options( &p_sys->mad_stream, MAD_OPTION_IGNORECRC );
 268
 269     p_dec->fmt_out.audio = p_dec->fmt_in.audio;
 270     p_dec->fmt_out.audio.i_format = VLC_CODEC_FL32;
 271     p_dec->fmt_out.i_codec = p_dec->fmt_out.audio.i_format;
 272
 273     aout_FormatPrepare( &p_dec->fmt_out.audio );
 274
 275     if( decoder_UpdateAudioFormat( p_dec ) )
 276     {
 277         Close( p_this );
 278         return VLC_EGENERIC;
 279     }
 280
 281     p_dec->pf_decode = DecodeAudio;
 282     p_dec->pf_flush  = DecodeFlush;
 283
 284     return VLC_SUCCESS;
 285 }
 286
 287 /*****************************************************************************
 288  * Close : deallocate data structures
 289  *****************************************************************************/
 290 static void Close( vlc_object_t *p_this )
 291 {
 292     decoder_t *p_dec = (decoder_t *)p_this;
 293     decoder_sys_t *p_sys = p_dec->p_sys;
 294
 295     mad_synth_finish( &p_sys->mad_synth );
 296     mad_frame_finish( &p_sys->mad_frame );
 297     mad_stream_finish( &p_sys->mad_stream );
 298     if( p_sys->p_last_buf )
 299         block_Release( p_sys->p_last_buf );
 300     free( p_sys );
 301 }