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