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_release( p_filter );
  75         return NULL;
  76     }
  77
  78     assert( p_filter->pf_audio_filter );
  79     return p_filter;
  80 }
  81
  82 /*****************************************************************************
  83  * SplitConversion: split a conversion in two parts
  84  *****************************************************************************
  85  * Returns the number of conversions required by the first part - 0 if only
  86  * one conversion was asked.
  87  * Beware : p_output_format can be modified during this function if the
  88  * developer passed SplitConversion( toto, titi, titi, ... ). That is legal.
  89  * SplitConversion( toto, titi, toto, ... ) isn't.
  90  *****************************************************************************/
  91 static int SplitConversion( const audio_sample_format_t * p_input_format,
  92                             const audio_sample_format_t * p_output_format,
  93                             audio_sample_format_t * p_middle_format )
  94 {
  95     bool b_format =
  96              (p_input_format->i_format != p_output_format->i_format);
  97     bool b_rate = (p_input_format->i_rate != p_output_format->i_rate);
  98     bool b_channels =
  99         (p_input_format->i_physical_channels
 100           != p_output_format->i_physical_channels)
 101      || (p_input_format->i_original_channels
 102           != p_output_format->i_original_channels);
 103     int i_nb_conversions = b_format + b_rate + b_channels;
 104
 105     if ( i_nb_conversions <= 1 ) return 0;
 106
 107     memcpy( p_middle_format, p_output_format, sizeof(audio_sample_format_t) );
 108
 109     if ( i_nb_conversions == 2 )
 110     {
 111         if ( !b_format || !b_channels )
 112         {
 113             p_middle_format->i_rate = p_input_format->i_rate;
 114             aout_FormatPrepare( p_middle_format );
 115             return 1;
 116         }
 117
 118         /* !b_rate */
 119         p_middle_format->i_physical_channels
 120              = p_input_format->i_physical_channels;
 121         p_middle_format->i_original_channels
 122              = p_input_format->i_original_channels;
 123         aout_FormatPrepare( p_middle_format );
 124         return 1;
 125     }
 126
 127     /* i_nb_conversion == 3 */
 128     p_middle_format->i_rate = p_input_format->i_rate;
 129     aout_FormatPrepare( p_middle_format );
 130     return 2;
 131 }
 132
 133 static void ReleaseFilter( filter_t * p_filter )
 134 {
 135     module_unneed( p_filter, p_filter->p_module );
 136     vlc_object_release( p_filter );
 137 }
 138
 139 /*****************************************************************************
 140  * aout_FiltersCreatePipeline: create a filters pipeline to transform a sample
 141  *                             format to another
 142  *****************************************************************************
 143  * pi_nb_filters must be initialized before calling this function
 144  *****************************************************************************/
 145 int aout_FiltersCreatePipeline( aout_instance_t * p_aout,
 146                                 filter_t ** pp_filters_start,
 147                                 int * pi_nb_filters,
 148                                 const audio_sample_format_t * p_input_format,
 149                                 const audio_sample_format_t * p_output_format )
 150 {
 151     filter_t** pp_filters = pp_filters_start + *pi_nb_filters;
 152     audio_sample_format_t temp_format;
 153     int i_nb_conversions;
 154
 155     if ( AOUT_FMTS_IDENTICAL( p_input_format, p_output_format ) )
 156     {
 157         msg_Dbg( p_aout, "no need for any filter" );
 158         return 0;
 159     }
 160
 161     aout_FormatsPrint( p_aout, "filter(s)", p_input_format, p_output_format );
 162
 163     if( *pi_nb_filters + 1 > AOUT_MAX_FILTERS )
 164     {
 165         msg_Err( p_aout, "max filter reached (%d)", AOUT_MAX_FILTERS );
 166         dialog_Fatal( p_aout, _("Audio filtering failed"),
 167                       _("The maximum number of filters (%d) was reached."),
 168                       AOUT_MAX_FILTERS );
 169         return -1;
 170     }
 171
 172     /* Try to find a filter to do the whole conversion. */
 173     pp_filters[0] = FindFilter( p_aout, p_input_format, p_output_format );
 174     if ( pp_filters[0] != NULL )
 175     {
 176         msg_Dbg( p_aout, "found a filter for the whole conversion" );
 177         ++*pi_nb_filters;
 178         return 0;
 179     }
 180
 181     /* We'll have to split the conversion. We always do the downmixing
 182      * before the resampling, because the audio decoder can probably do it
 183      * for us. */
 184     i_nb_conversions = SplitConversion( p_input_format,
 185                                         p_output_format, &temp_format );
 186     if ( !i_nb_conversions )
 187     {
 188         /* There was only one conversion to do, and we already failed. */
 189         msg_Err( p_aout, "couldn't find a filter for the conversion "
 190                 "%4.4s -> %4.4s",
 191                 &p_input_format->i_format, &p_output_format->i_format );
 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_release( p_filter );
 292     }
 293 }
 294
 295 /*****************************************************************************
 296  * aout_FiltersHintBuffers: fill in aout_alloc_t structures to optimize
 297  *                          buffer allocations
 298  *****************************************************************************/
 299 void aout_FiltersHintBuffers( aout_instance_t * p_aout,
 300                               filter_t ** pp_filters,
 301                               int i_nb_filters, aout_alloc_t * p_first_alloc )
 302 {
 303     int i;
 304
 305     (void)p_aout; /* unused */
 306
 307     for ( i = i_nb_filters - 1; i >= 0; i-- )
 308     {
 309         filter_t * p_filter = pp_filters[i];
 310
 311         int i_output_size = p_filter->fmt_out.audio.i_bytes_per_frame
 312                          * p_filter->fmt_out.audio.i_rate * AOUT_MAX_INPUT_RATE
 313                          / p_filter->fmt_out.audio.i_frame_length;
 314         int i_input_size = p_filter->fmt_in.audio.i_bytes_per_frame
 315                          * p_filter->fmt_in.audio.i_rate * AOUT_MAX_INPUT_RATE
 316                          / p_filter->fmt_in.audio.i_frame_length;
 317
 318         if( i_output_size > p_first_alloc->i_bytes_per_sec )
 319             p_first_alloc->i_bytes_per_sec = i_output_size;
 320         if( i_input_size > p_first_alloc->i_bytes_per_sec )
 321             p_first_alloc->i_bytes_per_sec = i_input_size;
 322     }
 323 }
 324
 325 /*****************************************************************************
 326  * aout_FiltersPlay: play a buffer
 327  *****************************************************************************/
 328 void aout_FiltersPlay( filter_t ** pp_filters,
 329                        unsigned i_nb_filters, block_t ** pp_block )
 330 {
 331     block_t *p_block = *pp_block;
 332
 333     /* TODO: use filter chain */
 334     for( unsigned i = 0; i < i_nb_filters; i++ )
 335     {
 336         filter_t * p_filter = pp_filters[i];
 337
 338         /* Please note that p_block->i_nb_samples & i_buffer
 339          * shall be set by the filter plug-in. */
 340         p_block = p_filter->pf_audio_filter( p_filter, p_block );
 341     }
 342     *pp_block = p_block;
 343 }
 344