git.sesse.net Git - vlc/blob - src/audio_output/filters.c

   1 /*****************************************************************************
   2  * filters.c : audio output filters management
   3  *****************************************************************************
   4  * Copyright (C) 2002-2007 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Christophe Massiot <massiot@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., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27 #ifdef HAVE_CONFIG_H
  28 # include "config.h"
  29 #endif
  30
  31 #include <assert.h>
  32
  33 #include <vlc_common.h>
  34 #include <vlc_dialog.h>
  35
  36 #include <vlc_aout.h>
  37 #include <vlc_filter.h>
  38 #include "aout_internal.h"
  39 #include <libvlc.h>
  40
  41 block_t *aout_FilterBufferNew( filter_t *p_filter, int size )
  42 {
  43     (void) p_filter;
  44     return block_Alloc( size );
  45 }
  46
  47 /*****************************************************************************
  48  * FindFilter: find an audio filter for a specific transformation
  49  *****************************************************************************/
  50 static filter_t * FindFilter( aout_instance_t * p_aout,
  51                               const audio_sample_format_t * p_input_format,
  52                               const audio_sample_format_t * p_output_format )
  53 {
  54     static const char typename[] = "audio filter";
  55     filter_t * p_filter;
  56
  57     p_filter = vlc_custom_create( p_aout, sizeof(*p_filter),
  58                                   VLC_OBJECT_GENERIC, typename );
  59
  60     if ( p_filter == NULL ) return NULL;
  61     vlc_object_attach( p_filter, p_aout );
  62
  63     memcpy( &p_filter->fmt_in.audio, p_input_format,
  64             sizeof(audio_sample_format_t) );
  65     p_filter->fmt_in.i_codec = p_input_format->i_format;
  66     memcpy( &p_filter->fmt_out.audio, p_output_format,
  67             sizeof(audio_sample_format_t) );
  68     p_filter->fmt_out.i_codec = p_output_format->i_format;
  69     p_filter->pf_audio_buffer_new = aout_FilterBufferNew;
  70
  71     p_filter->p_module = module_need( p_filter, "audio filter", NULL, false );
  72     if ( p_filter->p_module == NULL )
  73     {
  74         vlc_object_detach( p_filter );
  75         vlc_object_release( p_filter );
  76         return NULL;
  77     }
  78
  79     assert( p_filter->pf_audio_filter );
  80     return p_filter;
  81 }
  82
  83 /*****************************************************************************
  84  * SplitConversion: split a conversion in two parts
  85  *****************************************************************************
  86  * Returns the number of conversions required by the first part - 0 if only
  87  * one conversion was asked.
  88  * Beware : p_output_format can be modified during this function if the
  89  * developer passed SplitConversion( toto, titi, titi, ... ). That is legal.
  90  * SplitConversion( toto, titi, toto, ... ) isn't.
  91  *****************************************************************************/
  92 static int SplitConversion( const audio_sample_format_t * p_input_format,
  93                             const audio_sample_format_t * p_output_format,
  94                             audio_sample_format_t * p_middle_format )
  95 {
  96     bool b_format =
  97              (p_input_format->i_format != p_output_format->i_format);
  98     bool b_rate = (p_input_format->i_rate != p_output_format->i_rate);
  99     bool b_channels =
 100         (p_input_format->i_physical_channels
 101           != p_output_format->i_physical_channels)
 102      || (p_input_format->i_original_channels
 103           != p_output_format->i_original_channels);
 104     int i_nb_conversions = b_format + b_rate + b_channels;
 105
 106     if ( i_nb_conversions <= 1 ) return 0;
 107
 108     memcpy( p_middle_format, p_output_format, sizeof(audio_sample_format_t) );
 109
 110     if ( i_nb_conversions == 2 )
 111     {
 112         if ( !b_format || !b_channels )
 113         {
 114             p_middle_format->i_rate = p_input_format->i_rate;
 115             aout_FormatPrepare( p_middle_format );
 116             return 1;
 117         }
 118
 119         /* !b_rate */
 120         p_middle_format->i_physical_channels
 121              = p_input_format->i_physical_channels;
 122         p_middle_format->i_original_channels
 123              = p_input_format->i_original_channels;
 124         aout_FormatPrepare( p_middle_format );
 125         return 1;
 126     }
 127
 128     /* i_nb_conversion == 3 */
 129     p_middle_format->i_rate = p_input_format->i_rate;
 130     aout_FormatPrepare( p_middle_format );
 131     return 2;
 132 }
 133
 134 static void ReleaseFilter( filter_t * p_filter )
 135 {
 136     module_unneed( p_filter, p_filter->p_module );
 137     vlc_object_detach( p_filter );
 138     vlc_object_release( p_filter );
 139 }
 140
 141 /*****************************************************************************
 142  * aout_FiltersCreatePipeline: create a filters pipeline to transform a sample
 143  *                             format to another
 144  *****************************************************************************
 145  * pi_nb_filters must be initialized before calling this function
 146  *****************************************************************************/
 147 int aout_FiltersCreatePipeline( aout_instance_t * p_aout,
 148                                 filter_t ** pp_filters_start,
 149                                 int * pi_nb_filters,
 150                                 const audio_sample_format_t * p_input_format,
 151                                 const audio_sample_format_t * p_output_format )
 152 {
 153     filter_t** pp_filters = pp_filters_start + *pi_nb_filters;
 154     audio_sample_format_t temp_format;
 155     int i_nb_conversions;
 156
 157     if ( AOUT_FMTS_IDENTICAL( p_input_format, p_output_format ) )
 158     {
 159         msg_Dbg( p_aout, "no need for any filter" );
 160         return 0;
 161     }
 162
 163     aout_FormatsPrint( p_aout, "filter(s)", p_input_format, p_output_format );
 164
 165     if( *pi_nb_filters + 1 > AOUT_MAX_FILTERS )
 166     {
 167         msg_Err( p_aout, "max filter reached (%d)", AOUT_MAX_FILTERS );
 168         dialog_Fatal( p_aout, _("Audio filtering failed"),
 169                       _("The maximum number of filters (%d) was reached."),
 170                       AOUT_MAX_FILTERS );
 171         return -1;
 172     }
 173
 174     /* Try to find a filter to do the whole conversion. */
 175     pp_filters[0] = FindFilter( p_aout, p_input_format, p_output_format );
 176     if ( pp_filters[0] != NULL )
 177     {
 178         msg_Dbg( p_aout, "found a filter for the whole conversion" );
 179         ++*pi_nb_filters;
 180         return 0;
 181     }
 182
 183     /* We'll have to split the conversion. We always do the downmixing
 184      * before the resampling, because the audio decoder can probably do it
 185      * for us. */
 186     i_nb_conversions = SplitConversion( p_input_format,
 187                                         p_output_format, &temp_format );
 188     if ( !i_nb_conversions )
 189     {
 190         /* There was only one conversion to do, and we already failed. */
 191         msg_Err( p_aout, "couldn't find a filter for the conversion" );
 192         return -1;
 193     }
 194
 195     pp_filters[0] = FindFilter( p_aout, p_input_format, &temp_format );
 196     if ( pp_filters[0] == NULL && i_nb_conversions == 2 )
 197     {
 198         /* Try with only one conversion. */
 199         SplitConversion( p_input_format, &temp_format, &temp_format );
 200         pp_filters[0] = FindFilter( p_aout, p_input_format, &temp_format );
 201     }
 202     if ( pp_filters[0] == NULL )
 203     {
 204         msg_Err( p_aout,
 205               "couldn't find a filter for the first part of the conversion" );
 206         return -1;
 207     }
 208
 209     /* We have the first stage of the conversion. Find a filter for
 210      * the rest. */
 211     if( *pi_nb_filters + 2 > AOUT_MAX_FILTERS )
 212     {
 213         ReleaseFilter( pp_filters[0] );
 214         msg_Err( p_aout, "max filter reached (%d)", AOUT_MAX_FILTERS );
 215         dialog_Fatal( p_aout, _("Audio filtering failed"),
 216                       _("The maximum number of filters (%d) was reached."),
 217                       AOUT_MAX_FILTERS );
 218         return -1;
 219     }
 220     pp_filters[1] = FindFilter( p_aout, &pp_filters[0]->fmt_out.audio,
 221                                 p_output_format );
 222     if ( pp_filters[1] == NULL )
 223     {
 224         /* Try to split the conversion. */
 225         i_nb_conversions = SplitConversion( &pp_filters[0]->fmt_out.audio,
 226                                            p_output_format, &temp_format );
 227         if ( !i_nb_conversions )
 228         {
 229             ReleaseFilter( pp_filters[0] );
 230             msg_Err( p_aout,
 231               "couldn't find a filter for the second part of the conversion" );
 232             return -1;
 233         }
 234         if( *pi_nb_filters + 3 > AOUT_MAX_FILTERS )
 235         {
 236             ReleaseFilter( pp_filters[0] );
 237             msg_Err( p_aout, "max filter reached (%d)", AOUT_MAX_FILTERS );
 238             dialog_Fatal( p_aout, _("Audio filtering failed"),
 239                           _("The maximum number of filters (%d) was reached."),
 240                           AOUT_MAX_FILTERS );
 241             return -1;
 242         }
 243         pp_filters[1] = FindFilter( p_aout, &pp_filters[0]->fmt_out.audio,
 244                                     &temp_format );
 245         pp_filters[2] = FindFilter( p_aout, &temp_format,
 246                                     p_output_format );
 247
 248         if ( pp_filters[1] == NULL || pp_filters[2] == NULL )
 249         {
 250             ReleaseFilter( pp_filters[0] );
 251             if ( pp_filters[1] != NULL )
 252             {
 253                 ReleaseFilter( pp_filters[1] );
 254             }
 255             if ( pp_filters[2] != NULL )
 256             {
 257                 ReleaseFilter( pp_filters[2] );
 258             }
 259             msg_Err( p_aout,
 260                "couldn't find filters for the second part of the conversion" );
 261             return -1;
 262         }
 263         *pi_nb_filters += 3;
 264         msg_Dbg( p_aout, "found 3 filters for the whole conversion" );
 265     }
 266     else
 267     {
 268         *pi_nb_filters += 2;
 269         msg_Dbg( p_aout, "found 2 filters for the whole conversion" );
 270     }
 271
 272     return 0;
 273 }
 274
 275 /*****************************************************************************
 276  * aout_FiltersDestroyPipeline: deallocate a filters pipeline
 277  *****************************************************************************/
 278 void aout_FiltersDestroyPipeline( aout_instance_t * p_aout,
 279                                   filter_t ** pp_filters,
 280                                   int i_nb_filters )
 281 {
 282     int i;
 283     (void)p_aout;
 284
 285     for ( i = 0; i < i_nb_filters; i++ )
 286     {
 287         filter_t *p_filter = pp_filters[i];
 288
 289         module_unneed( p_filter, p_filter->p_module );
 290         free( p_filter->p_owner );
 291         vlc_object_detach( p_filter );
 292         vlc_object_release( p_filter );
 293     }
 294 }
 295
 296 /*****************************************************************************
 297  * aout_FiltersHintBuffers: fill in aout_alloc_t structures to optimize
 298  *                          buffer allocations
 299  *****************************************************************************/
 300 void aout_FiltersHintBuffers( aout_instance_t * p_aout,
 301                               filter_t ** pp_filters,
 302                               int i_nb_filters, aout_alloc_t * p_first_alloc )
 303 {
 304     int i;
 305
 306     (void)p_aout; /* unused */
 307
 308     for ( i = i_nb_filters - 1; i >= 0; i-- )
 309     {
 310         filter_t * p_filter = pp_filters[i];
 311
 312         int i_output_size = p_filter->fmt_out.audio.i_bytes_per_frame
 313                          * p_filter->fmt_out.audio.i_rate * AOUT_MAX_INPUT_RATE
 314                          / p_filter->fmt_out.audio.i_frame_length;
 315         int i_input_size = p_filter->fmt_in.audio.i_bytes_per_frame
 316                          * p_filter->fmt_in.audio.i_rate * AOUT_MAX_INPUT_RATE
 317                          / p_filter->fmt_in.audio.i_frame_length;
 318
 319         if( i_output_size > p_first_alloc->i_bytes_per_sec )
 320             p_first_alloc->i_bytes_per_sec = i_output_size;
 321         if( i_input_size > p_first_alloc->i_bytes_per_sec )
 322             p_first_alloc->i_bytes_per_sec = i_input_size;
 323     }
 324 }
 325
 326 /*****************************************************************************
 327  * aout_FiltersPlay: play a buffer
 328  *****************************************************************************/
 329 void aout_FiltersPlay( filter_t ** pp_filters,
 330                        unsigned i_nb_filters, block_t ** pp_block )
 331 {
 332     block_t *p_block = *pp_block;
 333
 334     /* TODO: use filter chain */
 335     for( unsigned i = 0; i < i_nb_filters; i++ )
 336     {
 337         filter_t * p_filter = pp_filters[i];
 338
 339         /* Please note that p_block->i_nb_samples & i_buffer
 340          * shall be set by the filter plug-in. */
 341         p_block = p_filter->pf_audio_filter( p_filter, p_block );
 342     }
 343     *pp_block = p_block;
 344 }
 345