f6b029bbf5ba1b7749ed5082e7b544595607f680
[vlc.git] / src / audio_output / input.c
1 /*****************************************************************************
2  * input.c : internal management of input streams for the audio output
3  *****************************************************************************
4  * Copyright (C) 2002-2004 VideoLAN
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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
22  *****************************************************************************/
23
24 /*****************************************************************************
25  * Preamble
26  *****************************************************************************/
27 #include <stdlib.h>                            /* calloc(), malloc(), free() */
28 #include <string.h>
29
30 #include <vlc/vlc.h>
31 #include <vlc/input.h>                 /* for input_thread_t and i_pts_delay */
32
33 #ifdef HAVE_ALLOCA_H
34 #   include <alloca.h>
35 #endif
36
37 #include "audio_output.h"
38 #include "aout_internal.h"
39
40 static int VisualizationCallback( vlc_object_t *, char const *,
41                                   vlc_value_t, vlc_value_t, void * );
42 static int EqualizerCallback( vlc_object_t *, char const *,
43                               vlc_value_t, vlc_value_t, void * );
44 static aout_filter_t * allocateUserChannelMixer( aout_instance_t *,
45                                                  audio_sample_format_t *,
46                                                  audio_sample_format_t * );
47
48 /*****************************************************************************
49  * aout_InputNew : allocate a new input and rework the filter pipeline
50  *****************************************************************************/
51 int aout_InputNew( aout_instance_t * p_aout, aout_input_t * p_input )
52 {
53     audio_sample_format_t user_filter_format;
54     audio_sample_format_t intermediate_format;/* input of resampler */
55     vlc_value_t val, text;
56     char * psz_filters;
57     aout_filter_t * p_user_channel_mixer;
58
59     aout_FormatPrint( p_aout, "input", &p_input->input );
60
61     /* Prepare FIFO. */
62     aout_FifoInit( p_aout, &p_input->fifo, p_aout->mixer.mixer.i_rate );
63     p_input->p_first_byte_to_mix = NULL;
64
65     /* Prepare format structure */
66     memcpy( &intermediate_format, &p_aout->mixer.mixer,
67             sizeof(audio_sample_format_t) );
68     intermediate_format.i_rate = p_input->input.i_rate;
69
70     /* Try to use the channel mixer chosen by the user */
71     memcpy ( &user_filter_format, &intermediate_format,
72              sizeof(audio_sample_format_t) );
73     user_filter_format.i_physical_channels = p_input->input.i_physical_channels;
74     user_filter_format.i_original_channels = p_input->input.i_original_channels;
75     user_filter_format.i_bytes_per_frame = user_filter_format.i_bytes_per_frame
76                               * aout_FormatNbChannels( &user_filter_format )
77                               / aout_FormatNbChannels( &intermediate_format );
78     p_user_channel_mixer = allocateUserChannelMixer( p_aout, &user_filter_format,
79                                                    &intermediate_format );
80     /* If it failed, let the main pipeline do channel mixing */
81     if ( ! p_user_channel_mixer )
82     {
83         memcpy ( &user_filter_format, &intermediate_format,
84                  sizeof(audio_sample_format_t) );
85     }
86
87     /* Create filters. */
88     if ( aout_FiltersCreatePipeline( p_aout, p_input->pp_filters,
89                                      &p_input->i_nb_filters,
90                                      &p_input->input,
91                                      &user_filter_format
92                                      ) < 0 )
93     {
94         msg_Err( p_aout, "couldn't set an input pipeline" );
95
96         aout_FifoDestroy( p_aout, &p_input->fifo );
97         p_input->b_error = 1;
98         return -1;
99     }
100
101     /* Now add user filters */
102     if( var_Type( p_aout, "visual" ) == 0 )
103     {
104         module_t *p_module;
105         var_Create( p_aout, "visual", VLC_VAR_STRING | VLC_VAR_HASCHOICE );
106         text.psz_string = _("Visualizations");
107         var_Change( p_aout, "visual", VLC_VAR_SETTEXT, &text, NULL );
108         val.psz_string = ""; text.psz_string = _("Disable");
109         var_Change( p_aout, "visual", VLC_VAR_ADDCHOICE, &val, &text );
110         val.psz_string = "random"; text.psz_string = _("Random");
111         var_Change( p_aout, "visual", VLC_VAR_ADDCHOICE, &val, &text );
112         val.psz_string = "scope"; text.psz_string = _("Scope");
113         var_Change( p_aout, "visual", VLC_VAR_ADDCHOICE, &val, &text );
114         val.psz_string = "spectrum"; text.psz_string = _("Spectrum");
115         var_Change( p_aout, "visual", VLC_VAR_ADDCHOICE, &val, &text );
116
117         /* Look for goom plugin */
118         p_module = config_FindModule( VLC_OBJECT(p_aout), "goom" );
119         if( p_module )
120         {
121             val.psz_string = "goom"; text.psz_string = _("Goom");
122             var_Change( p_aout, "visual", VLC_VAR_ADDCHOICE, &val, &text );
123         }
124
125         /* Look for galaktos plugin */
126         p_module = config_FindModule( VLC_OBJECT(p_aout), "galaktos" );
127         if( p_module )
128         {
129             val.psz_string = "galaktos"; text.psz_string = _("GaLaktos");
130             var_Change( p_aout, "visual", VLC_VAR_ADDCHOICE, &val, &text );
131         }
132
133         if( var_Get( p_aout, "effect-list", &val ) == VLC_SUCCESS )
134         {
135             var_Set( p_aout, "visual", val );
136             if( val.psz_string ) free( val.psz_string );
137         }
138         var_AddCallback( p_aout, "visual", VisualizationCallback, NULL );
139     }
140
141     if( var_Type( p_aout, "equalizer" ) == 0 )
142     {
143         module_config_t *p_config;
144         int i;
145
146         p_config = config_FindConfig( VLC_OBJECT(p_aout), "equalizer-preset" );
147         if( p_config && p_config->i_list )
148         {
149             var_Create( p_aout, "equalizer",
150                         VLC_VAR_STRING | VLC_VAR_HASCHOICE );
151             text.psz_string = _("Equalizer");
152             var_Change( p_aout, "equalizer", VLC_VAR_SETTEXT, &text, NULL );
153
154             val.psz_string = ""; text.psz_string = _("Disable");
155             var_Change( p_aout, "equalizer", VLC_VAR_ADDCHOICE, &val, &text );
156
157             for( i = 0; i < p_config->i_list; i++ )
158             {
159                 val.psz_string = p_config->ppsz_list[i];
160                 text.psz_string = p_config->ppsz_list_text[i];
161                 var_Change( p_aout, "equalizer", VLC_VAR_ADDCHOICE,
162                             &val, &text );
163             }
164
165             var_AddCallback( p_aout, "equalizer", EqualizerCallback, NULL );
166         }
167     }
168
169     if( var_Type( p_aout, "audio-filter" ) == 0 )
170     {
171         var_Create( p_aout, "audio-filter",
172                     VLC_VAR_STRING | VLC_VAR_DOINHERIT );
173         text.psz_string = _("Audio filters");
174         var_Change( p_aout, "audio-filter", VLC_VAR_SETTEXT, &text, NULL );
175     }
176
177     var_Get( p_aout, "audio-filter", &val );
178     psz_filters = val.psz_string;
179     if( psz_filters && *psz_filters )
180     {
181         char *psz_parser = psz_filters;
182         char *psz_next;
183
184         while( psz_parser && *psz_parser )
185         {
186             aout_filter_t * p_filter;
187
188             if( p_input->i_nb_filters >= AOUT_MAX_FILTERS )
189             {
190                 msg_Dbg( p_aout, "max filter reached (%d)", AOUT_MAX_FILTERS );
191                 break;
192             }
193
194             while( *psz_parser == ' ' && *psz_parser == ',' )
195             {
196                 psz_parser++;
197             }
198             if( ( psz_next = strchr( psz_parser , ','  ) ) )
199             {
200                 *psz_next++ = '\0';
201             }
202             if( *psz_parser =='\0' )
203             {
204                 break;
205             }
206
207             msg_Dbg( p_aout, "user filter \"%s\"", psz_parser );
208
209             /* Create a VLC object */
210             p_filter = vlc_object_create( p_aout, sizeof(aout_filter_t) );
211             if( p_filter == NULL )
212             {
213                 msg_Err( p_aout, "cannot add user filter %s (skipped)",
214                          psz_parser );
215                 psz_parser = psz_next;
216                 continue;
217             }
218
219             vlc_object_attach( p_filter , p_aout );
220             memcpy( &p_filter->input, &user_filter_format,
221                     sizeof(audio_sample_format_t) );
222             memcpy( &p_filter->output, &user_filter_format,
223                     sizeof(audio_sample_format_t) );
224
225             p_filter->p_module =
226                 module_Need( p_filter,"audio filter", psz_parser, VLC_TRUE );
227
228             if( p_filter->p_module== NULL )
229             {
230                 msg_Err( p_aout, "cannot add user filter %s (skipped)",
231                          psz_parser );
232
233                 vlc_object_detach( p_filter );
234                 vlc_object_destroy( p_filter );
235                 psz_parser = psz_next;
236                 continue;
237
238             }
239             p_filter->b_continuity = VLC_FALSE;
240
241             p_input->pp_filters[p_input->i_nb_filters++] = p_filter;
242
243             /* next filter if any */
244             psz_parser = psz_next;
245         }
246     }
247     if( psz_filters ) free( psz_filters );
248
249     /* Attach the user channel mixer */
250     if ( p_user_channel_mixer )
251     {
252         p_input->pp_filters[p_input->i_nb_filters++] = p_user_channel_mixer;
253     }
254
255     /* Prepare hints for the buffer allocator. */
256     p_input->input_alloc.i_alloc_type = AOUT_ALLOC_HEAP;
257     p_input->input_alloc.i_bytes_per_sec = -1;
258
259     if ( AOUT_FMT_NON_LINEAR( &p_aout->mixer.mixer ) )
260     {
261         p_input->i_nb_resamplers = 0;
262     }
263     else
264     {
265         /* Create resamplers. */
266         intermediate_format.i_rate = (__MAX(p_input->input.i_rate,
267                                             p_aout->mixer.mixer.i_rate)
268                                  * (100 + AOUT_MAX_RESAMPLING)) / 100;
269         if ( intermediate_format.i_rate == p_aout->mixer.mixer.i_rate )
270         {
271             /* Just in case... */
272             intermediate_format.i_rate++;
273         }
274         if ( aout_FiltersCreatePipeline( p_aout, p_input->pp_resamplers,
275                                          &p_input->i_nb_resamplers,
276                                          &intermediate_format,
277                                          &p_aout->mixer.mixer ) < 0 )
278         {
279             msg_Err( p_aout, "couldn't set a resampler pipeline" );
280
281             aout_FiltersDestroyPipeline( p_aout, p_input->pp_filters,
282                                          p_input->i_nb_filters );
283             aout_FifoDestroy( p_aout, &p_input->fifo );
284             var_Destroy( p_aout, "visual" );
285             p_input->b_error = 1;
286
287             return -1;
288         }
289
290         aout_FiltersHintBuffers( p_aout, p_input->pp_resamplers,
291                                  p_input->i_nb_resamplers,
292                                  &p_input->input_alloc );
293
294         /* Setup the initial rate of the resampler */
295         p_input->pp_resamplers[0]->input.i_rate = p_input->input.i_rate;
296     }
297     p_input->i_resampling_type = AOUT_RESAMPLING_NONE;
298
299     p_input->input_alloc.i_alloc_type = AOUT_ALLOC_HEAP;
300     aout_FiltersHintBuffers( p_aout, p_input->pp_filters,
301                              p_input->i_nb_filters,
302                              &p_input->input_alloc );
303
304     /* i_bytes_per_sec is still == -1 if no filters */
305     p_input->input_alloc.i_bytes_per_sec = __MAX(
306                                     p_input->input_alloc.i_bytes_per_sec,
307                                     (int)(p_input->input.i_bytes_per_frame
308                                      * p_input->input.i_rate
309                                      / p_input->input.i_frame_length) );
310     /* Allocate in the heap, it is more convenient for the decoder. */
311     p_input->input_alloc.i_alloc_type = AOUT_ALLOC_HEAP;
312
313     p_input->b_error = VLC_FALSE;
314     p_input->b_restart = VLC_FALSE;
315
316     return 0;
317 }
318
319 /*****************************************************************************
320  * aout_InputDelete : delete an input
321  *****************************************************************************
322  * This function must be entered with the mixer lock.
323  *****************************************************************************/
324 int aout_InputDelete( aout_instance_t * p_aout, aout_input_t * p_input )
325 {
326     if ( p_input->b_error ) return 0;
327
328     aout_FiltersDestroyPipeline( p_aout, p_input->pp_filters,
329                                  p_input->i_nb_filters );
330     aout_FiltersDestroyPipeline( p_aout, p_input->pp_resamplers,
331                                  p_input->i_nb_resamplers );
332     aout_FifoDestroy( p_aout, &p_input->fifo );
333
334     return 0;
335 }
336
337 /*****************************************************************************
338  * aout_InputPlay : play a buffer
339  *****************************************************************************
340  * This function must be entered with the input lock.
341  *****************************************************************************/
342 int aout_InputPlay( aout_instance_t * p_aout, aout_input_t * p_input,
343                     aout_buffer_t * p_buffer )
344 {
345     mtime_t start_date;
346
347     if( p_input->b_restart )
348     {
349         aout_fifo_t fifo, dummy_fifo;
350         byte_t      *p_first_byte_to_mix;
351
352         vlc_mutex_lock( &p_aout->mixer_lock );
353
354         /* A little trick to avoid loosing our input fifo */
355         aout_FifoInit( p_aout, &dummy_fifo, p_aout->mixer.mixer.i_rate );
356         p_first_byte_to_mix = p_input->p_first_byte_to_mix;
357         fifo = p_input->fifo;
358         p_input->fifo = dummy_fifo;
359         aout_InputDelete( p_aout, p_input );
360         aout_InputNew( p_aout, p_input );
361         p_input->p_first_byte_to_mix = p_first_byte_to_mix;
362         p_input->fifo = fifo;
363
364         vlc_mutex_unlock( &p_aout->mixer_lock );
365     }
366
367     /* We don't care if someone changes the start date behind our back after
368      * this. We'll deal with that when pushing the buffer, and compensate
369      * with the next incoming buffer. */
370     vlc_mutex_lock( &p_aout->input_fifos_lock );
371     start_date = aout_FifoNextStart( p_aout, &p_input->fifo );
372     vlc_mutex_unlock( &p_aout->input_fifos_lock );
373
374     if ( start_date != 0 && start_date < mdate() )
375     {
376         /* The decoder is _very_ late. This can only happen if the user
377          * pauses the stream (or if the decoder is buggy, which cannot
378          * happen :). */
379         msg_Warn( p_aout, "computed PTS is out of range ("I64Fd"), "
380                   "clearing out", mdate() - start_date );
381         vlc_mutex_lock( &p_aout->input_fifos_lock );
382         aout_FifoSet( p_aout, &p_input->fifo, 0 );
383         p_input->p_first_byte_to_mix = NULL;
384         vlc_mutex_unlock( &p_aout->input_fifos_lock );
385         if ( p_input->i_resampling_type != AOUT_RESAMPLING_NONE )
386             msg_Warn( p_aout, "timing screwed, stopping resampling" );
387         p_input->i_resampling_type = AOUT_RESAMPLING_NONE;
388         if ( p_input->i_nb_resamplers != 0 )
389         {
390             p_input->pp_resamplers[0]->input.i_rate = p_input->input.i_rate;
391             p_input->pp_resamplers[0]->b_continuity = VLC_FALSE;
392         }
393         start_date = 0;
394     }
395
396     if ( p_buffer->start_date < mdate() + AOUT_MIN_PREPARE_TIME )
397     {
398         /* The decoder gives us f*cked up PTS. It's its business, but we
399          * can't present it anyway, so drop the buffer. */
400         msg_Warn( p_aout, "PTS is out of range ("I64Fd"), dropping buffer",
401                   mdate() - p_buffer->start_date );
402         aout_BufferFree( p_buffer );
403         p_input->i_resampling_type = AOUT_RESAMPLING_NONE;
404         if ( p_input->i_nb_resamplers != 0 )
405         {
406             p_input->pp_resamplers[0]->input.i_rate = p_input->input.i_rate;
407             p_input->pp_resamplers[0]->b_continuity = VLC_FALSE;
408         }
409         return 0;
410     }
411
412     if ( start_date == 0 ) start_date = p_buffer->start_date;
413
414     /* Run pre-filters. */
415
416     aout_FiltersPlay( p_aout, p_input->pp_filters, p_input->i_nb_filters,
417                       &p_buffer );
418
419     /* Run the resampler if needed.
420      * We first need to calculate the output rate of this resampler. */
421     if ( ( p_input->i_resampling_type == AOUT_RESAMPLING_NONE ) &&
422          ( start_date < p_buffer->start_date - AOUT_PTS_TOLERANCE
423            || start_date > p_buffer->start_date + AOUT_PTS_TOLERANCE ) &&
424          p_input->i_nb_resamplers > 0 )
425     {
426         /* Can happen in several circumstances :
427          * 1. A problem at the input (clock drift)
428          * 2. A small pause triggered by the user
429          * 3. Some delay in the output stage, causing a loss of lip
430          *    synchronization
431          * Solution : resample the buffer to avoid a scratch.
432          */
433         mtime_t drift = p_buffer->start_date - start_date;
434
435         p_input->i_resamp_start_date = mdate();
436         p_input->i_resamp_start_drift = (int)drift;
437
438         if ( drift > 0 )
439             p_input->i_resampling_type = AOUT_RESAMPLING_DOWN;
440         else
441             p_input->i_resampling_type = AOUT_RESAMPLING_UP;
442
443         msg_Warn( p_aout, "buffer is "I64Fd" %s, triggering %ssampling",
444                           drift > 0 ? drift : -drift,
445                           drift > 0 ? "in advance" : "late",
446                           drift > 0 ? "down" : "up");
447     }
448
449     if ( p_input->i_resampling_type != AOUT_RESAMPLING_NONE )
450     {
451         /* Resampling has been triggered previously (because of dates
452          * mismatch). We want the resampling to happen progressively so
453          * it isn't too audible to the listener. */
454
455         if( p_input->i_resampling_type == AOUT_RESAMPLING_UP )
456         {
457             p_input->pp_resamplers[0]->input.i_rate += 10; /* Hz */
458         }
459         else
460         {
461             p_input->pp_resamplers[0]->input.i_rate -= 10; /* Hz */
462         }
463
464         /* Check if everything is back to normal, in which case we can stop the
465          * resampling */
466         if( p_input->pp_resamplers[0]->input.i_rate ==
467               p_input->input.i_rate )
468         {
469             p_input->i_resampling_type = AOUT_RESAMPLING_NONE;
470             msg_Warn( p_aout, "resampling stopped after "I64Fi" usec",
471                       mdate() - p_input->i_resamp_start_date );
472         }
473         else if( abs( (int)(p_buffer->start_date - start_date) ) <
474                  abs( p_input->i_resamp_start_drift ) / 2 )
475         {
476             /* if we reduced the drift from half, then it is time to switch
477              * back the resampling direction. */
478             if( p_input->i_resampling_type == AOUT_RESAMPLING_UP )
479                 p_input->i_resampling_type = AOUT_RESAMPLING_DOWN;
480             else
481                 p_input->i_resampling_type = AOUT_RESAMPLING_UP;
482             p_input->i_resamp_start_drift = 0;
483         }
484         else if( p_input->i_resamp_start_drift &&
485                  ( abs( (int)(p_buffer->start_date - start_date) ) >
486                    abs( p_input->i_resamp_start_drift ) * 3 / 2 ) )
487         {
488             /* If the drift is increasing and not decreasing, than something
489              * is bad. We'd better stop the resampling right now. */
490             msg_Warn( p_aout, "timing screwed, stopping resampling" );
491             p_input->i_resampling_type = AOUT_RESAMPLING_NONE;
492             p_input->pp_resamplers[0]->input.i_rate = p_input->input.i_rate;
493         }
494     }
495
496     /* Adding the start date will be managed by aout_FifoPush(). */
497     p_buffer->end_date = start_date +
498         (p_buffer->end_date - p_buffer->start_date);
499     p_buffer->start_date = start_date;
500
501     /* Actually run the resampler now. */
502     if ( p_input->i_nb_resamplers > 0 )
503     {
504         aout_FiltersPlay( p_aout, p_input->pp_resamplers,
505                           p_input->i_nb_resamplers,
506                           &p_buffer );
507     }
508
509     vlc_mutex_lock( &p_aout->input_fifos_lock );
510     aout_FifoPush( p_aout, &p_input->fifo, p_buffer );
511     vlc_mutex_unlock( &p_aout->input_fifos_lock );
512
513     return 0;
514 }
515
516 static int ChangeFiltersString( aout_instance_t * p_aout,
517                                  char *psz_name, vlc_bool_t b_add )
518 {
519     vlc_value_t val;
520     char *psz_parser;
521
522     var_Get( p_aout, "audio-filter", &val );
523
524     if( !val.psz_string ) val.psz_string = strdup("");
525
526     psz_parser = strstr( val.psz_string, psz_name );
527
528     if( b_add )
529     {
530         if( !psz_parser )
531         {
532             psz_parser = val.psz_string;
533             asprintf( &val.psz_string, (*val.psz_string) ? "%s,%s" : "%s%s",
534                       val.psz_string, psz_name );
535             free( psz_parser );
536         }
537         else
538         {
539             return 0;
540         }
541     }
542     else
543     {
544         if( psz_parser )
545         {
546             memmove( psz_parser, psz_parser + strlen(psz_name) +
547                      (*(psz_parser + strlen(psz_name)) == ',' ? 1 : 0 ),
548                      strlen(psz_parser + strlen(psz_name)) + 1 );
549         }
550         else
551         {
552             free( val.psz_string );
553             return 0;
554         }
555     }
556
557     var_Set( p_aout, "audio-filter", val );
558     free( val.psz_string );
559     return 1;
560 }
561
562 static int VisualizationCallback( vlc_object_t *p_this, char const *psz_cmd,
563                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
564 {
565     aout_instance_t *p_aout = (aout_instance_t *)p_this;
566     char *psz_mode = newval.psz_string;
567     vlc_value_t val;
568     int i;
569
570     if( !psz_mode || !*psz_mode )
571     {
572         ChangeFiltersString( p_aout, "goom", VLC_FALSE );
573         ChangeFiltersString( p_aout, "visual", VLC_FALSE );
574         ChangeFiltersString( p_aout, "galaktos", VLC_FALSE );
575     }
576     else
577     {
578         if( !strcmp( "goom", psz_mode ) )
579         {
580             ChangeFiltersString( p_aout, "visual", VLC_FALSE );
581             ChangeFiltersString( p_aout, "goom", VLC_TRUE );
582             ChangeFiltersString( p_aout, "galaktos", VLC_FALSE );
583         }
584         else if( !strcmp( "galaktos", psz_mode ) )
585         {
586             ChangeFiltersString( p_aout, "visual", VLC_FALSE );
587             ChangeFiltersString( p_aout, "goom", VLC_FALSE );
588             ChangeFiltersString( p_aout, "galaktos", VLC_TRUE );
589         }
590         else
591         {
592             val.psz_string = psz_mode;
593             var_Create( p_aout, "effect-list", VLC_VAR_STRING );
594             var_Set( p_aout, "effect-list", val );
595
596             ChangeFiltersString( p_aout, "goom", VLC_FALSE );
597             ChangeFiltersString( p_aout, "visual", VLC_TRUE );
598             ChangeFiltersString( p_aout, "galaktos", VLC_FALSE );
599         }
600     }
601
602     /* That sucks */
603     for( i = 0; i < p_aout->i_nb_inputs; i++ )
604     {
605         p_aout->pp_inputs[i]->b_restart = VLC_TRUE;
606     }
607
608     return VLC_SUCCESS;
609 }
610
611 static int EqualizerCallback( vlc_object_t *p_this, char const *psz_cmd,
612                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
613 {
614     aout_instance_t *p_aout = (aout_instance_t *)p_this;
615     char *psz_mode = newval.psz_string;
616     vlc_value_t val;
617     int i;
618     int i_ret;
619
620     if( !psz_mode || !*psz_mode )
621     {
622         i_ret = ChangeFiltersString( p_aout, "equalizer", VLC_FALSE );
623     }
624     else
625     {
626         val.psz_string = psz_mode;
627         var_Create( p_aout, "equalizer-preset", VLC_VAR_STRING );
628         var_Set( p_aout, "equalizer-preset", val );
629         i_ret = ChangeFiltersString( p_aout, "equalizer", VLC_TRUE );
630
631     }
632
633     /* That sucks */
634     if( i_ret == 1 )
635     {
636         for( i = 0; i < p_aout->i_nb_inputs; i++ )
637         {
638             p_aout->pp_inputs[i]->b_restart = VLC_TRUE;
639         }
640     }
641
642     return VLC_SUCCESS;
643 }
644
645 static aout_filter_t * allocateUserChannelMixer( aout_instance_t * p_aout,
646                                      audio_sample_format_t * p_input_format,
647                                      audio_sample_format_t * p_output_format )
648 {
649     aout_filter_t * p_channel_mixer;
650
651     /* Retreive user preferred channel mixer */
652     char * psz_name = config_GetPsz( p_aout, "audio-channel-mixer" );
653
654     /* Not specified => let the main pipeline do the mixing */
655     if ( ! psz_name ) return NULL;
656
657     /* Debug information */
658     aout_FormatsPrint( p_aout, "channel mixer", p_input_format,
659                        p_output_format );
660
661     /* Create a VLC object */
662     p_channel_mixer = vlc_object_create( p_aout, sizeof(aout_filter_t) );
663     if( p_channel_mixer == NULL )
664     {
665         msg_Err( p_aout, "cannot add user channel mixer %s", psz_name );
666         return NULL;
667     }
668     vlc_object_attach( p_channel_mixer , p_aout );
669
670     /* Attach the suitable module */
671     memcpy( &p_channel_mixer->input, p_input_format,
672                     sizeof(audio_sample_format_t) );
673     memcpy( &p_channel_mixer->output, p_output_format,
674                     sizeof(audio_sample_format_t) );
675     p_channel_mixer->p_module =
676         module_Need( p_channel_mixer,"audio filter", psz_name, VLC_TRUE );
677     if( p_channel_mixer->p_module== NULL )
678     {
679         msg_Err( p_aout, "cannot add user channel mixer %s", psz_name );
680         vlc_object_detach( p_channel_mixer );
681         vlc_object_destroy( p_channel_mixer );
682         return NULL;
683     }
684     p_channel_mixer->b_continuity = VLC_FALSE;
685
686     /* Ok */
687     return p_channel_mixer;
688 }