X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=modules%2Faudio_filter%2Fconverter%2Fa52tofloat32.c;h=895d7d83181400b00b6d40624a8552bd106812e6;hb=b674dab81ccd2a089896b26a2afc258118e6a990;hp=67cf392fda96482348852eb4041d575aa5fe4241;hpb=19281d93a9b32e20634229f2c6c2e1ec3a508206;p=vlc diff --git a/modules/audio_filter/converter/a52tofloat32.c b/modules/audio_filter/converter/a52tofloat32.c index 67cf392fda..895d7d8318 100644 --- a/modules/audio_filter/converter/a52tofloat32.c +++ b/modules/audio_filter/converter/a52tofloat32.c @@ -3,17 +3,17 @@ * This plugin makes use of liba52 to decode A/52 audio * (http://liba52.sf.net/). ***************************************************************************** - * Copyright (C) 2001, 2002 VideoLAN - * $Id: a52tofloat32.c,v 1.16 2004/01/25 13:37:11 kuehne Exp $ + * Copyright (C) 2001, 2002 the VideoLAN team + * $Id$ * - * Authors: Gildas Bazin + * Authors: Gildas Bazin * Christophe Massiot - * + * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. - * + * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the @@ -21,16 +21,19 @@ * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA. + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA. *****************************************************************************/ /***************************************************************************** * Preamble *****************************************************************************/ -#include +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include +#include -#include /* malloc(), free() */ -#include /* strdup() */ #ifdef HAVE_STDINT_H # include /* int16_t .. */ #elif HAVE_INTTYPES_H @@ -47,27 +50,45 @@ # include "a52dec/a52.h" #endif -#include "audio_output.h" -#include "aout_internal.h" +#include +#include +#include /***************************************************************************** * Local prototypes *****************************************************************************/ static int Create ( vlc_object_t * ); static void Destroy ( vlc_object_t * ); -static void DoWork ( aout_instance_t *, aout_filter_t *, aout_buffer_t *, +static void DoWork ( aout_instance_t *, aout_filter_t *, aout_buffer_t *, aout_buffer_t * ); +static int Open ( vlc_object_t *, filter_sys_t *, + audio_format_t, audio_format_t ); + +static int OpenFilter ( vlc_object_t * ); +static void CloseFilter( vlc_object_t * ); +static block_t *Convert( filter_t *, block_t * ); + +/* liba52 channel order */ +static const uint32_t pi_channels_in[] = +{ AOUT_CHAN_LFE, AOUT_CHAN_LEFT, AOUT_CHAN_CENTER, AOUT_CHAN_RIGHT, + AOUT_CHAN_REARLEFT, AOUT_CHAN_REARRIGHT, 0 }; +/* our internal channel order (WG-4 order) */ +static const uint32_t pi_channels_out[] = +{ AOUT_CHAN_LEFT, AOUT_CHAN_RIGHT, AOUT_CHAN_REARLEFT, AOUT_CHAN_REARRIGHT, + AOUT_CHAN_CENTER, AOUT_CHAN_LFE, 0 }; /***************************************************************************** * Local structures *****************************************************************************/ -struct aout_filter_sys_t +struct filter_sys_t { a52_state_t * p_liba52; /* liba52 internal structure */ - vlc_bool_t b_dynrng; /* see below */ + bool b_dynrng; /* see below */ int i_flags; /* liba52 flags, see a52dec/doc/liba52.txt */ - vlc_bool_t b_dontwarn; + bool b_dontwarn; int i_nb_channels; /* number of float32 per sample */ + + int pi_chan_table[AOUT_CHAN_MAX]; /* channel reordering */ }; /***************************************************************************** @@ -80,25 +101,41 @@ struct aout_filter_sys_t "environment without disturbing anyone. If you disable the dynamic range "\ "compression the playback will be more adapted to a movie theater or a " \ "listening room.") +#define UPMIX_TEXT N_("Enable internal upmixing") +#define UPMIX_LONGTEXT N_( \ + "Enable the internal upmixing algorithm (not recommended).") vlc_module_begin(); - add_category_hint( N_("Miscellaneous"), NULL, VLC_FALSE ); - add_bool( "a52-dynrng", 1, NULL, DYNRNG_TEXT, DYNRNG_LONGTEXT, VLC_FALSE ); - set_description( _("ATSC A/52 aka AC-3 audio decoder") ); + set_shortname( "A/52" ); + set_description( N_("ATSC A/52 (AC-3) audio decoder") ); + set_category( CAT_INPUT ); + set_subcategory( SUBCAT_INPUT_ACODEC ); + add_bool( "a52-dynrng", 1, NULL, DYNRNG_TEXT, DYNRNG_LONGTEXT, false ); + add_bool( "a52-upmix", 0, NULL, UPMIX_TEXT, UPMIX_LONGTEXT, true ); set_capability( "audio filter", 100 ); set_callbacks( Create, Destroy ); + + add_submodule(); + set_description( N_("ATSC A/52 (AC-3) audio decoder") ); + set_capability( "audio filter2", 100 ); + set_callbacks( OpenFilter, CloseFilter ); vlc_module_end(); /***************************************************************************** - * Create: + * Create: *****************************************************************************/ -static int Create( vlc_object_t * _p_filter ) +static int Create( vlc_object_t *p_this ) { - aout_filter_t * p_filter = (aout_filter_t *)_p_filter; - struct aout_filter_sys_t * p_sys; + aout_filter_t *p_filter = (aout_filter_t *)p_this; + filter_sys_t *p_sys = (filter_sys_t *)p_filter->p_sys; + int i_ret; if ( p_filter->input.i_format != VLC_FOURCC('a','5','2',' ') +#ifdef LIBA52_FIXED + || p_filter->output.i_format != VLC_FOURCC('f','i','3','2') ) +#else || p_filter->output.i_format != VLC_FOURCC('f','l','3','2') ) +#endif { return -1; } @@ -109,29 +146,52 @@ static int Create( vlc_object_t * _p_filter ) } /* Allocate the memory needed to store the module's structure */ - p_sys = p_filter->p_sys = malloc( sizeof(struct aout_filter_sys_t) ); + p_sys = malloc( sizeof(filter_sys_t) ); + p_filter->p_sys = (struct aout_filter_sys_t *)p_sys; if( p_sys == NULL ) - { - msg_Err( p_filter, "out of memory" ); return -1; - } - p_sys->b_dynrng = config_GetInt( p_filter, "a52-dynrng" ); + i_ret = Open( VLC_OBJECT(p_filter), p_sys, + p_filter->input, p_filter->output ); + + p_filter->pf_do_work = DoWork; + p_filter->b_in_place = 0; + + return i_ret; +} + +/***************************************************************************** + * Open: + *****************************************************************************/ +static int Open( vlc_object_t *p_this, filter_sys_t *p_sys, + audio_format_t input, audio_format_t output ) +{ + p_sys->b_dynrng = config_GetInt( p_this, "a52-dynrng" ); p_sys->b_dontwarn = 0; + /* No upmixing: it's not necessary and some other filters may want to do + * it themselves. */ + if ( aout_FormatNbChannels( &output ) > aout_FormatNbChannels( &input ) ) + { + if ( ! config_GetInt( p_this, "a52-upmix" ) ) + { + return VLC_EGENERIC; + } + } + /* We'll do our own downmixing, thanks. */ - p_sys->i_nb_channels = aout_FormatNbChannels( &p_filter->output ); - switch ( (p_filter->output.i_physical_channels & AOUT_CHAN_PHYSMASK) + p_sys->i_nb_channels = aout_FormatNbChannels( &output ); + switch ( (output.i_physical_channels & AOUT_CHAN_PHYSMASK) & ~AOUT_CHAN_LFE ) { case AOUT_CHAN_CENTER: - if ( (p_filter->output.i_original_channels & AOUT_CHAN_CENTER) - || (p_filter->output.i_original_channels + if ( (output.i_original_channels & AOUT_CHAN_CENTER) + || (output.i_original_channels & (AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT)) ) { p_sys->i_flags = A52_MONO; } - else if ( p_filter->output.i_original_channels & AOUT_CHAN_LEFT ) + else if ( output.i_original_channels & AOUT_CHAN_LEFT ) { p_sys->i_flags = A52_CHANNEL1; } @@ -142,23 +202,23 @@ static int Create( vlc_object_t * _p_filter ) break; case AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT: - if ( p_filter->output.i_original_channels & AOUT_CHAN_DOLBYSTEREO ) + if ( output.i_original_channels & AOUT_CHAN_DOLBYSTEREO ) { p_sys->i_flags = A52_DOLBY; } - else if ( p_filter->input.i_original_channels == AOUT_CHAN_CENTER ) + else if ( input.i_original_channels == AOUT_CHAN_CENTER ) { p_sys->i_flags = A52_MONO; } - else if ( p_filter->input.i_original_channels & AOUT_CHAN_DUALMONO ) + else if ( input.i_original_channels & AOUT_CHAN_DUALMONO ) { p_sys->i_flags = A52_CHANNEL; } - else if ( !(p_filter->output.i_original_channels & AOUT_CHAN_RIGHT) ) + else if ( !(output.i_original_channels & AOUT_CHAN_RIGHT) ) { p_sys->i_flags = A52_CHANNEL1; } - else if ( !(p_filter->output.i_original_channels & AOUT_CHAN_LEFT) ) + else if ( !(output.i_original_channels & AOUT_CHAN_LEFT) ) { p_sys->i_flags = A52_CHANNEL2; } @@ -192,11 +252,11 @@ static int Create( vlc_object_t * _p_filter ) break; default: - msg_Warn( p_filter, "unknown sample format!" ); + msg_Warn( p_this, "unknown sample format!" ); free( p_sys ); - return -1; + return VLC_EGENERIC; } - if ( p_filter->output.i_physical_channels & AOUT_CHAN_LFE ) + if ( output.i_physical_channels & AOUT_CHAN_LFE ) { p_sys->i_flags |= A52_LFE; } @@ -206,59 +266,33 @@ static int Create( vlc_object_t * _p_filter ) p_sys->p_liba52 = a52_init( 0 ); if( p_sys->p_liba52 == NULL ) { - msg_Err( p_filter, "unable to initialize liba52" ); - return -1; + msg_Err( p_this, "unable to initialize liba52" ); + free( p_sys ); + return VLC_EGENERIC; } - p_filter->pf_do_work = DoWork; - p_filter->b_in_place = 0; + aout_CheckChannelReorder( pi_channels_in, pi_channels_out, + output.i_physical_channels & AOUT_CHAN_PHYSMASK, + p_sys->i_nb_channels, + p_sys->pi_chan_table ); - return 0; + return VLC_SUCCESS; } /***************************************************************************** * Interleave: helper function to interleave channels *****************************************************************************/ -static void Interleave( float * p_out, const float * p_in, int i_nb_channels ) +static void Interleave( float * p_out, const float * p_in, int i_nb_channels, + int *pi_chan_table ) { - /* We do not only have to interleave, but also reorder the channels - * Channel reordering according to number of output channels of libA52 - * The reordering needs to be different for different channel configurations - * (3F2R, 1F2R etc), so this is only temporary. - * The WG-4 order is appropriate for stereo, quadrophonia, and 5.1 surround. - * - * 6 channel mode - * channel liba52 order WG-4 order - * 0 LFE // L - * 1 L // R - * 2 C // LS - * 3 R // RS - * 4 LS // C - * 5 RS // LFE - * - * The liba52 moves channels to the front if there are unused spaces, so - * there is no gap between channels. The translation table says which - * channel of the new stream is taken from which original channel [use - * the new channel as the array index, use the number you get from the - * array to address the original channel]. - */ - - static const int translation[7][6] = - {{ 0, 0, 0, 0, 0, 0 }, /* 0 channels (rarely used) */ - { 0, 0, 0, 0, 0, 0 }, /* 1 ch */ - { 0, 1, 0, 0, 0, 0 }, /* 2 */ - { 1, 2, 0, 0, 0, 0 }, /* 3 */ - { 1, 3, 2, 0, 0, 0 }, /* 4 */ - { 1, 3, 4, 2, 0, 0 }, /* 5 */ - { 1, 3, 4, 5, 2, 0 }}; /* 6 */ + /* We do not only have to interleave, but also reorder the channels */ int i, j; for ( j = 0; j < i_nb_channels; j++ ) { for ( i = 0; i < 256; i++ ) { - p_out[i * i_nb_channels + j] = p_in[translation[i_nb_channels][j] - * 256 + i]; + p_out[i * i_nb_channels + pi_chan_table[j]] = p_in[j * 256 + i]; } } } @@ -300,8 +334,12 @@ static void Exchange( float * p_out, const float * p_in ) static void DoWork( aout_instance_t * p_aout, aout_filter_t * p_filter, aout_buffer_t * p_in_buf, aout_buffer_t * p_out_buf ) { - struct aout_filter_sys_t * p_sys = p_filter->p_sys; + filter_sys_t *p_sys = (filter_sys_t *)p_filter->p_sys; +#ifdef LIBA52_FIXED + sample_t i_sample_level = (1 << 24); +#else sample_t i_sample_level = 1; +#endif int i_flags = p_sys->i_flags; int i_bytes_per_block = 256 * p_sys->i_nb_channels * sizeof(float); @@ -314,7 +352,7 @@ static void DoWork( aout_instance_t * p_aout, aout_filter_t * p_filter, if ( (i_flags & A52_CHANNEL_MASK) != (p_sys->i_flags & A52_CHANNEL_MASK) && !p_sys->b_dontwarn ) { - msg_Warn( p_filter, + msg_Warn( p_aout, "liba52 couldn't do the requested downmix 0x%x->0x%x", p_sys->i_flags & A52_CHANNEL_MASK, i_flags & A52_CHANNEL_MASK ); @@ -324,7 +362,7 @@ static void DoWork( aout_instance_t * p_aout, aout_filter_t * p_filter, if( !p_sys->b_dynrng ) { - a52_dynrng( p_filter->p_sys->p_liba52, NULL, NULL ); + a52_dynrng( p_sys->p_liba52, NULL, NULL ); } for ( i = 0; i < 6; i++ ) @@ -333,7 +371,7 @@ static void DoWork( aout_instance_t * p_aout, aout_filter_t * p_filter, if( a52_block( p_sys->p_liba52 ) ) { - msg_Warn( p_filter, "a52_block failed for block %d", i ); + msg_Warn( p_aout, "a52_block failed for block %d", i ); } p_samples = a52_samples( p_sys->p_liba52 ); @@ -341,7 +379,7 @@ static void DoWork( aout_instance_t * p_aout, aout_filter_t * p_filter, if ( ((p_sys->i_flags & A52_CHANNEL_MASK) == A52_CHANNEL1 || (p_sys->i_flags & A52_CHANNEL_MASK) == A52_CHANNEL2 || (p_sys->i_flags & A52_CHANNEL_MASK) == A52_MONO) - && (p_filter->output.i_physical_channels + && (p_filter->output.i_physical_channels & (AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT)) ) { Duplicate( (float *)(p_out_buf->p_buffer + i * i_bytes_per_block), @@ -355,9 +393,9 @@ static void DoWork( aout_instance_t * p_aout, aout_filter_t * p_filter, } else { - /* Interleave the *$£%ù samples. */ + /* Interleave the *$£%ù samples. */ Interleave( (float *)(p_out_buf->p_buffer + i * i_bytes_per_block), - p_samples, p_sys->i_nb_channels ); + p_samples, p_sys->i_nb_channels, p_sys->pi_chan_table); } } @@ -368,12 +406,113 @@ static void DoWork( aout_instance_t * p_aout, aout_filter_t * p_filter, /***************************************************************************** * Destroy : deallocate data structures *****************************************************************************/ -static void Destroy( vlc_object_t * _p_filter ) +static void Destroy( vlc_object_t *p_this ) +{ + aout_filter_t *p_filter = (aout_filter_t *)p_this; + filter_sys_t *p_sys = (filter_sys_t *)p_filter->p_sys; + + a52_free( p_sys->p_liba52 ); + free( p_sys ); +} + +/***************************************************************************** + * OpenFilter: + *****************************************************************************/ +static int OpenFilter( vlc_object_t *p_this ) +{ + filter_t *p_filter = (filter_t *)p_this; + filter_sys_t *p_sys; + int i_ret; + + if( p_filter->fmt_in.i_codec != VLC_FOURCC('a','5','2',' ') ) + { + return VLC_EGENERIC; + } + + p_filter->fmt_out.audio.i_format = +#ifdef LIBA52_FIXED + p_filter->fmt_out.i_codec = VLC_FOURCC('f','i','3','2'); +#else + p_filter->fmt_out.i_codec = VLC_FOURCC('f','l','3','2'); +#endif + p_filter->fmt_out.audio.i_bitspersample = + aout_BitsPerSample( p_filter->fmt_out.i_codec ); + + /* Allocate the memory needed to store the module's structure */ + p_filter->p_sys = p_sys = malloc( sizeof(filter_sys_t) ); + if( p_sys == NULL ) + return VLC_ENOMEM; + + i_ret = Open( VLC_OBJECT(p_filter), p_sys, + p_filter->fmt_in.audio, p_filter->fmt_out.audio ); + + p_filter->pf_audio_filter = Convert; + p_filter->fmt_out.audio.i_rate = p_filter->fmt_in.audio.i_rate; + + return i_ret; +} + +/***************************************************************************** + * CloseFilter : deallocate data structures + *****************************************************************************/ +static void CloseFilter( vlc_object_t *p_this ) { - aout_filter_t * p_filter = (aout_filter_t *)_p_filter; - struct aout_filter_sys_t * p_sys = p_filter->p_sys; + filter_t *p_filter = (filter_t *)p_this; + filter_sys_t *p_sys = p_filter->p_sys; a52_free( p_sys->p_liba52 ); free( p_sys ); } +static block_t *Convert( filter_t *p_filter, block_t *p_block ) +{ + aout_filter_t aout_filter; + aout_buffer_t in_buf, out_buf; + block_t *p_out; + int i_out_size; + + if( !p_block || !p_block->i_samples ) + { + if( p_block ) p_block->pf_release( p_block ); + return NULL; + } + + i_out_size = p_block->i_samples * + p_filter->fmt_out.audio.i_bitspersample * + p_filter->fmt_out.audio.i_channels / 8; + + p_out = p_filter->pf_audio_buffer_new( p_filter, i_out_size ); + if( !p_out ) + { + msg_Warn( p_filter, "can't get output buffer" ); + p_block->pf_release( p_block ); + return NULL; + } + + p_out->i_samples = p_block->i_samples; + p_out->i_dts = p_block->i_dts; + p_out->i_pts = p_block->i_pts; + p_out->i_length = p_block->i_length; + + aout_filter.p_sys = (struct aout_filter_sys_t *)p_filter->p_sys; + aout_filter.input = p_filter->fmt_in.audio; + aout_filter.input.i_format = p_filter->fmt_in.i_codec; + aout_filter.output = p_filter->fmt_out.audio; + aout_filter.output.i_format = p_filter->fmt_out.i_codec; + + in_buf.p_buffer = p_block->p_buffer; + in_buf.i_nb_bytes = p_block->i_buffer; + in_buf.i_nb_samples = p_block->i_samples; + out_buf.p_buffer = p_out->p_buffer; + out_buf.i_nb_bytes = p_out->i_buffer; + out_buf.i_nb_samples = p_out->i_samples; + + DoWork( (aout_instance_t *)p_filter, &aout_filter, &in_buf, &out_buf ); + + p_out->i_buffer = out_buf.i_nb_bytes; + p_out->i_samples = out_buf.i_nb_samples; + + p_block->pf_release( p_block ); + + return p_out; +}