X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=modules%2Faudio_filter%2Fchannel_mixer%2Fheadphone.c;h=de6858698635f3cee4f8d214123aa29aee17cd31;hb=2aa61dc55a77f535c3e70104b6ec2167766f8499;hp=911be1aa7f746824d8f069b7770523fe15e700d4;hpb=f8c95ffa2ba4bf2d21105a622ef805802605e224;p=vlc diff --git a/modules/audio_filter/channel_mixer/headphone.c b/modules/audio_filter/channel_mixer/headphone.c index 911be1aa7f..de68586986 100644 --- a/modules/audio_filter/channel_mixer/headphone.c +++ b/modules/audio_filter/channel_mixer/headphone.c @@ -2,72 +2,93 @@ * headphone.c : headphone virtual spatialization channel mixer module * -> gives the feeling of a real room with a simple headphone ***************************************************************************** - * Copyright (C) 2002 VideoLAN + * Copyright (C) 2002-2006 the VideoLAN team * $Id$ * - * Authors: Boris Dorès + * Authors: Boris Dorès * - * 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 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 - * GNU General Public License for more details. + * 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 GNU General Public License for + * more details. * - * 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. + * 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., 51 + * Franklin Street, Fifth Floor, Boston MA 02110-1301, USA. *****************************************************************************/ /***************************************************************************** * Preamble *****************************************************************************/ -#include /* malloc(), free() */ -#include + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + #include /* sqrt */ -#include -#include "audio_output.h" -#include "aout_internal.h" +#include +#include +#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 *, - aout_buffer_t * ); +static int OpenFilter ( vlc_object_t * ); +static void CloseFilter( vlc_object_t * ); +static block_t *Convert( filter_t *, block_t * ); /***************************************************************************** * Module descriptor *****************************************************************************/ #define MODULE_DESCRIPTION N_ ( \ "This effect gives you the feeling that you are standing in a room " \ - "with a complete 5.1 speaker set when using only a headphone, " \ + "with a complete 7.1 speaker set when using only a headphone, " \ "providing a more realistic sound experience. It should also be " \ "more comfortable and less tiring when listening to music for " \ "long periods of time.\nIt works with any source format from mono " \ - "to 5.1.") + "to 7.1.") #define HEADPHONE_DIM_TEXT N_("Characteristic dimension") #define HEADPHONE_DIM_LONGTEXT N_( \ - "Headphone virtual spatialization effect parameter: "\ - "distance between front left speaker and listener in meters.") - -vlc_module_begin(); - set_description( N_("headphone channel mixer with virtual spatialization effect") ); + "Distance between front left speaker and listener in meters.") + +#define HEADPHONE_COMPENSATE_TEXT N_("Compensate delay") +#define HEADPHONE_COMPENSATE_LONGTEXT N_( \ + "The delay which is introduced by the physical algorithm may "\ + "sometimes be disturbing for the synchronization between lips-movement "\ + "and speech. In case, turn this on to compensate.") + +#define HEADPHONE_DOLBY_TEXT N_("No decoding of Dolby Surround") +#define HEADPHONE_DOLBY_LONGTEXT N_( \ + "Dolby Surround encoded streams won't be decoded before being " \ + "processed by this filter. Enabling this setting is not recommended.") + +vlc_module_begin () + set_description( N_("Headphone virtual spatialization effect") ) + set_shortname( N_("Headphone effect") ) + set_help( MODULE_DESCRIPTION ) + set_category( CAT_AUDIO ) + set_subcategory( SUBCAT_AUDIO_AFILTER ) add_integer( "headphone-dim", 10, NULL, HEADPHONE_DIM_TEXT, - HEADPHONE_DIM_LONGTEXT, VLC_FALSE ); + HEADPHONE_DIM_LONGTEXT, false ) + add_bool( "headphone-compensate", false, NULL, HEADPHONE_COMPENSATE_TEXT, + HEADPHONE_COMPENSATE_LONGTEXT, true ) + add_bool( "headphone-dolby", false, NULL, HEADPHONE_DOLBY_TEXT, + HEADPHONE_DOLBY_LONGTEXT, true ) - set_capability( "audio filter", 0 ); - set_callbacks( Create, Destroy ); - add_shortcut( "headphone" ); -vlc_module_end(); + set_capability( "audio filter", 0 ) + set_callbacks( OpenFilter, CloseFilter ) + add_shortcut( "headphone" ) +vlc_module_end () /***************************************************************************** @@ -81,10 +102,10 @@ struct atomic_operation_t double d_amplitude_factor; }; -struct aout_filter_sys_t +struct filter_sys_t { size_t i_overflow_buffer_size;/* in bytes */ - byte_t * p_overflow_buffer; + uint8_t * p_overflow_buffer; unsigned int i_nb_atomic_operations; struct atomic_operation_t * p_atomic_operations; }; @@ -107,12 +128,13 @@ struct aout_filter_sys_t * * x-axis * */ -static void ComputeChannelOperations ( struct aout_filter_sys_t * p_data - , unsigned int i_rate , unsigned int i_next_atomic_operation - , int i_source_channel_offset , double d_x , double d_z - , double d_channel_amplitude_factor ) +static void ComputeChannelOperations( struct filter_sys_t * p_data + , unsigned int i_rate, unsigned int i_next_atomic_operation + , int i_source_channel_offset, double d_x, double d_z + , double d_compensation_length, double d_channel_amplitude_factor ) { double d_c = 340; /*sound celerity (unit: m/s)*/ + double d_compensation_delay = (d_compensation_length-0.1) / d_c * i_rate; /* Left ear */ p_data->p_atomic_operations[i_next_atomic_operation] @@ -121,13 +143,13 @@ static void ComputeChannelOperations ( struct aout_filter_sys_t * p_data .i_dest_channel_offset = 0;/* left */ p_data->p_atomic_operations[i_next_atomic_operation] .i_delay = (int)( sqrt( (-0.1-d_x)*(-0.1-d_x) + (0-d_z)*(0-d_z) ) - / d_c * i_rate ); - if ( d_x < 0 ) + / d_c * i_rate - d_compensation_delay ); + if( d_x < 0 ) { p_data->p_atomic_operations[i_next_atomic_operation] .d_amplitude_factor = d_channel_amplitude_factor * 1.1 / 2; } - else if ( d_x > 0 ) + else if( d_x > 0 ) { p_data->p_atomic_operations[i_next_atomic_operation] .d_amplitude_factor = d_channel_amplitude_factor * 0.9 / 2; @@ -145,13 +167,13 @@ static void ComputeChannelOperations ( struct aout_filter_sys_t * p_data .i_dest_channel_offset = 1;/* right */ p_data->p_atomic_operations[i_next_atomic_operation + 1] .i_delay = (int)( sqrt( (0.1-d_x)*(0.1-d_x) + (0-d_z)*(0-d_z) ) - / d_c * i_rate ); - if ( d_x < 0 ) + / d_c * i_rate - d_compensation_delay ); + if( d_x < 0 ) { p_data->p_atomic_operations[i_next_atomic_operation + 1] .d_amplitude_factor = d_channel_amplitude_factor * 0.9 / 2; } - else if ( d_x > 0 ) + else if( d_x > 0 ) { p_data->p_atomic_operations[i_next_atomic_operation + 1] .d_amplitude_factor = d_channel_amplitude_factor * 1.1 / 2; @@ -163,106 +185,120 @@ static void ComputeChannelOperations ( struct aout_filter_sys_t * p_data } } -static int Init ( aout_filter_t * p_filter , struct aout_filter_sys_t * p_data - , unsigned int i_nb_channels , uint32_t i_physical_channels +static int Init( vlc_object_t *p_this, struct filter_sys_t * p_data + , unsigned int i_nb_channels, uint32_t i_physical_channels , unsigned int i_rate ) { - double d_x = config_GetInt ( p_filter , "headphone-dim" ); + double d_x = config_GetInt( p_this, "headphone-dim" ); double d_z = d_x; double d_z_rear = -d_x/3; + double d_min = 0; unsigned int i_next_atomic_operation; int i_source_channel_offset; unsigned int i; - if ( p_data == NULL ) + if( config_GetInt( p_this, "headphone-compensate" ) ) { - msg_Dbg ( p_filter, "passing a null pointer as argument" ); - return 0; + /* minimal distance to any speaker */ + if( i_physical_channels & AOUT_CHAN_REARCENTER ) + { + d_min = d_z_rear; + } + else + { + d_min = d_z; + } } /* Number of elementary operations */ p_data->i_nb_atomic_operations = i_nb_channels * 2; - p_data->p_atomic_operations = malloc ( sizeof(struct atomic_operation_t) - * p_data->i_nb_atomic_operations ); - if ( p_data->p_atomic_operations == NULL ) + if( i_physical_channels & AOUT_CHAN_CENTER ) { - msg_Err( p_filter, "out of memory" ); - return -1; + p_data->i_nb_atomic_operations += 2; } + p_data->p_atomic_operations = malloc( sizeof(struct atomic_operation_t) + * p_data->i_nb_atomic_operations ); + if( p_data->p_atomic_operations == NULL ) + return -1; /* For each virtual speaker, computes elementary wave propagation time * to each ear */ i_next_atomic_operation = 0; i_source_channel_offset = 0; - if ( i_physical_channels & AOUT_CHAN_LEFT ) + if( i_physical_channels & AOUT_CHAN_LEFT ) { - ComputeChannelOperations ( p_data , i_rate + ComputeChannelOperations( p_data , i_rate , i_next_atomic_operation , i_source_channel_offset - , -d_x , d_z , 2.0 / i_nb_channels ); + , -d_x , d_z , d_min , 2.0 / i_nb_channels ); i_next_atomic_operation += 2; i_source_channel_offset++; } - if ( i_physical_channels & AOUT_CHAN_RIGHT ) + if( i_physical_channels & AOUT_CHAN_RIGHT ) { - ComputeChannelOperations ( p_data , i_rate + ComputeChannelOperations( p_data , i_rate , i_next_atomic_operation , i_source_channel_offset - , d_x , d_z , 2.0 / i_nb_channels ); + , d_x , d_z , d_min , 2.0 / i_nb_channels ); i_next_atomic_operation += 2; i_source_channel_offset++; } - if ( i_physical_channels & AOUT_CHAN_REARLEFT ) + if( i_physical_channels & AOUT_CHAN_MIDDLELEFT ) { - ComputeChannelOperations ( p_data , i_rate + ComputeChannelOperations( p_data , i_rate , i_next_atomic_operation , i_source_channel_offset - , -d_x , d_z_rear , 1.5 / i_nb_channels ); + , -d_x , 0 , d_min , 1.5 / i_nb_channels ); i_next_atomic_operation += 2; i_source_channel_offset++; } - if ( i_physical_channels & AOUT_CHAN_REARRIGHT ) + if( i_physical_channels & AOUT_CHAN_MIDDLERIGHT ) { - ComputeChannelOperations ( p_data , i_rate + ComputeChannelOperations( p_data , i_rate , i_next_atomic_operation , i_source_channel_offset - , d_x , d_z_rear , 1.5 / i_nb_channels ); + , d_x , 0 , d_min , 1.5 / i_nb_channels ); i_next_atomic_operation += 2; i_source_channel_offset++; } - if ( i_physical_channels & AOUT_CHAN_REARCENTER ) + if( i_physical_channels & AOUT_CHAN_REARLEFT ) { - ComputeChannelOperations ( p_data , i_rate + ComputeChannelOperations( p_data , i_rate , i_next_atomic_operation , i_source_channel_offset - , 0 , -d_z , 1.5 / i_nb_channels ); + , -d_x , d_z_rear , d_min , 1.5 / i_nb_channels ); i_next_atomic_operation += 2; i_source_channel_offset++; } - if ( i_physical_channels & AOUT_CHAN_CENTER ) + if( i_physical_channels & AOUT_CHAN_REARRIGHT ) { - ComputeChannelOperations ( p_data , i_rate + ComputeChannelOperations( p_data , i_rate , i_next_atomic_operation , i_source_channel_offset - , 0 , d_z , 1.5 / i_nb_channels ); + , d_x , d_z_rear , d_min , 1.5 / i_nb_channels ); i_next_atomic_operation += 2; i_source_channel_offset++; } - if ( i_physical_channels & AOUT_CHAN_LFE ) + if( i_physical_channels & AOUT_CHAN_REARCENTER ) { - ComputeChannelOperations ( p_data , i_rate + ComputeChannelOperations( p_data , i_rate , i_next_atomic_operation , i_source_channel_offset - , 0 , d_z_rear , 5.0 / i_nb_channels ); + , 0 , -d_z , d_min , 1.5 / i_nb_channels ); i_next_atomic_operation += 2; i_source_channel_offset++; } - if ( i_physical_channels & AOUT_CHAN_MIDDLELEFT ) + if( i_physical_channels & AOUT_CHAN_CENTER ) { - ComputeChannelOperations ( p_data , i_rate + /* having two center channels increases the spatialization effect */ + ComputeChannelOperations( p_data , i_rate , i_next_atomic_operation , i_source_channel_offset - , -d_x , 0 , 1.5 / i_nb_channels ); + , d_x / 5.0 , d_z , d_min , 0.75 / i_nb_channels ); + i_next_atomic_operation += 2; + ComputeChannelOperations( p_data , i_rate + , i_next_atomic_operation , i_source_channel_offset + , -d_x / 5.0 , d_z , d_min , 0.75 / i_nb_channels ); i_next_atomic_operation += 2; i_source_channel_offset++; } - if ( i_physical_channels & AOUT_CHAN_MIDDLERIGHT ) + if( i_physical_channels & AOUT_CHAN_LFE ) { - ComputeChannelOperations ( p_data , i_rate + ComputeChannelOperations( p_data , i_rate , i_next_atomic_operation , i_source_channel_offset - , d_x , 0 , 1.5 / i_nb_channels ); + , 0 , d_z_rear , d_min , 5.0 / i_nb_channels ); i_next_atomic_operation += 2; i_source_channel_offset++; } @@ -270,110 +306,43 @@ static int Init ( aout_filter_t * p_filter , struct aout_filter_sys_t * p_data /* Initialize the overflow buffer * we need it because the process induce a delay in the samples */ p_data->i_overflow_buffer_size = 0; - for ( i = 0 ; i < p_data->i_nb_atomic_operations ; i++ ) + for( i = 0 ; i < p_data->i_nb_atomic_operations ; i++ ) { - if ( p_data->i_overflow_buffer_size - < p_data->p_atomic_operations[i].i_delay * i_nb_channels - * sizeof (float) ) + if( p_data->i_overflow_buffer_size + < p_data->p_atomic_operations[i].i_delay * 2 * sizeof (float) ) { p_data->i_overflow_buffer_size - = p_data->p_atomic_operations[i].i_delay * i_nb_channels - * sizeof (float); + = p_data->p_atomic_operations[i].i_delay * 2 * sizeof (float); } } - p_data->p_overflow_buffer = malloc ( p_data->i_overflow_buffer_size ); - if ( p_data->p_atomic_operations == NULL ) - { - msg_Err( p_filter, "out of memory" ); - return -1; - } - memset ( p_data->p_overflow_buffer , 0 , p_data->i_overflow_buffer_size ); - - /* end */ - return 0; -} - -/***************************************************************************** - * Create: allocate headphone downmixer - *****************************************************************************/ -static int Create( vlc_object_t *p_this ) -{ - aout_filter_t * p_filter = (aout_filter_t *)p_this; - - if ( p_filter->output.i_physical_channels != ( AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT ) - || p_filter->input.i_format != p_filter->output.i_format - || p_filter->input.i_rate != p_filter->output.i_rate - || (p_filter->input.i_format != VLC_FOURCC('f','l','3','2') - && p_filter->input.i_format != VLC_FOURCC('f','i','3','2')) ) - { - msg_Dbg( p_filter, "Filter discarded (invalid format)" ); - return -1; - } - - /* Allocate the memory needed to store the module's structure */ - p_filter->p_sys = malloc( sizeof(struct aout_filter_sys_t) ); - if ( p_filter->p_sys == NULL ) - { - msg_Err( p_filter, "out of memory" ); - return -1; - } - p_filter->p_sys->i_overflow_buffer_size = 0; - p_filter->p_sys->p_overflow_buffer = NULL; - p_filter->p_sys->i_nb_atomic_operations = 0; - p_filter->p_sys->p_atomic_operations = NULL; - - if ( Init( p_filter , p_filter->p_sys - , aout_FormatNbChannels ( &p_filter->input ) - , p_filter->input.i_physical_channels - , p_filter->input.i_rate ) < 0 ) + p_data->p_overflow_buffer = malloc( p_data->i_overflow_buffer_size ); + if( p_data->p_overflow_buffer == NULL ) { + free( p_data->p_atomic_operations ); return -1; } - - p_filter->pf_do_work = DoWork; - p_filter->b_in_place = 0; + memset( p_data->p_overflow_buffer, 0 , p_data->i_overflow_buffer_size ); return 0; } -/***************************************************************************** - * Destroy: deallocate resources associated with headphone downmixer - *****************************************************************************/ -static void Destroy( vlc_object_t *p_this ) -{ - aout_filter_t * p_filter = (aout_filter_t *)p_this; - - if ( p_filter->p_sys != NULL ) - { - if ( p_filter->p_sys->p_overflow_buffer != NULL ) - { - free ( p_filter->p_sys->p_overflow_buffer ); - } - if ( p_filter->p_sys->p_atomic_operations != NULL ) - { - free ( p_filter->p_sys->p_atomic_operations ); - } - free ( p_filter->p_sys ); - p_filter->p_sys = NULL; - } -} - /***************************************************************************** * DoWork: convert a buffer *****************************************************************************/ -static void DoWork( aout_instance_t * p_aout, aout_filter_t * p_filter, +static void DoWork( filter_t * p_filter, aout_buffer_t * p_in_buf, aout_buffer_t * p_out_buf ) { - int i_input_nb = aout_FormatNbChannels( &p_filter->input ); - int i_output_nb = aout_FormatNbChannels( &p_filter->output ); + filter_sys_t *p_sys = p_filter->p_sys; + int i_input_nb = aout_FormatNbChannels( &p_filter->fmt_in.audio ); + int i_output_nb = aout_FormatNbChannels( &p_filter->fmt_out.audio ); float * p_in = (float*) p_in_buf->p_buffer; - byte_t * p_out; - byte_t * p_overflow; - byte_t * p_slide; + uint8_t * p_out; + uint8_t * p_overflow; + uint8_t * p_slide; - size_t i_overflow_size;/* in bytes */ - size_t i_out_size;/* in bytes */ + size_t i_overflow_size; /* in bytes */ + size_t i_out_size; /* in bytes */ unsigned int i, j; @@ -382,90 +351,206 @@ static void DoWork( aout_instance_t * p_aout, aout_filter_t * p_filter, unsigned int i_delay; double d_amplitude_factor; - /* out buffer characterisitcs */ p_out_buf->i_nb_samples = p_in_buf->i_nb_samples; - p_out_buf->i_nb_bytes = p_in_buf->i_nb_bytes * i_output_nb / i_input_nb; + p_out_buf->i_buffer = p_in_buf->i_buffer * i_output_nb / i_input_nb; p_out = p_out_buf->p_buffer; - i_out_size = p_out_buf->i_nb_bytes; + i_out_size = p_out_buf->i_buffer; - if ( p_filter->p_sys != NULL ) - { - /* Slide the overflow buffer */ - p_overflow = p_filter->p_sys->p_overflow_buffer; - i_overflow_size = p_filter->p_sys->i_overflow_buffer_size; + /* Slide the overflow buffer */ + p_overflow = p_sys->p_overflow_buffer; + i_overflow_size = p_sys->i_overflow_buffer_size; + + memset( p_out, 0, i_out_size ); + if ( i_out_size > i_overflow_size ) + memcpy( p_out, p_overflow, i_overflow_size ); + else + memcpy( p_out, p_overflow, i_out_size ); - memset ( p_out , 0 , i_out_size ); - if ( i_out_size > i_overflow_size ) - memcpy ( p_out , p_overflow , i_overflow_size ); + p_slide = p_sys->p_overflow_buffer; + while( p_slide < p_overflow + i_overflow_size ) + { + if( p_slide + i_out_size < p_overflow + i_overflow_size ) + { + memset( p_slide, 0, i_out_size ); + if( p_slide + 2 * i_out_size < p_overflow + i_overflow_size ) + memcpy( p_slide, p_slide + i_out_size, i_out_size ); + else + memcpy( p_slide, p_slide + i_out_size, + p_overflow + i_overflow_size - ( p_slide + i_out_size ) ); + } else - memcpy ( p_out , p_overflow , i_out_size ); + { + memset( p_slide, 0, p_overflow + i_overflow_size - p_slide ); + } + p_slide += i_out_size; + } - p_slide = p_filter->p_sys->p_overflow_buffer; - while ( p_slide < p_overflow + i_overflow_size ) + /* apply the atomic operations */ + for( i = 0; i < p_sys->i_nb_atomic_operations; i++ ) + { + /* shorter variable names */ + i_source_channel_offset + = p_sys->p_atomic_operations[i].i_source_channel_offset; + i_dest_channel_offset + = p_sys->p_atomic_operations[i].i_dest_channel_offset; + i_delay = p_sys->p_atomic_operations[i].i_delay; + d_amplitude_factor + = p_sys->p_atomic_operations[i].d_amplitude_factor; + + if( p_out_buf->i_nb_samples > i_delay ) { - if ( p_slide + i_out_size < p_overflow + i_overflow_size ) + /* current buffer coefficients */ + for( j = 0; j < p_out_buf->i_nb_samples - i_delay; j++ ) { - memset ( p_slide , 0 , i_out_size ); - if ( p_slide + 2 * i_out_size < p_overflow + i_overflow_size ) - memcpy ( p_slide , p_slide + i_out_size , i_out_size ); - else - memcpy ( p_slide , p_slide + i_out_size - , p_overflow + i_overflow_size - ( p_slide + i_out_size ) ); + ((float*)p_out)[ (i_delay+j)*i_output_nb + i_dest_channel_offset ] + += p_in[ j * i_input_nb + i_source_channel_offset ] + * d_amplitude_factor; } - else + + /* overflow buffer coefficients */ + for( j = 0; j < i_delay; j++ ) { - memset ( p_slide , 0 , p_overflow + i_overflow_size - p_slide ); + ((float*)p_overflow)[ j*i_output_nb + i_dest_channel_offset ] + += p_in[ (p_out_buf->i_nb_samples - i_delay + j) + * i_input_nb + i_source_channel_offset ] + * d_amplitude_factor; } - p_slide += i_out_size; } - - /* apply the atomic operations */ - for ( i = 0 ; i < p_filter->p_sys->i_nb_atomic_operations ; i++ ) + else { - /* shorter variable names */ - i_source_channel_offset - = p_filter->p_sys->p_atomic_operations[i].i_source_channel_offset; - i_dest_channel_offset - = p_filter->p_sys->p_atomic_operations[i].i_dest_channel_offset; - i_delay = p_filter->p_sys->p_atomic_operations[i].i_delay; - d_amplitude_factor - = p_filter->p_sys->p_atomic_operations[i].d_amplitude_factor; - - if ( p_out_buf->i_nb_samples > i_delay ) + /* overflow buffer coefficients only */ + for( j = 0; j < p_out_buf->i_nb_samples; j++ ) { - /* current buffer coefficients */ - for ( j = 0 ; j < p_out_buf->i_nb_samples - i_delay ; j++ ) - { - ((float*)p_out)[ (i_delay+j)*i_output_nb + i_dest_channel_offset ] - += p_in[ j * i_input_nb + i_source_channel_offset ] - * d_amplitude_factor; - } - - /* overflow buffer coefficients */ - for ( j = 0 ; j < i_delay ; j++ ) - { - ((float*)p_overflow)[ j*i_output_nb + i_dest_channel_offset ] - += p_in[ (p_out_buf->i_nb_samples - i_delay + j) - * i_input_nb + i_source_channel_offset ] - * d_amplitude_factor; - } - } - else - { - /* overflow buffer coefficients only */ - for ( j = 0 ; j < p_out_buf->i_nb_samples ; j++ ) - { - ((float*)p_overflow)[ (i_delay - p_out_buf->i_nb_samples + j) - * i_output_nb + i_dest_channel_offset ] - += p_in[ j * i_input_nb + i_source_channel_offset ] - * d_amplitude_factor; - } + ((float*)p_overflow)[ (i_delay - p_out_buf->i_nb_samples + j) + * i_output_nb + i_dest_channel_offset ] + += p_in[ j * i_input_nb + i_source_channel_offset ] + * d_amplitude_factor; } } } - else +} + +/* + * Audio filter 2 + */ +/***************************************************************************** + * OpenFilter: + *****************************************************************************/ +static int OpenFilter( vlc_object_t *p_this ) +{ + filter_t *p_filter = (filter_t *)p_this; + filter_sys_t *p_sys; + bool b_fit = true; + + /* Activate this filter only with stereo devices */ + if( p_filter->fmt_out.audio.i_physical_channels + != (AOUT_CHAN_LEFT|AOUT_CHAN_RIGHT) ) + { + msg_Dbg( p_filter, "filter discarded (incompatible format)" ); + return VLC_EGENERIC; + } + + /* Request a specific format if not already compatible */ + if( p_filter->fmt_in.audio.i_original_channels + != p_filter->fmt_out.audio.i_original_channels ) + { + b_fit = false; + p_filter->fmt_in.audio.i_original_channels = + p_filter->fmt_out.audio.i_original_channels; + } + if( p_filter->fmt_in.audio.i_format != VLC_CODEC_FL32 + || p_filter->fmt_out.audio.i_format != VLC_CODEC_FL32 ) + { + b_fit = false; + p_filter->fmt_in.audio.i_format = VLC_CODEC_FL32; + p_filter->fmt_out.audio.i_format = VLC_CODEC_FL32; + } + if( p_filter->fmt_in.audio.i_rate != p_filter->fmt_out.audio.i_rate ) + { + b_fit = false; + p_filter->fmt_in.audio.i_rate = p_filter->fmt_out.audio.i_rate; + } + if( p_filter->fmt_in.audio.i_physical_channels == (AOUT_CHAN_LEFT|AOUT_CHAN_RIGHT) + && ( p_filter->fmt_in.audio.i_original_channels & AOUT_CHAN_DOLBYSTEREO ) + && !config_GetInt( p_filter, "headphone-dolby" ) ) + { + b_fit = false; + p_filter->fmt_in.audio.i_physical_channels = AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | + AOUT_CHAN_CENTER | + AOUT_CHAN_REARLEFT | + AOUT_CHAN_REARRIGHT; + } + if( !b_fit ) + { + msg_Dbg( p_filter, "requesting specific format" ); + return VLC_EGENERIC; + } + + /* Allocate the memory needed to store the module's structure */ + p_sys = p_filter->p_sys = malloc( sizeof(struct filter_sys_t) ); + if( p_sys == NULL ) + return VLC_ENOMEM; + p_sys->i_overflow_buffer_size = 0; + p_sys->p_overflow_buffer = NULL; + p_sys->i_nb_atomic_operations = 0; + p_sys->p_atomic_operations = NULL; + + if( Init( VLC_OBJECT(p_filter), p_sys + , aout_FormatNbChannels ( &(p_filter->fmt_in.audio) ) + , p_filter->fmt_in.audio.i_physical_channels + , p_filter->fmt_in.audio.i_rate ) < 0 ) { - memset ( p_out , 0 , i_out_size ); + free( p_sys ); + return VLC_EGENERIC; } + + p_filter->pf_audio_filter = Convert; + p_filter->fmt_out.audio.i_rate = p_filter->fmt_in.audio.i_rate; + + return VLC_SUCCESS; +} + +/***************************************************************************** + * CloseFilter : deallocate data structures + *****************************************************************************/ +static void CloseFilter( vlc_object_t *p_this ) +{ + filter_t *p_filter = (filter_t *)p_this; + + free( p_filter->p_sys->p_overflow_buffer ); + free( p_filter->p_sys->p_atomic_operations ); + free( p_filter->p_sys ); +} + +static block_t *Convert( filter_t *p_filter, block_t *p_block ) +{ + if( !p_block || !p_block->i_nb_samples ) + { + if( p_block ) + block_Release( p_block ); + return NULL; + } + + size_t i_out_size = p_block->i_nb_samples * + p_filter->fmt_out.audio.i_bitspersample/8 * + aout_FormatNbChannels( &(p_filter->fmt_out.audio) ); + + block_t *p_out = filter_NewAudioBuffer( p_filter, i_out_size ); + if( !p_out ) + { + msg_Warn( p_filter, "can't get output buffer" ); + block_Release( p_block ); + return NULL; + } + + p_out->i_nb_samples = p_block->i_nb_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; + + DoWork( p_filter, p_block, p_out ); + + block_Release( p_block ); + return p_out; }